Discussion :

[shirohige]

Bonjour,

Je voudrais savoir se qu'il se passe lorsque l'on malloc. Je sais que l'orsque l'on malloc il y à une limite et que l'on repousse cette limite en malloquant. J'ai un peu de mal à visialiser la chose.

Pour l'exemple d'un char**, si je voulais malloc une grille pour un tetris, ce que je faisais était:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
char **tab;
int i = 0;
 
tab = malloc(20*sizeof(char*));
while (i < 20)
{
  tab[i] = malloc(10*sizeof(char));
  i++;
}

Et si je dois free:

Code :

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

1
2
3
4
 
while (i < 20)
 free(tab[i++]);
free(tab);

Le problème c'est que les "mini" malloc, ce de ma boucle sont, selon moi, des adresse à l'intérieur de mon adresse renvoyé par le gros malloc. Donc si je free le gros malloc je devrait aussi free ce à l'intérieur de celui-ci.

Merci de bien vouloir m'expliquer la chose.

[Obsidian]

Bonsoir,

Bonjour, Je voudrais savoir se qu'il se passe lorsque l'on malloc. Je sais que l'orsque l'on malloc il y à une limite et que l'on repousse cette limite en malloquant. J'ai un peu de mal à visialiser la chose.

« malloc » signifie simplement « memory allocation » et sert uniquement à allouer n octets de mémoire consécutifs. Cette fonction te renvoie alors un pointeur qui t'indique où se trouve la mémoire que tu as réclamée.

La seule véritable raison, au moins au départ, qui oblige le programme à faire cela est permettre au système de tenir à jour la liste des applications qui utilisent la mémoire (même s'il n'y en a qu'une seule) pour éviter qu'elles se marchent dessus et que lui-même n'utilise que de la mémoire réputée libre.

Pour l'exemple d'un char**, si je voulais malloc une grille pour un tetris, ce que je faisais était:

Code :

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

1
2
3
4
5
6
7
8
9
char **tab;
int i = 0;
 
tab = malloc(20*sizeof(char*));
while (i < 20)
{
  tab[i] = malloc(10*sizeof(char));
  i++;
}

Ton premier malloc alloue de la place pour vingt pointeurs qui — eux — ne vont servir qu'à recevoir les adresses renvoyées par tes mallocs suivants. Tu aurais pu tout aussi bien déclarer un tableau avec « char * tab[20] ». Ils se seraient alors automatiquement retrouvés dans la pile et tu n'aurais pas eu besoin du tout du premier malloc.

On alloue des pointeurs de la sorte dans deux cas :

• Soit tu ne connais pas à l'avance (comprendre : à la compilation) le nombre de pointeurs dont tu as besoin. Tu peux cependant recourir aux VLA mais ils n'existent que depuis C99 ;
• Soit tu as besoin d'un très grand nombre de pointeurs et dans ce cas, il faut passer par un appel au système lui demandant explicitement de mobiliser une grande partie de la mémoire et de s'organiser en conséquence. Autrement, toutes les variables locales que tu déclares vont automatiquement dans la pile qu'il faut s'efforcer de solliciter le moins possible. C'est une sorte de « facilité de caisse » qui est utilisé par toutes les ressources de ton programme, qui plante en cas de dépassement.

Et si je dois free:

Code :

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

1
2
3
4
 
while (i < 20)
 free(tab[i++]);
free(tab);

Le problème c'est que les "mini" malloc, ce de ma boucle sont, selon moi, des adresse à l'intérieur de mon adresse renvoyé par le gros malloc. Donc si je free le gros malloc je devrait aussi free ce à l'intérieur de celui-ci.

Non, car les différents appels à malloc sont complètement indépendants entre eux : tu as le droit de réclamer une première page de mémoire puis, plus tard, une seconde sans avoir à libérer la première. Il y a d'ailleurs des chances que le système la place complètement ailleurs en mémoire. Et comme dit juste au dessus, les pointeurs que tu as alloués ne sont là que pour recevoir le résultat de malloc. Il n'y a donc aucune notion d'imbrication à ce niveau.

Si tu libères les pointeurs en premier, tu perds l'information qu'ils contiennent. Et si tu n'as pas demandé au système de libérer ce qu'ils pointent auparavant, il n'y a aucune raison pour qu'il le fasse avant la fin du programme. Cela s'appelle une « fuite de mémoire » parce que si tu continues à en allouer d'autres au cours de son exécution, tu vas finir par l'épuiser entièrement.

[jouana]

Bonsoir,

Alors un malloc te permet d'allouer de la mémoire ou de réserver de la mémoire.

Dans ton tu as un pointeur de pointeur.

Un pointeur est une variable qui contient une adresse.

En gros imagine une tableau avec des case, l'adresse et en gros la coordonnée de ta case.

Maintenant si ont reprends ton code

Code :

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

1
2
 
tab = malloc(20*sizeof(char*));

la tu alloue un tableau de 20 case si tu fait tab[0] tu regarde dans la première case.
quand tu fait ça tu va voir ce qui est contenu dans la première cas et la sur un char** tu vas encore tomber sur une adresse mémoire ou rien si il n'y a eu aucune allocation

Code :

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

1
2
3
4
5
6
 
while (i < 20)
{
  tab[i] = malloc(10*sizeof(char));
  i++;
}

La tu parcours le premier niveau pour venir allouer un tableau de 10 case maintenant qui va contenir des caractères.
Ensuite pour parcourir ces tableaux le principe reste le même.

Le malloc lui te réserve un bout de mémoire équivalent à la taille du type fois le nombre de case que tu désire.

En gros le coup du tableau c'est pour t'aider a visualiser la chose en esperant que ça ne te perd pas

Le gros malloc en gros initialise le premier niveau et les petits malloc initialise ce qui est à l'intérieur.

Bonne soirée

[shirohige]

Ok, merci pour vos réponses c'est claire maintenant.