bulgakov

32. Область видимости: где живёт переменная

У каждой переменной есть область, где её имя работает. Раньше мы объявляли переменные и сразу пользовались ими. Теперь выясним, где именно имя «видно» и почему вне этого места компилятор его не знает. Это нужно перед массивами, сортировкой и указателями.

Что пригодится из прошлого: переменные, цикл for, свои функции. Если эти темы знакомы, читайте дальше. Если нет — загляните по ссылке, потом возвращайтесь.

Область видимости: где имя можно использовать

Область видимости переменной — участок программы, в котором её имя можно использовать. Начинается она с места объявления. Заканчивается там, где закрывается блок, в котором переменная объявлена. Блок — это код между { и }. Тело функции, тело цикла, тело if — всё это блоки.

Полная программа:

C
#include <stdio.h>

int main(void)
{
    for (int i = 0; i < 3; i++) {
        printf("%d\n", i);
    }
    return 0;
}

Вывод:

0
1
2

Переменная i объявлена в заголовке for. Поэтому она существует только внутри этого оператора: в условии, в шаге и в теле цикла. Когда цикл закончился, имя i исчезает.

Теперь добавим печать i после цикла:

C
#include <stdio.h>

int main(void)
{
    for (int i = 0; i < 3; i++) {
        printf("%d\n", i);
    }
    printf("%d\n", i);
    return 0;
}

Компилятор остановится на последнем printf. Формулировка зависит от компилятора. Например, Clang пишет:

error: use of undeclared identifier 'i'

«Необъявленное имя» значит именно это: в том месте, где стоит printf, переменной i уже нет. Исправить можно двумя способами. Первый — не использовать i после цикла. Второй — объявить переменную до цикла, тогда её область будет шире:

C
int i;
for (i = 0; i < 3; i++) {
    printf("%d\n", i);
}
printf("%d\n", i);   /* здесь i равно 3 */

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

Локальные переменные

Локальная переменная — переменная, объявленная внутри функции или блока. Она доступна только там. Переменные внутри main — локальные по отношению к main. Переменная i в заголовке for — локальная по отношению к этому for. Параметры функции тоже локальные переменные: они существуют только внутри своей функции, как будто объявлены в её начале. На этом держится правило из урока про свои функции: параметр — это копия значения, и изменение копии не затрагивает исходную переменную.

Полная программа, которая возводит число в степень:

C
#include <stdio.h>

int main(void)
{
    int base, power;
    int res = 1;
    if (scanf("%d%d", &base, &power) != 2) {
        printf("Input error\n");
        return 1;
    }
    for (int i = 0; i < power; i++) {
        res *= base;
    }
    printf("Result = %d\n", res);
    return 0;
}

Ввод:

2 10

Вывод:

Result = 1024

Здесь у имён разные области видимости:

Имя Где объявлено Где доступно
base, power, res в теле main во всём main после своих объявлений
i в заголовке for только внутри этого for

Картинка к этой программе. Представьте, что main — комната, а цикл for — маленькая комната внутри неё. Вещь, оставленная во внутренней комнате, из внешней не видна. А вещи внешней комнаты видны и изнутри:

Схема
┌─ main ──────────────────────────────────────────
│  base   power  res        ← видны во всём main
│
│  ┌─ for ────────────────────────────
│  │  i                    ← видна только здесь
│  │  (base, power, res отсюда тоже видны)
│  └──────────────────────────────────
│
│  здесь переменной i уже нет
└─────────────────────────────────────────────────

Расчёт для 2 10: res стартует с 1, и десять раз умножается на 2. После одного шага 2, после двух 4, после десяти 1024.

Локальные переменные одной функции не видны в другой. Это две разные комнаты с закрытыми дверями:

C
#include <stdio.h>

void first(void)
{
    int secret = 42;
    printf("%d\n", secret);
}

void second(void)
{
    printf("%d\n", secret);
}

int main(void)
{
    first();
    second();
    return 0;
}

Функция second не знает про secret, поэтому компилятор сообщает: use of undeclared identifier 'secret'. Чтобы передать значение между функциями, нужны параметры и возвращаемое значение, как в уроке про свои функции.

Глобальные переменные

Глобальная переменная объявляется вне всех функций. Она доступна в любой функции, которая записана ниже этого объявления.

Та же программа, но res сделана глобальной:

C
#include <stdio.h>

int res = 1;

int main(void)
{
    int base, power;
    if (scanf("%d%d", &base, &power) != 2) {
        printf("Input error\n");
        return 1;
    }
    for (int i = 0; i < power; i++) {
        res *= base;
    }
    printf("Result = %d\n", res);
    return 0;
}

Ввод 2 10, вывод: Result = 1024. Результат тот же, изменилось только место объявления. Слово «ниже» важно: компилятор читает файл сверху вниз. Если объявить res после main, внутри main это имя ещё неизвестно.

Чем глобальная переменная отличается от локальной, видно по такой программе:

C
#include <stdio.h>

int calls = 0;

void count_call(void)
{
    int local = 0;
    local++;
    calls++;
    printf("local = %d, calls = %d\n", local, calls);
}

int main(void)
{
    count_call();
    count_call();
    count_call();
    return 0;
}

Вывод:

local = 1, calls = 1
local = 1, calls = 2
local = 1, calls = 3

Локальная local при каждом вызове создаётся заново и начинается с 0: после local++ всегда 1. Когда функция заканчивается, local исчезает. Глобальная calls создаётся один раз и существует всё время работы программы, поэтому накапливает значение: 1, 2, 3. Это второй вопрос про переменную: не только «где видно имя», но и «как долго живёт значение».

Ещё одно отличие. Глобальная переменная без начального значения сразу равна нулю:

C
#include <stdio.h>

int total;

int main(void)
{
    printf("%d\n", total);
    return 0;
}

Вывод: 0. Локальная переменная без начального значения содержит случайный остаток прежних данных памяти. Читать её до присваивания нельзя: результат непредсказуем. Поэтому локальным переменным значение всегда задают сами.

Осторожно с глобальными переменными. Они удобны, но опасны. Любая функция может изменить их без предупреждения. В большой программе трудно понять, кто и когда поменял значение. В этом курсе по умолчанию используем локальные переменные и параметры. Глобальную переменную берём тогда, когда значение действительно общее для всей программы, и документируем это.

Когда два имени одинаковы

Блок { ... } можно писать и сам по себе, без if или for: C разрешает. Так удобно показать, как работает область видимости.

Внутренний блок может объявить переменную с тем же именем, что у внешней. Тогда внутри блока видна только внутренняя. Внешняя от этого не меняется:

C
#include <stdio.h>

int main(void)
{
    int x = 1;
    {
        int x = 2;
        printf("inside: %d\n", x);
    }
    printf("outside: %d\n", x);
    return 0;
}

Вывод:

inside: 2
outside: 1

По шагам, как две отдельные коробочки с одним именем:

Момент Внешний x Внутренний x Что видит код
int x = 1; 1 ещё нет внешний
вошли в блок, int x = 2; 1 2 внутренний
вышли из блока 1 исчез внешний

Это называется затенением: внутренний x закрывает внешний, пока блок не закончился. Затенение — частая причина путаницы, поэтому разным вещам давайте разные имена.

Что запомнить

  • Область видимости начинается с объявления и заканчивается концом блока.
  • Переменная из заголовка for существует только в этом for.
  • Локальные переменные доступны только в своей функции или блоке и при каждом вызове создаются заново.
  • Глобальные переменные объявляются вне функций, живут всю программу и по умолчанию равны нулю.
  • Между функциями значения лучше передавать через параметры и return.
ПрактикаЗагружаем тест…