1. Introduction
On va commencer avec une analogie du quotidien. Imagine une recette :
Mélange la farine, les œufs et le sucre fouette ajoute le beurre fouette encore une fois.
Ça a l’air bizarre ? Maintenant, imagine qu’il y a une virgule ou des parenthèses entre "fouette" et "ajoute". L’ordre des actions devient tout de suite plus clair.
En programmation, c’est pareil quand tu écris une expression compliquée :
bool result = a > 0 && b < 10 || c == 3;
C’est quoi l’ordre ? Qu’est-ce qui est calculé en premier : a > 0 && b < 10, puis || c == 3 ? Ou l’inverse ? Sans un ordre de calcul clair, l’ordi peut "mélanger les ingrédients" et ton résultat sera chelou.
2. Priorité des opérateurs en C#
C# (comme la plupart des langages de prog) utilise une table de priorité des opérateurs.
Les opérateurs avec une priorité plus haute sont exécutés avant ceux avec une priorité plus basse.
Regarde la partie la plus importante de cette table (pour les expressions conditionnelles) :
| Opérateur | Description | Priorité |
|---|---|---|
| () | Parenthèses | la plus haute |
| ! | Logique "NON" | haute |
| ==, != | Égal / pas égal | moyenne |
| <, >, <=, >= | Comparaisons | moyenne |
| && | Logique "ET" | plus bas |
| || | Logique "OU" | encore plus bas |
(Il y a aussi les opérateurs arithmétiques — ils sont au-dessus des logiques en priorité.)
La règle principale
Les opérateurs "ET" (&&) ont une priorité plus haute que "OU" (||),
donc "ET" sera calculé d’abord, puis "OU".
Schéma de calcul de la priorité des conditions
En pratique : a > 0 && b < 10 || c == 3 — d’abord on calcule a > 0 && b < 10, puis le résultat est comparé avec c == 3 via ||.
3. Direction des opérateurs : de gauche à droite et inversement
En plus de la priorité, il y a aussi ce mot : associativité.
C’est la règle qui dit dans quel sens les opérateurs sont calculés s’ils sont "côte à côte" et ont la même priorité.
Exemple :
bool a = true, b = false, c = true;
bool result = a && b && c;
Question : comment ça va être calculé ?
Réponse : l’associativité de && est de gauche à droite.
Donc d’abord a && b, puis le résultat avec c.
Pour les conditions :
| Opérateur | Associativité |
|---|---|
| &&, || | de gauche à droite |
| ! | de droite à gauche |
4. Les parenthèses — ton meilleur pote dans les conditions complexes
C’est là que la magie opère (et que tu te sauves la vie). Quand tu écris une expression, les parenthèses changent la priorité et rendent ton code plus clair et plus safe.
Exemple 1 (sans parenthèses) :
// On veut : "Si l’utilisateur est adulte et citoyen, ou s’il a un pass spécial"
bool isAdult = age >= 18;
bool isCitizen = country == "Biélorussie";
bool hasPermit = hasSpecialPass == true;
if (isAdult && isCitizen || hasPermit)
{
Console.WriteLine("Accès autorisé !");
}
Comment C# calcule :
D’abord il calcule isAdult && isCitizen, puis il compare le résultat avec || et hasPermit.
- Disons, isAdult = true, isCitizen = false, hasPermit = true
isAdult && isCitizen→true && false→falsefalse || true→true
Donc, si la personne a un pass spécial, elle passe quand même.
Et si elle n’a pas de pass mais qu’elle est adulte et citoyenne — elle passe aussi.
Exemple 2 (avec parenthèses) :
if (isAdult && (isCitizen || hasPermit))
{
Console.WriteLine("Accès autorisé !");
}
Maintenant le programme vérifie d’abord :
isCitizen || hasPermit, puis ce résultat avec isAdult.
Donc tu dois être adulte et (soit citoyen, soit avoir un pass spécial).
Une petite différence de parenthèses — une grosse différence dans la logique !
GO TO FULL VERSION