Opérateurs Zig
Les opérateurs et les expressions sont des composants fondamentaux des langages de programmation, utilisés pour effectuer diverses opérations.
En Zig, les opérateurs peuvent être divisés en plusieurs catégories, notamment les opérateurs arithmétiques, les opérateurs relationnels, les opérateurs logiques, les opérateurs bit à bit, les opérateurs d'affectation et d'autres opérateurs.
Voici des descriptions détaillées et des exemples de chaque type d'opérateur.
Opérateurs arithmétiques
| Operator | Description |
|---|---|
| + | Addition |
| - | Soustraction |
| * | Multiplication |
| / | Division |
| % | Reste (opération modulo) |
Exemple
pub fn main() void {
const a: i32 = 5;
const b: i32 = 3;
const add: i32 = a + b;
const subtract: i32 = a - b;
const multiply: i32 = a * b;
const divide: i32 = a / b;
const remainder: i32 = a % b;
std.debug.print("a + b = {}\n", .{add});
std.debug.print("a - b = {}\n", .{subtract});
std.debug.print("a * b = {}\n", .{multiply});
std.debug.print("a / b = {}\n", .{divide});
std.debug.print("a % b = {}\n", .{remainder});
}
La sortie compilée est :
a + b = 8 a - b = 2 a * b = 15 a / b = 1 a % b = 2
Opérateurs relationnels
| Operator | Description |
|---|---|
| == | Égal à |
| != | Différent de |
| > | Supérieur à |
| < | Inférieur à |
| >= | Supérieur ou égal à |
| <= | Inférieur ou égal à |
Exemple
pub fn main() void {
const a: i32 = 5;
const b: i32 = 3;
const equal: bool = a == b;
const not_equal: bool = a != b;
const greater: bool = a > b;
const less: bool = a < b;
const greater_equal: bool = a >= b;
const less_equal: bool = a <= b;
std.debug.print("a == b: {}\n", .{equal});
std.debug.print("a != b: {}\n", .{not_equal});
std.debug.print("a > b: {}\n", .{greater});
std.debug.print("a < b: {}\n", .{less});
std.debug.print("a >= b: {}\n", .{greater_equal});
std.debug.print("a <= b: {}\n", .{less_equal});
}
La sortie compilée est :
a == b: false a != b: true a > b: true a < b: false a >= b: true a <= b: false
Opérateurs logiques
| Operator | Description |
|---|---|
| et | ET logique |
| ou | OU logique |
| ! | NON logique |
Exemple
pub fn main() void {
const a: bool = true;
const b: bool = false;
const and_result: bool = a and b;
const or_result: bool = a or b;
const not_result: bool = !a;
std.debug.print("a et b: {}\n", .{and_result}); // false
std.debug.print("a ou b: {}\n", .{or_result}); // vrai
std.debug.print("!a: {}\n", .{not_result}); // false
}
La sortie compilée est :
a and b: false a or b: true !a: false
Opérateurs bit à bit
| Operator | Description |
|---|---|
| & | ET bit à bit |
| | | OU bit à bit |
| ^ | OU exclusif bit à bit |
| ~ | NON bit à bit |
| << | Décalage à gauche |
| >> | Décalage à droite |
Exemple
pub fn main() void {
const a: i32 = 5; // 0101
const b: i32 = 3; // 0011
const bit_and: i32 = a & b; // 0001
const bit_or: i32 = a | b; // 0111
const bit_xor: i32 = a ^ b; // 0110
const bit_not: i32 = ~a; // 11111111111111111111111111111010
const left_shift: i32 = a << 1; // 1010
const right_shift: i32 = a >> 1; // 0010
std.debug.print("a & b: {}\n", .{bit_and});
std.debug.print("a | b: {}\n", .{bit_or});
std.debug.print("a ^ b: {}\n", .{bit_xor});
std.debug.print("~a: {}\n", .{bit_not});
std.debug.print("a << 1: {}\n", .{left_shift});
std.debug.print("a >> 1: {}\n", .{right_shift});
}
La sortie compilée est :
a & b: 1 a | b: 7 a ^ b: 6 ~a: -6 a << 1: 10 a >> 1: 2
Opérateurs d'affectation
| Operator | Description |
|---|---|
| = | Affectation |
| += | Affectation par addition |
| -= | Affectation par soustraction |
| *= | Affectation par multiplication |
| /= | Affectation de division |
| %= | Affectation de reste |
| &= | Affectation ET bit à bit |
| |= | Affectation OU bit à bit |
| ^= | Affectation OU exclusif bit à bit |
| <<= | Affectation par décalage à gauche |
| >>= | Affectation par décalage à droite |
Exemple
pub fn main() void {
var a: i32 = 5;
const b: i32 = 3;
a += b; // équivalent à a = a + b;
std.debug.print("a += b: {}\n", .{a});
a -= b; // équivalent à a = a - b;
std.debug.print("a -= b: {}\n", .{a});
a *= b; // équivalent à a = a * b;
std.debug.print("a *= b: {}\n", .{a});
a = @divTrunc(a, b); // équivalent à a = a / b;
std.debug.print("a /= b: {}\n", .{a});
a = @mod(a, b); // équivalent à a = a % b;
std.debug.print("a %= b: {}\n", .{a});
a &= b; // équivalent à a = a & b;
std.debug.print("a &= b: {}\n", .{a});
a |= b; // équivalent à a = a | b;
std.debug.print("a |= b: {}\n", .{a});
a ^= b; // équivalent à a = a ^ b;
std.debug.print("a ^= b: {}\n", .{a});
a <<= 1; // équivalent à a = a << 1;
std.debug.print("a <<= 1: {}\n", .{a});
a >>= 1; // équivalent à a = a >> 1;
std.debug.print("a >>= 1: {}\n", .{a});
}
La sortie compilée est :
a += b: 8 a -= b: 5 a *= b: 15 a /= b: 5 a %= b: 2 a &= b: 2 a |= b: 3 a ^= b: 0 a <<= 1: 0 a >>= 1: 0
Autres opérateurs
| Operator | Description |
|---|---|
| ++ | Incrémentation |
| -- | Décrémentation |
Exemple
pub fn main() void {
var a: i32 = 5;
a += 1; // Zig n'a pas l'opérateur ++, utilisez += 1 à la place
std.debug.print("a += 1: {}\n", .{a});
a -= 1; // Zig n'a pas l'opérateur --, utilisez -= 1 à la place
std.debug.print("a -= 1: {}\n", .{a});
}
La sortie compilée est :
a += 1: 6 a -= 1: 5
Précédence des opérateurs
Voici une liste de priorité des opérateurs Zig, classée de la plus élevée à la plus faible :
| Priorité | Operator | Description |
|---|---|---|
| 1 | [] | Opération d'indice, accès à un tableau ou à un pointeur |
| 1 | . | Accès aux membres |
| 2 | fn_call() | Appel de fonction |
| 2 | @builtin() | Appel de fonction intégrée |
| 3 | ! | Propagation des erreurs |
| 3 | ? | Déballage de valeur optionnelle |
| 4 | * & | Déréférencement de pointeur et opérations d'adresse |
| 5 | + - | Plus et moins unaires |
| 6 | ~ | NON bit à bit |
| 7 | * / % | Multiplication, division, reste |
| 8 | + - | Addition, soustraction |
| 9 | << >> | Décalage bit à bit à gauche, à droite |
| 10 | & | ET bit à bit |
| 11 | ^ | OU exclusif bit à bit |
| 12 | ` | ` |
| 13 | == != | Égal, différent |
| 13 | < <= > >= | Inférieur à, inférieur ou égal à, supérieur à, supérieur ou égal à |
| 14 | and | ET logique |
| 15 | or | OU logique |
| 16 | orelse | Ou sinon retourner une autre valeur |
| 17 | catch | Capturer l'erreur |
| 18 | = | Affectation |
| 19 | -> | Corps de fonction de fermeture ou indicateur de type de valeur de retour |
Notes :
- Associativité: Généralement, les opérateurs Zig sont associatifs à gauche, mais vous pouvez vous référer à la documentation en fonction de la fonction spécifique de l'opérateur.
- Remarques: Les opérateurs en Zig sont conçus pour être simples et clairs, en évitant les comportements implicites complexes que l'on trouve dans de nombreux langages, comme l'absence de conversion de type implicite.
L'exemple suivant montre comment la priorité des opérateurs affecte l'ordre d'évaluation des expressions :
Exemple
pub fn main() void {
const a: i32 = 5;
const b: i32 = 3;
const c: i32 = 2;
// La multiplication a une priorité plus élevée que l'addition
const result1: i32 = a + b * c; // 5 + (3 * 2) = 11
std.debug.print("a + b * c = {}\n", .{result1});
// Utiliser des parenthèses pour changer la priorité
const result2: i32 = (a + b) * c; // (5 + 3) * 2 = 16
std.debug.print("(a + b) * c = {}\n", .{result2});
// Les opérateurs de comparaison ont une priorité plus élevée que les opérateurs logiques
const result3: bool = a > b and b > c; // (5 > 3) and (3 > 2) = true
std.debug.print("a > b and b > c = {}\n", .{result3});
// L'opérateur NON logique a une priorité plus élevée que l'opérateur ET logique
const result4: bool = !(a > b) and b > c; // !(5 > 3) and (3 > 2) = false
std.debug.print("!(a > b) and b > c = {}\n", .{result4});
}
La sortie compilée est :
a + b * c = 11 (a + b) * c = 16 a > b and b > c = true !(a > b) and b > c = falseAutres extensions