passer un tableau issu d'un malloc a une fonction

Salut !

Sauriez vous (je n'en doute pas :p) comment passer un tableau issu d'un malloc a une fonction ? (et utilisable come tel dedans)

merci beaucoup, ++ Tix.

Typiquement, on le passe en tant que pointeur_vers_le_premier_élément + taille_en_elements.

EDIT: ok, j'ai rien dit, voir juste au-dessus et juste en-dessous :oops:

Qu'est-ce qu'un tableau ?
Un tableau est un pointeur constant pointant sur le premier élément du tableau. Donc tout ce que tu as à faire, c'est passer le tableau tel quel, sans autre modification:

Code:

---

1 2 3 4 5 6 7 8 9 10

/* Fonction utilisant le tableau */ void foo(int* tab) { tab[0] = 3; /* Exemple d'utilisation du tableau */ }   /* Appel de la fonction */ int* tab = malloc(sizeof(int)*taille); foo(tab);

---

Perdu.
Un tableau est un tableau. Mais il y a une conversion implicite entre un tableau et un pointeur vers son premier élément.
Et tu n'as pas passé la taille.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

/* Fonction utilisant le tableau */ void foo(int* tab, size_t taille) { size_t i; for(i=0 ; i<taille ; i++) { tab[i] = 42; } }   /* Allocation */ int* tab = malloc(sizeof(*tab) * taille_voulue); /* Ici, tab est un pointeur vers le premier élément tu tableau.   Mais tab N'EST PAS un tableau, ni un pointeur sur tableau! */   foo(tab, taille_voulue);

---

Code:

---

int t[10];

---

Déclare un tableau de 10 entiers : t
Les 10 éléments de ce tableau sont : t[0], t[1], ... t[9]

t, t tout court, pointe sur le premier élément du tableau (t :mouarf: ) à savoir : t[0]. Autrement dit : t <=> &(t[0]). t est donc un pointeur, mais un pointeur constant et pour être plus précis un pointeur constant vers t[0]. De même : t + 1 <=> &(t[1]) et ainsi de suite.

Donc pour passer un taleau en argument d'une fonction, pour retourner un tableau, etc. on passe (ou retourne ...) simplement un pointeur sur le premier élément.

Remarques :
Etant donné un tableau t, sizeof(t) vaut le nombre d'éléments du tableau * la taille d'un élément. Donc pour connaître le nombre d'éléments de t on peut faire par exemple :

Code:

---

sizeof(t)/sizeof(t[0])

---

. Cependant ...

Code:

---

1 2 3 4 5

size_t Taille(int * p) { return sizeof(p); }

---

Taille(t) ne retournera pas sizeof(t) mais ... sizeof(int *). En effet p est une variable locale à Taille qui est de type int *. Donc fais gaffe.

Code:

---

1 2	void TraiterTableau(int * p, size_t taille);

---

Citation:

---

Envoyé par Melem

Code:

---

int t[10];

---

Déclare un tableau de 10 entiers : t
Les 10 éléments de ce tableau sont : t[0], t[1], ... t[9]

---

Oui.

Citation:

---

t, t tout court, pointe sur le premier élément du tableau (t :mouarf: ) à savoir : t[0]. Autrement dit : t <=> &(t[0]). t est donc un pointeur, mais un pointeur constant et pour être plus précis un pointeur constant vers t[0]. De même : t + 1 <=> &(t[1]) et ainsi de suite.

---

Non : t n'est pas un "pointeur constant", et n'a pas le type pointeur. t est un tableau et possède le type "tableau de 10 int", c'est tout.
Néanmoins, t est implicitement convertible en pointeur vers son premier élément.

Cela est mis en évidence par du code ainsi fait:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

void UneFonction(int (*pTab)[10]) { } void UneAutreFonction(int **pTab) { } void TestArray3(void) { int tab[10]; UneFonction(&tab); UneAutreFonction(&tab); /* ne compile pas. */ }

---

Le reste est OK.

merci beaucoup !