FAQ CConsultez toutes les FAQ

Nombre d'auteurs : 27, nombre de questions : 175, dernière mise à jour : 17 décembre 2010  Ajouter une question

 

Cette FAQ a été réalisée à partir des questions fréquemment posées sur les forums de www.developpez.com et de l'expérience personnelle des auteurs.

Je tiens à souligner que cette FAQ ne garantit en aucun cas que les informations qu'elle propose sont correctes ; les auteurs font le maximum, mais l'erreur est humaine. Cette FAQ ne prétend pas non plus être complète. Si vous trouvez une erreur, ou que vous souhaitez devenir rédacteur, lisez ceci .

Sur ce, je vous souhaite une bonne lecture.


SommairePointeurs, tableaux et chaînes de caractèresL'allocation dynamique de mémoire (5)
précédent sommaire suivant
 

Il faut toujours libérer les ressources que l'on a allouées. chaque malloc ou calloc doit correspondre un et un seul free.

Certains systèmes libèrent automatiquement de telles ressources à la fin de l'exécution du programme. Toutefois ce comportement n'est pas garanti et la libération, si elle a lieu, est faite uniquement lors de l'arrêt du programme, il convient donc de ne pas compter sur cet effet de bord et libérer soi-même les différentes ressources allouées.

Mis à jour le 2 mars 2003 gl LFE

Si la mémoire a été allouée avec malloc, elle contient… n'importe quoi. En effet, malloc ne fait qu'allouer de la mémoire, mais ne l'initialise pas. Pour initialiser la zone mémoire, on peut utiliser calloc qui remplit la mémoire allouée de 0. On peut aussi l'initialiser soi-même mais le résultat est le même.

Code C :
1
2
3
4
5
6
7
8
9
10
11
12
#include <stdlib.h> 
#include <string.h> 
  
... 
  
char * p = malloc(16); /* allocation d'une mémoire de 16 octets */ 
if (p != NULL) 
{ 
    memset(p, 0x00, 16); /* initialisation de la mémoire allouée */ 
    ... 
    free(p); 
}
Ou :

Code C :
1
2
3
4
5
6
7
8
9
10
#include <stdlib.h> 
  
... 
  
char * p = calloc(16, sizeof(char)); /* allocation d'une mémoire initialisée (16 octets) */ 
if (p != NULL) 
{ 
    ... 
    free(p); 
}

Mis à jour le 1er février 2003 gl LFE PRomu@ld

Le pointeur reste inchangé (en effet il est passé par valeur à free) mais la mémoire qu'il pointe ne doit plus être utilisée par le programme (on dit que la mémoire a été « libérée »).

Une bonne habitude à prendre est de mettre tout pointeur libre à NULL :

Code C :
1
2
3
4
5
6
7
8
9
char * p = malloc(10); 
  
... 
  
free(p); 
  
/* p ne sert plus a rien (pour le moment ...), mettons-le à NULL */ 
  
p = NULL;
Ce qui provoque, en cas d'accès à p, une erreur systématique qui est plus simple à corriger qu'un programme au comportement erratique.

Mis à jour le 1er février 2003 gl LFE

Il n'existe pas en C de fonction permettant de connaître la taille d'un tableau alloué dynamiquement, il faut donc impérativement conserver la taille de chaque tableau alloué. Une implémentation particulière peut cependant fournir une fonction permettant d'obtenir cette information (la fonction _msize sous Windows par exemple).

Mis à jour le 20 septembre 2004 gl haypo

Si on désire allouer un tableau de N * M élements, il y a deux méthodes possibles :

- On alloue un tableau de N pointeurs vers des tableaux de M éléments chacun.

Code C :
1
2
3
4
5
6
/* On veut avoir int * tab[N], sauf que tab sera créé dynamiquement */ 
  
int ** tab = malloc(N * sizeof(int *)); 
/* On crée maintenant les N tableaux de M éléments chacun */ 
for(i = 0; i < N; i++) 
    tab[i] = malloc(M * sizeof(int));
En fait, cette méthode ne crée pas vraiment un tableau de N * M entiers mais un tableau de N pointeurs, chaque pointeur pointant vers un tableau de M entiers. L'avantage, c'est que l'accès à un "élément" de ce tableau se fait comme si le tableau était réellement un tableau « à deux dimensions » : tab[j][i] = ...;. L'inconvénient, c'est qu'elle est plus difficile à mettre en œuvre par rapport à l'autre méthode.

- On alloue réellement un tableau de N * M éléments.

Code C :
int * tab = malloc(N * M * sizeof(int));
L'avantage, c'est que c'est simple à mettre en œuvre. L'inconvénient, c'est que l'accès à un élément du tableau ne se fait pas aussi aisément qu'avec l'autre méthode : tab[M * j + i] = ...;.

Mis à jour le 1er février 2003 LFE

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2014 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

 
 
 
 
Partenaires

PlanetHoster
Ikoula