Discussion :

[manticore]

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 ?

[florianjoy54]

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

admettons que tu sois dans la fonction main:

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

[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 :

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

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 :

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

1
2
3
 
int tab[x] = ...
//x max =

merci

[florianjoy54]

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 :

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

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

[jeroman]

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 :

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

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 ?

[manticore]

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

[florianjoy54]

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 ...

[diogene]

donc en gros ça ferait :

Code :

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

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 :

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

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 :

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

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 
}

[manticore]

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

[jeroman]

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.