Variables et constantes Zig
Dans le langage Zig, les variables sont des conteneurs pour stocker des données.
En Zig, la définition et l'utilisation des variables sont très intuitives et puissantes.
Cet article détaillera comment définir et utiliser les variables en Zig, y compris les constantes, les variables, l'inférence de type, la portée et d'autres aspects.
En Zig, les constantes sont définies à l'aide du mot-cléconst, tandis que les variables sont définies à l'aide du mot-clévar.
Variables
En Zig, les variables sont définies à l'aide du mot-clévar.
Le type des variables doit être explicitement spécifié lors de la définition, ou le compilateur peut déduire le type à partir de la valeur d'initialisation.
Déclaration de variable
En Zig, la déclaration de variable nécessite de spécifier un type. La syntaxe de déclaration de variable est la suivante :
var variable_name: type = value;
variable_nameest le nom de la variable,typeest le type,valueest la valeur de la variable.
Par exemple :
var x: i32 = 42; // 定义一个 i32 类型的变量 x,初始值为 42 var y = 10; // 编译器推断 y 的类型为 comptime_int
La valeur d'une variable peut être modifiée pendant l'exécution du programme :
Exemple
pub fn main() void {
var b: i32 = 20; // Définir une variable entière b avec une valeur initiale de 20
b = 30; // Modifier la valeur de la variable b
std.debug.print("b: {}\n", .{b});
}
Caractéristiques des variables
1. Le type doit être explicite:
Zig est un langage fortement typé. Le type d'une variable doit être explicitement spécifié lors de la définition, ou inféré à partir de la valeur d'initialisation.
S'il n'y a pas de valeur d'initialisation, le type doit être explicitement spécifié.
Exemple
var y = 20; // Le compilateur infère le type comme comptime_int
2. Mutabilité:
-
Les variables définies à l'aide du
varmot-clé sont mutables, et leurs valeurs peuvent être modifiées dans le code ultérieur.
Exemple
x = 20; // Modifier la valeur de x
3. Portée:
-
La portée d'une variable est la portée de bloc, ce qui signifie qu'elle est valide dans le bloc de code où elle est définie.
Exemple
var x: i32 = 10;
std.debug.print("x = {}\n", .{x}); // Sortie : x = 10
}
// Ici, x est hors de portée et n'est pas accessible
4. Variables non initialisées:
-
Zig n'autorise pas l'utilisation de variables non initialisées. Si une variable n'est pas initialisée, le compilateur signalera une erreur.
Exemple
x = 10; // Doit d'abord être initialisée
Types de variables
Zig prend en charge plusieurs types de données, y compris, mais sans s'y limiter :
- Types de base : entiers (
i32,i64etc.), entiers non signés (u32,u64etc.), nombres à virgule flottante (f32,f64etc.), booléens (bool), caractères (char)。 - Types composites : tableaux (
[]T), structures (struct), énumérations (enum), unions (union), tuples ([]const T)。 - Pointeurs et références : pointeurs (
*T), références (&T), types optionnels (?T)。 - Types de fonctions :
fn(...) -> R。
Règles de nommage des variables
Le nommage des variables Zig suit quelques règles de base, notamment :
Les noms de variables doivent commencer par une lettre ou un trait de soulignement.
Les noms de variables peuvent contenir des lettres, des chiffres et des traits de soulignement.
Les noms de variables sont sensibles à la casse.
Les noms de variables ne peuvent pas être des mots-clés Zig (tels que
var、const、fnetc.).
Exemple
var _value: f64 = 3.14; // Nom de variable valide
var 1var: i32 = 10; // Nom de variable non valide
Inférence de type
Zig prend en charge l'inférence de type. Si une variable est initialisée lors de sa définition, le compilateur peut déduire le type de la variable à partir de la valeur initiale.
Exemple
var y = 3.14; // Le compilateur déduit le type de y comme comptime_float
var z = "Hello"; // Le compilateur déduit le type de z comme *const [5:0]u8
Portée
La portée d'une variable est déterminée par l'endroit où elle est définie.
En Zig, les variables peuvent être définies dans la portée globale, la portée locale et la portée de bloc.
Portée globale- Les variables globales sont accessibles n'importe où dans le programme.
Exemple
const g: i32 = 90; // Constante globale
pub fn main() void {
std.debug.print("g: {}\n", .{g});
}
Portée locale- Les variables locales ne sont accessibles qu'au sein de la fonction ou du bloc de code où elles sont définies.
Exemple
pub fn main() void {
var h: i32 = 100; // Variable locale
{
var i: i32 = 110; // Variable de portée de bloc
std.debug.print("i: {}\n", .{i});
}
// std.debug.print("i: {}\n", .{i}); // Cette ligne de code provoquera une erreur de compilation car i n'est pas dans la portée de la fonction main
std.debug.print("h: {}\n", .{h});
}
Conversion de type
Zig fournit des fonctions de conversion de type pour convertir un type en un autre.
Exemple
pub fn main() void {
const j: i32 = 120;
const k: f64 = @intToFloat(f64, j); // Convertir l'entier j en nombre à virgule flottante k
std.debug.print("j: {}, k: {}\n", .{j, k});
}
Valeurs par défaut
Les variables doivent être initialisées lors de leur définition, sinon cela provoquera une erreur de compilation.
Zig n'autorise pas l'utilisation de variables non initialisées.
Exemple
pub fn main() void {
var l: i32 = 0; // Initialiser la variable l
std.debug.print("l: {}\n", .{l});
}
Exemples d'utilisation de variables
Ce qui suit est un programme Zig complet qui démontre la définition et l'utilisation de variables :
Exemple
pub fn main() void {
// Définir la variable
var x: i32 = 10;
var y = 20; // Type déduit comme comptime_int
// Modifier la valeur de la variable
x = 30;
y = 40;
// Afficher la valeur de la variable
std.debug.print("x = {}\n", .{x}); // Sortie : x = 30
std.debug.print("y = {}\n", .{y}); // Sortie : y = 40
// Portée au niveau du bloc
{
var z: i32 = 50;
std.debug.print("z = {}\n", .{z}); // Sortie : z = 50
}
// Ici, z est hors de portée et on ne peut pas y accéder
}
Constantes
En Zig, les constantes sont définies à l'aide du mot-cléconst.
Une fois qu'une constante est définie, sa valeur ne peut pas être modifiée.
Exemple
pub fn main() void {
const a: i32 = 10; // Définir une constante entière a avec une valeur de 10
std.debug.print("a: {}\n", .{a});
}
Caractéristiques des constantes :
-
Immutabilité: La valeur d'une constante ne peut pas être modifiée après sa définition.
-
Déterminée à la compilation: La valeur d'une constante doit être déterminée à la compilation et ne peut pas être le résultat d'un calcul à l'exécution.
-
Inférence de type: Si le type d'une constante n'est pas explicitement spécifié, le compilateur déduira le type à partir de la valeur initiale.
-
Convention de nommage: Les constantes sont généralement nommées en utilisant des lettres majuscules et des tirets bas (comme
MAX_SIZE) pour les distinguer des variables.
Constantes de compilation
Zig prend en charge les constantes de compilation (constantes comptime). Les valeurs de ces constantes sont calculées à la compilation et peuvent être utilisées pour la logique de compilation.
Définition des constantes de compilation
Utilisez le mot-clé comptime pour définir des constantes de compilation.
Syntaxe :
comptime const constant_name: type = value;
Par exemple :
comptime const MAX_SIZE: usize = 100; // 编译时常量
Caractéristiques
- Calcul à la compilation :Les valeurs des constantes de compilation sont calculées à la compilation et peuvent être utilisées pour la logique de compilation (comme les tailles de tableaux, les calculs de types, etc.).
- Sûreté de typage :Le type d'une constante de compilation doit être déterminé à la compilation.
- Optimisation des performances :L'utilisation de constantes de compilation permet d'éviter les surcoûts de calcul à l'exécution.
Exemple
pub fn main() void {
comptime const SIZE: usize = 10; // Constante à la compilation
var arr: [SIZE]i32 = undefined; // Utiliser une constante à la compilation pour définir la taille du tableau
std.debug.print("Array size = {}\n", .{SIZE}); // Sortie : Array size = 10
}
Différences entre les variables et les constantes
| Fonctionnalité | Variable (var) | Constante (const) | Constante à la compilation (comptime const) |
|---|---|---|---|
| Mutabilité | Mutable | Immuable | Immuable |
| Mot-clé de définition | var | const | comptime const |
| Exigence d'initialisation | Doit être initialisée | Doit être initialisée | Doit être initialisée |
| Inférence de type | Pris en charge | Pris en charge | Pris en charge |
| Portée | Portée de bloc | Portée de bloc | Portée de bloc |
| Scénarios d'utilisation | Valeurs à modifier | Valeurs qui n'ont pas besoin de modification | Valeurs calculées à la compilation |
Exemple
pub fn main() void {
// variable
var x: i32 = 10;
x = 20;
std.debug.print("x = {}\n", .{x}); // Sortie : x = 20
// constante
const PI: f64 = 3.14159;
std.debug.print("PI = {}\n", .{PI}); // Sortie : PI = 3.14159
// constante de compilation
comptime const SIZE: usize = 5;
var arr: [SIZE]i32 = undefined;
std.debug.print("Array size = {}\n", .{SIZE}); // Sortie : Taille du tableau = 5
}