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

OperatorDescription
+Addition
-Soustraction
*Multiplication
/Division
%Reste (opération modulo)

Exemple

const std = @import("std");

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

OperatorDescription
==Égal à
!=Différent de
>Supérieur à
<Inférieur à
>=Supérieur ou égal à
<=Inférieur ou égal à

Exemple

const std = @import("std");

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

OperatorDescription
etET logique
ouOU logique
!NON logique

Exemple

const std = @import("std");

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

OperatorDescription
&ET bit à bit
|OU bit à bit
^OU exclusif bit à bit
~NON bit à bit
<<Décalage à gauche
>>Décalage à droite

Exemple

const std = @import("std");

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

OperatorDescription
=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

const std = @import("std");

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

OperatorDescription
++Incrémentation
--Décrémentation

Exemple

const std = @import("std");

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éOperatorDescription
1[]Opération d'indice, accès à un tableau ou à un pointeur
1.Accès aux membres
2fn_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 à
14andET logique
15orOU logique
16orelseOu sinon retourner une autre valeur
17catchCapturer 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

const std = @import("std");

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 = false
Autres extensions