6.1 – Составные инструкции (блоки)

Составная инструкция (также называемая блоком или блочной инструкцией) – это группа из нуля или более инструкций, которая обрабатывается компилятором, как если бы это была одна инструкция.

Блоки начинаются с символа {, заканчиваются символом }, а выполняемые инструкции помещаются между ними. Блоки можно использовать везде, где разрешено использование одной инструкции. В конце блока точка с запятой не нужна.

Вы уже видели пример блоков при написании функций, так как тело функции – это тоже блок:

int add(int x, int y)
{ // начало блока
    return x + y;
} // конец блока (точки с запятой нет)
 
int main()
{ // начало блока
 
    // несколько инструкций
    int value {}; // это инициализация, а не блок
    add(3, 4);
 
    return 0;
 
} // конец блока (точки с запятой нет)

Блоки внутри других блоков

Хотя функции не могут быть вложены в другие функции, но блоки могут быть вложены в другие блоки:

int add(int x, int y)
{ // блок
    return x + y;
} // конец блока
 
int main()
{ // внешний блок
 
    // несколько инструкций
    int value {};
 
    { // внутренний/вложенный блок
        add(3, 4);
    } // конец внутреннего/вложенного блока
 
    return 0;
 
} // конец внешнего блока

Когда блоки вложены, охватывающий блок обычно называется внешним блоком, а закрытый блок – внутренним блоком или вложенным блоком.

Использование блоков для условного выполнения нескольких инструкций

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

Например:

#include <iostream>
 
int main()
{ // начало внешнего блока
    std::cout << "Enter an integer: ";
    int value {};
    std::cin >> value;
    
    if (value >= 0)
    { // начало вложенного блока
        std::cout << value << " is a positive integer (or zero)\n";
        std::cout << "Double this number is " << value * 2 << '\n';
    } // конец вложенного блока
    else
    { // начало другого вложенного блока
        std::cout << value << " is a negative integer\n";
        std::cout << "The positive of this number is " << -value << '\n';
    } // конец другого вложенного блока
 
    return 0;
} // конец внешнего блока 

Если пользователь вводит число 3, эта программа напечатает:

Enter an integer: 3
3 is a positive integer (or zero)
Double this number is 6

Если пользователь вводит число -4, программа напечатает:

Enter an integer: -4
-4 is a negative integer
The positive of this number is 4

Уровни вложенности блоков

Блоки можно даже помещать внутри блоков внутри других блоков:

int main()
{ // блок 1, уровень вложенности 1
    std::cout << "Enter an integer: ";
    int value {};
    std::cin >> value;
    
    if (value >  0)
    { // блок 2, уровень вложенности 2
        if ((value % 2) == 0)
        { // блок 3, уровень вложенности 3
            std::cout << value << " is positive and even\n";
        }
        else
        { // блок 4, также уровень вложенности 3
            std::cout << value << " is positive and odd\n";
        }
    }
 
    return 0;
}

Уровень вложенности (также называемый глубиной вложенности) функции – это максимальное количество вложенных блоков, внутри которых вы можете находиться в любой точке функции (включая внешний блок). В приведенной выше функции есть 4 блока, но уровень вложенности равен 3, поскольку в этой программе вы в какой-либо момент никогда не можете находиться внутри более 3 блоков.

Стандарт C++ говорит, что компиляторы C++ должны поддерживать 256 уровней вложенности, однако не все это поддерживают (например, на момент написания Visual Studio поддерживает где-то между 100 и 110 уровнями вложенности).

Несмотря на то, что C++ технически поддерживает 256 уровней, в своем коде рекомендуется поддерживать уровень вложенности 3 или меньше. Точно так же, как слишком длинные функции являются хорошими кандидатами для рефакторинга (разбиения на более мелкие функции), функции с чрезмерно большими уровнями вложенности трудны для чтения и являются хорошими кандидатами для рефакторинга (при этом блоки с максимальной вложенностью становятся отдельными функциями).

Теги