Apprendre Opérateurs Logiques | Structures de Contrôle

Les opérateurs logiques peuvent être utilisés pour combiner deux expressions logiques ou valeurs logiques. Voici les trois opérateurs logiques :

Remarque

Un opérande désigne une valeur ou une expression utilisée comme entrée pour un opérateur dans une instruction ou une expression. Par exemple, dans l'expression 1 + 2, les valeurs 1 et 2 sont des opérandes. Dans le cas des opérateurs logiques, un opérande est toujours une expression ou une valeur booléenne.

Vous pouvez voir l'utilisation de ces opérandes dans les exemples ci-dessous :

Utilisation pratique :

L'opérateur ET (&&) prend deux opérandes et retourne true uniquement si les deux opérandes sont true. Ceci est illustré par le code suivant :

main.cs


              123456789101112131415
            
using System;

namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
			Console.WriteLine(true && true); // Output: True
			Console.WriteLine(true && false); // Output: False
			Console.WriteLine(false && true); // Output: False
			Console.WriteLine(false && false); // Output: False
        }
    }
}

Au lieu d'utiliser directement les littéraux true et false (valeurs), nous utilisons couramment des expressions :

main.cs


              123456789101112131415161718
            
using System;

namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
			/* A program to check if the variable `value` 
            is in the range specified by `range_start` 
            and `range_end` variables.*/
			int value = 7;
			int range_start = 0;
			int range_end = 10;
			Console.WriteLine(range_start < value && value < range_end); // Output: True
        }
    }
}

L'opérateur OU (||) retourne true si au moins un des opérandes est true :

main.cs


              123456789101112131415
            
using System;

namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
			Console.WriteLine(true || true); // Output: True
			Console.WriteLine(true || false); // Output: True
			Console.WriteLine(false || true); // Output: True
			Console.WriteLine(false || false); // Output: False
        }
    }
}

Voici un exemple utilisant l'opérateur OU (||) :

main.cs


              12345678910111213141516
            
using System;

namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
			int val1 = 5;
			int val2 = 7;
			int val3 = 9;

			Console.WriteLine(val2 > val1 || val2 > val3); // Output: True
        }
    }
}

L'opérateur NOT (!) inverse simplement l'expression ou la valeur logique. Ainsi, si une expression retourne true, elle devient false.

main.cs


              1234567891011121314151617
            
using System;

namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
			Console.WriteLine(!true); // Output: False
			Console.WriteLine(!false); // Output: True

			// We need to enclose expressions in brackets () before negating them
			Console.WriteLine(!(5 < 0)); // Output: True
			Console.WriteLine(!(0 < 5 && 5 < 10)); // Output: False
        }
    }
}

Tout était clair ?

Merci pour vos commentaires !

Section 3. Chapitre 2

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

Suggested prompts:

What are some real-world examples of using logical operators?

Can you explain the difference between AND, OR, and NOT with more examples?

How do logical operators work with complex expressions?

Awesome!

Completion rate improved to 1.59

Glissez pour afficher le menu

Les opérateurs logiques peuvent être utilisés pour combiner deux expressions logiques ou valeurs logiques. Voici les trois opérateurs logiques :

Remarque

Un opérande désigne une valeur ou une expression utilisée comme entrée pour un opérateur dans une instruction ou une expression. Par exemple, dans l'expression 1 + 2, les valeurs 1 et 2 sont des opérandes. Dans le cas des opérateurs logiques, un opérande est toujours une expression ou une valeur booléenne.

Vous pouvez voir l'utilisation de ces opérandes dans les exemples ci-dessous :

Utilisation pratique :

L'opérateur ET (&&) prend deux opérandes et retourne true uniquement si les deux opérandes sont true. Ceci est illustré par le code suivant :

main.cs


              123456789101112131415
            
using System;

namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
			Console.WriteLine(true && true); // Output: True
			Console.WriteLine(true && false); // Output: False
			Console.WriteLine(false && true); // Output: False
			Console.WriteLine(false && false); // Output: False
        }
    }
}

Au lieu d'utiliser directement les littéraux true et false (valeurs), nous utilisons couramment des expressions :

main.cs


              123456789101112131415161718
            
using System;

namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
			/* A program to check if the variable `value` 
            is in the range specified by `range_start` 
            and `range_end` variables.*/
			int value = 7;
			int range_start = 0;
			int range_end = 10;
			Console.WriteLine(range_start < value && value < range_end); // Output: True
        }
    }
}

L'opérateur OU (||) retourne true si au moins un des opérandes est true :

main.cs


              123456789101112131415
            
using System;

namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
			Console.WriteLine(true || true); // Output: True
			Console.WriteLine(true || false); // Output: True
			Console.WriteLine(false || true); // Output: True
			Console.WriteLine(false || false); // Output: False
        }
    }
}

Voici un exemple utilisant l'opérateur OU (||) :

main.cs


              12345678910111213141516
            
using System;

namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
			int val1 = 5;
			int val2 = 7;
			int val3 = 9;

			Console.WriteLine(val2 > val1 || val2 > val3); // Output: True
        }
    }
}

L'opérateur NOT (!) inverse simplement l'expression ou la valeur logique. Ainsi, si une expression retourne true, elle devient false.

main.cs


              1234567891011121314151617
            
using System;

namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
			Console.WriteLine(!true); // Output: False
			Console.WriteLine(!false); // Output: True

			// We need to enclose expressions in brackets () before negating them
			Console.WriteLine(!(5 < 0)); // Output: True
			Console.WriteLine(!(0 < 5 && 5 < 10)); // Output: False
        }
    }
}

Tout était clair ?

Merci pour vos commentaires !

Section 3. Chapitre 2