Логические операторы C#

Логические операторы C# предназначены для выстраивания логики программы, например, они позволяют определить какое действие должна выполнить программа в результате получение какого-либо значения выражения. В C# логические операторы, как и арифметические могут быть унарными и бинарными.

Логические операторы C#

Унарные:

• логическое отрицание (!)

Бинарные:

• логическое И (&),
• логическое ИЛИ (|),
• логическое исключающее ИЛИ  (^).
• условное логическое И (&&)
• условное логическое ИЛИ  (||)

Операторы равенства:

• равенство (==)
• неравенство (!=)

Операторы сравнения

• меньше чем (<),
• больше чем (>),
• меньше или равно (<=)
• больше или равно (>=)

Теперь рассмотрим более подробно логические операторы в C#.

Унарный логический оператор (!)

Унарный префиксный оператор ! выполняет логическое отрицание операнда, то есть, возвращает true, если операнд имеет значение false, и, наоборот, false, если операнд имеет значение true. Этот оператор работает аналогично арифметическому унарному оператору -, т.е. меняет какое-либо логическое значение на противоположное.

Например,

bool b = true;
Console.WriteLine(!b);

вернет нам в консоль строку

Операторы равенства в C#

Операторы равенства возвращают значение true (истина), если условие верно и false (ложь) в противоположном случае. В C# используются два оператора равенства.

Равенство (==)

Этот оператор возвращает true, если оба операнда равны. Например,

int a = 1;
int b = 2;
Console.WriteLine(a == b); //False, так как a НЕ равно b

int с = 1 + 2 + 3; //значение переменной с = 6
int d = 6;
Console.WriteLine(c == d); //True, так как и c и d равны 6

Неравенство (!=)

Оператор вернет true, если операнды не равны между собой. Действие оператора аналогично оператору равенства. Например,

int a = 1; 
int b = 2; 
Console.WriteLine(a != b); //True, так как a НЕ РАВНО b

Операторы сравнения

Эти операторы поддерживаются всеми целочисленными типами и типами с плавающей запятой.

Меньше чем (<)

Оператор < возвращает true, если его левый операнд строго меньше правого. В противном случае возвращается false. Например,

int a = 1; 
int b = 2; 
Console.WriteLine(a < b); //True, так как a СТРОГО МЕНЬШЕ b

Больше чем (>)

Оператор > возвращает true, если его левый операнд строго больше правого. В противном случае возвращается false. Например,

int a = 1; 
int b = 2; 
Console.WriteLine(a > b); //FALSE, так как a МЕНЬШЕ b

Меньше или равно (<=)

Оператор <= возвращает true, если его левый операнд меньше или равен правому. В противном случае возвращается false. Например,

int a = 2; 
int b = 2; 
Console.WriteLine(a <= b); //True, так как a равно b

Больше или равно (>=)

Оператор >= возвращает true, если его левый операнд больше или равен правому. В противном случае возвращается false. Например,

int a = 3; 
int b = 2; Console.WriteLine(a >= b); //True, так как a больше b

Для дальнейшего рассмотрения темы логических операторов в C# стоит затронуть вопрос о таком условном операторе, как if..else

Условный оператор if..else

Логические операторы C# часто используются с условным оператором if..else . В C# этот операторы выглядит следующим образом:

if (условие)
  {действие 1};
else
  {действие 2};

Этот оператор действует следующим образом:

• если выполняется условие, то программы переходит на действие 1,
• иначе — на действие 2.

Пример работы условного оператора if

Рассмотрим такую задачу: заданы два числа a и b, если a меньше b, то необходимо вывести на экран их сумму, иначе — вывести на экран их разность.

Эту задачу можно решить с использованием условного оператора if следующим образом:

namespace OperatorIf
{
    internal class Program
    {
        static void Main(string[] args)
        {
            int a = 3; //задаем значение переменной a
            int b = 4; //задаем значение переменной b
            if (a < b) //проверяем условие: a меньше, чем b
            {
                Console.WriteLine(a + b); //если условие соблюдается 
            }
            else 
            {
                Console.WriteLine(a - b); //если условие НЕ соблюдается 
            }
        }
    }
}

В результате, мы увидим в консоли значение 7 так как условие a<b соблюдается.

При разработке приложений в C# нам часто будет необходимо производить какие-то логические операции, которые потребуют сравнения не двух, а сразу группы операндов. В этом случае, мы можем использовать различные логические операторы C# для конструирования самых разнообразных условий.

Логические операции в C#

Логическое И (&)

Это оператор всегда обрабатывает оба операнда и возвращает True только в том случае, если оба оператора равны True.

Пример использования логического И

Например, решим такую задачу

даны два числа a и b. Если оба числа больше 2, то вывести на экран их сумму, иначе — утроенную сумму.

Без оператора & мы могли бы решить эту задачу так:

namespace OperatorAnd
{
    internal class Program
    {
        static void Main(string[] args)
        {
            int a = 2;
            int b = 3;
            if (a > 2) //проверяем, что a больше 2
            {
                if (b > 2)
                {
                    //b тоже больше двух - выводим сумму a + b
                    Console.WriteLine(a + b);
                }
                else 
                {
                    //b меньше или равно 2 - условие задачи не соблюдается - выводим утроенную сумму
                    Console.WriteLine(3*(a + b));
                }
            }
            else 
            {
                //переменная a меньше 2, следовательно, b можно не проверять - условие задачи уже не соблюдается 
                //следовательно - выводим утроенную сумму
                Console.WriteLine(3 * (a + b));
            }
        }
    }
}

здесь мы последовательно проверяем условие для каждой переменной и, исходя из результатов проверки, выполняем арифметические операции. Код, конечно, рабочий, но, используя оператор & мы можем сделать его намного короче:

namespace OperatorAnd
{
    internal class Program
    {
        static void Main(string[] args)
        {
            int a = 2;
            int b = 3;
            if ((a > 2) & (b > 2))
            {
                Console.WriteLine(a + b);
            }
            else
            {
                Console.WriteLine(3 * (a + b));
            }
        }
    }
}

В данном случае, наша программа будет действовать следующим образом:

1. присваиваются значения переменным a и b
2. проверяется первое условие оператора if: a > 2. Это условие ложно, так как a = 2. Следовательно левый операнд для оператора & будет равен false
3. проверяется второе условие оператора if: b > 2. Это условие истинно, так как b = 3. Следовательно правый операнд оператора & будет равен true
4. проверяется условие false & true. Так как один из операндов равен false, то результатом выполнения оператора будет также false
5. так как условие оператора if не соблюдается (равно false), то переходим к ветке else условного оператора и считаем утроенную сумму

Логическое ИЛИ (|)

Так же, как и предыдущий оператор, логическое ИЛИ обрабатывает оба операнда. В отличие от логического И этот оператор вернет True, если хотя бы один операнд будет иметь значение True.

Пример использования логического ИЛИ

Перефразируем предыдущую задачу следующим образом:

даны два числа a и b. Если хотя бы одно число больше 2, то вывести на экран их сумму, иначе — утроенную сумму.

Решение задачи будет следующим:

namespace OperatorOr
{
    internal class Program
    {
        static void Main(string[] args)
        {
            int a = 2;
            int b = 3;
            
            if ((a > 2) | (b > 2))
            {
                Console.WriteLine(a + b);
            }
            else
            {
                Console.WriteLine(3 * (a + b));
            }
        }
    }
}

В данном случае, наша программа будет действовать следующим образом:

1. присваиваются значения переменным a и b
2. проверяется первое условие оператора if: a > 2. Это условие ложно, так как a = 2. Следовательно левый операнд для оператора | будет равен false
3. проверяется второе условие оператора if: b > 2. Это условие истинно, так как b = 3. Следовательно правый операнд оператора |  будет равен true
4. проверяется условие false | true. Так как один из операндов равен true, то результатом выполнения оператора будет также true
5. так как условие оператора if  соблюдается (равно true), то выполняется основная ветка условного оператора и считается сумма a + b.

Логическое исключающее ИЛИ  (^).

Вычисляет оба операнда, но возвращает True только в том случае, если левый и правы операторы не равны, то есть результат применения этого оператора можно представить следующим образом:

Пример использования логического исключающего ИЛИ

Рассмотрим следующую задачу:

Даны два числа, если первое входит в диапазон [-10; 0], то второе не должно входить в диапазон [1; 10], и наоборот. Вывести сообщение об ошибке, если оба числа входят в указанные для них диапазоны.

Эту задачу можно решить, используя логическое исключающее ИЛИ следующим образом

namespace OperatorXOR
{
    internal class Program
    {
        static void Main(string[] args)
        {
            int a = -1;
            int b = -2;

            bool left = (a < 0) & (a > -10); //true - если число a входит в диапазон
            bool right = (b > 1) & (b < 10); //true - если число b входит в диапазон

            if (left ^ right)
            {
                Console.WriteLine("Условие соблюдается - одно из чисел не входит в заданный диапазон");
            }
            else 
            {
                Console.WriteLine("Ошибка - оба числа входят в свои диапазоны");
            }
        }
    }
}

Здесь, чтобы код программы было по-легче читать, мы ввели дополнительно две переменные типа bool — left и right, которые, соответственно, будут содержать результаты определения того, входит ли число в свой диапазон. Так как по значениям переменных a и b видно, что переменная b не входит в свой диапазон, то программа выведет сообщение о том, что условие соблюдается. То есть проверятся будет условие true ^ false (третья строка в таблице выше)

Условное логическое И (&&)

В отличие от предыдущих бинарных логических операторов C# этот оператор обрабатывает правый операнд только тогда, когда это необходимо. Действие этого оператора следующее — он возвращает True только тогда, когда оба оператора равны True.

Код, демонстрирующий работу оператора представлен ниже

class Program
    {
        static bool Eval(bool b)
        {
            Console.WriteLine("Правый операнд обработан");
            return b;
        }
        static void Main(string[] args)
        {
            bool a = true;
            bool b = true;
            Console.WriteLine(a && Eval(b)); 

            a = false;
            b = false;
            Console.WriteLine(a && Eval(b)); 

            a = true;
            b = false;
            Console.WriteLine(a && Eval(b)); 

            a = false;
            b = true;
            Console.WriteLine(a && Eval(b)); 

            Console.ReadLine();
        }
    }
    }

Вывод консоли будет следующим

Условное логическое ИЛИ  (||)

Также, как и предыдущий оператор, условное логическое ИЛИ обрабатывает правый оператор только когда необходимо. При этом результат выполнения условного логического ИЛИ будет True, если хотя бы один из операндов равен True.

Код, демонстрирующий поведение уловного логического ИЛИ представлен ниже:

class Program
    {
        static bool Eval(bool b)
        {
            Console.WriteLine("Правый операнд обработан");
            return b;
        }
        static void Main(string[] args)
        {
            bool a = true;
            bool b = true;
            Console.WriteLine(a || Eval(b)); 

            a = false;
            b = false;
            Console.WriteLine(a || Eval(b)); 

            a = true;
            b = false;
            Console.WriteLine(a || Eval(b)); 

            a = false;
            b = true;
            Console.WriteLine(a || Eval(b)); 

            Console.ReadLine();
        }
    }

Вывод консоли будет следующим:

Следует отметить, что условные логические операторы && или || используются в C# намного более чаще, чем обычные & и | так как позволяют избегать лишних проверок и, тем самым, экономить время выполнения операция, повышая производительность программных продуктов.

Итого

Сегодня мы познакомились с логическими операторами в C#, а также рассмотрели некоторые особенности использования этих операторов. На данный момент мы знаем, что такое переменная, как объявлять и инициализировать переменные, какие типы данных есть в C#, а также какие арифметические и логические операторы мы можем применять в своих приложения на C#.