Переменные, область видимости, время жизни: auto, static, extern, register

Введение

Объявление переменных без подробного разбора их области видимости и времени жизни — в этой статье разберём эти два связанных, но различных понятия систематически, вместе со спецификаторами auto (в его историческом, до-C++11 смысле), static, extern и register, управляющими этими аспектами.

Концепция

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

Пример кода

#include <iostream>

int globalVariable = 100; // область видимости — весь файл (и потенциально весь проект, без static)

void incrementCounter()
{
    static int callCount = 0; // инициализируется ОДИН раз, сохраняет значение между вызовами функции
    callCount++;
    std::cout << "Эта функция вызвана " << callCount << " раз" << std::endl;
}

int main()
{
    incrementCounter(); // "Эта функция вызвана 1 раз"
    incrementCounter(); // "Эта функция вызвана 2 раз" — callCount НЕ сбросился между вызовами!
    incrementCounter(); // "Эта функция вызвана 3 раз"

    {
        int blockScopedVariable = 42; // область видимости — только этот конкретный блок {}
        std::cout << blockScopedVariable << std::endl;
    }
    // blockScopedVariable здесь уже НЕДОСТУПЕН — вышел из области видимости

    return 0;
}

// file1.cpp
int sharedCounter = 0; // ОПРЕДЕЛЕНИЕ переменной — реальное выделение памяти для неё

// file2.cpp
extern int sharedCounter; // ОБЪЯВЛЕНИЕ — "эта переменная существует где-то в другом файле"

void incrementSharedCounter()
{
    sharedCounter++; // доступ к ОДНОЙ И ТОЙ ЖЕ переменной, реально определённой в file1.cpp
}

// static на уровне файла — ограничение видимости ТОЛЬКО этим файлом (внутренняя линковка)
static int fileLocalOnly = 10; // НЕ может быть использован через extern из другого файла

void localHelperFunction() // static перед функцией — аналогичное ограничение видимости только файлом
{
    // вспомогательная функция, не предназначенная для использования за пределами этого файла
}

Пояснения к коду

incrementCounter() с static int callCount = 0 показывает ключевое отличие static-локальной переменной от обычной — инициализация = 0 выполняется лишь ОДИН раз, при первом вызове функции, и при последующих вызовах переменная сохраняет значение, оставшееся от предыдущего вызова, что принципиально отличается от обычной локальной переменной, пересоздаваемой «с нуля» при каждом вызове функции. Пример с extern int sharedCounter в file2.cpp показывает механизм совместного использования одной и той же переменной между разными единицами трансляции — объявление через extern сообщает компилятору, что реальное определение (и, соответственно, реальное выделение памяти) находится в другом файле, и линковщик впоследствии связывает оба использования с одной и той же физической переменной. static int fileLocalOnly на уровне файла (вне функции) показывает противоположный случай — static здесь ограничивает видимость переменной исключительно текущим файлом («внутренняя линковка»), делая попытку получить к ней доступ через extern из другого файла ошибкой линковки.

Подводные камни

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