Structures et énumérations Zig
Dans le langage de programmation Zig, les structures et les énumérations sont deux types de données fondamentaux.
Les structures et les énumérations sont deux manières principales de définir et d'utiliser des types de données personnalisés.
Les structures et les énumérations offrent un niveau supérieur d'organisation des données et de sécurité de type, adaptés à différents scénarios de programmation.
- Structure: Utilisée pour combiner des variables liées en un type de données composite. Les structures peuvent contenir des champs et des méthodes, adaptées à l'organisation de données complexes.
- Énumération: Utilisée pour définir un ensemble de constantes nommées, qui peuvent être des énumérations sans valeurs ou avec valeurs. Les énumérations conviennent pour représenter un ensemble fini de valeurs discrètes.
Struct
Une structure est un type de données composite qui permet de combiner plusieurs éléments de données de types différents en un seul type.
La syntaxe des structures en Zig est la suivante :
const structName = struct {
field1: FieldType1,
field2: FieldType2,
// 其他字段
};
Dans le code suivant, MyStruct est un type de structure avec trois champs : field1 est un entier de 32 bits, field2 est un nombre à virgule flottante à double précision, et field3 est un pointeur vers un tableau d'octets.
struct MyStruct {
field1: i32,
field2: f64,
field3: []const u8,
}
Exemple
// Définir une structure
const Person = struct {
name: []const u8,
age: u32,
};
pub fn main() void {
// Créer une instance de structure
const person = Person{
.name = "Alice",
.age = 30,
};
// Accéder aux champs de la structure et formater correctement
std.debug.print("Nom : {s}\n", .{person.name}); // Utilisez {s} pour formater les tranches
std.debug.print("Âge : {}\n", .{person.age});
}
Compilez et exécutez le code ci-dessus, la sortie est :
Name: Alice Age: 30
Pour modifier les champs d'une struct, assurez-vous d'utiliser var pour définir l'instance de la struct afin de pouvoir modifier les valeurs des champs. Si vous utilisez const pour définir une instance de struct, vous ne pouvez pas modifier les valeurs de ses champs.
Exemple
// Définir une structure
const Person = struct {
name: []const u8,
age: u32,
};
pub fn main() void {
// Créer une instance de structure
var person = Person{
.name = "Alice",
.age = 30,
};
// Afficher les valeurs initiales
std.debug.print("Nom initial : {s}\n", .{person.name});
std.debug.print("Âge initial : {}\n", .{person.age});
// Modifier les valeurs des champs d'une struct
person.name = "Bob";
person.age = 35;
// Afficher les valeurs modifiées
std.debug.print("Modified Name: {s}\n", .{person.name});
std.debug.print("Modified Age: {}\n", .{person.age});
}
Compilez et exécutez le code ci-dessus, la sortie est :
Initial Name: Alice Initial Age: 30 Modified Name: Bob Modified Age: 35
Méthodes
En Zig, les méthodes de struct sont définies à l'aide du mot-clé fn, comme les méthodes de classe dans d'autres langages de programmation.
Exemple
const Rectangle = struct {
width: u32,
height: u32,
// Méthode pour calculer l'aire
fn area(self: Rectangle) u32 {
return self.width * self.height;
}
};
pub fn main() void {
var rect = Rectangle{
.width = 10,
.height = 5,
};
// Appeler la méthode de struct
std.debug.print("Area: {}\n", .{rect.area()});
}
Compilez et exécutez le code ci-dessus, la sortie est :
Area: 50
Énumération
Un enum est un type de données constitué d'un ensemble fixe de valeurs constantes.
La syntaxe des énumérations en Zig est la suivante :
const enumName = enum {
Variant1,
Variant2,
// 其他变体
};Dans le code suivant, MyEnum est un type d'énumération avec trois valeurs possibles : Option1, Option2 et Option3.
enum MyEnum {
Option1,
Option2,
Option3,
}
Exemple
// Définir une énumération
const Color = enum {
Red,
Green,
Blue,
};
pub fn main() void {
// Utiliser l'énumération
const favoriteColor = Color.Green;
switch (favoriteColor) {
Color.Red => std.debug.print("Red\n", .{}),
Color.Green => std.debug.print("Green\n", .{}),
Color.Blue => std.debug.print("Blue\n", .{}),
}
}
Compilez et exécutez le code ci-dessus, la sortie est :
Green
Énumérations avec valeurs
Zig permet de spécifier des valeurs spécifiques pour chaque variante d'une énumération, ce qui peut être utilisé pour représenter davantage d'informations ou à des fins de comparaison.
Exemple
// Définir une énumération avec des valeurs
const Status = enum(u32) {
En attente = 1,
InProgress = 2,
Completed = 3,
};
pub fn main() void {
const taskStatus = Status.InProgress;
switch (taskStatus) {
Status.Pending => std.debug.print("Pending\n", .{}),
Status.InProgress => std.debug.print("InProgress\n", .{}),
Status.Completed => std.debug.print("Completed\n", .{}),
}
}
Compilez et exécutez le code ci-dessus, la sortie est :
InProgress
Utilisation des énumérations comme champs
Les énumérations peuvent être utilisées comme champs de structure, ce qui rend les structures plus flexibles et puissantes.
Exemple
const Status = enum {
Active,
Inactive,
Suspended,
};
const User = struct {
name: []const u8,
status: Status,
};
pub fn main() void {
// Créer une instance de User
const user = User{
.name = "Alice",
.status = Status.Active,
};
// Afficher le champ du nom de l'utilisateur
std.debug.print("Utilisateur : {s}\n", .{user.name}); // Utilisez {s} pour formater les tranches
// Utiliser une instruction switch pour afficher différents états en fonction du statut
switch (user.status) {
Status.Active => std.debug.print("Statut : Actif\n", .{}),
Status.Inactive => std.debug.print("Statut : Inactif\n", .{}),
Status.Suspended => std.debug.print("Statut : Suspendu\n", .{}),
}
}
Compilez et exécutez le code ci-dessus, la sortie est :
User: Alice Status: ActiveAutres extensions