Panoramica del linguaggio Zig

Zig 0.14 — linguaggio di sistema | nessun flusso di controllo nascosto | nessuna allocazione nascosta | nessun preprocessore | esecuzione in fase di compilazione

Paradigma

Imperativo, procedurale, orientato ai dati. Tipizzazione statica con inferenza, tipizzazione strutturale (duck) tramite comptime. Compilazione tramite LLVM + backend self-hosted. Nessun sovraccarico dell'operatore, nessuna eccezione, nessun RAII, nessuna macro.

Tipi

Dichiarazioni

Flusso di controllo

Cambia funzionalità

• L'esaustività è stata controllata in fase di compilazione
• Articoli multipli per braccio: 1, 2 => ...
• Bracci della gamma: 0...10 => ...
• Nomi dei poli di cattura: inline else => \|tag\| ...

Operatori

Comptime (metaprogrammazione)

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 { ... }
    };
}

Funzionalità di tempo libero

• comptime i blocchi vengono eseguiti durante la compilazione
• comptime i parametri della funzione sono noti in fase di compilazione
• inline for / inline while srotola i loop in fase di comptime
• @Type(...) costruire tipi in comptime
• @fieldParentPtr ricerca inversa sul campo
• @hasDecl @hasField riflessione in fase di compilazione
• @typeInfo ottiene informazioni sul tipo come struttura

Memoria

Allocatori

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

La filosofia dell'allocatore di Zig

• Ogni allocazione accetta un parametro allocatore esplicito
• Nessun allocatore globale, nessuna allocazione implicita
• I ripartitori compongono (pool → arena → pagina)

Gestione degli errori

// 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 { ... }

Differire e Errdefer

{
    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

Libreria standard (selezionata)

Test

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

Compilazione incrociata

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 viene fornito con intestazioni libc e toolchain di compilazione incrociata per tutti i principali target: non è necessario un compilatore incrociato separato.

Interoperabilità 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

Notevoli differenze rispetto a C

• Nessun preprocessore (usa comptime)
• Nessun cast implicito (esplicito @intCast @floatCast)
• Nessun UB per impostazione predefinita (controlli di sicurezza nel debug, attivazione @setRuntimeSafety)
• defer sostituisce goto cleanup modelli
• anytype sostituisce void* + macro generici
• Il tipo di array include la lunghezza ([N]T rispetto a T[N])
• undefined anziché non inizializzato
• null di facoltativo ?*T, non puntatore

Compilazione

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

Modalità di costruzione