Declarations

Declarations are how names are introduced (or re-introduced) into the C++ program. Not all declarations actually declare anything, and each kind of entity is declared differently. Definitions are declarations that are sufficient to use the entity identified by the name.

A declaration is one of the following:

• Function definition
• Template declaration (including Partial template specialization )
• Explicit template instantiation
• Explicit template specialization
• Namespace definition
• Linkage specification

• Empty declaration ( ; )
• A function declaration without a decl-specifier-seq :

This declaration must declare a constructor, destructor, or user-defined type conversion function . It can only be used as part of a template declaration , explicit specialization , or explicit instantiation.

• block-declaration (a declaration that can appear inside a block ), which, in turn, can be one of the following:

• asm declaration

• namespace alias definition
• using-declaration
• using directive

• simple declaration

Simple declaration

A simple declaration is a statement that introduces, creates, and optionally initializes one or several identifiers, typically variables.

init-declarator-list can only be omitted when declaring a named class or a named enumeration.

The syntax of init-declarator is defined as follows:

Specifiers

Declaration specifiers ( decl-specifier-seq ) is a sequence of the following whitespace-separated specifiers, in any order:

• the typedef specifier. If present, the entire declaration is a typedef declaration and each declarator introduces a new type name, not an object or a function.
• function specifiers ( inline , virtual , explicit ), only allowed in function declarations .

• the friend specifier, allowed in class and function declarations.

• storage class specifier ( register , (until C++17) static , thread_local , (since C++11) extern , mutable ). Only one storage class specifier is allowed , except that thread_local may appear together with extern or static (since C++11) .
• Type specifiers ( type-specifier-seq ), a sequence of specifiers that names a type. The type of every entity introduced by the declaration is this type, optionally modified by the declarator (see below). This sequence of specifiers is also used by type-id . Only the following specifiers are part of type-specifier-seq , in any order:

• class specifier
• enum specifier
• simple type specifier

• char , char8_t , (since C++20) char16_t , char32_t , (since C++11) wchar_t , bool , short , int , long , signed , unsigned , float , double , void

• previously declared class name (optionally qualified )
• previously declared enum name (optionally qualified )
• previously declared typedef-name or type alias (since C++11) (optionally qualified )
• template name with template arguments (optionally qualified , optionally using template disambiguator )

• elaborated type specifier

• the keyword class , struct , or union , followed by the identifier (optionally qualified ), previously defined as the name of a class.
• the keyword class , struct , or union , followed by template name with template arguments (optionally qualified , optionally using template disambiguator ), previously defined as the name of a class template.
• the keyword enum followed by the identifier (optionally qualified ), previously declared as the name of an enumeration.

• typename specifier
• cv qualifier

only one type specifier is allowed in a decl-specifier-seq, with the following exceptions:

• const can be combined with any type specifier except itself.
• volatile can be combined with any type specifier except itself.
• signed or unsigned can be combined with char , long , short , or int .
• short or long can be combined with int .
• long can be combined with double .

Attributes may appear in decl-specifier-seq , in which case they apply to the type determined by the preceding specifiers.

Repetitions of any specifier in a decl-specifier-seq , such as const static const , or virtual inline virtual are errors , except that long is allowed to appear twice (since C++11) .

Declarators

Each init-declarator in an init-declarator-list S D1, D2, D3 ; is processed as if it were a standalone declaration with the same specifiers: S D1 ; S D2 ; S D3 ; .

Each declarator introduces exactly one object, reference, function, or (for typedef declarations) type alias, whose type is provided by decl-specifier-seq and optionally modified by operators such as & (reference to) or [ ] (array of) or ( ) (function returning) in the declarator. These operators can be applied recursively, as shown below.

A declarator is one of the following:

cv is a sequence of const and volatile qualifiers, where either qualifier may appear at most once in the sequence.

Notes

When a block-declaration appears inside a block , and an identifier introduced by a declaration was previously declared in an outer block, the outer declaration is hidden for the remainder of the block.

If a declaration introduces a variable with automatic storage duration, it is initialized when its declaration statement is executed. All automatic variables declared in a block are destroyed on exit from the block (regardless how the block is exited: via exception , goto , or by reaching its end), in order opposite to their order of initialization.

Example

#include <type_traits>
struct S
{
    int member;
    // decl-specifier-seq is "int"
    // declarator is "member"
} obj, *pObj(&obj);
// decl-specifier-seq is "struct S { int member; }"
// declarator "obj" declares an object of type S
// declarator "*pObj" declares a pointer to S,
//     and initializer "(&obj)" initializes it
int i = 1, *p = nullptr, f(), (*pf)(double);
// decl-specifier-seq is "int"
// declarator "i" declares a variable of type int,
//     and initializer "= 1" initializes it
// declarator "*p" declares a variable of type int*,
//     and initializer "= nullptr" initializes it
// declarator "f()" declares (but doesn't define)
//     a function taking no arguments and returning int
// declarator "(*pf)(double)" declares a pointer to function
//     taking double and returning int
int (*(*var1)(double))[3] = nullptr;
// decl-specifier-seq is "int"
// declarator is "(*(*var1)(double))[3]"
// initializer is "= nullptr"
// 1. declarator "(*(*var1)(double))[3]" is an array declarator:
//    Type declared is: "(*(*var1)(double))" array of 3 elements
// 2. declarator "(*(*var1)(double))" is a pointer declarator:
//    Type declared is: "(*var1)(double)" pointer to array of 3 elements
// 3. declarator "(*var1)(double)" is a function declarator:
//    Type declared is: "(*var1)" function taking "(double)",
//    returning pointer to array of 3 elements.
// 4. declarator "(*var1)" is a pointer declarator:
//    Type declared is: "var1" pointer to function taking "(double)",
//    returning pointer to array of 3 elements.
// 5. declarator "var1" is an identifier.
// This declaration declares the object var1 of type "pointer to function
// taking double and returning pointer to array of 3 elements of type int"
// The initializer "= nullptr" provides the initial value of this pointer.
// C++11 alternative syntax:
auto (*var2)(double) -> int (*)[3] = nullptr;
// decl-specifier-seq is "auto"
// declarator is "(*var2)(double) -> int (*)[3]"
// initializer is "= nullptr"
// 1. declarator "(*var2)(double) -> int (*)[3]" is a function declarator:
//    Type declared is: "(*var2)" function taking "(double)", returning "int (*)[3]"
// ...
int main()
{
    static_assert(std::is_same_v<decltype(var1), decltype(var2)>);
}

Defect reports

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

See also