Zig-Variablen und Konstanten

In der Sprache Zig sind Variablen Container zum Speichern von Daten.

In Zig ist die Definition und Verwendung von Variablen sehr intuitiv und leistungsstark.

Dieser Artikel beschreibt ausführlich, wie Variablen in Zig definiert und verwendet werden, einschließlich Konstanten, Variablen, Typinferenz, Gültigkeitsbereich und anderer Aspekte.

In Zig werden Konstanten mit demconstSchlüsselwort definiert, während Variablen mit demvarSchlüsselwort definiert werden.


Variablen

In Zig werden Variablen mit demvarSchlüsselwort definiert.

Bei Variablen muss bei der Definition der Typ explizit angegeben werden, oder der Compiler kann den Typ aus dem Initialisierungswert ableiten.

Variablendeklaration

In Zig erfordert die Variablendeklaration die Angabe eines Typs. Die Syntax für die Variablendeklaration lautet wie folgt:

var variable_name: type = value;

variable_nameist der Variablenname,typeist der Typ,valueist der Variablenwert.

Zum Beispiel:

var x: i32 = 42; // 定义一个 i32 类型的变量 x,初始值为 42
var y = 10;      // 编译器推断 y 的类型为 comptime_int

Der Wert einer Variablen kann während der Programmausführung geändert werden:

Beispiel

const std = @import("std");

pub fn main() void {
    var b: i32 = 20; // Definiere eine ganzzahlige Variable b mit einem Anfangswert von 20
    b = 30; // Ändere den Wert der Variablen b
    std.debug.print("b: {}\n", .{b});
}

Merkmale von Variablen

1. Der Typ muss explizit sein:

  • Zig ist eine stark typisierte Sprache. Der Typ einer Variablen muss bei der Definition explizit angegeben oder aus dem Initialisierungswert abgeleitet werden.

  • Wenn kein Initialisierungswert vorhanden ist, muss der Typ explizit angegeben werden.

Beispiel

var x: i32 = 10; // Typ explizit angeben
var y = 20;      // Der Compiler leitet den Typ als comptime_int ab

2. Veränderbarkeit:

  • Variablen, die mit demvarSchlüsselwort definiert werden, sind veränderbar, und ihre Werte können im nachfolgenden Code geändert werden.

Beispiel

var x: i32 = 10;
x = 20; // Den Wert von x ändern

3. Gültigkeitsbereich:

  • Der Gültigkeitsbereich einer Variablen ist der Blockbereich, was bedeutet, dass sie innerhalb des Codeblocks gültig ist, in dem sie definiert wird.

Beispiel

{
    var x: i32 = 10;
    std.debug.print("x = {}\n", .{x}); // Ausgabe: x = 10
}
// Hier ist x außerhalb des Gültigkeitsbereichs und kann nicht darauf zugegriffen werden

4. Nicht initialisierte Variablen:

  • Zig erlaubt die Verwendung nicht initialisierter Variablen nicht. Wenn eine Variable nicht initialisiert ist, meldet der Compiler einen Fehler.

Beispiel

var x: i32; // Fehler: Variable x ist nicht initialisiert
x = 10;    // Muss zuerst initialisiert werden

Variablentypen

Zig unterstützt mehrere Datentypen, einschließlich, aber nicht beschränkt auf:

  • Grundlegende Typen: Ganzzahlen (i32, i64usw.), vorzeichenlose Ganzzahlen (u32, u64usw.), Gleitkommazahlen (f32, f64usw.), boolesche Werte (bool), Zeichen (char)。
  • Zusammengesetzte Typen: Arrays ([]T), Strukturen (struct), Enumerationen (enum), Unions (union), Tupel ([]const T)。
  • Zeiger und Referenzen: Zeiger (*T), Referenzen (&T), optionale Typen (?T)。
  • Funktionstypen:fn(...) -> R。

Regeln für Variablennamen

Die Benennung von Zig-Variablen folgt einigen grundlegenden Regeln, darunter:

  • Variablennamen müssen mit einem Buchstaben oder einem Unterstrich beginnen.

  • Variablennamen können Buchstaben, Ziffern und Unterstriche enthalten.

  • Bei Variablennamen wird zwischen Groß- und Kleinschreibung unterschieden.

  • Variablennamen dürfen keine Zig-Schlüsselwörter sein (wie etwavar、const、fnusw.).

Beispiel

var my_var: i32 = 10; // Zulässiger Variablenname
var _value: f64 = 3.14; // Zulässiger Variablenname
var 1var: i32 = 10; // Unzulässiger Variablenname

Typinferenz

Zig unterstützt Typinferenz. Wenn eine Variable bei der Definition initialisiert wird, kann der Compiler den Typ der Variable aus dem Initialwert ableiten.

Beispiel

var x = 10;      // Der Compiler leitet den Typ von x als comptime_int ab
var y = 3.14;    // Der Compiler leitet den Typ von y als comptime_float ab
var z = "Hello"; // Der Compiler leitet den Typ von z als *const [5:0]u8 ab

Geltungsbereich

Der Gültigkeitsbereich einer Variable wird dadurch bestimmt, wo sie definiert ist.

In Zig können Variablen im globalen Gültigkeitsbereich, im lokalen Gültigkeitsbereich und im Block-Gültigkeitsbereich definiert werden.

Globaler Gültigkeitsbereich- Auf globale Variablen kann überall im Programm zugegriffen werden.

Beispiel

const std = @import("std");

const g: i32 = 90; // Globale Konstante

pub fn main() void {
    std.debug.print("g: {}\n", .{g});
}

Lokaler Gültigkeitsbereich- Auf lokale Variablen kann nur innerhalb der Funktion oder des Codeblocks zugegriffen werden, in dem sie definiert sind.

Beispiel

const std = @import("std");

pub fn main() void {
    var h: i32 = 100; // Lokale Variable
    {
        var i: i32 = 110; // Variable im Blockbereich
        std.debug.print("i: {}\n", .{i});
    }
    // std.debug.print("i: {}\n", .{i}); // Diese Codezeile verursacht einen Kompilierungsfehler, weil i nicht im Gültigkeitsbereich der main-Funktion liegt
    std.debug.print("h: {}\n", .{h});
}

Typkonvertierung

Zig bietet Typkonvertierungsfunktionen, um einen Typ in einen anderen umzuwandeln.

Beispiel

const std = @import("std");

pub fn main() void {
    const j: i32 = 120;
    const k: f64 = @intToFloat(f64, j); // Ganzzahl j in Gleitkommazahl k umwandeln
    std.debug.print("j: {}, k: {}\n", .{j, k});
}

Standardwerte

Variablen müssen bei der Definition initialisiert werden, andernfalls verursacht dies einen Kompilierungsfehler.

Zig erlaubt nicht die Verwendung nicht initialisierter Variablen.

Beispiel

const std = @import("std");

pub fn main() void {
    var l: i32 = 0; // Variable l initialisieren
    std.debug.print("l: {}\n", .{l});
}

Beispiele für die Verwendung von Variablen

Das Folgende ist ein vollständiges Zig-Programm, das die Definition und Verwendung von Variablen demonstriert:

Beispiel

const std = @import("std");

pub fn main() void {
    // Variable definieren
    var x: i32 = 10;
    var y = 20; // Typ wird als comptime_int abgeleitet

    // Den Wert der Variable ändern
    x = 30;
    y = 40;

    // Den Wert der Variable ausgeben
    std.debug.print("x = {}\n", .{x}); // Ausgabe: x = 30
    std.debug.print("y = {}\n", .{y}); // Ausgabe: y = 40

    // Gültigkeitsbereich auf Blockebene
    {
        var z: i32 = 50;
        std.debug.print("z = {}\n", .{z}); // Ausgabe: z = 50
    }
    // Hier ist z außerhalb des Gültigkeitsbereichs und nicht zugänglich
}

Konstanten

In Zig werden Konstanten mit demconstSchlüsselwort definiert.

Sobald eine Konstante definiert ist, kann ihr Wert nicht geändert werden.

Beispiel

const std = @import("std");

pub fn main() void {
    const a: i32 = 10; // Definiere eine Ganzzahl-Konstante a mit dem Wert 10
    std.debug.print("a: {}\n", .{a});
}

Eigenschaften von Konstanten:

  • Unveränderlichkeit: Der Wert einer Konstante kann nach der Definition nicht geändert werden.

  • Zur Compile-Zeit bestimmt: Der Wert einer Konstante muss zur Compile-Zeit bestimmt werden und darf nicht das Ergebnis einer Laufzeitberechnung sein.

  • Typinferenz: Wenn der Typ einer Konstante nicht explizit angegeben wird, leitet der Compiler den Typ aus dem Anfangswert ab.

  • Namenskonvention: Konstanten werden üblicherweise mit lauter Großbuchstaben und Unterstrichen benannt (wieMAX_SIZE) um sie von Variablen zu unterscheiden.


Konstanten zur Compile-Zeit

Zig unterstützt Compile-Zeit-Konstanten (comptime-Konstanten). Die Werte dieser Konstanten werden zur Compile-Zeit berechnet und können für Compile-Zeit-Logik verwendet werden.

Definieren von Compile-Zeit-Konstanten

Verwenden Sie das Schlüsselwort comptime, um Compile-Zeit-Konstanten zu definieren.

Syntax:

comptime const constant_name: type = value;

Zum Beispiel:

comptime const MAX_SIZE: usize = 100; // 编译时常量

Eigenschaften

  • Compile-Zeit-Berechnung:Die Werte von Compile-Zeit-Konstanten werden zur Compile-Zeit berechnet und können für Compile-Zeit-Logik verwendet werden (wie Array-Größen, Typberechnungen usw.).
  • Typsicherheit:Der Typ einer Compile-Zeit-Konstante muss zur Compile-Zeit bestimmt werden.
  • Leistungsoptimierung:Die Verwendung von Compile-Zeit-Konstanten kann den Overhead für Laufzeitberechnungen vermeiden.

Beispiel

const std = @import("std");

pub fn main() void {
    comptime const SIZE: usize = 10; // Kompilierzeit-Konstante
    var arr: [SIZE]i32 = undefined;  // Verwende eine Kompilierzeit-Konstante, um die Array-Größe zu definieren
    std.debug.print("Array-Größe = {}\n", .{SIZE}); // Ausgabe: Array-Größe = 10
}

Unterschiede zwischen Variablen und Konstanten

MerkmalVariable (var)Konstante (const)Kompilierzeit-Konstante (comptime const)
VeränderbarkeitVeränderbarUnveränderlichUnveränderlich
Definitionsschlüsselwortvarconstcomptime const
InitialisierungsanforderungMuss initialisiert werdenMuss initialisiert werdenMuss initialisiert werden
TypinferenzUnterstütztUnterstütztUnterstützt
GeltungsbereichBlockgültigkeitsbereichBlockgültigkeitsbereichBlockgültigkeitsbereich
AnwendungsszenarienWerte, die geändert werden müssenWerte, die nicht geändert werden müssenWerte, die zur Compile-Zeit berechnet werden

Beispiel

const std = @import("std");

pub fn main() void {
    // Variable
    var x: i32 = 10;
    x = 20;
    std.debug.print("x = {}\n", .{x}); // Ausgabe: x = 20

    // Konstante
    const PI: f64 = 3.14159;
    std.debug.print(PI =\n", .{PI}); // Ausgabe: PI = 3.14159

    // Compile-Time-Konstante
    comptime const SIZE: usize = 5;
    var arr: [SIZE]i32 = undefined;
    std.debug.print("Array-Größe = {}\n", .{SIZE}); // Ausgabe: Array size = 5
}
Weitere Erweiterungen