malloc et réservation mémoire

Bonjour,

j'aurai besoin d'une confirmation concernant malloc, j'ai lu (sur wikipedia pour ne pas le citer) que malloc réserve une zone mémoire de x caractères.

Il faut ensuite la libérer avec la commande free.

J'ai fais la conclusion que si je passe un pointeur dans une fonction, puis que je fais un malloc sur ce pointeur. La mémoire est réservé tant que je ne fais pas de free, donc je peux utiliser mon pointeur comme il me sied dans ma méthode main ?

J'ai juste ?

normalement l'allocation se fait dans la fonction meme. (meilleur lisibilité)

admettons que tu sois dans la fonction main:

Code:

---

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

int main() { int *memoire = NULL;   memoire = malloc(sizeof(int)); // tu alloues la mémoire de la taille d'un int.   if (memoire == NULL) // si l'allocation à échoué exit (0); else ... //suite du programme   free(memoire); // Lorsqu'on a plus besoin de la mémoire, on la libère   return (0); }

---

C'est plus propre de le faire avant ou sinon ça marche pas ?

Car il me semblait mieux de m'assurer que le tableau allouer soit de la bonne taille.

donc en gros ça ferait :

Code:

---

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

main(..) { int *tab; fonction(tab); }   void fonction(int * tab) { tab = malloc(100); // traitement }

---

et une autre question dont j'arrive pas à trouver une réponse récente, quelle est la taille maximal d'un tableau ? Donc :

Code:

---

1 2 3

int tab[x] = ... //x max =

---

merci

c'est bon mais il est plus logique (pour moi) de connaitre la taille du tableau avant de le passer dans une fonction.

La taille du tableaux maximum varie. Mais généralement c'est toi qui définie cette taille maximum.

Code:

---

1 2 3

#define MAX 5 int tab[MAX] = {1,2,3,4,5};

---

De toute façon si tu dépasses cette taille maximum. tu seras alerté par un message du type segmentation fault ou autre

Citation:

---

Envoyé par manticore

C'est plus propre de le faire avant ou sinon ça marche pas ?

Car il me semblait mieux de m'assurer que le tableau allouer soit de la bonne taille.

donc en gros ça ferait :

Code:

---

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

main(..) { int *tab; fonction(tab); }   void fonction(int * tab) { tab = malloc(100); // traitement }

---

---

Pourquoi passer un pointeur en argument pour écraser sa valeur ?

Donc il est mieux de définir la taille du tableau avant, je vais le faire ainsi, j'imaginais qu'il était plus sûr de contrôler le malloc à l'intérieur de la fonction, surtout si l'on passe cette fonction à quelqu'un d'autre.

Par contre si je fais un malloc dans une fonction, la case mémoire est conservé jusqu'à un free ? Où je ne peux pas utiliser cette variable dans mon "main" ?

Merci de votre aide

oui tant que tu n'as pas free la zone mémoire est allouée.

et tu free quand tu n'as plus besoin de la zone mémoire allouée.
attention de free au bon endroit.

tu pourrais glibc ...

Un grand merci pour vos réponses si rapides, donc l'erreur que je cherche ne vient pas de la ;)

Citation:

---

Envoyé par manticore

donc en gros ça ferait :

Code:

---

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

main(..) { int *tab; fonction(tab); }   void fonction(int * tab) { tab = malloc(100); // traitement }

---

---

Ceci est faux.
L'appel à la fonction fonction() ne peux pas modifier le tab de main() qui restera de valeur indéterminée : le tab de fonction() n'est qu'une copie du tab de main().

Tu dois procéder de l'une de ces deux façons (en excluant évidemment l'usage de globales) :

Code:

---

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

main(..) { int *tab = fonction(); }   int * fonction(void) { int *tab = malloc(100); // traitement return tab; }

---

ou

Code:

---

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

main(..) { int *tab; fonction(&tab); }   void fonction(int ** tab) { *tab = malloc(100); // traitement }

---

Merci de cette correction, donc l'erreur vient probablement de la ;)

Donc malloc reécrit sur le pointeur qui est une copie de l'adresse. Donc l'adresse change...

Merci encore

Citation:

---

Donc malloc reécrit sur le pointeur qui est une copie de l'adresse. Donc l'adresse change...

---

malloc ne fait "que" allouer de la mémoire dynamique et retourner son adresse.
Le problème dans ton code, c'était que tu assignais cette valeur (l'adresse retournée par malloc) à un pointeur local à ta fonction, ce qui avait trois conséquences :
* la valeur était perdue à la fin de cette fonction
* cela provoque une fuite de mémoire
* le pointeur dans la fonction appelante ne peut pas être modifié

D'où les deux solutions au choix proposées par diogene :
* Soit la fonction appelée retourne l'adresse retournée par malloc, ce qui permet de l'assigner directement au pointeur de la fonction appelante.
* Soit la valeur est modifiée via un pointeur de pointeur. Et pour cela, il faut donc passer à la fonction appelée non pas la valeur du pointeur mais son adresse, afin que sa valeur puisse être modifiée par la fonction appelée.