32. Область видимости: где живёт переменная
У каждой переменной есть область, где её имя работает. Раньше мы объявляли переменные и сразу пользовались ими. Теперь выясним, где именно имя «видно» и почему вне этого места компилятор его не знает. Это нужно перед массивами, сортировкой и указателями.
Что пригодится из прошлого: переменные, цикл for, свои функции. Если эти темы знакомы, читайте дальше. Если нет — загляните по ссылке, потом возвращайтесь.
Область видимости: где имя можно использовать
Область видимости переменной — участок программы, в котором её имя можно использовать. Начинается она с места объявления. Заканчивается там, где закрывается блок, в котором переменная объявлена. Блок — это код между { и }. Тело функции, тело цикла, тело if — всё это блоки.
Полная программа:
#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 после цикла:
#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 после цикла. Второй — объявить переменную до цикла, тогда её область будет шире:
int i;
for (i = 0; i < 3; i++) {
printf("%d\n", i);
}
printf("%d\n", i); /* здесь i равно 3 */
Выбирайте узкую область, если значение нужно только внутри цикла. Широкая область нужна, когда результат цикла используется дальше.
Локальные переменные
Локальная переменная — переменная, объявленная внутри функции или блока. Она доступна только там. Переменные внутри main — локальные по отношению к main. Переменная i в заголовке for — локальная по отношению к этому for. Параметры функции тоже локальные переменные: они существуют только внутри своей функции, как будто объявлены в её начале. На этом держится правило из урока про свои функции: параметр — это копия значения, и изменение копии не затрагивает исходную переменную.
Полная программа, которая возводит число в степень:
#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.
Локальные переменные одной функции не видны в другой. Это две разные комнаты с закрытыми дверями:
#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 сделана глобальной:
#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 это имя ещё неизвестно.
Чем глобальная переменная отличается от локальной, видно по такой программе:
#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. Это второй вопрос про переменную: не только «где видно имя», но и «как долго живёт значение».
Ещё одно отличие. Глобальная переменная без начального значения сразу равна нулю:
#include <stdio.h>
int total;
int main(void)
{
printf("%d\n", total);
return 0;
}
Вывод: 0. Локальная переменная без начального значения содержит случайный остаток прежних данных памяти. Читать её до присваивания нельзя: результат непредсказуем. Поэтому локальным переменным значение всегда задают сами.
Осторожно с глобальными переменными. Они удобны, но опасны. Любая функция может изменить их без предупреждения. В большой программе трудно понять, кто и когда поменял значение. В этом курсе по умолчанию используем локальные переменные и параметры. Глобальную переменную берём тогда, когда значение действительно общее для всей программы, и документируем это.
Когда два имени одинаковы
Блок { ... } можно писать и сам по себе, без if или for: 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.
