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) ) ;
}