Условная конструкция if-else направляет ход программы по одному из возможных путей в зависимости от условия. Она проверяет истинность условия, и если оно истинно, выполняет блок инструкций. В простейшем виде конструкция if имеет следующую сокращенную форму:
if (условие)
{
инструкции;
}
В качестве условия использоваться условное выражение, которое возвращает true или false. Если условие возвращает true, то выполняются последующие инструкции, которые входят в блок if. Если условие возвращает false, то последующие инструкции не выполняются. Блок инструкций заключается в фигурные скобки. Например:
#include <iostream>
int main()
{
int a {8};
if(a == 8)
{
std::cout << "a == 8" << std::endl;
}
std::cout << "End of program" << std::endl;
}
Здесь условие конструкции if представляет выражение a == 8, то есть мы сравниваем, равно ли значение переменной a числу 8.
И это условие верно и возвращает true. Соответственно будет выполняться единственная инструкция из блока if, которая выведет на консоль строку "a == 8". А консольный вывод будет следующим:
a == 8 End of program
После конструкции if могут идти остальные инструкции программы, которые выполняются вне зависимости от условия. Так, в примере выше после блока if идет инструкция, которая выводит на консоль строку
"End of program".
Теперь посмотрим на противоположную ситуацию:
#include <iostream>
int main()
{
int a {8};
if(a == 7)
{
std::cout << "a == 7" << std::endl;
}
std::cout << "End of program" << std::endl;
}
Здесь уже другое условие: a == 7, то есть мы сравниваем, равно ли значение переменной a числу 7. Но переменная
a НЕ равна 7, поэтому условие неверно и возвращает false. Соответственно инструкции в блоке if НЕ выполняются. А консольный вывод будет следующим:
End of program
Стоит отметить, что если блок инструкций состоит из одной инструкции, то мы можем не использовать фигурные скобки:
#include <iostream>
int main()
{
int a {8};
if(a == 8) // только одна инструкция
std::cout << "a == 8" << std::endl;
std::cout << "End of program" << std::endl;
}
Можно вовсе поместить инструкцию на одной строке с условием:
if(a == 8) std::cout << "a == 8" << std::endl;
Также мы можем использовать полную форму конструкции if, которая включает оператор else:
if(выражение_условия)
{
инструкция_1
}
else
{
инструкция_2
}
После оператора else мы можем определить набор инструкций, которые выполняются, если условие в операторе if возвращает false. То есть если
условие истинно, выполняются инструкции после оператора if, а если это выражение ложно, то выполняются инструкции после оператора else.
#include <iostream>
int main()
{
int n {21};
if (n > 22)
{
std::cout << "n > 22" << std::endl;
}
else
{
std::cout << "n <= 22" << std::endl;
}
}
В данном случае условие n > 22 ложно, то есть возвращает false, поэтому будет выполняться блок else. И в итоге на консоль будет выведена строка
"n <= 22".
Однако нередко надо обработать не два возможных альтернативных варианта, а гораздо больше. Например, в случае выше можно насчитать три условия: переменная n может быть больше 22, меньше 22 и равна 22. Для проверки альтернативных условий мы можем вводить выражения else if:
#include <iostream>
int main()
{
int n {21};
if (n > 22)
{
std::cout << "n > 22" << std::endl;
}
else if (n < 22)
{
std::cout << "n < 22" << std::endl;
}
else
{
std::cout << "n == 22" << std::endl;
}
}
То есть в данном случае мы получаем три ветки развития событий в программе.
Подобных альтернативных условий с помощью выражения else if можно вводить больше одного:
#include <iostream>
int main()
{
int n {21};
if (n == 20)
{
std::cout << "n == 20" << std::endl;
}
else if(n==21)
{
std::cout << "n == 21" << std::endl;
}
else if(n==22)
{
std::cout << "n == 22" << std::endl;
}
else if(n==23)
{
std::cout << "n == 23" << std::endl;
}
}
Если в блоке if или else или else-if необходимо выполнить только одну инструкцию, то фигурные скобки можно опустить:
#include <iostream>
int main()
{
int n {21};
if (n > 22)
std::cout << "n > 22" << std::endl;
else if (n < 22)
std::cout << "n < 22" << std::endl;
else
std::cout << "n == 22" << std::endl;
}
Стоит отметить, что если вместо значений типа bool передаются целые числа, то они преобразуются к типу bool - для нулевых значений возвращается
false, для ненулевых - true, например:
#include <iostream>
int main()
{
int a {8};
// a = true
if(a) std::cout << "a = true" << std::endl;
else std::cout << "a = false" << std::endl;
int b {};
// b = false
if(b) std::cout << "b = true" << std::endl;
else std::cout << "b = false" << std::endl;
}
Здесь переменная a равна 8, соответственно условие if(a) будет равно true. А вот переменная b по умолчанию равна 0, поэтому
условие в if(b) возвращает false.
Конструкции if..else могут быть вложенными. Например:
#include <iostream>
int main()
{
int a {5};
int b {8};
if(a==5)
{
if(b==8)
{
std::cout << "b == 8" << std::endl;
}
else
{
std::cout << "b != 8" << std::endl;
}
std::cout << "a == 5" << std::endl;
}
else
{
std::cout << "a != 5 " << std::endl;
}
}
Здесь, если a == 5, то выполнение переходит к вложенноей конструкции if(b==8), которая проверяет условие b==8 и выполняет либо блок if,
либо блок else.
Иногда в конструкции if для различных промежуточных вычислений необходимо определить переменную. Мы можем это сделать непосредственно в блоке кода. Однако начиная со стандарта
C++17 язык С++ поддерживает особую форму конструкции if:
if(инициализация; условие)
{
// инструкции
}
Подобная форма также принимает условие, только перед ним еще может идти определение и инициализация переменной. Например:
#include <iostream>
int main()
{
int a {5};
int b {3};
if(int c {a - b}; a > b)
{
std::cout << "a=" << a << "; c=" << c << std::endl;
}
else
{
std::cout << "b=" << b << "; c=" << c << std::endl;
}
}
В данном случае выражение инициализации int c {a - b} представляет определение и инициализацию переменной c. Дальше идет условие a > b.
Если оно верно, то выполняется инструкция
std::cout << "a=" << a << "; c=" << c << std::endl;
иначе выполняется инструкция
std::cout << "b=" << b << "; c=" << c << std::endl;
Но в обоих случаях мы можем использовать переменную c. Вне конструкции if-else переменная c не доступна.
Другой пример. Допустим, нам надо выяснить, делится ли одно число на другое без остатка. Если же есть остаток, то вывести его на консоль:
#include <iostream>
int main()
{
int a {5};
int b {3};
if(int rem {a % b}; rem == 0)
{
std::cout << "a divisible by b" << std::endl;
}
else
{
std::cout << "remaining of a / b = " << rem << std::endl;
}
}
В данном случае в конструкции if определяется переменная rem, которая представляет остаток от деления a на b.
Тернарный оператор в некотором роде похож на конструкцию if-else. Он принимает три операнда в следующем виде:
операнд1? операнд2 : операнд3
Первый операнд представляет условие. Если это условие верно (равно true), тогда выбирается/выполняется второй операнд, который помещается после символа ?. Если условие не верно, тогда выбирается/выполняется третий операнд, который помещается после двоеточия.
Например, возьмем следующую конструкцию if-else:
#include <iostream>
int main()
{
int a {5};
int b {8};
int c{};
if(a > b)
{
c = a - b;
}
else
{
c = a + b;
}
std::cout << "c = " << c << std::endl; // c = 13
}
Здесь если a больше b, то c=a-b, иначе c=a+b. Перепишем ее с помощью тернарного оператора:
#include <iostream>
int main()
{
int a {5};
int b {8};
int c = a > b ? a - b : a + b;
std::cout << "c = " << c << std::endl; // c = 13
}
Здесь первым операндом тернарного оператора является условие a > b. Если это условие верно, то возвращается второй операнд - результат
выражения a - b. Если условие не верно, то возвращается третий операнд - a + b. И возвращенный операнд присваивается переменной c.
Тернарный оператор не обязательно должен возвращать некоторое значение, он может просто выполнять некоторые действия. Например:
#include <iostream>
int main()
{
int a {5};
int b {8};
a > b ? std::cout << a-b : std::cout << a+b;
}
Здесь тот же первый операнд-условие. Если оно верно, выполняется второй операнд - std::cout << a-b, если нет, то третий операнд - std::cout << a+b.
В рамках одного тернарного оператора можно комбинировать несколько других. Например:
#include <iostream>
int main()
{
int a {5};
int b {8};
std::cout << (a < b ? "a is less than b" :
(a == b ? "a is equal to b" : "a is greater than b"));
}
Здесь условие представляет выражение a < b. Если оно верно, то возвращается второй операнд - строка "a is less than b". Но если условие не верно, то возвращается третий операнд,
который, в свою очередь, представляет другой тернарный оператор (a == b ? "a is equal to b" : "a is greater than b"). Здесь опять же оценивается условие-первый операнд
a == b. Если оно верно, то возвращается строка "a is equal to b". Если нет, то строка - "a is greater than b".