Maîtriser la priorité et l'associativité des opérateurs en C# : Guide pratique

Maîtriser la priorité et l'associativité des opérateurs en C#

Ce tutoriel approfondi explique comment le compilateur C# évalue les expressions en appliquant les règles de priorité et d'associativité des opérateurs. Apprenez avec des exemples clairs et des tableaux de référence.

Priorité des opérateurs en C#

La priorité des opérateurs définit l'ordre dans lequel les parties d'une expression sont évaluées. Chaque opérateur C# possède un niveau de priorité fixe, assurant que le compilateur traite les expressions de manière cohérente.

Par exemple, l'opérateur de multiplication * a une priorité plus élevée que l'addition +. Ainsi, dans l'expression

int x = 4 + 3 * 5;

la multiplication s'effectue en premier, donnant x = 19.

Si l'addition était prioritaire sur la multiplication, le résultat serait 35 — mais C# suit la hiérarchie de priorité établie.

---

Tableau de priorité des opérateurs

Le tableau ci-dessous liste les opérateurs de la priorité la plus élevée à la plus faible.

Priorité des opérateurs C#

Catégorie	Opérateurs
Incrémentation et décrémentation postfixées	++, --
Incrémentation, décrémentation prefixées unaires	++, --, +, -, !, ~
Multiplicatifs	*, /, %
Additifs	+, -
Décalage	<<, >>
Relationnels	<, <=, >, >=
Égalité	==, !=
ET bit à bit	&
OU exclusif bit à bit	^
OU bit à bit	|
ET logique	&&
OU logique	||
Conditionnel (ternaire)	? :
Assignation	=, +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=

Les assignations ont la priorité la plus faible, tandis que les incrémentations/décrémentations postfixées se situent au sommet.

---

Exemple 1 : Priorité des opérateurs

using System;
namespace OperatorDemo {
    class OperatorPrecedence {
        public static void Main(string[] args) {
            int result1;
            int a = 5, b = 6, c = 4;
            result1 = --a * b - ++c;
            Console.WriteLine(result1);
            bool result2;
            result2 = b >= c + a;
            Console.WriteLine(result2);
        }
    }
}

L'exécution de ce programme affiche :

19
False

Étapes d'évaluation :

• (--a) → 4 (a devient 4)
• (++c) → 5 (c devient 5)
• (a * b) → 24
• Soustraction : 24 - 5 = 19

La seconde expression montre que l'addition + a une priorité plus élevée que la comparaison >=, donc c + a est évalué avant la comparaison.

---

Associativité des opérateurs en C#

Lorsque deux opérateurs partagent la même priorité, le compilateur utilise l'associativité pour décider de l'ordre d'évaluation. La plupart des opérateurs C# sont associatifs de gauche à droite, mais quelques-uns le sont de droite à gauche.

Exemple :

int a = 5, b = 6, c = 3;
int result = a * b / c;

Comme * et / sont associatifs de gauche à droite, la multiplication est effectuée en premier, donnant 10.

L'associativité de droite à gauche est cruciale dans les chaînes d'assignation :

int a = 5, b = 6, c = 3;
a = b = c;

La valeur 3 est assignée à b, puis b à a, résultant en toutes les variables contenant 3.

Le tableau ci-dessous résume l'associativité des opérateurs C#.

Associativité des opérateurs C#

Catégorie	Opérateurs	Associativité
Incrémentation et décrémentation postfixées	++, --	Gauche à droite
Incrémentation, décrémentation prefixées unaires	++, --, +, -, !, ~	Droite à gauche
Multiplicatifs	*, /, %	Gauche à droite
Additifs	+, -	Gauche à droite
Décalage	<<, >>	Gauche à droite
Relationnels	<, <=, >, >=	Gauche à droite
Égalité	==, !=	Gauche à droite
ET bit à bit	&	Gauche à droite
OU exclusif bit à bit	^	Gauche à droite
OU bit à bit	|	Gauche à droite
ET logique	&&	Gauche à droite
OU logique	||	Gauche à droite
Conditionnel (ternaire)	? :	Droite à gauche
Assignation	=, +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=	Droite à gauche

Les principaux opérateurs associatifs de droite à gauche incluent les préfixes unaires, l'opérateur ternaire et toutes les assignations.

---

Exemple 2 : Associativité en action

using System;
namespace OperatorDemo {
    class OperatorAssociativity {
        public static void Main(string[] args) {
            int a = 5, b = 6, c = 3;
            int result = a * b / c;
            Console.WriteLine(result);
            a = b = c;
            Console.WriteLine($"a = {a}, b = {b}, c = {c}");
        }
    }
}

La sortie est :

10
a = 3, b = 3, c = 3