Le langage C nous permet de définir des variables comme suit :
// Une variable déclarée à l'intérieur d'une fonction est généralement stockée sur la pile.
int a = 42;
// Une variable déclarée avec `static` ou au niveau du fichier est généralement stockée dans `.data`
// ou `.rodata`.
static int b = 2026;
Le stockage de ces variables est géré automatiquement par le langage lui-même. Cependant, il nous arrive de devoir gérer la mémoire manuellement. Dans ce cas, nous pouvons obtenir de la mémoire allouée dynamiquement à l’aide de fonctions telles que malloc(), calloc() et realloc().
// La mémoire allouée dynamiquement provient généralement du tas.
int *c = malloc(sizeof *c);
*c = 42;
Lorsque la mémoire n’est plus nécessaire, nous la libérons à l’aide de free().
free(c);
Cela nous permet d’allouer et de libérer de la mémoire avec souplesse, et ainsi d’implémenter toutes sortes de structures de données complexes et, par conséquent, de réaliser de nombreuses choses qui seraient difficiles, voire impossibles, avec uniquement de la mémoire allouée statiquement.
Cependant, cette approche introduit également un problème.
Considérons le scénario suivant :
int *a = malloc(sizeof *a);
int *b = a;
Qui est responsable de la libération de la mémoire ?
Il est évident que laisser cette allocation sans la libérer n’est pas une solution, car cela provoquerait une fuite de mémoire. La libérer à l’aide des deux pointeurs ne l’est pas davantage, car cela entraînerait un comportement indéfini selon la norme ISO/IEC 9899, communément appelé double libération.
Nous devons libérer la mémoire au moyen d’un seul de ces pointeurs. Mais comment déterminer lequel ? Cela nous amène à un concept important de la gestion de la mémoire et, plus généralement, de la gestion des ressources : la propriété.
Propriété, emprunt et transfert
La propriété est un contrat qui précise quelle partie d’un programme est responsable de la gestion d’une ressource et de sa libération lorsqu’elle n’est plus nécessaire. Nous disons qu’un pointeur possède la mémoire lorsqu’il est désigné comme responsable de sa libération à l’aide de free().
Pour expliquer comment la propriété nous aide à gérer correctement les ressources, implémentons une liste chaînée. Commençons par définir la structure suivante :
typedef struct N
{
int data;
struct N *previous;
struct N *next;
} Node;
Nous utilisons previous == NULL pour désigner le nœud sentinelle (dont le membre data n’a aucune signification), et next == NULL pour désigner le dernier élément de la liste chaînée.
Supposons que nous ayons une variable Node définie au niveau du fichier et que nous l’utilisions comme nœud sentinelle :
Node l = {0, NULL, NULL};
Nous avons besoin de quelques fonctions pour manipuler cette liste chaînée.
Définissons les fonctions suivantes :
Node *getNode(Node *guard, int index)
{
if (index < 0)
return NULL; // L'indice est négatif.
else if (index > 0 && guard->next == NULL)
return NULL; // L'indice est hors limites.
else if (index == 0)
return guard->next;
else return getNode(guard->next, index - 1);
}
void setData(Node *x, int data)
{
x->data = data;
}
int getData(Node *x)
{
return x->data;
}
Voici quelques instructions de notre fonction main() :
/* ... */
Node *a = malloc(sizeof *a);
a->previous = NULL;
a->next = NULL;
setData(a, 42);
printf("%d\n", getData(a));
/* ... */
Qui est responsable de la libération de la mémoire pointée par a après les appels à setData() et getData() ? Évidemment, cette responsabilité incombe toujours à a. Les fonctions setData() et getData() ne font que lire ou modifier la mémoire qui leur est transmise par leurs paramètres ; elles n’allouent ni ne libèrent de mémoire. Elles ne transmettent pas non plus les pointeurs à d’autres fonctions ou à des variables globales qui se chargeraient également de gérer cette mémoire. Nous disons donc que ces fonctions empruntent la mémoire au lieu d’en prendre la propriété.
L’emprunt signifie qu’une fonction accède à une ressource sans prendre la responsabilité de sa durée de vie. Selon le contrat de l’interface, la fonction peut lire ou modifier cette ressource, mais elle ne doit pas la libérer elle-même.
Il en va de même pour getNode() : cette fonction parcourt la liste chaînée et récupère un nœud en fonction de son indice. Elle n’alloue ni ne libère de mémoire et ne transfère pas non plus la propriété d’une ressource.
Cependant, ce n’est pas toujours le cas. Considérons les fonctions suivantes :
Node *createNode(int data)
{
Node *ans = malloc(sizeof *ans);
if (! ans)
exit(EXIT_FAILURE);
ans->data = data;
ans->previous = NULL;
ans->next = NULL;
return ans;
}
int insertNode(Node *guard, Node *n, int index)
{
if (index < 0)
return 1; // L'indice est négatif.
else if (index > 0 && guard->next == NULL)
return 2; // L'indice est hors limites.
else if (index == 0)
{
if (guard->next)
{
n->next = guard->next;
guard->next->previous = n;
}
n->previous = guard;
guard->next = n;
return 0;
}
else return insertNode(guard->next, n, index - 1);
}
Nous pouvons maintenant passer a à insertNode() afin d’insérer le nœud que nous avons alloué dans la liste chaînée :
/* ... */
insertNode(&l, a, 0);
/* ... */
Que se passe-t-il maintenant ?
Évidemment, nous ne devons plus appeler free() sur a après un appel réussi à insertNode(), car cela endommagerait la liste chaînée. Le nœud doit plutôt être libéré lorsque nous détruisons la liste chaînée :
void destroyExceptGuard(Node *guard)
{
if (guard == NULL)
return;
Node *current = guard->next;
guard->next = NULL;
while (current != NULL)
{
Node *next = current->next;
free(current);
current = next;
}
}
Lorsque insertNode() insère un nœud avec succès, la propriété de ce nœud est transférée de l’appelant à la liste chaînée. La fonction effectue ce transfert, mais c’est la liste chaînée qui devient responsable du nœud après son insertion.
La fonction createNode() fait l’inverse : elle alloue de la mémoire et renvoie un pointeur vers celle-ci. Une fois la fonction terminée, elle n’est plus responsable de la libération de cette mémoire. Cette responsabilité revient à l’appelant, qui reçoit le pointeur renvoyé. Nous disons que la fonction transfère la propriété à l’appelant.
Durées de vie — Combien de temps une ressource doit-elle vivre ?
Être propriétaire signifie que le propriétaire est responsable non seulement de libérer la mémoire, mais aussi de décider quand le faire. Autrement dit, le propriétaire détermine la durée de vie de la ressource.
Plus généralement, la propriété est un contrat de programmation qui établit quelle partie d’un programme est responsable de la gestion de la durée de vie d’une ressource et, en particulier, de sa libération lorsqu’elle n’est plus nécessaire. Un pointeur peut désigner une ressource sans en être propriétaire, et plusieurs pointeurs peuvent désigner la même ressource.
En C, la durée de vie d’un objet dans de la mémoire allouée est gérée à l’aide de free() et d’autres fonctions susceptibles de modifier l’allocation. L’objet existe à partir du moment où il est alloué, jusqu’à ce que l’une de ces fonctions soit appelée sur cette allocation.
Examinons à nouveau notre nœud de liste chaînée :
typedef struct N
{
int data;
struct N *previous;
struct N *next;
} Node;
Une liste chaînée complète et bien formée doit contenir un nœud sentinelle et des nœuds représentant les éléments, reliés correctement les uns aux autres par leurs pointeurs. Si un nœud est libéré sans que les pointeurs concernés soient d’abord mis à jour, les nœuds voisins peuvent conserver des valeurs de pointeur qui désignent un objet dont la durée de vie a pris fin. Ces pointeurs ne doivent pas être utilisés. Par conséquent, parcourir la liste chaînée en suivant ces relations peut entraîner un comportement indéfini. De plus, les nœuds situés après le nœud détruit peuvent devenir inaccessibles lors d’un parcours à partir du nœud sentinelle.
Lorsque nous parlons de la durée de vie d’un pointeur, nous faisons généralement référence à la durée de vie de l’objet qu’il désigne, plutôt qu’à celle de la variable pointeur elle-même. La variable pointeur possède également sa propre durée de vie, mais celle-ci est distincte et ne détermine pas la durée de vie de son référent.
Les problèmes de durée de vie ne concernent pas uniquement la mémoire allouée dynamiquement, dont nous gérons nous-mêmes la durée de vie. Par exemple, supposons que nous remplacions createNode() par l’implémentation suivante :
Node *createNode(int data)
{
Node ans;
ans.data = data;
ans.previous = NULL;
ans.next = NULL;
return &ans;
}
Cette implémentation est invalide, car la durée de vie de ans se limite à la période pendant laquelle la fonction s’exécute. Elle prend fin lorsque la fonction retourne, et le pointeur renvoyé ne désigne alors plus un objet existant.
Ajouter static à Node ans ne résoudrait pas le problème. Cela donnerait à ans une durée de vie qui s’étend sur toute l’exécution du programme, mais chaque appel de la fonction ferait référence au même objet au lieu d’en créer un nouveau.
Propriété et durées de vie dans différents langages de programmation
En C, la propriété n’est pas imposée par le langage lui-même. Il s’agit plutôt d’un contrat que les programmeurs établissent et respectent afin d’éviter les plantages et les comportements inattendus. En revanche, les durées de vie des objets sont définies par le langage lui-même.
Dans certains autres langages de programmation, la propriété est imposée par le langage lui-même. Rust en est un exemple notable : il possède un système de propriété contrôlé par son compilateur. Chaque valeur a un propriétaire, et la propriété peut être transférée entre variables au moyen de la sémantique de déplacement. Les références (&T et &mut T) permettent à d’autres parties du programme d’emprunter des valeurs sans en prendre la propriété. Les règles de durée de vie de Rust garantissent que les références empruntées ne peuvent pas survivre aux valeurs qu’elles désignent. Par exemple, String est un type propriétaire qui gère un tampon alloué dynamiquement contenant ses données textuelles, tandis que &str est une tranche de chaîne de caractères empruntée. Rust fournit également des types tels que Rc<T> et Arc<T> pour permettre la propriété partagée.
C++ utilise le principe RAII et combine la gestion automatique des ressources avec des possibilités de gestion manuelle. Nous pouvons gérer la mémoire manuellement à l’aide de new et delete, ou utiliser des pointeurs intelligents tels que std::unique_ptr<T> et std::shared_ptr<T>, fournis par la bibliothèque standard C++. Ces objets encapsulent les informations relatives à la propriété de la mémoire allouée dynamiquement, ce qui permet au langage de gérer automatiquement les ressources. Nous pouvons également implémenter nos propres pointeurs intelligents. std::unique_ptr<T> impose une propriété exclusive, de manière similaire aux contrats de propriété exclusive en C, tout en gérant automatiquement la ressource. std::shared_ptr<T> utilise un compteur pour suivre le nombre de variables qui partagent la propriété d’une ressource. Il libère automatiquement cette ressource lorsqu’aucune variable ne conserve plus la propriété partagée.
Des langages tels que Python utilisent généralement une gestion automatique de la mémoire, sans obliger les programmeurs à allouer et à libérer explicitement la mémoire. CPython, par exemple, utilise le comptage de références ainsi qu’un ramasse-miettes cyclique.