Условные выражения

Условные выражения представляют собой некоторое условие и возвращают значение типа bool, то есть значение true (если условие истинно), либо значение false (если условие ложно). К условным выражениям относятся операции сравнения и логические операции.

Операции сравнения

В языке программирования C++ есть следующие операции сравнения:

• ==

  Операция "равно". Возвращает true, если оба операнда равны, и false, если они не равны:

  int a {10};
  int b {4};
  bool c {a == b};	// false
  bool d {a == 10};	// true
  

• >

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

  int a {10};
  int b {4};
  bool c {a > b};	// true
  

• <

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

  bool c {10 < 4};	// false
  

• <=

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

  bool c = 10 <= 4;	// false
  bool d = 10 <= 14;	// true
  

• >=

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

  bool c = 10 >= 4;	// true
  bool d = 10 >= 14;	// false
  

• !=

  Операция "не равно". Возвращает true, если первый операнд не равен второму, и false, если оба операнда равны:

  bool c {10 != 4};	// true
  bool d = 4 != 4;	// false
  

Стоит отметить, что если мы выводим значение типа bool на консоль, то по умолчанию на консоль выводится 1 (если true) и 0 (если false):

#include <iostream> 

int main()
{
    int a {8};
    int b {11};
    bool c {a == b};    // false
    bool d {a != b};    // true
    std::cout << "c = " << c << std::endl;  // c = 0
    std::cout << "d = " << d << std::endl;  // d = 1
}

Чтобы все-таки вывести true/false, перед выводимым значением указывается манипулятор std::boolalpha:

#include <iostream> 

int main()
{
    int a {8};
    int b {11};
    bool c {a == b};    // false
    bool d {a != b};    // true
    std::cout << "c = " << std::boolalpha << c << std::endl;  // c = false
    std::cout << "d = " << std::boolalpha << d << std::endl;  // d = true
}

Обычно операции сравнения применяются в условных конструкциях типа if...else, которые будут рассмотрены далее.

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

Логические операции обычно объединяют несколько операций сравнения. К логическим операциям относят следующие:

• ! (операция отрицания)

  Унарная операция, которая возвращает true, если операнд равен false. Если операнд равен true, операция возвращает false.

  bool a {true};
  bool b {!a};	// false
  bool c {!b};	// true
  

• && (конъюнкция, логическое умножение)

  Возвращает true, если оба операнда не равны false. Возвращает false, если хотя бы один операнд равен false.

  bool a {true};
  bool b {false};
  bool c {a && b};	// false
  bool d {a && true};	// true
  

• || (дизъюнкция, логическое сложение)

  Возвращает true, если хотя бы один операнд равен true. Возвращает false, если оба операнда равны false.

  bool a {true};
  bool b {false};
  bool c {a || b};		// true
  bool d {b || false};	// false
  

• ^ ( XOR или eXclusive OR)

  Возвращает true, если хотя бы оба операнда имеют разные значения. Возвращает false, если оба операнда равны.

  bool a {true};
  bool b {false};
  bool c {a ^ b};		     // true
  bool d {b ^ false};	    // false
  bool d {a ^ true};	    // false
  

Логические операции удобно применять для объединения операций сравнения или других логических операций:

#include <iostream> 

int main()
{
    int a {5};
    int b {8};
    bool result1 = a ==5 && b > 8;  // если и a ==5, и b > 8
    bool result2 = a ==5 || b > 8;  // если или a ==5, или b > 8 (или оба варианты истины)
    bool result3 = a ==5 ^ b > 8;  // если оба операнда возвращают разные значения

    std::cout << "(a ==5 && b > 8) - " << std::boolalpha << result1 << std::endl;
    std::cout << "(a ==5 || b > 8) - " << std::boolalpha << result2 << std::endl;
    std::cout << "(a ==5 ^ b > 8) - " << std::boolalpha << result3 << std::endl;
}

Стоит учитывать, что операции сравнения имеют больший приоритет, чем логические операции. Поэтому в выражении a ==5 && b > 8 вначале будут выполняться подвыражения - операции сравнения a ==5 и b > 8, а затем собственно операция логического умножения.

В данном случае первое условие a ==5 && b > 8 будет истинно, если верны одновременно обе операции сравнения. А условие a ==5 || b > 8 будет верно, если хотя бы одна из операций сравнения возвращает true. Соответственно мы получим следующий консольный вывод:

(a ==5 && b > 8) - false
(a ==5 || b > 8) - true
(a ==5 ^ b > 8) - true

Стоит отметить, что логические операторы && и || представляют операторы сокращенного вычисления (short-circuit evaluation). Это значит, что если первый операнд операции достаточен для того, чтобы определить результат всей операции, то второй операнд не вычисляется. Так, возьмем следующую операцию:

int a {5};
int b {8};
bool result1 = a ==6 && b ==8;

Первый операнд, который представляет выражение a ==6, возвращает false. В этом случае для операции && нет смысла вычислять второй операнд, поскольку результат операции в любом случае будет равен false.

Аналогично обстоит дело с операцией ||:

int a {5};
int b {8};
bool result1 = a ==5 || b ==0;

Первый операнд, который представляет выражение a ==5, возвращает true. В этом случае для операции || нет смысла вычислять второй операнд, поскольку результат операции в любом случае будет равен true.