Namespaces
Variants
Views
Actions

Declarations

From cppreference.com
< cpp‎ | language
Revision as of 08:56, 10 May 2013 by P12 (Talk | contribs)

 
 
C++ language
General topics
Flow control
Conditional execution statements
Iteration statements
Jump statements
Functions
function declaration
lambda function declaration
function template
inline specifier
exception specifications (deprecated)
noexcept specifier (C++11)
Exceptions
Namespaces
Types
decltype specifier (C++11)
Specifiers
cv specifiers
storage duration specifiers
constexpr specifier (C++11)
auto specifier (C++11)
alignas specifier (C++11)
Initialization
Literals
Expressions
alternative representations
Utilities
Types
typedef declaration
type alias declaration (C++11)
attributes (C++11)
Casts
implicit conversions
const_cast conversion
static_cast conversion
dynamic_cast conversion
reinterpret_cast conversion
C-style and functional cast
Memory allocation
Classes
Class-specific function properties
Special member functions
Templates
class template
function template
template specialization
parameter packs (C++11)
Miscellaneous
Inline assembly
 

Declarations introduce (or re-introduce) names into the C++ program. 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:

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

Template:sparam(optional) Template:sparam(optional) Template:sparam(optional) ; (1)
Template:sparam(C++11) - optional sequence of any number of attributes
Template:sparam - sequence of type specifiers including the type name. It is only optional in the declarations of constructors, destructors, and user-defined type conversion functions
Template:sparam - comma-separated list of declarators with optional initializers. Init-declarator-list is optional when declaring a named class/struct/union or a named enumeration

Contents

Specifiers

Template:sparam is a sequence of the following whitespace-separated specifiers:

  • elaborated type specifier
  • the keyword class, struct, or union, followed by the identifier (optionally qualified)), previously defined as the name of a class, struct, or union.
  • 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 defined as the name of an enumeration.
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.

Declarators

Template:sparam is a comma-separated sequence of one or more init-declarators, which have the following syntax:

Template:sparam Template:sparam(optional) (1)
Template:sparam - the declarator
Template:sparam - optional initializer (except where required, such as when initializing references or const objects). See Initialization for details.

Each init-declaractor in a init-declarator sequence 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, function, or (for typedef declarations) type alias, whose type is provided by Template:sparam 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 Template:sparam is one of the following:

Template:sparam Template:sparam(optional) (1)
... Template:sparam Template:sparam(optional) (2) (since C++11)
* Template:sparam(optional) Template:sparam(optional) Template:sparam (3)
Template:sparam * Template:sparam(optional) Template:sparam(optional) Template:sparam (4)
& Template:sparam(optional) Template:sparam (5)
&& Template:sparam(optional) Template:sparam (6) (since C++11)
Template:sparam [ Template:sparam(optional) ] Template:sparam(optional) (7)
Template:sparam ( Template:sparam ) Template:sparam(optional) Template:sparam(optional) Template:sparam(optional) Template:sparam (8)
1) The identifier that is declared. A declarator that consist of just an identifier, declares an object of exactly the type provided by Template:sparam.
2) Parameter pack, only appears in function parameter lists for variadic function templates.
3) Pointer declarator: the declaration S * D; declares D as a pointer to the type determined by Template:sparam S.
4) Pointer to member declaration: the declaration S C::*D; declares D as a pointer to member of C of type determined by Template:sparam S. Template:sparam is a sequence of names and scope resolution operators ::
5) Lvalue reference declarator: the declaration S & D; declares the object D with type lvalue reference to the type determined by Template:sparam S.
6) Rvalue reference declarator: the declaration S && D; declares the object D with type rvalue reference to the type determined by Template:sparam S.
7) Array declarator. Template:sparam any valid declarator, but if it begins with *, &, or &&, it has to be surrounded by parentheses.
8) Function declarator. Template:sparam any valid declarator, but if it begins with *, &, or &&, it has to be surrounded by parentheses. Note that the outermost function declarator may end with the optional trailing return type.

In all cases, Template:sparam is an optional sequence of attributes. When appearing immediately after the identifier, it applies to the object being declared.

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), in order opposite to their order of initialization.

Examples

class C {
    std::string member; // decl-specifier-seq is "std::string"
                        // declarator is "member"
} obj, *pObj(&obj);
// decl-specifier-seq is "class C { std::string member; }"
// declarator "obj" defines an object of type C
// declarator "*pObj(&obj)" declares and initializes a pointer to C
 
int a = 1, *p = NULL, f(), (*pf)(double);
// decl-specifier-seq is int
// declarator a=1 defines and initializes a variable of type int
// declarator *p=NULL defines and initializes a variable of type int*
// declarator (f)() declares (but doesn't define)
//                  a function taking no arguments and returning int
// declarator (*pf)(double) defines a pointer to function
//                  taking double and returning int
 
int (*(*foo)(double))[3] = NULL;
// decl-specifier-seq is int
// 1. declarator "(*(*foo)(double))[3]" is an array declarator:
//    the type declared is "/nested declarator/ array of 3 int"
// 2. the nested declarator is "*(*foo)(double))", which is a pointer declarator
//    the type declared is "/nested declarator/ pointer to array of 3 int"
// 3. the nested declarator is "(*foo)(double)", which is a function declarator
//    the type declared is "/nested declarator/ function taking double and returning
//        pointer to array of 3 int"
// 4. the nested declarator is "(*foo)" which is a (parenthesized, as required by
//        function declarator syntax) pointer declarator.
//    the type declared is "/nested declarator/ pointer to function taking double
//        and returning pointer to array of 3 int"
// 5. the nested declarator is "foo", which is an identifier.
// The declaration declares the object foo of type "pointer to function taking double 
//     and returning pointer to array of 3 int"
// The initializer "= NULL" provides the initial value of this pointer.