Область видимости, ввод и итоговая практика

Последний урок Stage 00 закрывает два оставшихся вопроса — где именно «живёт» переменная и как программе получить данные не из кода, а от пользователя (std::cin) — а затем собирает всё, что было в этапе, в одной итоговой практике.

01Что ты изучишь

• Область видимости (scope) — где переменная существует, а где о ней уже «не знают»
• Как параметры функций и переменные внутри блоков соотносятся со scope
• std::cin — чтение данных, введённых пользователем
• Итоговую практику, использующую всё из Stage 00 сразу

02Основная идея: комнаты в доме

Область видимости — это как комнаты в доме. Вещь, оставленная в одной комнате (переменная, объявленная в блоке { }), доступна, пока ты находишься в этой комнате или в любой комнате внутри неё (вложенный блок) — но её не видно и не достать из соседней комнаты или из коридора снаружи. Когда ты выходишь из комнаты (блок заканчивается закрывающей }), всё, что было оставлено только в ней, становится недоступным — не потому что «пропало», а потому что ты уже не там, где оно лежит. Именно поэтому в две разные, не вложенные друг в друга комнаты можно положить вещи с одинаковым названием, не создавая путаницы — они просто в разных местах.

03Область видимости — где переменная существует

Перенесём аналогию с комнатами на настоящий код и посмотрим, где именно проходит граница. Правило простое, хоть и не сразу очевидное, пока не увидишь его в действии: переменная существует от точки объявления до конца того блока { }, в котором она объявлена, — и становится недоступна сразу за закрывающей скобкой. Это и называется областью видимости (scope): часть программы, где к переменной можно обратиться по имени.

int main()
{
    int score = 10;   // score существует до конца main()

    {
        int bonus = 5;              // bonus существует только внутри этого блока
        std::cout << score + bonus; // здесь виден и score, и bonus
    }
    // здесь bonus уже недоступен — блок выше закончился

    std::cout << score;   // score всё ещё виден — main() не закончился

    return 0;
}

Это же правило уже работало в предыдущих уроках, просто без названия: параметр функции (седьмой урок) виден только внутри тела этой функции — это его scope; переменные, объявленные внутри тела if или цикла, видны только внутри этого блока. Два разных блока могут использовать одно и то же имя переменной независимо друг от друга — это не конфликт, потому что их области видимости не пересекаются (см. практику ниже).

Вложенность может идти глубже одного уровня — правило то же самое на любой глубине:

int main()
{
    int a = 1;          // видна везде в main(), включая оба блока ниже

    {
        int b = 2;       // видна в этом блоке и во вложенном ниже, но не в main() после
        {
            int c = 3;     // видна только здесь, внутри самого глубокого блока
            std::cout << a + b + c;   // здесь видны все три: a, b и c
        }
        // c уже недоступна — самый глубокий блок закончился
        // std::cout << c;   // ошибка компиляции, если раскомментировать
    }
    // b тоже уже недоступна

    return 0;
}

Общее правило: переменная видна в своём блоке и во всех блоках, вложенных внутрь него, но не видна снаружи и не видна в блоках, объявленных раньше или позже на том же уровне. Ниже — та же мысль в виде таблицы:

04std::cin — чтение ввода

Всё, что программа выводила до сих пор, было либо литералом, либо результатом вычисления в самом коде. std::cin (input stream) — симметричный std::cout инструмент: читает данные, которые вводит пользователь, вместо того чтобы их выводить. Тот же #include <iostream> подключает и cout, и cin — они из одной библиотеки.

int score = 0;
std::cout << "Enter score: ";
std::cin >> score;   // ждёт ввод от пользователя, сохраняет его в score
std::cout << "You entered: " << score;

Оператор >> у cin — зеркальное отражение << у cout: данные «текут» в переменную, а не из неё. Тип переменной справа определяет, как cin разбирает введённый текст — для int score он ожидает число и остановится на первом пробеле или переводе строки.

Как и << у cout, оператор >> можно повторять подряд в одной инструкции — тогда cin читает несколько значений одно за другим, по порядку:

int width = 0;
int height = 0;

std::cout << "Enter width and height (через пробел): ";
std::cin >> width >> height;   // два значения одной инструкцией

int area = width * height;
std::cout << "Area: " << area;

Пользователь может ввести оба числа через пробел на одной строке (например, «4 5») или на разных строках — cin игнорирует пробелы и переводы строк между значениями и просто последовательно заполняет width, затем height, в том порядке, в котором они перечислены после cin.

05Что делает программу «настоящей консольной программой»

Все программы этого этапа были однонаправленными: код — на входе, текст на экране — на выходе, без участия пользователя в процессе выполнения. Полноценная консольная программа обычно устроена как цикл «ввод → обработка → вывод»: получить данные от пользователя (cin), что-то с ними сделать (переменные, операторы, условия, циклы, функции — всё, что уже пройдено), и показать результат (cout). Итоговая практика ниже построена именно по этой схеме.

06Область видимости параметра функции шаг за шагом

Параметр функции (седьмой урок) — тоже переменная со своей областью видимости, просто её «комната» — это тело функции. Ниже — та же функция, к которой на каждом шаге добавляется ещё одна деталь, чтобы стало видно, где именно начинается и заканчивается эта комната.

void printDoubled(int value)
{
    std::cout << value * 2 << "\n";
}

value существует и доступен по имени только внутри тела printDoubled — от открывающей до закрывающей { } этой функции.

void printDoubled(int value)
{
    int doubled = value * 2;   // локальная переменная, своя "комната" — тоже тело функции
    std::cout << doubled << "\n";
}

doubled — обычная локальная переменная с тем же правилом scope, что и любой блок { }: она видна до конца функции, но не снаружи. И value, и doubled живут в одной и той же «комнате» — теле функции.

void printDoubled(int value)
{
    int doubled = value * 2;
    std::cout << doubled << "\n";
}

int main()
{
    printDoubled(21);
    // value и doubled здесь не существуют — они жили только внутри printDoubled
    // std::cout << value;    // ошибка компиляции, если раскомментировать
    // std::cout << doubled;  // тоже ошибка компиляции

    return 0;
}

Из main() не видно ни value, ни doubled — обе переменные существовали только на время выполнения printDoubled и исчезли, как только функция завершилась. Это та же самая граница «комнаты», что и с обычным блоком { }, просто для функций она называется отдельным термином — область видимости функции.

07Хуже → лучше: тень переменной

Задача — вывести бонусные очки внутри вложенного блока, а затем основной счёт снаружи. Оба значения существуют одновременно, но в разных областях видимости.

int score = 10;
{
    int score = 99;
    std::cout << score << "\n";
}
std::cout << score << "\n";

Программа работает правильно — вложенный score временно затеняет внешний, и каждое обращение видит то, что должно. Но при чтении кода (особенно если блоки станут длиннее) легко принять это за баг: «почему score вдруг стал 99, а потом снова 10?» — без внимательного взгляда на фигурные скобки ответ не очевиден.

int score = 10;
{
    int bonusPoints = 99;
    std::cout << bonusPoints << "\n";
}
std::cout << score << "\n";

Те же самые значения и тот же порядок вывода — но теперь по одним только именам понятно, что это два разных значения, а не одно и то же, «магическим образом» поменявшееся между строками.

int score = 10;
{
    int bonusPoints = 99;
    std::cout << "Bonus: " << bonusPoints << "\n";
}
std::cout << "Score: " << score << "\n";

Подписанный вывод (приём из самого первого урока) вместе с осмысленными именами (приём из третьего урока) — код и его результат теперь понятны без необходимости заглядывать в объявления переменных выше по файлу.

08Попробуй изменить

• В примере из раздела «Область видимости» попробуй обратиться к bonus после закрывающей скобки его блока — компилятор откажется: имя вне своей области видимости не существует.
• В примере из раздела «std::cin» замени тип score на double и попробуй ввести дробное число — cin прочитает его целиком, с дробной частью.

09Живая отладка: типичные ошибки

{
    int bonus = 5;
}
std::cout << bonus;   // bonus существовал только внутри блока выше

std::cin >> score;   // #include <iostream> выше отсутствует

10Итоговая практика Stage 00

Второе задание ниже (★★★) — это финал программы-персонажа, которую мы собирали от урока к уроку начиная с «Переменных»: hp появился там, типы и статы — в «Основных типах данных», операторы и условия — в «Операторах» и «Условиях», gradeFor — в прошлом уроке про функции. Здесь всё это соединяется в одну настоящую консольную программу с вводом от пользователя.

11Проверь себя

12Термины

13Что ты теперь умеешь

• Определить границы области видимости любой переменной — от объявления до конца её блока { } — и объяснить, почему обращение к ней снаружи не скомпилируется.
• Узнать затенение (shadowing) в чужом коде: понять, какое из двух одноимённых значений видно в конкретной строке, и предсказать, что снова станет видно после закрытия вложенного блока.
• Прочитать данные, введённые пользователем, через std::cin — как одно значение, так и несколько подряд — и построить программу по циклу «ввод → обработка → вывод».
• Собрать все восемь тем Stage 00 в одну работающую программу: переменные и типы, операторы и условия, циклы и функции, теперь ещё и с вводом от пользователя вместо статичных чисел в коде.

14Кратко

• Область видимости переменной — от объявления до конца блока { }, в котором она объявлена.
• Параметры функций и переменные внутри if/циклов/произвольных блоков подчиняются тому же правилу.
• Одинаковое имя в разных, не вложенных блоках — не конфликт: области видимости не пересекаются.
• Тень переменной (shadowing) во вложенном блоке компилируется, но затрудняет чтение — в этом курсе её стоит избегать.
• std::cin >> переменная; — чтение пользовательского ввода, симметрично std::cout <<.
• Полноценная консольная программа — это цикл «ввод → обработка → вывод».

На этом Stage 00 закончен: восемь уроков, от первой скомпилированной строчки до программы, которая сама читает данные от игрока и считает результат. Дальше начинается Stage 01 — и первый его урок, const, отвечает на вопрос, который до сих пор не поднимался ни разу: что мешает случайно изменить значение, которое по смыслу вообще не должно меняться (например, максимальный HP персонажа)?

void AMyActor::BeginPlay()
{
    Super::BeginPlay();

    int32 StartingBonus = 100;              // локальная переменная — живёт только внутри BeginPlay()
    Health = MaxHealth + StartingBonus;      // Health — переменная-член класса, видна во всех методах

    // StartingBonus здесь ещё существует...
}
// ...а здесь, в Tick() или любом другом методе того же класса, StartingBonus уже недоступна —
// её scope закончился вместе с BeginPlay(), в отличие от Health