Partage via

Opérateurs logiques booléens - AND, OR, NOT, XOR

Les opérateurs booléens logiques effectuent des opérations logiques avec des opérandes bool. Les opérateurs incluent la négation logique unaire (!), la logique binaire AND (&), OR (|) et OR exclusif (^) et la logique binaire AND (&&) et OR (||).

En ce qui concerne les opérandes de type numérique intégral, les opérateurs &, | et ^ effectuent des opérations logiques binaires. Pour plus d’informations, consultez Opérateurs de bits et de décalage.

La documentation de référence du langage C# décrit la version la plus récente du langage C#. Il contient également la documentation initiale des fonctionnalités dans les préversions publiques pour la prochaine version du langage.

La documentation identifie toute fonctionnalité introduite en premier dans les trois dernières versions de la langue ou dans les préversions publiques actuelles.

Conseil / Astuce

Pour savoir quand une fonctionnalité a été introduite en C#, consultez l’article sur l’historique des versions du langage C#.

L’opérateur de négation logique !

L’opérateur de préfixe ! unaire calcule la négation logique de son opérande. Elle produit true si l’opérande prend falsela valeur , et false si l’opérande est évalué à true:

bool passed = false;
Console.WriteLine(!passed);  // output: True
Console.WriteLine(!true);    // output: False

L’opérateur postfix ! unaire est l’opérateur null-forgiving.

Opérateur ET logique &

L’opérateur & calcule le AND logique de ses opérandes. Le résultat de x & y est true si x et y sont true. Sinon, le résultat est false.

L’opérateur & évalue toujours les deux opérandes. Lorsque l’opérande de gauche est false, le résultat de l’opération est false indépendamment de la valeur de l’opérande de droite. Toutefois, l’opérande de droite est toujours évalué.

Dans l’exemple suivant, l’opérande de droite de l’opérateur & est un appel de méthode, qui s’exécute indépendamment de la valeur de l’opérande de gauche :

bool SecondOperand()
{
    Console.WriteLine("Second operand is evaluated.");
    return true;
}

bool a = false & SecondOperand();
Console.WriteLine(a);
// Output:
// Second operand is evaluated.
// False

bool b = true & SecondOperand();
Console.WriteLine(b);
// Output:
// Second operand is evaluated.
// True

L’opérateur &&AND logique conditionnel calcule également la logique AND de ses opérandes, mais elle n’évalue pas l’opérande de droite si l’opérande de gauche est false.

Dans le cas des opérandes de types numériques intégraux, &l’opérateur calcule le AND logique binaire de ses opérandes. L’opérateur unaire & est l’opérateur address-of.

L’opérateur OR exclusif logique ^

L’opérateur ^ calcule le OR exclusif logique, également appelé XOR logique, de ses opérandes. Le résultat de x ^ y est true si x est true et y est false, ou x est false et y est true. Sinon, le résultat est false. Pour bool les opérandes, l’opérateur ^ calcule le même résultat que l’opérateur !=d’inégalité.

Console.WriteLine(true ^ true);    // output: False
Console.WriteLine(true ^ false);   // output: True
Console.WriteLine(false ^ true);   // output: True
Console.WriteLine(false ^ false);  // output: False

Dans le cas des opérandes de types numériques intégraux, ^l’opérateur calcule l’opération logique exclusive OU binaire de ses opérandes.

L’opérateur OU logique |

L’opérateur | calcule le OR logique de ses opérandes. Le résultat de x | y est true si x ou y prend la valeur true. Sinon, le résultat est false.

L’opérateur | évalue toujours les deux opérandes. Lorsque l’opérande de gauche est évalué à true, le résultat de l’opération est true, quelle que soit la valeur de l’opérande de droite. Même ensuite, l’opérande de droite est toutefois évalué.

Dans l’exemple suivant, l’opérande de partie droite de l’opérateur | est un appel de méthode, effectué indépendamment de la valeur de l’opérande de partie gauche :

bool SecondOperand()
{
    Console.WriteLine("Second operand is evaluated.");
    return true;
}

bool a = true | SecondOperand();
Console.WriteLine(a);
// Output:
// Second operand is evaluated.
// True

bool b = false | SecondOperand();
Console.WriteLine(b);
// Output:
// Second operand is evaluated.
// True

L’opérateur ||OR logique conditionnel calcule également l’or logique de ses opérandes, mais il n’évalue pas l’opérande de droite si l’opérande de gauche prend truela valeur .

Dans le cas des opérandes de types numériques intégraux, |l’opérateur calcule le OR logique binaire de ses opérandes.

Opérateur AND logique conditionnel &&

L’opérateur AND logique conditionnel &&, également appelé opérateur AND logique de « court-circuit », calcule le AND logique de ses opérandes. Le résultat de x && y est true si x et y prennent la valeur true. Sinon, le résultat est false. Si x est évalué à false, y n’est pas évalué.

Dans l’exemple suivant, l’opérande de partie droite de l’opérateur && est un appel de méthode, non effectué si l’opérande de partie gauche donne la valeur de false :

bool SecondOperand()
{
    Console.WriteLine("Second operand is evaluated.");
    return true;
}

bool a = false && SecondOperand();
Console.WriteLine(a);
// Output:
// False

bool b = true && SecondOperand();
Console.WriteLine(b);
// Output:
// Second operand is evaluated.
// True

L’opérateur &AND logique calcule également le AND logique de ses opérandes, mais il évalue toujours les deux opérandes.

Opérateur OR logique conditionnel ||

L’opérateur OR logique conditionnel ||, également appelé opérateur OR logique de « court-circuit », calcule le OR logique de ses opérandes. Le résultat de x || y est true si x ou y prend la valeur true. Sinon, le résultat est false. Si x est évalué à true, y n’est pas évalué.

Dans l’exemple suivant, l’opérande de partie droite de l’opérateur || est un appel de méthode, non effectué si l’opérande de partie gauche donne la valeur de true :

bool SecondOperand()
{
    Console.WriteLine("Second operand is evaluated.");
    return true;
}

bool a = true || SecondOperand();
Console.WriteLine(a);
// Output:
// True

bool b = false || SecondOperand();
Console.WriteLine(b);
// Output:
// Second operand is evaluated.
// True

L’opérateur OR logique| calcule également le OR logique de ses opérandes, mais évalue toujours les deux opérandes.

Les opérateurs logiques booléens Nullable

Pour bool? les opérandes, les & opérateurs (AND logique) et | (OR logique) prennent en charge la logique à trois valeurs comme suit :

  • L’opérateur & ne retourne true que si les deux opérandes sont évalués à true. Si l’une ou l’autre x est évaluée à false, x & y retourne false (même si un autre opérande est évalué à null).y Sinon, le résultat de x & y est null.

  • L’opérateur | produit false uniquement si les deux opérandes sont évalués à false. Si l’une ou l’autre de x ou y est évaluée à true, x | y produit true (même si un autre opérande est évalué à null ). Sinon, le résultat de x | y est null.

Le tableau suivant présente cette sémantique :

x y x &y x | y
vrai vrai vrai vrai
vrai faux faux vrai
vrai zéro zéro vrai
faux vrai faux vrai
faux faux faux faux
faux zéro faux zéro
zéro vrai zéro vrai
zéro faux faux zéro
zéro zéro zéro zéro

Le comportement de ces opérateurs diffère du comportement classique des opérateurs avec des types valeur Nullable. En règle générale, un opérateur défini pour les opérandes d’un type valeur peut également être utilisé avec des opérandes du type valeur Nullable correspondant. Un tel opérateur produit null si l’un de ses opérandes est null. Toutefois, les opérateurs & et | peuvent produire une valeur non null même si l’un des opérandes est évalué à null. Pour plus d’informations sur le comportement des opérateurs avec des types valeur pouvant accepter la valeur Null, voir la section Opérateurs de l’article Utiliser des types pouvant accepter la valeur Null.

Vous pouvez également utiliser les opérateurs ! et ^ avec les opérandes bool?, comme le montre l’exemple suivant :

bool? test = null;
Display(!test);         // output: null
Display(test ^ false);  // output: null
Display(test ^ null);   // output: null
Display(true ^ null);   // output: null

void Display(bool? b) => Console.WriteLine(b is null ? "null" : b.Value.ToString());

Les opérateurs logiques conditionnels && et || ne prennent pas en charge les opérandes bool?.

Assignation composée

Pour un opérateur binaire op, une expression d’assignation composée du formulaire

x op= y

Équivaut à

x = x op y

Sauf que x est évalué une seule fois.

Les opérateurs &, | et ^ prennent en charge l’assignation composée, comme le montre l’exemple suivant :

bool test = true;
test &= false;
Console.WriteLine(test);  // output: False

test |= true;
Console.WriteLine(test);  // output: True

test ^= false;
Console.WriteLine(test);  // output: True

Notes

Les opérateurs logiques conditionnels && et || ne prennent pas en charge l’assignation composée.

Priorité des opérateurs

La liste suivante présente les opérateurs logiques par ordre de précédence, de la plus élevée à la plus basse :

  • Opérateur de négation logique !
  • L’opérateur AND logique &
  • Opérateur OR exclusif logique ^
  • Opérateur OR logique |
  • Opérateur AND logique conditionnel &&
  • Opérateur OR logique conditionnel ||

Utilisez des parenthèses, (), pour modifier l’ordre d’évaluation imposé par la précédence des opérateurs :

Console.WriteLine(true | true & false);   // output: True
Console.WriteLine((true | true) & false); // output: False

bool Operand(string name, bool value)
{
    Console.WriteLine($"Operand {name} is evaluated.");
    return value;
}

var byDefaultPrecedence = Operand("A", true) || Operand("B", true) && Operand("C", false);
Console.WriteLine(byDefaultPrecedence);
// Output:
// Operand A is evaluated.
// True

var changedOrder = (Operand("A", true) || Operand("B", true)) && Operand("C", false);
Console.WriteLine(changedOrder);
// Output:
// Operand A is evaluated.
// Operand C is evaluated.
// False

Pour obtenir la liste complète des opérateurs C# classés par niveau de priorité, consultez la section Priorité des opérateurs de l’article Opérateurs C#.

Capacité de surcharge de l’opérateur

Un type défini par l’utilisateur peut surcharger les opérateurs !, &, | et ^. Quand un opérateur binaire est surchargé, l’opérateur d’assignation composée correspondant est aussi implicitement surchargé. À compter de C# 14, un type défini par l’utilisateur peut surcharger explicitement les opérateurs d’affectation composée pour fournir une implémentation plus efficace. En règle générale, un type surcharge ces opérateurs, car la valeur peut être mise à jour en place, plutôt que d’allouer une nouvelle instance pour contenir le résultat de l’opération binaire. Si un type ne fournit pas de surcharge explicite, le compilateur génère la surcharge implicite.

Un type défini par l’utilisateur ne peut pas surcharger les opérateurs logiques conditionnels && et ||. Toutefois, si un type défini par l’utilisateur surcharge les opérateurs true et false et l’opérateur & ou | d’une certaine manière, l’opération && ou || peut être évaluée respectivement pour les opérandes de ce type. Pour plus d’informations, consultez la section Opérateurs logiques conditionnels définis par l’utilisateur de la spécification du langage C#.

spécification du langage C#

Pour plus d’informations, consultez les sections suivantes de la spécification du langage C# :

Voir aussi

  • Last updated on