Спецификаторы класса хранения

Спецификаторы класса хранения являются частью decl-specifier-seq синтаксиса объявления имени. Вместе со областью видимости имени они контролируют две независимые свойства имени: его срок существования и его связь.

• отсутствие спецификатора или auto(до C++11) - автоматический срок существования.

• static - статический или поточный срок существования и внутренняя связь (или внешняя связь для статических членов класса, не находящихся в анонимном пространстве имён).
• extern - статический или поточный срок существования и внешняя связь.

• mutable - не влияет на срок существования или связь. Смотрите const/volatile для объяснения.

В объявлении может присутствовать только один спецификатор класса хранения за исключением того, что thread_local может быть объединён с static или с extern(с C++11).

Объяснение

Срок существования

Все объекты в программе имеют один из следующих сроков существования:

• автоматический срок существования. Память для объекта выделяется в начале содержащего блока кода и освобождается в конце. Все локальные объекты имеют такой срок существования, за исключением объявленных static, extern или thread_local.
• статический срок существования. Память для объекта выделяется при запуске программы и освобождается при завершении. Существует только один экземпляр объекта. Все объекты, объявленные на уровне пространства имён (включая глобальное пространство имён), имеют такой срок существования, а также те, которые объявлены с static или extern. Смотрите Нелокальные переменные и Статические локальные переменные для получения подробностей об инициализации объектов с этим сроком существования.

• динамический срок существования. Память для объекта выделяется и освобождается по запросу с помощью функций динамического выделения памяти. Смотрите new-выражение для получения подробностей об инициализации объектов с этим сроком существования.

Срок существования подобъектов и членов-ссылок совпадает со сроком существования их родительского объекта.

Связь

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

Признаются следующие виды связей:

Отсутствие связи

К имени можно обратиться только из области видимости, в которой оно объявлено.

Любое из следующих имен, объявленных в области блока, не имеет связи:

• переменные, которые явно не объявлены extern (независимо от модификатора static);
• локальные классы и их члены-функции;
• другие имена, объявленные в области блока, такие как typedef, перечисления и перечислители.

Имена, не указанные с внешней, модульной,(с C++20) или внутренней связью, также не имеют связи, независимо от того, в какой области видимости они объявлены.

Внутренняя связь

К имени можно обратиться из всех областей видимости в текущем объекте трансляции.

Любое из следующих имён, объявленных на уровне пространства имён, имеет внутреннюю связь:

• переменные, шаблонные переменные(с C++14), функции или шаблоны функций, объявленные static;
• нешаблонные (с C++14)переменные неподписанного константного типа, за исключением

• они явно объявлены extern, или
• они были объявлены ранее, и предыдущее объявление не имело внутренней связи;
• члены данных анонимных объединений.

Внешняя связь

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

Любое из следующих имён, объявленных на уровне пространства имён, имеет внешнюю связь, за исключением случаев объявления в безымянном пространстве имён или если их объявления привязаны к именованному модулю и не экспортируются(с C++20):

• переменные и функции, не перечисленные выше (то есть, функции, не объявленные static, не-const переменные, не объявленные static, и любые переменные, объявленные extern);
• перечисления;
• имена классов, их методов-членов, статических данных-членов (const или нет), вложенных классов и перечислений, а также функций, впервые объявленных с помощью friend в телах классов;
• имена всех шаблонов, не перечисленных выше (то есть, не шаблонов функций, объявленных static).

Любые из следующих имён, объявленные в области видимости блока, имеют внешний связующий компонент:

• имена переменных, объявленных extern;
• имена функций.

Статические локальные переменные

Переменные, объявленные в области видимости блока со спецификатором static или thread_local(с C++11) имеют статическую или потоковую(с C++11) продолжительность хранения, но инициализируются в первый раз, когда управление проходит через их объявление (если их инициализация не является нулевой или постоянной, которая может быть выполнена до первого входа в блок). При последующих вызовах объявление пропускается.

Если инициализация выбрасывает исключение, переменная не считается инициализированной, и инициализация будет повторно попытана в следующий раз, когда управление пройдёт через объявление.

Если инициализация рекурсивно входит в блок, в котором переменная инициализируется, поведение неопределённо.

Деструктор для статической переменной в области видимости блока вызывается при выходе программы, но только если инициализация прошла успешно.

Статические объекты в локальной функции во всех определениях одной и той же встроенной функции (которая может быть неявной встроенной) все ссылаются на один и тот же объект, определённый в одной единице трансляции, при условии, что функция имеет внешний связующий компонент.

Локальные сущности единицы трансляции

Концепция локальных сущностей единицы трансляции стандартизована в C++20, см. эту страницу для получения более подробной информации.

Сущность является локальной для единицы трансляции (или локальной для ТУ) если

• она имеет имя с внутренней связью, или
• она не имеет связи с именем и вводится в определении сущности локальной для ТУ, или
• она является шаблоном или специализацией шаблона, аргумент шаблона или объявление шаблона которого используют сущность локальную для ТУ.

Плохие вещи (обычно нарушение ODR) могут произойти, если тип сущности, не являющейся локальной для ТУ, зависит от сущности, локальной для ТУ, или если объявление, или руководство по выводу для,(с C++17) сущности, не являющейся локальной для ТУ, называет сущность, локальную для ТУ, за пределами её

• тела функции для нестатической функции или шаблона функции
• инициализатора переменной или шаблона переменной
• объявлений friend в определении класса
• использования значения переменной, если переменная может быть использована в константных выражениях

Примечания

Имена в области видимости пространства имён верхнего уровня (область видимости файла в C), которые являются const и не extern, имеют внешнюю связь в C, но внутреннюю связь в C++.

С C++11, auto больше не является спецификатором класса хранения; он используется для указания вывода типа.

Имена переменных thread_local с внутренней или внешней связью, на которые ссылаются разные области видимости, могут ссылаться на один и тот же или на разные экземпляры в зависимости от того, выполняется ли код в одном или разных потоках.

Ключевое слово extern также может быть использовано для указания связи языка и явно объявленных шаблонов классов, но в этих случаях это не спецификатор класса хранения (за исключением случаев, когда объявление непосредственно содержится в спецификации связи языка, в этом случае объявление рассматривается так, как будто оно содержит спецификатор extern).

Ключевое слово mutable является спецификатором класса хранения в грамматике языка C++, хотя оно не влияет на продолжительность хранения или связь.

Спецификаторы класса хранения, за исключением thread_local, не допускаются для явных специализаций и явных инстанциаций:

template<class T>
struct S
{
    thread_local static int tlm;
};
 
template<>
thread_local int S<float>::tlm = 0; // "static" does not appear here

Ключевые слова

auto, register, static, extern, thread_local, mutable

Пример

#include <iostream>
#include <mutex>
#include <string>
#include <thread>
 
thread_local unsigned int rage = 1; 
std::mutex cout_mutex;
 
void increase_rage(const std::string& thread_name)
{
    ++rage; // modifying outside a lock is okay; this is a thread-local variable
    std::lock_guard<std::mutex> lock(cout_mutex);
    std::cout << "Rage counter for " << thread_name << ": " << rage << '\n';
}
 
int main()
{
    std::thread a(increase_rage, "a"), b(increase_rage, "b");
 
    {
        std::lock_guard<std::mutex> lock(cout_mutex);
        std::cout << "Rage counter for main: " << rage << '\n';
    }
 
    a.join();
    b.join();
}

Rage counter for a: 2
Rage counter for main: 1
Rage counter for b: 2

Отчёты об ошибках

Следующие отчёты об ошибках, изменяющие поведение, были применены ретроактивно к ранее опубликованным стандартам C++.

См. также