Comment gérer la mémoire?
Allocation sur la pile
Lorsque l'on a affaire à des constantes, ou des variables bien définies et fixées en terme de taille, et a usage local seulement, l'allocation sur la pile est appropriée.
Allocation dynamique
Lorsque les variables ont des tailles non fixées ou encore ne sont pas à usage local, il est sûr d'utiliser l'allocation dynamique.
Manipulation dynamique de la mémoire
Allocation de la mémoire: malloc()
Prototype:
#include <stdlib.h>
void *malloc(size_t size);
Comportement:
Malloc prend en argument la taille de la zone mémoire désirée et retourne le pointeur sur la zone allouée ou 0 (pointeur nul) s'il n'y a pas assez d'espace mémoire contigu.
Une zone mémoire fraichement allouée par malloc n'est a priori pas initialisée et peut contenir n'importe quoi (données aléatoires provenant d'anciennes applications ayant utilisé le même espace, ou données aléatoires).
Il est donc nécessaire de l'initialiser avec des valeurs appropriées (par exemple 0) en fonction du type de donées à inserer dans ces zones allouées et / ou en fonction des règles de programmation utilisées. On pourra initialiser l'ensemble de la zone avec la fonction memset(), recopier des zones existantes avec memcpy(), ou encore initialiser les blocs en fonction de leur découpage (types, structures, tableaux, ...).
A retenir:
|
la fonction calloc()
Prototype :
#include <stdlib.h>
void *calloc(size_t nmemb, size_t size);
Comportement :
A la différence de malloc(), calloc() alloue un tableau de nmemb élements ayant chacun size pour taille. La mémoire allouée est initialisée à 0.
Pour le reste, calloc() fonctionne comme malloc(): si la mémoire a bien été réservée et initialisée, calloc() retourne le pointeur sur la zone. Sinon, calloc() returne 0 (pointeur nul).
Désallocation de la mémoire: free()
Prototype :
#include <stdlib.h>
void free(void *ptr);
Comportement :
La fonction free() annule la réservation d'une zone de mémoire pointée par ptr, allouée par malloc() ou calloc() ou par toute autre fonction réservant de la mémoire, comme strdup() qui duplique une chaine de caractères.
Si l'on tente de libérer un espace mémoire qui n'a pas été allouée par malloc() ou calloc(), directement ou par le biais d'une fonction appelant malloc() ou calloc(), la fonction free() enverra un signal 11 (SIGSEGV « Invalid memory reference ») qui terminera brutalement le programme.
La fonction free() n'écrase pas la mémoire de la zone.
Il est fortement recommandé d'annuler le pointeur qui vient d'être libéré par free(), afin de ne pas tenter d'adresser un espace qui pourra être réutilisé. On pourra par exemple réécrire une fonction:
void *my_free(void *ptr) {
if (ptr) free(ptr);
return NULL;
}
et l'utiliser de la manière suivante:
ptr = my_free(ptr);
ou encore écrire la macro qui s'utilise de la même manière que free():
#define FREE(x) { if (x) free(x); x = NULL; }
Réallocation de la mémoire : realloc()
Prototype :
#include <stdlib.h>
void *realloc(void *ptr, size_t size);
Comportement :
La fonction realloc() prend en argument le pointeur sur la zone de mémoire (ptr) dont il faut modifier la taille, et la nouvelle taille désirée (size). Si l'opération s'est bien passée, realloc() returne le pointeur sur la zone mémoire.
Attention:
il est fort possible que le nouveau pointeur soit
différent de l'ancien! En effet, si la zone mémoire
doit être augmentée, et que la zone en cours n'est pas
assez grande pour supporter la nouvelle taille, realloc() allouera
une nouvelle zone de mémoire contigue et recopiera
complètement l'ancienne zone.
Il est donc impératif de ne pas adresser directement par un pointeur un espace mémoire dont la taille doit/peut être modifiée par realloc:
Les zones en rouge sont
des zones de mémoire occupées. La zone jaune est la
zone de mémoire que nous avons réservé et
modifié par realloc. Si nous conservons un pointeur sur la
zone avant le réalloc, ce pointeur ne sera plus utilisable
après car in adressera une zone non réservée et
contenant des données aléatoires.
Si l'opération échoue, realloc() retourne 0, mais ne déasalloue pas la zone d'origine. Il est impératif de ne pas réassigner le même pointeur immédiatement avec le résultat de realloc() au risque de perdre toutes les données en mémoire et de ne jamais pouvoir les libérer.
Ce qu'il ne faut pas faire:
ptr = realloc(ptr, newsize);
Ce qu'il faut faire:
{
void *p;
if ((p = realloc(ptr, newsize))) {
/* la réallocation s'est bien passée , l'affectation est sûre: */
ptr = p;
} else {
/* la réallocation a échoué, le processus ne peut pas
continuer mais la mémoire est encore utilisée: */
free (ptr);
}
return NULL;
}
Fonctions annexes: memset(), memcpy(), memmove()
Initialisation d'une zone memoire: memset()
Prototype:
#include <string.h>
void *memset(void *s, int c, size_t n);
Comportement:
memset() prend en argument le pointeur sur la zone allouée (s) à initialiser, la valeur à affecter à toute la zone mémoire (c), et le nombre d'octets devant subir le traitement (n).
Il est à noter que seul le premier octet de la valeur d'initialisation est pris en compte.
memset retourne le pointeur d'entrée (s).
Copie de zone mémoire : memcpy()
Prototype:
#include <string.h>
void *memcpy(void *dest, const void *src, size_t n);
Comportement:
memcpy prend en entrée le pointeur zone de mémoire allouée de destination, le poinrteur sur la zone de mémoire cible, et le nombre d'octets devant être copiés.
memcpy retourne le pointeur de destination (dest).
Attention:
- dest doit au minimum avoir de l'espace pour les n octets à copier.
- Les deux zones de mémoire ne doivent pas se chevaucher (i.e. src + n < dest ou dest + n < src).
Déplacement de zone mémoire: memmove()
Prototype:
#include <string.h>
void *memmove(void *dest, const void *src, size_t n);
Comportement:
La fonction memmove() déplace le contenu d'une zone mémoire vers une autre. Elle prend en argument le pointeur vers la zone mémoire allouée vers laquelle déplacer le contenu mémoire (dest), le pointeur vers la zone de départ de la copie (src) et le nombre d'octets à déplacer. Elle retourne le pointeur vers la zone de destination (dest).
Contrairement à memcpy(), il est possible que les 2 zones se supperposent.
Gestion des chaines de caractères:
La manipulation de chaines de caractères est une source de nombreux problèmes dont sont victime autant les programmeurs débutants que les chevronnés. Ces quelques lignes permettrons peut être à certains d'éviter quelques écueils.
Rappels
Une chaine de caractères est un tableau d'octets terminé par un octet nul (ou caractère nul = 0 = '\0').
Si l'on veut réserver la mémoire pour la chaine « bonjour, monde », il est nécessaire de penser que cette chaine doit en fait s'écrire « bonjour, monde\0 » et réserver l'espace en conséquence.
La fonction strlen() retourne la taille d'une chaine de caractère sans son terminateur.
L'indexe d'un tableau commence toujours par 0 et non par 1. Aussi, lorsque l'on réserve 50 chars pour une chaine, le caractère nul devra se trouver au plus à l'index 49.
Certaines fonctions nécessitent une attention toute particulière:
strcpy()
Prototype:
#include <string.h>
char *strcpy(char *dest, const char *src);
Comportement:
La fonction strcpy recopie le contenu de la chaine src vers la chaine allouée pointée par dest et retourne le pointeur vers la chaine de destination (le caractère nul est inclus dans la copie).
Mais attention: il est
nécessaire au préalable de s'être assuré
que la taille réservé dans dest est supérieure
ou égale à la taille de la chaine pointée par
src.
Si ce n'est pas le cas, nous risquons d'avoir un écrasement
d'une zone mémoire.
Cet écrasement peut modifier des
données stockées sur la pile, ou pire, écraser
une partie du programme lui même puisque la définition
de la pile précède le code dans la mémoire.
Ce défaut est la base de la technique de piratage la plus
répendue: le pirate fournit au programme une chaine assez
longue pour empiéter sur le code de la fonction et contient un
autre code au format binaire qui sera exécuté au lieu
du code de la fonction (voir Linux Mag # ...)
strncpy()
Prototype:
#include <string.h>
char *strncpy(char *dest, const char *src, size_t n);
Comportement:
strncpy() prend les mêmes arguments que strcpy() plus n, le nombre maximal d'octets à recopier.
Mais, là encore, attention car strncpy() recopie au plus n caractères sans pour autant tester que le dernier caractère copié est bien NULL. Il est donc nécessaire de s'assurer après un strncpy() que le dernier caractère est bien nul:
char* mystrncpy(char *dest, char *src, size_t n) {
if (!dest) return 0;
if (!src || n <= 1) return *dest = 0;
strncpy(dest, src, n);
dest[n - 1] = 0;
return dest;
}
strcat()
Prototype:
#include <string.h>
char *strcat(char *dest, const char *src);
Comportement:
strcat ajoute à la chaine dest la chaine src. Il est nécessaire d'être sûr d'avoir réservé assez de place dans la chaine dest pour recevoir la chaine src en plus de son contenu. De même que pour strncpy, il existe une variation permettant de limiter la longueur de la chaine globale:
char *strncat(char *dest, const char *src, size_t n)
strncat() ne recopie que les n premiers octets de src à la fin de dest et ajoute 0 à la fin, 0 n'étant pas pris en compte dans n.
Pour ne pas faire de débordement mémoire, il faut donc que n soit égal à la taille réservée de dest, diminué de strlen(dest) et encore diminué de 1 pour le caractère nul final.
sprintf() et snprintf()
Prototype
#include <stdio.h>
int sprintf(char *str, const char *format, ...);
Comportement
Cette fonction « imprime » remplit une chaine de caractères allouée (str) à partir d'un format (format) et, eventuellement, des données (...) et retourne le nombre de caractères de la nouvelle chaine (caractère nul final non compris). Une fois encore, aucun test n'est effectué sur la taille maximale de la chaine de caractères de destination. Pour cette fonction aussi, il existe une « parade »: la fonction snprintf().
int snprintf(char *str, size_t size, const char *format, ...);
snprintf() tronque la nouvelle chaine « str » à size caractères y compris le caractère nul final. Dans le cas où la chaine str est inférieure à size, la fonction retourne la taille de str. Sinon, la taille de str est size - 1 et la fonction retourne -1.
Il existe d'autres groupes de fonctions avec des propriétés similaires, telles que strcmp et strncmp, strdup et strndup, vsprintf et vsnprintf (les équivalent de sprintf et snprintf mais dont le le dernier argument est une va_list (voir man vsprintf et man stdarg).
Règles de base
- Eviter au
maximum les variables globales et les conflits possibles sur le
nommage des variables globales:
Les variables globales constituent une fonctionnalité parfois indispensables, mais elles ont aussi de gros travers:- Elles peuvent poser des problèmes dans les programmes « réentrant »,
- Elles risquent de masquer des bugs lors de passage de paramètres,
- Elles risquent de rentrer en conflit avec d'autres variables.
- Définir ces variables de manière statique (static) afin de restreindre la portée de la variable au fichier en cours,
- Nommer ces
variables de manière à ce qu'elles aient la plus
faible probabilité de renter en conflit avec d'autres
variables. On pourra par exemple utiliser comme préfixe un
code correspondant au nom du fichier, et ajouter en début et
en fin de nom des « _ ». Cette typologie est
concise et évite d'avoir à ajouter un préfixe
de « portée sur toutes les variables (l pour local
et g pour global).
Exemple:
static int _mod_today_;
- Eviter l'allocation statique en dehors de l'utilisation locale de données
- Eviter l'allocation statique pour des tailles variables de données
- Penser au caractère nul des chaines de caractères
- Utiliser de préférence les fonctions de manipulation de chaine de caractères vérifiant la taille des chaines allouées (strncpy, strncat, strncmp, snprinf, vsnprintf, ...)
- Toujours initialiser un pointeur à 0 (NULL)
- Tester systématiquement les pointeurs après malloc
- Tester systématiquement les pointeurs passés en paramètres
- Tester que le retour de la fonction realloc n'est pas NULL
- Toujours désallouer avec free() la mémoire allouée avec malloc()
- Toujours remettre à 0 (NULL) les pointeurs déalloués par free()