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ées | Exemples de types de données | Description |
|---|---|---|
| Types entiers | i8, i16, i32, i64, isize | Type entier signé,isizela taille dépend de la plateforme. |
| Entiers non signés | u8, u16, u32, u64, usize | Type entier non signé,usizela taille dépend de la plateforme. |
| Nombres à virgule flottante | f16, f32, f64, f128 | Types à virgule flottante IEEE. |
| Type booléen | bool | Type booléen, avec les valeurstrueoufalse。 |
| Type de caractère | char | Valeurs scalaires Unicode. |
| Types composites | array, vector | Tableaux de taille fixe et tableaux de taille dynamique. |
| Types de pointeurs | *T, *const T, *mut T | Pointant versTune valeur du type,*constqui est en lecture seule,*mutqui est mutable. |
| Types de référence | &T, &const T, &mut T | PairTRé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 | ?T | Peut êtrenullouTune valeur du type. |
| Types d'ensemble d'erreurs | error{...} | Un type énumération qui contient des valeurs d'erreur. |
| Types de fonction | fn(T1, T2, ...) -> R | Un type de fonction qui accepte des paramètres et renvoie un résultat. |
| Types de structure | struct { ... } | Un type de données composite contenant plusieurs champs. |
| Types d'énumération | enum { ... } | Une collection d'un nombre fixe de valeurs nommées. |
| Types d'union | union { ... } | Un type qui peut stocker des valeurs de plusieurs types différents, mais un seul à la fois. |
| Types d'alias | alias T = U | TOuiUAlias 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
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});
}
Zig prend en charge deux types à virgule flottante : f32 et f64.
Exemple
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
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
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
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 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 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 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
pub fn main() void {
var a: i32 = 10;
const p: *i32 = &a; // Pointeur vers a
std.debug.print("Value: {}, Pointer: {}",\n", .{a, p.*});
}