DEV Community

gregory charbonneau
gregory charbonneau

Posted on

[Cours Zig #3] À la découverte des types de données (u8, i32, f64, bool...)

Note : Cet article a été écrit avec la version 0.17.0 de Zig sur VS Code avec l'extension ZLS.

Salut à tous !
Dans le Cours #2, on a vu comment stocker des informations avec const et var, et vous aviez sûrement remarqué un mystérieux : u8 à côté de ma variable. Aujourd'hui, on décortique les principaux types de données en Zig !

Pourquoi Zig est-il aussi précis sur les types ?

En Zig, on doit toujours indiquer à l'ordinateur la nature et la taille exacte de nos données en mémoire. C'est ce qui rend le langage ultra-rapide et évite les mauvaises surprises.
Voici les grandes familles que j'ai testées aujourd'hui :
• u8, u16, u32, u64 (Entiers positifs) : Le u veut dire unsigned (non signé, donc zéro ou positif uniquement). Plus le chiffre est grand, plus on peut stocker un grand nombre.
• i8, i16, i32, i64 (Entiers signés) : Le i veut dire integer. Ils acceptent aussi bien les nombres positifs que négatifs.
• f32, f64 (Nombres à virgule) : Le f veut dire float (flottant), toujours écrits avec un point (ex: 3.14).
• bool (Booléens) : Uniquement true (vrai) ou false (faux).
• Caractères et Texte : Une lettre seule s'écrit entre guillemets simples ('Z') et est en fait un u8. Une phrase s'écrit entre guillemets doubles ("...") et a pour type []const u8.

Le grand programme de test

Pour bien tout retenir, j'ai réécrit un programme complet qui regroupe et affiche tous ces types :

const std = @import("std");

pub fn main() void {
    // 1. LES ENTIERS POSITIFS (u = unsigned : zéro ou positif uniquement)
    const petit_positif: u8 = 255;
    const moyen_positif: u16 = 65_000;
    const grand_positif: u32 = 4_000_000_000;
    const tres_grand_positif: u64 = 10_000_000_000;

    // 2. LES ENTIERS SIGNÉS (i = integer : positifs et négatifs)
    const petit_negatif: i8 = -128;
    const moyen_negatif: i16 = -30_000;
    const grand_negatif: i32 = -2_000_000_000;
    const tres_grand_negatif: i64 = -9_000_000_000;

    // 3. LES NOMBRES À VIRGULE (f = float)
    const virgule_simple: f32 = 3.14;
    const virgule_double: f64 = 3.1415926535;

    // 4. LES BOOLÉENS (vrai ou faux)
    const est_genial: bool = true;
    const est_difficile: bool = false;

    // 5. LES CARACTÈRES ET LE TEXTE
    const initiale: u8 = 'Z';
    const message: []const u8 = "Zig est super clair !";

    // AFFICHAGE DE TOUS LES RÉSULTATS
    std.debug.print("--- 1. Entiers positifs (u) ---\n", .{});
    std.debug.print("u8: {d} | u16: {d} | u32: {d} | u64: {d}\n\n", .{
        petit_positif,
        moyen_positif,
        grand_positif,
        tres_grand_positif,
    });

    std.debug.print("--- 2. Entiers signés (i) ---\n", .{});
    std.debug.print("i8: {d} | i16: {d} | i32: {d} | i64: {d}\n\n", .{
        petit_negatif,
        moyen_negatif,
        grand_negatif,
        tres_grand_negatif,
    });

    std.debug.print("--- 3. Nombres à virgule (f) ---\n", .{});
    std.debug.print("f32: {d:.2} | f64: {d:.6}\n\n", .{
        virgule_simple,
        virgule_double,
    });

    std.debug.print("--- 4. Booléens (bool) ---\n", .{});
    std.debug.print("Zig est génial : {} | Zig est impossible : {}\n\n", .{
        est_genial,
        est_difficile,
    });

    std.debug.print("--- 5. Caractère et Texte ---\n", .{});
    std.debug.print("Initiale ({c}) : {s}\n", .{ initiale, message });
}
Enter fullscreen mode Exit fullscreen mode

Trois astuces géniales découvertes aujourd'hui

• Le tiret bas _ pour lire les grands nombres : Écrire 4_000_000_000 au lieu de 4000000000 est autorisé en Zig ! Le compilateur ignore les _, mais pour nos yeux c'est tellement plus lisible.
• Arrondir les virgules à l'affichage : Avec {d:.2}, on demande à Zig d'afficher seulement 2 chiffres après la virgule au lieu d'une longue suite de zéros.
• Afficher un caractère avec {c} : Comme 'Z' est stocké comme un nombre (u8), il faut utiliser {c} dans print pour voir la lettre Z et non son code numérique 90.

La suite du programme

Maintenant que je connais les variables et les types de base, il est temps de passer à la pratique ! Dans le prochain billet, je m'attaque à mon tout premier exercice pratique proposé par l'IA pour faire des calculs et manipuler tout ça.
À très vite, et n'hésitez pas à me dire en commentaire si ce genre de récapitulatif vous aide !

Top comments (0)