Opérateurs logiques booléens en C #

opérateurs booléens sont utilisés en C # pour contrôler le flux de programmes et prendre des décisions logiques. C # est un langage orienté objet largement utilisé par .Développeurs nets.

Dans cet article, nous explorerons les bases de Opérateurs logiques booléens en C # et comment ils peuvent être utilisés pour contrôler le flux du programme.

Quels sont les opérateurs logiques booléens?

Opérateurs logiques booléens sont des symboles spéciaux ou des mots clés qui évaluent soit vrai ou faux. Ils sont utilisés pour prendre des décisions dans un programme en fonction des conditions d'entrée. Les opérateurs booléens utilisent l'algèbre booléenne qui a été utilisée pour la première fois par George Boole.

C # prend en charge les opérateurs logiques booléens suivants:

• ET (&&)
• Ou (||)
• PAS (!)
• Xor (^)

En utilisant l'opérateur (&&)

Le ET L'opérateur en programmation C # combine plus d'une condition. Pour produire une vraie valeur toutes les conditions d'entrée doivent être vraies. La syntaxe pour l'utilisation de l'opérateur et en C # est la suivante:

if (condition1 && condition2)

// code pour exécuter si les deux conditions sont vraies

En utilisant l'opérateur ou (||)

Le OU L'opérateur est utilisé pour combiner deux conditions ou plus, dont une seule doit être vraie pour l'expression globale pour évaluer comme vrai. La syntaxe pour utiliser le OU L'opérateur en C # est le suivant:

if (condition1 || condition2)

// code à exécuter si condition1 ou condition2 est vrai

En utilisant l'opérateur non (!)

Le PAS Opérateur en C # Reverse ou modifie la valeur de la logique d'entrée. Si nous donnons une véritable entrée, l'opérateur non sortira faux et de même si la fausse condition est donnée au PAS opérateur, il renverra une vraie valeur. Ci-dessous les lignes de code expliquent le PAS Syntaxe de l'opérateur en C #:

si (!condition 1)

// code pour exécuter si la condition1 est fausse

Utilisation de l'opérateur XOR (^)

Le xor en C Sharp est indiqué avec le "^" (circonflexe) Symbole. Il effectue une exclusivité logique ou une opération sur deux opérandes.

La sortie sera vraie si une condition est vraie, la seconde est fausse et vice versa. La sortie sera fausse si les deux conditions sont vraies ou fausses.

if (condition1 ^ condition2)

// Code pour exécuter si Condition1 est vrai ou condition2 est faux et vice versa

Exemple de code des quatre opérateurs et (&&), ou (||), pas (!), et xor (^)

Suivant le code donné explique l'utilisation des quatre opérateurs en C #.

Utilisation du système;
Exemple d'espace de noms

programme de classe

statique void main (String [] args)

int num1 = 25, num2 = 5;
bool bool1 = false, résultat;
// et opérateur
résultat = (num1> = num2) && (num1 < 20);
Console.WriteLine ("et opérateur:" + résultat);
// ou opérateur
résultat = (num1 < num2) || (num1 >= 30);
Console.WriteLine ("ou opérateur:" + résultat);
// pas opérateur
résultat = !bool1;
Console.WriteLine ("Non opérateur:" + résultat);
result = (num1> num2) ^ (num1> 20);
Console.WriteLine ("Opérateur XOR:" + Résultat);
Console.WriteLine ("Appuyez sur la touche Entrée pour quitter…");
Console.ReadLine ();

Dans ce code, nous avons deux variables entières num1 et num2, et une variable booléenne bool1 initialisé avec faux.

Nous utilisons l'opérateur, ou opérateur et opérateur XOR pour évaluer chacun deux expressions booléennes et attribuer les valeurs booléennes résultantes à la variable de résultat.

Nous utilisons également l'opérateur Not pour inverser la valeur du bool1 variable et attribuer la valeur booléenne résultante à la variable de résultat.

Enfin, nous affichons les résultats des quatre opérateurs en utilisant le Console.WriteLine () Méthode et attendre que l'utilisateur appuye sur la touche Entrée avant de quitter le programme.

Conclusion

Les opérateurs logiques booléens sont largement utilisés en C #. Ces opérateurs nous permettent de créer des conditions et de générer ou de vérifier la sortie spécifique. En utilisant la syntaxe détaillée et l'exemple de code expliqués dans cet article, nous pouvons facilement implémenter des opérateurs booléens en C #.