Malloc dans une fonction

Salut !
Je ne comprends pas pourquoi dans ce code, la fonction allouer ne fonctionne pas :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

#include<stdio.h> #include<stdlib.h>   void allouer(int* ptr){ ptr = malloc(10*sizeof(int)); }   void ptrEstIlNull(int* ptr){ if(ptr==NULL) printf("tab est null\n"); else printf("tab n'est pas null\n"); }     int main(){ int* tab; ptrEstIlNull(tab);   allouer(tab); ptrEstIlNull(tab);   tab = malloc(10*sizeof(int)); ptrEstIlNull(tab);   return 0; }

---

Le résultat obtenu à la console est :

Code:

---

1 2 3

tab est null tab est null tab n'est pas null

---

Mais j'aurais imaginé que le résultat serait :

Code:

---

1 2 3

tab est null tab n'est pas null tab n'est pas null

---

La solution, c'est de modifier la fonction allouer pour qu'elle renvoie le pointeur. Mais la solution je m'en moque, je veux juste comprendre.

Erreur de débutant :mrgreen: ou :whistle:

Il faut passer un double pointeur, parce que sinon le pointeur retourné par malloc est mis dans la copie du pointeur (les joyeusetés du passage par copie :mouarf:)

Sinon n'oublie pas le free ;)

Édit: Un petit schéma

Pointeur simple: | tab |-> NULL / Passage de paramètre * / | ptr - copie de tab |-> X - retour de la fonction malloc.
Double Pointeur: | tab |-> NULL / Passage de paramètre ** / | ptr | -> | tab |-> X - retour de la fonction malloc.

Ah d'accord. Je trouvais ça compliqué d'utiliser un double pointeur juste pour faire un simple malloc. C'est limite contre-intuitif.
Déjà que les pointeurs, ça se comprend pas tout de suite, alors les double pointeurs... :weird:

J'ai modifié le code et ça donne ça :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

#include<stdio.h> #include<stdlib.h>   void allouer(int** ptr){ (*ptr) = malloc(10*sizeof(int)); }   void ptrEstIlNull(int* ptr){ if(ptr==NULL) printf("tab est null\n"); else printf("tab n'est pas null\n"); }     int main(){ int* tab; ptrEstIlNull(tab);   allouer(&tab); ptrEstIlNull(tab);   tab = malloc(10*sizeof(int)); ptrEstIlNull(tab);   free(tab); return 0; }

---

Il te manque un free à la ligne 22 ;)

Oh tu m'embêtes, c'était juste pour l'exemple.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

#include<stdio.h> #include<stdlib.h>   void allouer(int** ptr){ (*ptr) = malloc(10*sizeof(int)); }   void ptrEstIlNull(int* ptr){ if(ptr==NULL) printf("tab est null\n"); else printf("tab n'est pas null\n"); }     int main(){ int* tab; ptrEstIlNull(tab);   allouer(&tab); ptrEstIlNull(tab); free(tab);   tab = malloc(10*sizeof(int)); ptrEstIlNull(tab); free(tab);   return 0; }

---

C'est pour ton bien. :lol:

Bonjour

Citation:

---

Envoyé par corent2

Oh tu m'embêtes, c'était juste pour l'exemple.

---

Ce qui a été dit est pour ton bien, mais si tu comptes ne pas utiliser les doubles pointeurs, tu peux toujours écrire une fonction qui te retourne un pointeur sur la zone qui a été allouer exemple

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

int *f_AllocPtr( size_t size ){   int *ptr = NULL; size = ( size <= 0 ? 10 : size ); ptr = (int*)malloc( size *sizeof(int) ); if( ptr == NULL ){ fprintf(stderr, "Erreur d'allocation\n" ); exit( EXIT_FAILURE ); } return( ptr ); } int *f_Alloc2Ptr( size_t size ){   int *ptr = NULL; size = ( size <= 0 ? 10 : size ); ptr = (int*)calloc( size, sizeof(int) ); if( ptr == NULL ){ fprintf(stderr, "Erreur Allocation\n" ); exit( EXIT_FAILURE ); } return ( ptr ); }

---

à bientôt

Pourquoi caster le retour de malloc()? Tu n'as pas besoin de le faire.

Si ça ne compile pas sans le cast, c'est que tu as fait une erreur ailleurs (oubli d'inclusion, compilation du code C par un compilateur C++, etc.)

Bonjour
Désolé pour ma réponse tardive.
Par habitude, je fais une conversion afin de convertir le pointeur retourné par ces deux fonctions (void*) dans le type de l'objet.
à bientôt

En C, la conversion implicite suffit. Et la conversion explicite n'est plus recommandée par les inventeurs du langage depuis l'errata du nouveau testament K&R2.

Bonjour,

Je sais que tu vas dire qu'on est tatillon, mais :

Citation:

---

Envoyé par corent2

Le résultat obtenu à la console est :

Code:

---

1 2 3

tab est null tab est null tab n'est pas null

---

Mais j'aurais imaginé que le résultat serait :

Code:

---

1 2 3

tab est null tab n'est pas null tab n'est pas null

---

---

Le résultat auquel tu aurais dû t'attendre est :

Code:

---

1 2 3

tab n'est pas null tab n'est pas null tab n'est pas null

---

En effet, lorsque tu écris int * tab;, tu déclares bien un pointeur "tab" sur un int, mais tu ne l'initialises pas, et il n'y a donc aucune raison qu'il vaille NULL plus qu'autre chose. A ce stade, ton pointeur vaut "quelque chose", et pointe sur une zone que tu n'as pas allouée, et donc dans laquelle tu n'as pas le droit d'écrire.

Si je reprends ton code :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

#include<stdio.h> #include<stdlib.h> void allouer(int** ptr){ (*ptr) = malloc(10*sizeof(int)); } void ptrEstIlNull(int* ptr){ if(ptr==NULL) printf("tab est null\n"); else printf("tab n'est pas null\n"); } int main(){ int* tab; /* Initialisations */ tab = NULL; ptrEstIlNull(tab); allouer(&tab); /* Tu ne traites pas le cas où l'allocation échoue, ce qui peut faire crasher ton programme */ ptrEstIlNull(tab); free(tab); /* Non symétrique : tu as une fonction pour allouer, mais pas pour désallouer, ce qui n'est pas une bonne habitude */ tab = malloc(10*sizeof(int)); ptrEstIlNull(tab); free(tab); return 0; }

---