Types de données Zig

Zig prend en charge plusieurs types de données, notamment les entiers, les nombres à virgule flottante, les booléens, les caractères, les tableaux, les tranches, les structures, les énumérations, les unions et les pointeurs.

Le tableau suivant décrit les différents types de données en Zig :

Catégorie de type de donnéesExemples de types de donnéesDescription
Types entiersi8, i16, i32, i64, isizeType entier signé,isizela taille dépend de la plateforme.
Entiers non signésu8, u16, u32, u64, usizeType entier non signé,usizela taille dépend de la plateforme.
Nombres à virgule flottantef16, f32, f64, f128Types à virgule flottante IEEE.
Type booléenboolType booléen, avec les valeurstrueoufalse。
Type de caractèrecharValeurs scalaires Unicode.
Types compositesarray, vectorTableaux de taille fixe et tableaux de taille dynamique.
Types de pointeurs*T, *const T, *mut TPointant versTune valeur du type,*constqui est en lecture seule,*mutqui est mutable.
Types de référence&T, &const T, &mut TPairTRéférence à une valeur du type,&constqui est en lecture seule,&mutqui est mutable.
Types de tuples(T1, T2, ...)Une collection ordonnée de valeurs avec un nombre et des types fixes.
Types optionnels?TPeut êtrenullouTune valeur du type.
Types d'ensemble d'erreurserror{...}Un type énumération qui contient des valeurs d'erreur.
Types de fonctionfn(T1, T2, ...) -> RUn type de fonction qui accepte des paramètres et renvoie un résultat.
Types de structurestruct { ... }Un type de données composite contenant plusieurs champs.
Types d'énumérationenum { ... }Une collection d'un nombre fixe de valeurs nommées.
Types d'unionunion { ... }Un type qui peut stocker des valeurs de plusieurs types différents, mais un seul à la fois.
Types d'aliasalias T = UTOuiUAlias de.

1. Types entiers

Zig propose divers types entiers, notamment des entiers signés et non signés, dont la taille va de 8 bits à 64 bits.

Exemple

const std = @import("std");

pub fn main() void {
    const a: i8 = -128; // entier signé 8 bits
    const b: u8 = 255;  // entier non signé 8 bits
    const c: i32 = -2147483648; // entier signé 32 bits
    const d: u64 = 18446744073709551615; // entier non signé 64 bits

    std.debug.print("a: {}, b: {}, c: {}, d: {}\n", .{a, b, c, d});
}
2. Types à virgule flottante

Zig prend en charge deux types à virgule flottante : f32 et f64.

Exemple

const std = @import("std");

pub fn main() void {
    const pi: f32 = 3.14;   // nombre à virgule flottante 32 bits
    const e: f64 = 2.71828; // nombre à virgule flottante 64 bits

    std.debug.print("pi: {}, e: {}\n", .{pi, e});
}

3. Type booléen

Le type booléen est représenté par bool, et ses valeurs peuvent être true ou false.

Exemple

const std = @import("std");

pub fn main() void {
    const is_true: bool = true;
    const is_false: bool = false;

    std.debug.print("is_true: {}, is_false: {}\n", .{is_true, is_false});
}

4. Type caractère

Le type caractère utilise u8 pour représenter un seul caractère.

Exemple

const std = @import("std");

pub fn main() void {
    const letter: u8 = 'A';

    std.debug.print("letter: {}\n", .{letter});
}

5. Tableaux et tranches

Les tableaux ont une taille fixe, tandis que les tranches sont des tableaux de taille dynamique.

Exemple

const std = @import("std");

pub fn main() void {
    const array: [5]i32 = [5]i32{1, 2, 3, 4, 5}; // Tableau de taille fixe
    const slice: []const i32 = array[1..4]; // Tranche

    std.debug.print("array: {}, slice: {}\n", .{array, slice});
}

6. Structures

Les structures sont définies avec struct, ce qui vous permet de créer des types de données complexes.

Exemple

const std = @import("std");

const Point = struct {
    x: i32,
    y: i32,
};

pub fn main() void {
    const p = Point{ .x = 10, .y = 20 };

    std.debug.print("Point: ({}, {})\n", .{p.x, p.y});
}

7. Énumérations

Les énumérations sont définies avec enum, ce qui vous permet de créer des types avec des valeurs nommées.

Exemple

const std = @import("std");

const Color = enum {
    Red,
    Green,
    Blue,
};

pub fn main() void {
    const color: Color = Color.Green;

    std.debug.print("Couleur : {}\n", .{color});
}

8. Unions

Les unions sont définies avec union, ce qui vous permet de créer une variable pouvant stocker des valeurs de types différents.

Exemple

const std = @import("std");

const Number = union(enum) {
    Int: i32,
    Float: f32,
};

pub fn main() void {
    const num: Number = Number{ .Int = 10 };

    switch (num) {
        Number.Int => std.debug.print("Entier : {}\n", .{num.Int}),
        Number.Float => std.debug.print("Flottant : {}\n", .{num.Float}),
    }
}

9. Pointeurs

Les pointeurs sont définis avec*et peuvent pointer vers des variables d'un type spécifique.

Exemple

const std = @import("std");

pub fn main() void {
    var a: i32 = 10;
    const p: *i32 = &a; // Pointeur vers a

    std.debug.print("Value: {}, Pointer: {}",\n", .{a, p.*});
}
Autres extensions