Declarations - cppreference.com (original) (raw)

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 :

| | | | | -------------------------------- | | | | attr (optional) declarator ; | | | | | | |

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

Contents

• 1 Simple declaration
• 2 Specifiers
• 3 Declarators
• 4 Notes
• 5 Example
• 6 Defect reports
• 7 See also

[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 of init-declarator is defined as follows:

| | | | | --------------------------------------------------------------- | --- | | | declarator initializer | (1) | | | | | | | declarator requires-clause (optional) contract-specs (optional) | (2) | | | | | |

1. A declarator with an initializer.

2. A declarator without an initializer.

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

[edit] 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:

1. The name that is declared.

2. Pointer declarator: the declaration S * D; declares D as a pointer to the type determined by decl-specifier-seq S.

3. Lvalue reference declarator: the declaration S & D; declares D as an lvalue reference to the type determined by decl-specifier-seq S.

4. Rvalue reference declarator: the declaration S && D; declares D as an rvalue reference to the type determined by decl-specifier-seq S.

5. Array declarator. noptr-declarator any valid declarator, but if it begins with *, &, or &&, it has to be surrounded by parentheses.

6. Function declarator. noptr-declarator any valid declarator, but if it begins with *, &, or &&, it has to be surrounded by parentheses. It may end with the optional trailing return type.(since C++11)

7. Parenthesized declarator.

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

[edit] 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.

[edit] Example

Note: this example demonstrates how some complex declarations are parsed in terms of the language grammar. Other popular mnemonics are: the spiral rule, reading inside-out, and declaration mirrors use. There is also an automated parser at https://cdecl.org.

#include   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