Операторы и управление потоком

Условная конструкция нужна, когда программа должна действовать по-разному в зависимости от данных. Условие не описывает действие само по себе: оно вычисляет ответ, который приводится к bool. Например, age >= 18 проверяет ограничение, а тело if задаёт, что сделать при успешной проверке. Даже короткие ветви удобно оформлять фигурными скобками, чтобы их границы были очевидны.

В цепочке if / else if / else срабатывает первая подходящая ветвь. Несколько отдельных if работают иначе: программа проверяет каждый из них, поэтому может выполнить сразу несколько действий. Выбирайте форму по смыслу задачи. Для оценки «плохо, достаточно, хорошо» обычно нужен один из взаимоисключающих вариантов; для нескольких независимых проверок могут понадобиться отдельные условия.

if (score >= 90) {
    std::cout << "Отлично";
} else if (score >= 60) {
    std::cout << "Зачёт";
} else {
    std::cout << "Пересдача";
}

switch (x) {
    case 1:
        std::cout << "A";
        // нет break: fallthrough
    case 2:
        std::cout << "B";
        break;
    default:
        std::cout << "C";
}

Цикл позволяет описать повторяющуюся работу один раз: прочитать несколько чисел, пройти по строке или накопить сумму. У любого конечного цикла должна быть понятна причина остановки. Перед запуском проверьте, какое состояние есть в начале, что меняется после каждого шага и почему условие когда-нибудь перестанет выполняться. Это помогает заметить бесконечное повторение ещё до отладки.

while (condition()) {
    work();
}

do {
    work();
} while (condition());

for (int i = 0; i < 5; ++i) {
    std::cout << i;
}

У цикла for (int i = 0; i < 3; ++i) сначала один раз создаётся i, затем проверяется условие, выполняется тело и только потом делается шаг ++i. В тело попадут значения 0, 1 и 2. Инструкция continue пропускает остаток текущего тела, после чего у такого for выполняется шаг цикла; break завершает цикл целиком.

for (int i=0; i<3; ++i) {
  sum += i;
}

#include <iostream>
#include <vector>

int main() {
    std::vector<int> values{2, 4, 6};
    int total = 0;
    for (int value : values) {
        total += value;
    }
    std::cout << total << '\n';
}

#include <iostream>

int main() {
    for (int value = 1; value <= 8; ++value) {
        if (value == 6) {
            break;
        }
        if (value % 2 == 0) {
            continue;
        }
        std::cout << value << ' ';
    }
    std::cout << '\n';
}

for (int i = 0; i < 3; ++i) {
    if (i == 1) continue;
    if (i == 2) break;
}

// C++17: инициализация в условном операторе
if (int x = calculate(); x > 0) {
    use(x);
}

Разобранный пример и самостоятельная проверка

Цикл описывает повторение, но важно, когда он решает, выполнять ли тело. While сначала проверяет условие. Если оно ложно уже в начале, тело не выполняется ни разу. Do while сначала выполняет тело и только затем проверяет продолжение. Поэтому даже при ложном начальном условии один проход уже произойдёт. В программе ниже переменные before и after считают фактически выполненные тела. При n, равном нулю, получатся разные результаты. Измените n на один и три и заранее составьте таблицу значений после каждого прохода. For обычно объединяет начальное состояние, условие и шаг, но порядок его обычной работы также начинается с проверки. Нажатие «следующий шаг» в модели должно показывать конкретную инструкцию, а не просто увеличивать число проходов. До первого шага счётчик выполненных тел равен нулю у всех трёх циклов. Условие остановки нужно объяснять изменением состояния.

#include <iostream>

int main() {
    const int n = 0;
    int before = 0;
    while (before < n) {
        ++before;
    }
    int after = 0;
    do {
        ++after;
    } while (after < n);
    std::cout << before << ' ' << after << '\n';
}

Инкремент увеличивает переменную на единицу, а декремент уменьшает. Важно различать два результата: новое состояние переменной и значение самого выражения с ++. Если выражение записано отдельной инструкцией, как ++count;, обычно нужен только факт увеличения. Когда его результат присваивается другой переменной или передаётся дальше, разница между префиксной и постфиксной формой становится заметной.

Пусть x равно пяти. После отдельной инструкции int old = x++; переменная old содержит пять, а x — шесть. Если затем выполнить int current = ++x;, сначала x станет равно семи, и это же значение получит current. Разбирайте эти шаги по одному: так проще не перепутать сохранённое прежнее значение с уже изменившейся переменной.

#include <iostream>

int main() {
    int value = 5;
    int before = value++;
    int after = ++value;
    std::cout << before << ' ' << after << ' ' << value << '\n';
}

#include <iostream>

int main() {
    int total = 0;
    for (int i = 0; i < 4; ++i) {
        total += i;
    }
    std::cout << total << '\n';
}

int x = 5;
int a = ++x;        // x == 6, a == 6
int b = x++;        // b == 6, x == 7
++x = 9;            // корректно: меняем x
// x++ = 9;          // ошибка компиляции

Условный оператор полезен, когда из двух вариантов нужно получить одно значение: подпись, число или результат расчёта. В записи score >= 60 ? "passed" : "retry" условие отвечает за выбор одной из строк. Это именно выражение (его результат можно присвоить переменной), поэтому оно отличается от конструкции if, которая прежде всего управляет выполнением инструкций.

То, что одна ветвь не вычисляется, не означает, что компилятор может полностью игнорировать её запись. Он всё равно должен проверить корректность выражения и определить тип результата. Если в обеих ветвях нужны длинные действия, несколько присваиваний или вложенные проверки, обычный if / else будет понятнее. Условный оператор лучше оставлять коротким выбором значения, который легко прочитать целиком.

#include <iostream>
#include <string>

int main() {
    int score = 72;
    std::string status = score >= 60 ? "passed" : "retry";
    std::cout << status << '\n';
}

#include <iostream>

int left() {
    std::cout << "left\n";
    return 10;
}
int right() {
    std::cout << "right\n";
    return 20;
}

int main() {
    bool choose_left = false;
    int result = choose_left ? left() : right();
    std::cout << result << '\n';
}

bool ok = true;
int x = 2, y = 5;
(ok ? x : y) = 10;    // x = 10 (lvalue)
double a = ok ? 1 : 0.5; // тип выражения double
// (ok ? x : x + 1) = 3; // ошибка компиляции

Сложное выражение сначала нужно правильно прочитать, расставив подразумеваемые скобки. Это задача приоритета и ассоциативности. Например, 10 - 3 - 2 означает (10 - 3) - 2, поэтому результат равен пяти. Если написать 10 - (3 - 2), получится девять. Те же символы и числа дали другой результат из-за другой структуры выражения.

После расстановки скобок ещё нельзя автоматически рассказывать, что процессор «сначала посчитает левую часть». Скобки показывают, какие результаты используются какими операциями, но не заменяют правила порядка вычислений. Когда выражение содержит вызовы функций или изменение переменных, эти вопросы нужно разобрать отдельно. Если структура не очевидна читателю, явные скобки обычно полезнее попытки запомнить всю таблицу приоритетов.

У одного символа в C++ могут быть разные роли. Запятая иногда разделяет независимые части записи, а иногда сама является оператором с собственным результатом. Чтобы различить случаи, смотрите на конструкцию целиком: список аргументов функции — одна грамматическая форма, а выражение в скобках (first, second) может означать последовательное вычисление через оператор запятой.

int x = 1, y = 2;     // запятая-разделитель
int z = (x++, y + 5); // оператор запятая: x=2, z=7
f(x, y);              // два аргумента, НЕ оператор
f((x++, y));          // ОДИН аргумент = y

С sizeof полезно задавать вопрос: «Размер чего именно я сейчас узнаю?». Для int x = 5; выражение sizeof(x++) не увеличит x, потому что этот операнд не вычисляется. Для vector размер самого объекта контейнера не включает отдельно выделенную память его элементов. А количество хранимых значений узнают через size(), а не через sizeof.

#include <vector>
#include <cstddef>

std::vector<int> v = {1, 2, 3};
std::size_t bytes = sizeof(v); // размер объекта v
std::size_t count = v.size();  // 3 элемента
std::size_t capacity = v.capacity(); // >= 3

В выражении бывают не только вычисления чисел, но и действия: функция что-то печатает, переменная увеличивается, контейнер меняется. Такие изменения называют побочными эффектами (они остаются в программе помимо полученного значения). Когда несколько действий помещены в одну строку, необходимо понимать, какие из них язык гарантированно упорядочивает, а какие не обещает выполнять в выбранной вами последовательности.

Если важно сначала вызвать read(), затем transform() и только после этого сложить результаты, запишите эти шаги отдельными инструкциями. Это одновременно делает намерение очевидным и позволяет отдельно проверить каждое промежуточное значение. Не пытайтесь устанавливать правила языка по одному запуску сложного выражения: другой компилятор или другой режим сборки может выбрать иной допустимый порядок.

int i = 0;
// int bad = i++ + i++; // UB: два неупорядоченных изменения
int a = i++;
int b = i++; // два отдельных полных выражения: корректно

bool ok = false;
if (ok && (++i > 0)) { /* ++i не выполнится */ }

Компилятор не читает исходный код как человек, угадывающий намерения автора. Сначала он выделяет токены (значимые кусочки записи), и только затем собирает из них выражения и инструкции. Поэтому несколько соседних плюсов могут превратиться не в те операции, которые вы мысленно подразумевали. Пробелы и понятное форматирование помогают явно показать нужные границы.

Сравните a++ + b и a + ++b. В первой записи увеличивается a, но в сумму попадает его прежнее значение. Во второй сначала увеличивается b, и в сумму идёт уже новое значение b. Слитная запись a+++b разбирается как первый вариант. Если результат неожиданен, сначала выпишите отдельные токены, а уже потом применяйте правила приоритета.

int a = 1, b = 2;
int q = a+++b;      // a++ + b
int r = a + ++b;    // другая группировка
// a++++;           // (a++)++ — ошибка
++++a;              // ++(++a) — корректно для int