Le langage Zig
Partie 3 sur 4
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.
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.
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.