Fonctions Zig
Les fonctions sont un outil important dans les langages de programmation pour organiser le code et implémenter la logique.
Les fonctions sont un outil important pour organiser le code. Utiliser correctement les fonctions peut améliorer la lisibilité et la réutilisabilité du code.
Dans la pratique de la programmation, vous pouvez définir diverses fonctions selon vos besoins pour implémenter des fonctionnalités spécifiques.
Les fonctions Zig sont définies à l'aide du mot-cléfn.
Syntaxe de base
En Zig, la syntaxe de base pour la définition d'une fonction est la suivante :
fn 函数名(参数列表) 返回类型 {
// 函数体
}Par exemple, définissez une fonction simple printHello qui affiche "Hello, World!" :
Exemple
pub fn main() void {
printHello();
}
fn printHello() void {
std.debug.print("Hello, World!\n", .{});
}
La sortie après compilation est :
Hello, World!
Passage de paramètres
Les fonctions peuvent accepter des paramètres, qui peuvent être des valeurs de divers types.
Les paramètres sont listés lors de la définition de la fonction et transmis à la fonction lors de son appel, par exemple :
Exemple
pub fn main() void {
greet("Alice");
}
fn greet(name: []const u8) void {
std.debug.print("Hello, {s}!\n", .{name}); // Utilisez le spécificateur de format {s} pour afficher une tranche de chaîne
}
La sortie après compilation est :
Hello, Alice!
Valeurs de retour
Les fonctions peuvent renvoyer des valeurs. Le type de retour est spécifié dans la définition de la fonction à l'aide du mot-cléreturn.
Par exemple, définissez une fonction qui calcule la somme de deux entiers :
Exemple
pub fn main() void {
const result = add(3, 5);
std.debug.print("3 + 5 = {}\n", .{result});
}
fn add(a: i32, b: i32) i32 {
return a + b;
}
La sortie après compilation est :
3 + 5 = 8
Récursion
Les fonctions peuvent s'appeler elles-mêmes, ce qui constitue un appel récursif.
Par exemple, définissez une fonction récursive qui calcule la factorielle :
Exemple
pub fn main() void {
const result = factorial(5);
std.debug.print("5! = {}\n", .{result});
}
fn factorial(n: i32) i32 {
if (n == 0) {
return 1;
} else {
return n * factorial(n - 1);
}
}
La sortie après compilation est :
5! = 120
Surcharge de fonction
Zig ne prend pas en charge la surcharge de fonctions au sens traditionnel (c'est-à-dire plusieurs fonctions portant le même nom mais avec des paramètres différents).
Zig fournit des fonctionnalités de fonctions génériques. En utilisant des paramètres constants à la compilation, vous pouvez obtenir des effets similaires à la surcharge de fonctions, par exemple :
Exemple
pub fn main() void {
printValue(i32, 5); // Spécifier explicitement le type comme i32
printValue([]const u8, "Hello"); // Spécifier explicitement le type comme []const u8
}
fn printValue(comptime T: type, value: T) void {
std.debug.print("{any}\n", .{value}); // Utiliser {any} pour gérer des valeurs de types différents
}
Dans cet exemple, la fonction printValue peut accepter des paramètres de n'importe quel type et afficher en fonction du type du paramètre.
La sortie après compilation est :
5
{ 72, 101, 108, 108, 111 }
Fonctions inline
Une fonction inline signifie que le code de la fonction est directement inséré au site d'appel lors de la compilation, ce qui évite le surcoût d'un appel de fonction.
En Zig, vous pouvez utiliser le mot-cléinlinepour définir des fonctions inline, par exemple :
Exemple
// Définir une fonction inline
inline fn square(x: i32) i32 {
return x * x;
}
pub fn main() void {
const result = square(5); // Insérer le code de la fonction inline au site d'appel
std.debug.print("Le carré de 5 est {}\n", .{result});
}
Dans cet exemple, la fonction square est définie comme une fonction inline, et le compilateur insérera son code directement au site d'appel.
La sortie après compilation est :
Square of 5 is 25Autres extensions