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

Содержание

Логические операторы C#
Условный оператор if..else
- Пример работы условного оператора if
Логические операции в C#
Итого

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

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

Унарные:

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

Бинарные:

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

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

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

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

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

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

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

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

Например,

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

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

False

Операторы равенства в 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 соблюдается.

Скачать код проекта из Github

При разработке приложений в 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));
            }
        }
    }
}

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

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

Этот оператор также называют логическим умножением. Чтобы понять почему именно такое название, достаточно помнить, то значение логическое значение true в двоичной системе счисления определяется как единица (1), а значение false — как ноль (0). Теперь вернемся к п.4 решения нашей задачи и заменим все логические значения и оператор & на обычные математические. В результате выражение:

false & true = false

становится простым математическим примером:

0 * 1 = 0 (ноль умножить на один равно нулю)

Скачать код проекта из Github

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

Так же, как и предыдущий оператор, логическое ИЛИ обрабатывает оба операнда. В отличие от логического И этот оператор вернет 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));
            }
        }
    }
}

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

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

Оператор | также называют логическим сложением. Причина та же, что и в случае с оператором &. Снова заменим всю «логику» на «математику» и выражение

false | true

превращается в

0 + 1 = 1 (ноль плюс один равно единице)

Скачать код проекта из Github

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

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

a	b	Результат ^
True	True	False
False	False	False
True	False	True
False	True	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 (третья строка в таблице выше)

Скачать код проекта из Github

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

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

a	b	Результат &&
True	True	True (правый операнд обработан)
False	False	False (правый операнд не обработан)
True	False	False (правый операнд обработан)
False	True	False (правый операнд не обработан

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

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

False

Правый операнд обработан

False

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

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

a	b	Результат \|\|
True	True	True (правый не операнд обработан)
False	False	False (правый операнд обработан)
True	False	True (правый не операнд обработан)
False	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

Правый операнд обработан

False

True

Правый операнд обработан

True

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

Итого

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Итого

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

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

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

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

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

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