Présentation du langage Zig

Zig 0.14 — langage système | pas de flux de contrôle caché | pas d'allocations cachées | pas de préprocesseur | exécution à la compilation

Paradigme

Impératif, procédural, orienté données. Typage statique avec inférence, typage structurel (canard) via comptime. Compilation via LLVM + backend auto-hébergé. Pas de surcharge d'opérateurs, pas d'exceptions, pas de RAII, pas de macros.

Espèces

Déclarations

Flux de contrôle

Fonctionnalités du commutateur

• exhaustivité vérifiée au moment de la compilation
• Plusieurs articles par bras : 1, 2 => ...
• Bras de portée : 0...10 => ...
• Noms des broches de capture : inline else => \|tag\| ...

Opérateurs

Comptime (Métaprogrammation)

fn max(comptime T: type, a: T, b: T) T {
    return if (a > b) a else b;
}

comptime {
    // Runs at compile time
    @compileLog("building for", @tagName(builtin.cpu));
}

// Generics via comptime parameters
fn ArrayList(comptime T: type) type {
    return struct {
        items: []T,
        fn init(self: *Self) void { ... }
    };
}

Fonctionnalités Comptime

• comptime les blocs s'exécutent pendant la compilation
• comptime les paramètres de la fonction sont connus au moment de la compilation
• inline for / inline while dérouler les boucles au moment du concours
• @Type(...) construire des types à comptime
• @fieldParentPtr recherche de champ inversée
• @hasDecl @hasField réflexion au moment de la compilation
• @typeInfo obtient les informations de type sous forme de structure

Mémoire

Allocateurs

std.heap.page_allocator std.heap.arena_allocator std.heap.FixedBufferAllocator std.heap.ArenaAllocator std.heap.StackFallbackAllocator std.heap.c_allocator

La philosophie de l'allocateur de Zig

• Chaque allocation prend un paramètre d'allocateur explicite
• Pas d'allocateur global, pas d'allocations implicites
• Les répartiteurs composent (pool → arène → page)

Gestion des erreurs

// Error union type: ReturnType!Error
fn div(a: i32, b: i32) !i32 {
    if (b == 0) return error.DivisionByZero;
    return a / b;
}

// Try operator: early return on error
const result = try div(10, 2);

// Catch: provide default
const val = div(10, 0) catch 0;

// Global error set vs specific
fn parse() ParseError!i32 { ... }

Différer et reporter les erreurs

{
    const buf = try allocator.alloc(u8, 100);
    defer allocator.free(buf);  // always runs at scope exit
    errdefer allocator.free(buf);  // runs only if error returned

    // ... use buf
}  // defer triggers here

Bibliothèque standard (sélectionnée)

Tests

test "basic addition" {
    try std.testing.expectEqual(4, add(2, 2));
    try std.testing.expect(add(1, 1) == 2);
    try std.testing.expectError(error.DivisionByZero, div(1, 0));
}

zig test file.zig        # run tests
zig build test           # run all tests in project
zig test --name "filter" # filter test names

Compilation croisée

zig build-exe main.zig --target x86_64-windows  # cross-compile to Windows
zig build-exe main.zig --target aarch64-linux    # cross-compile to ARM64 Linux
zig build-exe main.zig --target riscv64-linux    # cross-compile to RISC-V

Zig est livré avec des en-têtes libc et des chaînes d'outils de compilation croisée pour toutes les cibles principales — aucun compilateur croisé séparé n'est nécessaire.

Interopérabilité C

// Import C header
const c = @cImport({
    @cInclude("stdio.h");
});

// Link C library
pub fn main() void {
    _ = c.printf("hello %d\n", 42);
}

// Direct use of C ABI
extern "c" fn strlen(s: [*:0]u8) usize;

// Zig is a better C:
// - @cImport for headers
// - export fn for C-ABI exports
// - [*:0]T for null-terminated strings
// - @ptrCast for pointer conversion
// - packed struct for ABI-compatible layouts

Différences notables par rapport à C

• Pas de préprocesseur (utilisez comptime)
• Aucune conversion implicite (explicite @intCast @floatCast)
• Pas d'UB par défaut (contrôles de sécurité lors du débogage, opt-in @setRuntimeSafety)
• defer remplace goto cleanup modèles
• anytype remplace void* + macro génériques
• Le type de tableau inclut la longueur ([N]T vs T[N])
• undefined au lieu de non initialisé
• null d'optionnel ?*T, pas un pointeur

Compilation

zig build-exe main.zig     # compile executable
zig build-lib lib.zig       # compile library
zig build-obj obj.zig       # compile object
zig run main.zig            # compile + run
zig test file.zig           # compile + run tests
zig fmt file.zig            # format code
zig build                   # build project (build.zig)
zig translate-c foo.h       # translate C header to Zig

Modes de construction