Aller au contenu
Encyclopédie informatique Édition 2026

Le langage Zig

Partie 3 sur 4

Niveau de lecture :

5La mémoire est explicite

5.1Pas de ramasse-miettes, pas de surprise

Un programme range ses données à deux endroits : la pile (réservée automatiquement pour les variables locales, libérée à la sortie de la fonction) et le tas (mémoire dynamique, réservée à la demande, dont la taille n’est pas connue d’avance, voir la gestion de la mémoire). Les langages à ramasse-miettes (Go, Java) libèrent le tas tout seuls, au prix d’une pause et d’une consommation de mémoire imprévisible. Le C laisse le programmeur réserver (malloc) et libérer (free), à la main. Zig choisit la seconde voie, mais la rend visible : une fonction qui a besoin du tas reçoit un allocateur en paramètre.

fn copier(allocator: std.mem.Allocator, texte: []const u8) ![]u8 {
    const copie = try allocator.alloc(u8, texte.len);
    @memcpy(copie, texte);
    return copie;
}

L’appelant choisit quel allocateur fournir et libère le résultat, en pratique avec un defer :

const copie = try copier(allocator, "Gabon");
defer allocator.free(copie);

La figure 1 en montre le principe. Lire la signature d’une fonction suffit pour savoir si elle réserve de la mémoire : si elle ne prend pas d’allocateur, elle n’en réserve pas.

QUI DEMANDE, QUI FOURNIT, QUI LIBÈRE 1. Le programme principal choisit un allocateur 2. Il le passe en paramètre à chaque fonction qui en a besoin 3. La fonction réserve : allocator.alloc(...) Au choix de l’appelant : usage général détecte les fuites en développement arène (arena) tout rendu d’un coup, sans free un par un zone fixe aucun tas : mémoire connue d’avance L’appelant libère avec defer allocator.free(...). Pas d’allocateur dans la signature = pas de mémoire dynamique.
Figure 1. En Zig, la mémoire dynamique est toujours demandée à un allocateur fourni par l’appelant.

5.2Des allocateurs au choix

Cette règle permet de choisir l’allocateur selon le besoin : un allocateur d’usage général, qui en mode de développement détecte les fuites (mémoire jamais rendue) et les doubles libérations ; un allocateur arène (arena), qui rend tout d’un coup à la fin d’une opération et dispense de libérer chaque objet ; un allocateur sur une zone fixe de la pile, sans tas du tout, utile pour les systèmes embarqués. On peut écrire un programme dont on est sûr qu’il ne réservera jamais de mémoire en cours de route, ce qui compte pour les logiciels dont l’arrêt serait grave.

Pour s’exercer

Exercice 2 : Trouver la fuite

Cette fonction compile mais fuit de la mémoire dans certains cas. Où, et comment le corriger ?

fn charger(allocator: std.mem.Allocator) !void {
    const tampon = try allocator.alloc(u8, 1024);
    try lire(tampon);
    allocator.free(tampon);
}
Voir la réponse

Si lire(tampon) échoue, le try quitte la fonction immédiatement et la ligne allocator.free(tampon) n’est jamais exécutée : la mémoire fuit. Correction : écrire defer allocator.free(tampon); juste après l’allocation. Le defer s’exécute à la sortie de la fonction, quelle que soit la façon dont on en sort.

6Le calcul à la compilation : comptime

Le mot comptime (« temps de compilation ») fait exécuter du code Zig par le compilateur, avant la production du programme. Son résultat est alors une constante. Les usages sont variés :

  • les génériques : une fonction qui accepte un type comme paramètre ;
  • les tables précalculées : calculer une fois pour toutes une table de valeurs plutôt qu’à chaque lancement ;
  • les vérifications : refuser de compiler si une condition n’est pas remplie.
fn carre(comptime T: type, x: T) T {
    return x * x;
}
const a = carre(i32, 7);   // 49
const b = carre(f64, 1.5); // 2.25

Le type T est un paramètre de la fonction, connu à la compilation : le compilateur produit une version pour chaque type utilisé. Là où le C emploie des macros (du remplacement de texte) et le C++ des modèles (templates), Zig emploie le même langage à la compilation et à l’exécution, ce qui rend le code plus simple à lire. La figure 2 en résume l’idée.

DEUX MOMENTS : COMPILER, PUIS EXÉCUTER À la compilation (comptime) • le compilateur exécute du code Zig • il calcule tables et constantes • il crée une fonction par type utilisé • il refuse de compiler si une règle est brisée À l’exécution • le programme utilise les constantes • aucun calcul répété à chaque lancement • le code est plus petit et plus rapide • seules les entrées réelles restent à traiter produit Même langage aux deux moments : pas de macros ni de modèles à part comme en C et en C++.
Figure 2. Le code Zig s’exécute à deux moments : à la compilation et à l’exécution.

Pour s’exercer

Exercice 3 : Traiter l’absence

La fonction fn trouver(xs: []const i32, v: i32) ?usize renvoie la position de v dans xs, ou null s’il est absent. Écrivez l’appel qui donne 0 quand la valeur est absente, puis celui qui affiche « absent » dans ce cas.

Voir la réponse

Pour obtenir 0 en cas d’absence : const p = trouver(xs, v) orelse 0;. Pour afficher « absent » : if (trouver(xs, v)) |i| { ... } else { std.debug.print("absent\n", .{}); }. Dans le premier bloc, i est la position trouvée.