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 (includingPartial template specialization)
• Explicit template instantiation
• Explicit template specialization
• Namespace definition
• Linkage specification

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

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

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

• asm declaration

• namespace alias definition
• using-declaration
• using directive

• simple declaration

[edit]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 ofinit-declarator is defined as follows:

[edit]Specifiers

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

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

• thefriend 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 thatthread_local may appear together withextern orstatic(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 bytype-id. Only the following specifiers are part oftype-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 (optionallyqualified)
• previously declared enum name (optionallyqualified)
• previously declaredtypedef-name ortype alias(since C++11) (optionallyqualified)
• template name with template arguments (optionallyqualified, optionally usingtemplate disambiguator)

• elaborated type specifier

• the keywordclass,struct, orunion, followed by the identifier (optionallyqualified), previously defined as the name of a class.
• the keywordclass,struct, orunion, followed by template name with template arguments (optionallyqualified, optionally usingtemplate disambiguator), previously defined as the name of a class template.
• the keywordenum followed by the identifier (optionallyqualified), 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 orunsigned can be combined withchar,long,short, orint.
• short orlong can be combined withint.
• long can be combined withdouble.

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

Repetitions of any specifier in adecl-specifier-seq, such asconststaticconst, orvirtualinlinevirtual are errors, except thatlong is allowed to appear twice(since C++11).

[edit]Declarators

Eachinit-declarator in aninit-declarator-listS 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 bydecl-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.

Adeclarator is one of the following:

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

[edit]Notes

When ablock-declaration appearsinside a block, and an identifier introduced by a declaration was previously declared in an outer block, theouter 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: viaexception,goto, or by reaching its end), in order opposite to their order of initialization.

[edit]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)>);}

[edit]Defect reports

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

[edit]See also

• In other languages

• Español
• 日本語
• Русский
• 中文