Pattern de destructeur

Fait partie de la section Programmation Orientée Objet du Journey C de Coddy. Leçon 13 sur 61.

Tout objet créé avec malloc doit finalement être libéré. Tout comme nous avons écrit une fonction create_ pour gérer l’allocation, nous écrivons une fonction free_ pour gérer le nettoyage. C’est le modèle du destructeur.

L’idée essentielle est que la libération doit s’effectuer dans l’ordre inverse de l’allocation. Si votre constructeur a d’abord alloué les membres internes, puis la structure elle-même, votre destructeur doit d’abord libérer les membres de la structure, puis la structure :

typedef struct {
    char *name;
    int age;
} Person;

void free_person(Person *p) {
    if (p == NULL) return;  // Vérification de sécurité
    free(p->name);          // Libérer d'abord le membre interne
    free(p);                // Puis libérer la structure elle-même
}

La vérification de NULL au début empêche les plantages si quelqu’un transmet accidentellement un pointeur non valide. Après avoir libéré la chaîne name interne, nous libérons la structure elle-même. Si nous libérions p en premier, nous perdrions l’accès à p->name et provoquerions une fuite de mémoire.

Utiliser le destructeur est simple :

Person *alice = create_person("Alice", 30);
// ... utilisez alice ...
free_person(alice);  // Nettoyer une fois terminé

Ce modèle garantit que toute la mémoire est correctement libérée. Sans lui, chaque objet que vous créez provoquerait une fuite de mémoire jusqu’à ce que votre programme n’en ait plus.

Défi

Facile

Construisons un module Movie qui illustre le cycle de vie complet d’un objet : sa création et sa destruction. Tu vas t’exercer à écrire une fonction destructrice qui libère correctement toute la mémoire allouée dans le bon ordre.

Tu vas créer trois fichiers :

movie.h : Déclarer une structure Movie avec deux membres : char *title (une chaîne allouée dynamiquement) et int year. Déclarer à la fois un constructeur create_movie qui prend un titre et une année, et un destructeur free_movie qui prend un pointeur vers un Movie. Utiliser des gardes d’inclusion avec le symbole MOVIE_H.
movie.c : Implémenter les deux fonctions. Ton constructeur doit allouer de la mémoire pour la structure et pour sa chaîne de titre (n’oublie pas le caractère nul terminal). Ton destructeur doit libérer la mémoire dans l’ordre inverse de l’allocation : d’abord la chaîne interne title, puis la structure elle-même. Ajouter une vérification de NULL au début de ton destructeur par sécurité.
main.c : Créer un film, afficher ses informations, puis libérer correctement la mémoire.

Tu recevras deux entrées : le titre du film (une chaîne) et l’année de sortie (un entier).

Dans ton fichier principal, utilise create_movie pour créer un nouveau film, affiche ses informations, puis appelle free_movie pour libérer toute la mémoire. Après la libération, affiche un message de confirmation.

Affiche la sortie dans ce format :

Movie: {title} ({year})
Memory freed

Par exemple, avec les entrées Inception et 2010, la sortie serait :

Movie: Inception (2010)
Memory freed

Souviens-toi : la clé d’un destructeur correct est de libérer dans l’ordre inverse. Ce que ton constructeur alloue en premier est libéré en dernier, et ce qu’il alloue en dernier est libéré en premier.

Essayez vous-même

#include <stdio.h>
#include <stdlib.h>
#include "movie.h"

int main() {
    char title[100];
    int year;
    
    // Lire l'entrée
    scanf("%[^\n]", title);
    scanf("%d", &year);
    
    // TODO: Créer un film en utilisant create_movie
    
    // TODO: Afficher les informations du film au format :
    // Film : {title} ({year})
    
    // TODO: Libérer le film en utilisant free_movie
    
    // TODO: Afficher "Memory freed"
    
    return 0;
}