The storage class specifiers are a part of thedecl-specifier-seq of a name'sdeclaration syntax. Together with thescope of the name, they control two independent properties of the name: itsstorage duration and itslinkage.

[edit]Storage duration

Thestorage duration is the property of anobject that defines the minimum potential lifetime of the storage containing the object. The storage duration is determined by the construct used to create the object and is one of the following:

• static storage duration

• automatic storage duration
• dynamic storage duration

Static, thread,(since C++11) and automatic storage durations are associated with objects introduced bydeclarations and withtemporary objects. The dynamic storage duration is associated with objects created by anew expression or withimplicitly created objects.

The storage duration categories apply to references as well.

The storage duration ofsubobjects and reference members is that of their complete object.

[edit]Specifiers

The following keywords arestorage class specifiers :

• static

• extern
• mutable

In adecl-specifier-seq, there can be at most one storage class specifier, except thatthread_local may appear withstatic orextern(since C++11).

mutable has no effect on storage duration. For its usage, seeconst/volatile.

Other storage class specifiers can appear in thedecl-specifier-seq s of the following declarations:

Anonymous unions can also be declared withstatic.

[edit]Static storage duration

A variable satisfying all following conditions hasstatic storage duration :

• It belongs to anamespace scope or are first declared withstatic orextern.

The storage for these entities lasts for the duration of the program.

[edit]Automatic storage duration

The following variables haveautomatic storage duration :

• Variables that belong to ablock scope and are not explicitly declaredstatic,thread_local,(since C++11) orextern. The storage for such variables lasts until the block in which they are created exits.
• Variables that belong to a parameter scope (i.e. function parameters). The storage for a function parameter lasts until immediately after itsdestruction.

[edit]Dynamic storage duration

Objects created by the following methods during program execution havedynamic storage duration :

• new expressions. The storage for such objects is allocated byallocation functions and deallocated bydeallocation functions.
• Implicitly creation by other means. The storage for such objects overlaps with some existing storage.
• Exception objects. The storage for such objects is allocated and deallocated in an unspecified way.

[edit]Linkage

A name can haveexternal linkage ,module linkage(since C++20),internal linkage, orno linkage:

• An entity whose name has external linkage can beredeclared in anothertranslation unit, and the redeclaration can beattached to a different module(since C++20).

• An entity whose name has internal linkage can be redeclared in another scope in the same translation unit.
• An entity whose name has no linkage can only be redeclared in the same scope.

The following linkages are recognized:

[edit]No linkage

Any of the following names declared at block scope have no linkage:

• variables that are not explicitly declaredextern (regardless of thestatic modifier);
• local classes and their member functions;
• other names declared at block scope such as typedefs, enumerations, and enumerators.

Names not specified with external, module,(since C++20) or internal linkage also have no linkage, regardless of which scope they are declared in.

[edit]Internal linkage

Any of the following names declared at namespace scope have internal linkage:

• variables, variable templates(since C++14), functions, or function templates declaredstatic;
• non-template(since C++14)variables of non-volatile const-qualified type, unless

• they are explicitly declaredextern, or
• they were previously declared and the prior declaration did not have internal linkage;

• data members ofanonymous unions.

[edit]External linkage

Variables and functions with external linkage also havelanguage linkage, which makes it possible to link translation units written in different programming languages.

Any of the following names declared at namespace scope have external linkage, unless they are declared in an unnamed namespace or their declarations are attached to a named module and are not exported(since C++20):

• variables and functions not listed above (that is, functions not declaredstatic, non-const variables not declaredstatic, and any variables declaredextern);
• enumerations;
• names of classes, their member functions, static data members (const or not), nested classes and enumerations, and functions first introduced withfriend declarations inside class bodies;
• names of all templates not listed above (that is, not function templates declaredstatic).

Any of the following names first declared at block scope have external linkage:

• names of variables declaredextern;
• names of functions.

[edit]Static block variables

Block variables with static or thread(since C++11) storage duration are initialized the first time control passes through their declaration (unless their initialization iszero- orconstant-initialization, which can be performed before the block is first entered). On all further calls, the declaration is skipped.

• If the initializationthrows an exception, the variable is not considered to be initialized, and initialization will be attempted again the next time control passes through the declaration.
• If the initialization recursively enters the block in which the variable is being initialized, the behavior is undefined.

The destructor for a block variable with static storage durationis called at program exit, but only if the initialization took place successfully.

Variables with static storage duration in all definitions of the sameinline function (which may be implicitly inline) all refer to the same object defined in one translation unit, as long as the function has external linkage.

[edit]Translation-unit-local entities

The concept of translation-unit-local entities is standardized in C++20, seethis page for more details.

An entity istranslation-unit-local (orTU-local for short) if

• it has a name with internal linkage, or
• it does not have a name with linkage and is introduced within the definition of a TU-local entity, or
• it is a template or template specialization whose template argument or template declaration uses a TU-local entity.

Bad things (usually violation ofODR) can happen if the type of a non-TU-local entity depends on a TU-local entity, or if a declaration of, or adeduction guide for,(since C++17) a non-TU-local entity names a TU-local entity outside its

• function-body for a non-inline function or function template
• initializer for a variable or variable template
• friend declarations in a class definition
• use of value of a variable, if the variable isusable in constant expressions

[edit]Notes

Names at the top-level namespace scope (file scope in C) that areconst and notextern have external linkage in C, but internal linkage in C++.

Since C++11,auto is no longer a storage class specifier; it is used to indicate type deduction.

Names ofthread_local variables with internal or external linkage referred from different scopes may refer to the same or to different instances depending on whether the code is executing in the same or in different threads.

Theextern keyword can also be used to specifylanguage linkage andexplicit template instantiation declarations, but it's not a storage class specifier in those cases (except when a declaration is directly contained in a language linkage specification, in which case the declaration is treated as if it contains theextern specifier).

Storage class specifiers, except forthread_local, are not allowed onexplicit specializations andexplicit instantiations:

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

[edit]Keywords

auto,register,static,extern,thread_local,mutable

[edit]Example

#include <iostream>#include <mutex>#include <string>#include <thread> thread_localunsignedint rage=1;std::mutex cout_mutex; void increase_rage(conststd::string& thread_name){++rage;// modifying outside a lock is okay; this is a thread-local variablestd::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: 2Rage counter for main: 1Rage counter for b: 2

[edit]Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[edit]References

[edit]See also

• In other languages

• Deutsch
• Español
• Français
• Italiano
• 日本語
• Português
• Русский
• 中文