Zig-Structs und Enums

In der Programmiersprache Zig sind Structs und Enums zwei grundlegende Datentypen.

Structs und Enums sind zwei Hauptarten, benutzerdefinierte Datentypen zu definieren und zu verwenden.

Structs und Enums bieten eine höhere Ebene der Datenorganisation und Typsicherheit und eignen sich für verschiedene Programmszenarien.

  • Struct: Wird verwendet, um zugehörige Variablen zu einem zusammengesetzten Datentyp zu kombinieren. Structs können Felder und Methoden enthalten und eignen sich zum Organisieren komplexer Daten.
  • Enum: Wird verwendet, um eine Menge benannter Konstanten zu definieren, die Enums ohne Werte oder mit Werten sein können. Enums eignen sich zur Darstellung einer endlichen Menge diskreter Werte.

Struktur

Ein Struct ist ein zusammengesetzter Datentyp, der es ermöglicht, mehrere Datenelemente unterschiedlicher Typen zu einem einzigen Typ zu kombinieren.

Die Syntax für Structs in Zig ist wie folgt:

const structName = struct {
    field1: FieldType1,
    field2: FieldType2,
    // 其他字段
};

Im folgenden Code ist MyStruct ein Struct-Typ mit drei Feldern: field1 ist eine 32-Bit-Ganzzahl, field2 ist eine Gleitkommazahl mit doppelter Genauigkeit und field3 ist ein Zeiger auf ein Byte-Array.

struct MyStruct {
    field1: i32,
    field2: f64,
    field3: []const u8,
}

Beispiel

const std = @import("std");

// Definiere eine Struktur
const Person = struct {
    name: []const u8,
    age: u32,
};

pub fn main() void {
    // Eine Struct-Instanz erstellen
    const person = Person{
        .name = "Alice",
        .age = 30,
    };

    // Auf Struct-Felder zugreifen und korrekt formatieren
    std.debug.print("Name: {s}\n", .{person.name}); // Verwende {s}, um Slices zu formatieren
    std.debug.print("Alter: {}\n", .{person.age});
}

Kompiliere und führe den obigen Code aus, die Ausgabe ist:

Name: Alice
Age: 30

Um Felder in einem Struct zu ändern, stelle sicher, dass du var verwendest, um die Struct-Instanz zu definieren, damit du Feldwerte ändern kannst. Wenn du const verwendest, um eine Struct-Instanz zu definieren, kannst du ihre Feldwerte nicht ändern.

Beispiel

const std = @import("std");

// Definiere eine Struktur
const Person = struct {
    name: []const u8,
    age: u32,
};

pub fn main() void {
    // Eine Struct-Instanz erstellen
    var person = Person{
        .name = "Alice",
        .age = 30,
    };

    // Gib die Anfangswerte aus
    std.debug.print("Anfänglicher Name: {s}\n", .{person.name});
    std.debug.print("Anfängliches Alter: {}\n", .{person.age});

    // Ändere die Werte der Struct-Felder
    person.name = "Bob";
    person.age = 35;

    // Die geänderten Werte ausgeben
    std.debug.print("Geänderter Name: {s}\n", .{person.name});
    std.debug.print("Geändertes Alter: {}\n", .{person.age});
}

Kompiliere und führe den obigen Code aus, die Ausgabe ist:

Initial Name: Alice
Initial Age: 30
Modified Name: Bob
Modified Age: 35

Methoden

In Zig werden Struct-Methoden mit dem Schlüsselwort fn definiert, ähnlich wie Klassenmethoden in anderen Programmiersprachen.

Beispiel

const std = @import("std");

const Rectangle = struct {
    width: u32,
    height: u32,

    // Methode zur Berechnung der Fläche
    fn area(self: Rectangle) u32 {
        return self.width * self.height;
    }
};

pub fn main() void {
    var rect = Rectangle{
        .width = 10,
        .height = 5,
    };

    // Struct-Methode aufrufen
    std.debug.print("Fläche: {}\n", .{rect.area()});
}

Kompiliere und führe den obigen Code aus, die Ausgabe ist:

Area: 50

Enum

Ein Enum ist ein Datentyp, der aus einer festen Menge konstanter Werte besteht.

Die Syntax für Enums in Zig ist wie folgt:

const enumName = enum {
    Variant1,
    Variant2,
    // 其他变体
};

Im folgenden Code ist MyEnum ein Enum-Typ mit drei möglichen Werten: Option1, Option2 und Option3.

enum MyEnum {
    Option1,
    Option2,
    Option3,
}

Beispiel

const std = @import("std");

// Ein Enum definieren
const Color = enum {
    Red,
    Green,
    Blau,
};

pub fn main() void {
    // Das Enum verwenden
    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", .{}),
    }
}

Kompiliere und führe den obigen Code aus, die Ausgabe ist:

Green

Enums mit Werten

Zig ermöglicht die Angabe bestimmter Werte für jede Variante eines Enums, die verwendet werden können, um mehr Informationen darzustellen oder um zu vergleichen.

Beispiel

const std = @import("std");

// Ein Enum mit Werten definieren
const Status = enum(u32) {
    Ausstehend = 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", .{}),
    }
}

Kompiliere und führe den obigen Code aus, die Ausgabe ist:

InProgress

Enums als Felder verwenden

Enums können als Felder in Structs verwendet werden, wodurch Structs flexibler und leistungsfähiger werden.

Beispiel

const std = @import("std");

const Status = enum {
    Active,
    Inactive,
    Suspended,
};

const User = struct {
    name: []const u8,
    status: Status,
};

pub fn main() void {
    // Eine User-Instanz erstellen
    const user = User{
        .name = "Alice",
        .status = Status.Active,
    };

    // Ausgabe des Namensfelds von User
    std.debug.print("Benutzer: {s}\n", .{user.name}); // Verwende {s}, um Slices zu formatieren

    // Verwende eine switch-Anweisung, um je nach status verschiedene Zustände auszugeben
    switch (user.status) {
        Status.Active => std.debug.print("Status: Aktiv\n", .{}),
        Status.Inactive => std.debug.print("Status: Inaktiv\n", .{}),
        Status.Suspended => std.debug.print("Status: Suspendiert\n", .{}),
    }
}

Kompiliere und führe den obigen Code aus, die Ausgabe ist:

User: Alice
Status: Active
Andere Erweiterungen