Discussion :

[DooSquare]

Bonjour je voudrai savoir comment faire une fonction qui retourne un tableau d'entier

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
int valbalise(int a){
...
    return(tab[100]);
}
 
 
int main(){
int tab[100];
 
tab=valbalise(1);
}

je ne récupére pas mon tableau...
je ne sais pas comment faire...

merci d'avance pour toute votre aide

[Gruik]

Salut,

Plusieurs solutions :
1) Tu alloues un nouveau tableau

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
T * creer_tableau(void)
{
  T * tab;
  tab = calloc(NB_ELEMENTS, sizeof *T);
  return tab;
}

Faut biensur penser à liberer (et ne libérer qu'une fois)

2) Tu laisses l'utilisateur creer et gérer le tableau, la fonction se contenterait de valoriser les éléments

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
void init_tableau(T * tab)
{
  memset(tab, 0, (sizeof *tab) * NB_ELEMENTS);
}

3) Tu retournes un tableau global (interne) ou statique => il reste accessible au retour de la fonction (c'est ce que fait par exemple getenv(), ou encore localtime()).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
T * get_tableau(void)
{
  static T tab[NB_ELEMENTS];
  memset(tab, 0, (sizeof *tab) * NB_ELEMENTS);
  return tab;
}

L'inconvenient c'est que tu peux avoir qu'un seul tableau en même temps (sinon il faut le copier).

Note : dans tous les cas, le nombre d'éléments est fixé, et l'initialisation consistait juste en la mise à zero des elements.

[millie]

Il est possible de retourner un tableau alloué sur la pile, comme apparement tu souhaites le faire. Mais je te le déconseilles car cela est très gourmand en temps (et il y a des risques de Stack Overflow dans le cas où le tableau est vraiment grand).


La méthode pour éviter une allocation dynamique (donc autre que la méthode de Gruik) est de passer un pointeur vers le tableau en paramètre, avec éventuellement la taille :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
int mafonction(int * tab, size_t taille) {
 
 ....
}
 
 
void autrefonction(void) {
 int tab[100];
 
 mafonction(tab, sizeof(tab));
 
 /* ou */
 size_t taille = 100;
 int * tab2 = malloc(sizeof(int) * taille);
 if(tab2==NULL) ....
 
 mafonction(tab2, taille);
 
}

[gege2061]

Il est possible de retourner un tableau

Pour être précis il n'est pas possible de retourner un tableau, uniquement un pointeur !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 mafonction(tab, sizeof(tab));

Pour connaître le nombre d'éléments d'un tableau c'est :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

sizeof (tab) / sizeof (*tab)

[Médinoc]

Pour être précis il n'est pas possible de retourner un tableau, uniquement un pointeur !

Et moi, j'ai des doutes et je me demande si millie n'a pas raison quelque part.

Par exemple, en retournant un tableau encapsulé dans une structure (retour de TRÈS gros objet sur la pile)...

[millie]

Pour être précis il n'est pas possible de retourner un tableau, uniquement un pointeur !


Pour connaître le nombre d'éléments d'un tableau c'est :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

sizeof (tab) / sizeof (*tab)

Voilà, à vouloir éviter de mettre un 100 en dur, je me plante bêtement .

Sinon, je pensais en fait à une astuce du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
#include <stdio.h>
#include <stdlib.h>
 
struct Tableau {
 int tab[100];
};
 
struct Tableau fonction(void) {
 struct Tableau tableau;
 /* ... */
 return tableau;
}
 
int main(void)
{
    struct Tableau sTab;
    sTab = fonction();
 
    return 0;
}

J'avais pensé un instant pouvoir retourner des tableaux par exemple avec un prototype :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
int[100] fonction(void);

Mais, n'ayant jamais essayé ce type de code (car c'est très peu performant), je viens seulement de me rendre compte que ce n'était pas possible autrement que d'encapsuler le tableau dans une structure, comme l'a indiqué Medinoc.

Au temps pour moi,

[souviron34]

euh.. Il y a encore une solution que vous n'avez pas mentionné

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
void Cree_tableau(int ** tab, int taille)
{
  *tab = malloc ( taille*sizeof(int) ) ;
}

[dj.motte]

Salut,

En retour de fonction, pour un tableau d'entiers, un pointeur sur le tableau d'entiers.

En retour de fonction, pour un tableau de structures, un pointeur sur le tableau de structures.

Le C ce n'est pas le langage des pointeurs, sans raison...

[Emmanuel Delahaye]

En retour de fonction, pour un tableau d'entiers, un pointeur sur le tableau d'entiers.

En retour de fonction, pour un tableau de structures, un pointeur sur le tableau de structures.

Vi vi. Mais le problème est de savoir sur quoi on pointe...

[kromartien]

les méthodes manipulation de tableau se basent toujours sur l'utilisation de pointeurs, je crois que c'est la valeur retournée qui doit compter. Le déférencement multiple inutile, je suis un peu sceptique

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
int * create_tab_int(size_t taille)
{
   int * tab_out=calloc( taille, sizeof(int) );
   /*
   ou traitement quelconque
   */
   return tab_out
}

ce n'est pas une méthode générique suffisante pour créer et/ou manipuler des valeurs de tableau?

[Emmanuel Delahaye]

les méthodes manipulation de tableau se basent toujours sur l'utilisation de pointeurs, je crois que c'est la valeur retournée qui doit compter. Le déférencement multiple inutile, je suis un peu sceptique

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
int * create_tab_int(size_t taille)
{
   int * tab_out=calloc( taille, sizeof(int) );
   /*
   ou traitement quelconque
   */
   return tab_out
}

ce n'est pas une méthode générique suffisante pour créer et/ou manipuler des valeurs de tableau?

Pour moi, ça va et ça ne nécessite pas de complication supplémentaire. Juste un peu de mise au point :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
int * create_tab_int(size_t taille)
{
   int * tab_out = malloc (taille * sizeof *tab_out);
   /*
   ou traitement quelconque
   */
   return tab_out;
}

[kromartien]

oui et aussi une fonction qui fait du traitement sur les éléments du tableau (permutations) ne renvoie rien (void), à part si on a recopie de tableau avec allocation dynamique lors de la séquence de tri (par exemple une séquence de tri) ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
void tri(int * tab_in)
{
   /*
   operations de tri
   */
}

ou

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
int * tri(int const * tab_in)
{
   /*
   copie du tableau tab_in dans tab_out
   */
 
   /*
   operations de tri sur la copie
   */
 
   return tab_out
}

[edit] correction de médinoc intégrée

[Médinoc]

Si tu fais une fonction qui alloue une copie triée du tableau, déclare tab_in const dans la seconde fonction.

[Melem]

Retourner un tableau:
Variables globales:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int Tableau1[10], Tableau2[10];

Fonction qui retourne un tableau:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
typedef int TABLEAU[10];
 
TABLEAU f(int num_tableau)
{
    switch(num_tableau)
    {
    case 1:
        return Tableau1;
 
    case 2:
        return Tableau2;
    }
}

Par contre si tu veux créer dynamiquement un tableau, il faut utiliser malloc() (ou calloc() ...). Tu peux créer une fonction à l'intérieur de laquelle tu crée dynamiquement un tableau:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
int * f(size_t taille_du_tableau)
{
    int * tableau;
 
    tableau = malloc(taille_du_tableau);
 
    return tableau;
}

Ensuite free() pour détruire le tableau lorsqu'on n'en aura plus besoin.

[Jean-Marc.Bourguet]

Fonction qui retourne un tableau:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
...

Et ca compile avec quel compilateur?

[kromartien]

mais je ne suis pas d'accord avec Melem. En C, on ne retourne pas un tableau. Les fonctions ne retournent qu'un élément, qui est du type explicité dans le prototype de la fonction.

En l'occurence, s'il ne s'agit que de tableaux, il est vraiment inutile et nuisible à la compréhension d'utiliser un type dédié, ou alors c'est une structure qui contient le pointeur sur le tableau et la taille du tableau, avec potentiellement en supplément un const char * qui contient le type de données, mais là, présentamment, ce genre de bidouillage à la Melem, ça fait peur.

[Melem]

J'a fais la même erreur que millie on dirait j'aurais du lire les autres posts avant

Donc vraiment pas moyen de retourner directement un tableau comme ca, il faut toujours retourner l'adresse du début du tableau, même si le tableau a été déclaré globalement.

[diogene]

Melem :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
typedef int TABLEAU[10];
TABLEAU f(int num_tableau)
{
    switch(num_tableau)
    {
    case 1:
        return Tableau1;
.....

Ici Tableau1 n'est pas du type TABLEAU mais du type int*

[DooSquare]

merci pour toutes vos réponses c'est trop sympa !!!

encore merci