9 Declarations [dcl.dcl]

9.3 Declarators [dcl.decl]

9.3.4 Meaning of declarators [dcl.meaning]

9.3.4.1 General [dcl.meaning.general]

A declarator contains exactly one declarator-id; it names the entity that is declared.

If the unqualified-id occurring in a declarator-id is a template-id, the declarator shall appear in the declaration of a template-declaration ([temp.decls]), explicit-specialization ([temp.expl.spec]), or explicit-instantiation ([temp.explicit]).

[Note 1:

An unqualified-id that is not an identifier is used to declare certain functions ([class.conv.fct], [class.dtor], [over.oper], [over.literal]).

— end note]

The optional attribute-specifier-seq following a declarator-id appertains to the entity that is declared.

If the declaration is a friend declaration:

(2.1)
The declarator does not bind a name.
(2.2)
If the id-expression E in the declarator-id of the declarator is a qualified-id or a template-id:
- (2.2.1)
  If the friend declaration is not a template declaration, then in the lookup for the terminal name of E:
  (2.2.1.1)
  if the unqualified-id in E is a template-id, all function declarations are discarded;
  (2.2.1.2)
  otherwise, if the declarator corresponds ([basic.scope.scope]) to any declaration found of a non-template function, all function template declarations are discarded;
  (2.2.1.3)
  each remaining function template is replaced with the specialization chosen by deduction from the friend declaration ([temp.deduct.decl]) or discarded if deduction fails.
- (2.2.2)
  The declarator shall correspond to one or more declarations found by the lookup; they shall all have the same target scope, and the target scope of the declarator is that scope.
(2.3)
Otherwise, the terminal name of E is not looked up.

The declaration's target scope is the innermost enclosing namespace scope; if the declaration is contained by a block scope, the declaration shall correspond to a reachable ([module.reach]) declaration that inhabits the innermost block scope.

Otherwise:

(3.1)
If the id-expression in the declarator-id of the declarator is a qualified-id Q, let S be its lookup context ([basic.lookup.qual]); the declaration shall inhabit a namespace scope.
(3.2)
Otherwise, let S be the entity associated with the scope inhabited by the declarator.
(3.3)
If the declarator declares an explicit instantiation or a partial or explicit specialization, the declarator does not bind a name.

If it declares a class member, the terminal name of the declarator-id is not looked up; otherwise, only those lookup results that are nominable in S are considered when identifying any function template specialization being declared ([temp.deduct.decl]).

[Example 1: namespace N { inline namespace O { template<class T> void f(T); // #1 template<class T> void g(T) {} } namespace P { template<class T> void f(T*); // #2, more specialized than #1 template<class> int g; } using P::f,P::g; } template<> void N::f(int*) {} // OK, #2 is not nominable template void N::g(int); // error: lookup is ambiguous — end example]
(3.4)
Otherwise, the terminal name of the declarator-id is not looked up.

If it is a qualified name, the declarator shall correspond to one or more declarations nominable in S; all the declarations shall have the same target scope and the target scope of the declarator is that scope.

[Example 2: namespace Q { namespace V { void f(); } void V::f() { /* ... */ } // OK void V::g() { /* ... */ } // error: g() is not yet a member of V namespace V { void g(); } } namespace R { void Q::V::g() { /* ... */ } // error: R doesn't enclose Q } — end example]
(3.5)
If the declaration inhabits a block scope S and declares a function ([dcl.fct]) or uses the extern specifier, the declaration shall not be attached to a named module ([module.unit]); its target scope is the innermost enclosing namespace scope, but the name is bound in S.

[Example 3: namespace X { void p() { q(); // error: q not yet declared extern void q(); // q is a member of namespace X extern void r(); // r is a member of namespace X } void middle() { q(); // error: q not found } void q() { /* ... */ } // definition of X::q } void q() { /* ... */ } // some other, unrelated q void X::r() { /* ... */ } // error: r cannot be declared by qualified-id — end example]

A static, thread_local, extern, mutable, friend, inline, virtual, constexpr, consteval, constinit, or typedef specifier or an explicit-specifier applies directly to each declarator-id in a declaration; the type specified for each declarator-id depends on both the decl-specifier-seq and its declarator.

Thus, (for each declarator) a declaration has the form T D where T is of the form attribute-specifier-seq

_{o p t}

decl-specifier-seq and D is a declarator.

Following is a recursive procedure for determining the type specified for the contained declarator-id by such a declaration.

First, the decl-specifier-seq determines a type.

In a declaration T D the decl-specifier-seq T determines the type T.

[Example 4:

In the declaration int unsigned i; the type specifiers int unsigned determine the type “unsigned int” ([dcl.type.simple]).

— end example]

In a declaration attribute-specifier-seq

_{o p t}

T D where D is an unadorned declarator-id, the type of the declared entity is “T”.

In a declaration T D where D has the form

( D1 )

the type of the contained declarator-id is the same as that of the contained declarator-id in the declaration T D1

Parentheses do not alter the type of the embedded declarator-id, but they can alter the binding of complex declarators.

9.3.4.2 Pointers [dcl.ptr]

In a declaration T D where D has the form

* attribute-specifier-seq

_{o p t}

cv-qualifier-seq

_{o p t}

and the type of the contained declarator-id in the declaration T D1 is “derived-declarator-type-list T”, the type of the declarator-id in D is “derived-declarator-type-list cv-qualifier-seq pointer to T”.

The cv-qualifiers apply to the pointer and not to the object pointed to.

Similarly, the optional attribute-specifier-seq ([dcl.attr.grammar]) appertains to the pointer and not to the object pointed to.

[Example 1:

The declarations const int ci = 10, *pc = &ci, *const cpc = pc, **ppc; int i, *p, *const cp = &i; declare ci, a constant integer; pc, a pointer to a constant integer; cpc, a constant pointer to a constant integer; ppc, a pointer to a pointer to a constant integer; i, an integer; p, a pointer to integer; and cp, a constant pointer to integer.

The value of ci, cpc, and cp cannot be changed after initialization.

The value of pc can be changed, and so can the object pointed to by cp.

Examples of some correct operations are i = ci; *cp = ci; pc++; pc = cpc; pc = p; ppc = &pc;

Examples of ill-formed operations are ci = 1; // error ci++; // error *pc = 2; // error cp = &ci; // error cpc++; // error p = pc; // error ppc = &p; // error

Each is unacceptable because it would either change the value of an object declared const or allow it to be changed through a cv-unqualified pointer later, for example: *ppc = &ci; // OK, but would make p point to ci because of previous error *p = 5; // clobber ci

— end example]

9.3.4.3 References [dcl.ref]

In a declaration T D where D has either of the forms

& attribute-specifier-seq

_{o p t}

D1
&& attribute-specifier-seq

_{o p t}

The optional attribute-specifier-seq appertains to the reference type.

Cv-qualified references are ill-formed except when the cv-qualifiers are introduced through the use of a typedef-name ([dcl.typedef], [temp.param]) or decltype-specifier ([dcl.type.decltype]), in which case the cv-qualifiers are ignored.

[Example 1: typedef int& A; const A aref = 3; // error: lvalue reference to non-const initialized with rvalue

The type of aref is “lvalue reference to int”, not “lvalue reference to const int”.

— end example]

[Note 1:

A reference can be thought of as a name of an object.

— end note]

Forming the type “reference to cv void” is ill-formed.

A reference type that is declared using & is called an lvalue reference, and a reference type that is declared using && is called an rvalue reference.

Lvalue references and rvalue references are distinct types.

Except where explicitly noted, they are semantically equivalent and commonly referred to as references.

[Example 2:

void f(double& a) { a += 3.14; } // ... double d = 0; f(d); declares a to be a reference parameter of f so the call f(d) will add 3.14 to d.

int v[20]; // ... int& g(int i) { return v[i]; } // ... g(3) = 7; declares the function g() to return a reference to an integer so g(3)=7 will assign 7 to the fourth element of the array v.

For another example, struct link { link* next; }; link* first; void h(link*& p) { // p is a reference to pointer p->next = first; first = p; p = 0; } void k() { link* q = new link; h(q); } declares p to be a reference to a pointer to link so h(q) will leave q with the value zero.

9.3.4.4 Pointers to members [dcl.mptr]

The component names of a ptr-operator are those of its nested-name-specifier, if any.

In a declaration T D where D has the form

nested-name-specifier * attribute-specifier-seq

_{o p t}

cv-qualifier-seq

_{o p t}

and the nested-name-specifier denotes a class, and the type of the contained declarator-id in the declaration T D1 is “derived-declarator-type-list T”, the type of the declarator-id in D is “derived-declarator-type-list cv-qualifier-seq pointer to member of class nested-name-specifier of type T”.

The optional attribute-specifier-seq ([dcl.attr.grammar]) appertains to the pointer-to-member.

[Example 1:

struct X { void f(int); int a; }; struct Y; int X::* pmi = &X::a; void (X::* pmf)(int) = &X::f; double X::* pmd; char Y::* pmc; declares pmi, pmf, pmd and pmc to be a pointer to a member of X of type int, a pointer to a member of X of type void(int), a pointer to a member of X of type double and a pointer to a member of Y of type char respectively.

The declaration of pmd is well-formed even though X has no members of type double.

Similarly, the declaration of pmc is well-formed even though Y is an incomplete type.

pmi and pmf can be used like this: X obj; // ... obj.*pmi = 7; // assign 7 to an integer member of obj (obj.*pmf)(7); // call a function member of obj with the argument 7

— end example]

A pointer to member shall not point to a static member of a class ([class.static]), a member with reference type, or “cv void”.

[Note 1:

See also [expr.unary] and [expr.mptr.oper].

The type “pointer to member” is distinct from the type “pointer”, that is, a pointer to member is declared only by the pointer-to-member declarator syntax, and never by the pointer declarator syntax.

There is no “reference-to-member” type in C++.

— end note]

9.3.4.5 Arrays [dcl.array]

In a declaration T D where D has the form

D1 [ constant-expression

_{o p t}

] attribute-specifier-seq

_{o p t}

The constant-expression shall be a converted constant expression of type std::size_t ([expr.const]).

Its value N specifies the array bound, i.e., the number of elements in the array; N shall be greater than zero.

In a declaration T D where D has the form

D1 [ ] attribute-specifier-seq

_{o p t}

A type of the form “array of N U” or “array of unknown bound of U” is an array type.

The optional attribute-specifier-seq appertains to the array type.

U is called the array element type; this type shall not be a reference type, a function type, an array of unknown bound, or cv void.

[Note 1:

An array can be constructed from one of the fundamental types (except void), from a pointer, from a pointer to member, from a class, from an enumeration type, or from an array of known bound.

— end note]

[Example 1:

float fa[17], *afp[17]; declares an array of float numbers and an array of pointers to float numbers.

— end example]

Any type of the form “cv-qualifier-seq array of N U” is adjusted to “array of N cv-qualifier-seq U”, and similarly for “array of unknown bound of U”.

[Example 2: typedef int A[5], AA[2][3]; typedef const A CA; // type is “array of 5 const int'' typedef const AA CAA; // type is “array of 2 array of 3 const int'' — end example]

[Note 2:

An “array of N cv-qualifier-seq U” has cv-qualified type; see [basic.type.qualifier].

— end note]

An object of type “array of N U” consists of a contiguously allocated non-empty set of N subobjects of type U, known as the elements of the array, and numbered 0 to N-1.

In addition to declarations in which an incomplete object type is allowed, an array bound may be omitted in some cases in the declaration of a function parameter ([dcl.fct]).

An array bound may also be omitted when an object (but not a non-static data member) of array type is initialized and the declarator is followed by an initializer ([dcl.init], [class.mem], [expr.type.conv], [expr.new]).

In these cases, the array bound is calculated from the number of initial elements (say, N) supplied ([dcl.init.aggr]), and the type of the array is “array of N U”.

Furthermore, if there is a reachable declaration of the entity that inhabits the same scope in which the bound was specified, an omitted array bound is taken to be the same as in that earlier declaration, and similarly for the definition of a static data member of a class.

[Example 3: extern int x[10]; struct S { static int y[10]; }; int x[]; // OK, bound is 10 int S::y[]; // OK, bound is 10 void f() { extern int x[]; int i = sizeof(x); // error: incomplete object type } — end example]

[Note 3:

When several “array of” specifications are adjacent, a multidimensional array type is created; only the first of the constant expressions that specify the bounds of the arrays can be omitted.

[Example 4:

int x3d[3][5][7]; declares an array of three elements, each of which is an array of five elements, each of which is an array of seven integers.

The overall array can be viewed as a three-dimensional array of integers, with rank 3 ×5 ×7.

Any of the expressions x3d, x3d[i], x3d[i][j], x3d[i][j][k] can reasonably appear in an expression.

The expression x3d[i] is equivalent to *(x3d + i); in that expression, x3d is subject to the array-to-pointer conversion ([conv.array]) and is first converted to a pointer to a 2-dimensional array with rank 5 ×7 that points to the first element of x3d.

Then i is added, which on typical implementations involves multiplying i by the length of the object to which the pointer points, which is sizeof(int)×5 ×7.

The result of the addition and indirection is an lvalue denoting the

i^{th}

array element of x3d (an array of five arrays of seven integers).

If there is another subscript, the same argument applies again, so x3d[i][j] is an lvalue denoting the

j^{th}

array element of the

i^{th}

array element of x3d (an array of seven integers), and x3d[i][j][k] is an lvalue denoting the

k^{th}

array element of the

j^{th}

array element of the

i^{th}

array element of x3d (an integer).

— end example]

The first subscript in the declaration helps determine the amount of storage consumed by an array but plays no other part in subscript calculations.

— end note]

[Note 4:

Conversions affecting expressions of array type are described in [conv.array].

— end note]

[Note 5:

The subscript operator can be overloaded for a class ([over.sub]).

For the operator's built-in meaning, see [expr.sub].

— end note]

9.3.4.6 Functions [dcl.fct]

In a declaration T D where T may be empty and D has the form

D1 ( parameter-declaration-clause ) cv-qualifier-seq

_{o p t}

ref-qualifier

_{o p t}

noexcept-specifier

_{o p t}

attribute-specifier-seq

_{o p t}

trailing-return-type

_{o p t}

a derived-declarator-type-list is determined as follows:

(1.1)
If the unqualified-id of the declarator-id is a conversion-function-id, the derived-declarator-type-list is empty.
(1.2)
Otherwise, the derived-declarator-type-list is as appears in the type “derived-declarator-type-list T” of the contained declarator-id in the declaration T D1.

The declared return type U of the function type is determined as follows:

(1.3)
If the trailing-return-type is present, T shall be the single type-specifier auto, and U is the type specified by the trailing-return-type.
(1.4)
Otherwise, if the declaration declares a conversion function, see [class.conv.fct].
(1.5)
Otherwise, U is T.

The type of the declarator-id in D is “derived-declarator-type-list noexcept

_{o p t}

function of parameter-type-list cv-qualifier-seq

_{o p t}

ref-qualifier

_{o p t}

returning U”, where

(1.6)
the parameter-type-list is derived from the parameter-declaration-clause as described below and
(1.7)
the optional noexcept is present if and only if the exception specification ([except.spec]) is non-throwing.

Such a type is a function type.75

The optional attribute-specifier-seq appertains to the function type.

parameter-declaration-clause:
...
parameter-declaration-list

_{o p t}

parameter-declaration-list , ...
parameter-declaration-list ...

parameter-declaration-list:
parameter-declaration
parameter-declaration-list , parameter-declaration

parameter-declaration:
attribute-specifier-seq

_{o p t}

this

_{o p t}

decl-specifier-seq declarator
attribute-specifier-seq

_{o p t}

decl-specifier-seq declarator = initializer-clause
attribute-specifier-seq

_{o p t}

this

_{o p t}

decl-specifier-seq abstract-declarator

_{o p t}

attribute-specifier-seq

_{o p t}

decl-specifier-seq abstract-declarator

_{o p t}

= initializer-clause

The optional attribute-specifier-seq in a parameter-declaration appertains to the parameter.

The parameter-declaration-clause determines the arguments that can be specified, and their processing, when the function is called.

[Note 1:

The parameter-declaration-clause is used to convert the arguments specified on the function call; see [expr.call].

— end note]

If the parameter-declaration-clause is empty, the function takes no arguments.

A parameter list consisting of a single unnamed non-object parameter of non-dependent type void is equivalent to an empty parameter list.

Except for this special case, a parameter shall not have type cv void.

A parameter with volatile-qualified type is deprecated; see [depr.volatile.type].

If the parameter-declaration-clause terminates with an ellipsis or a function parameter pack ([temp.variadic]), the number of arguments shall be equal to or greater than the number of parameters that do not have a default argument and are not function parameter packs.

Where syntactically correct and where “...” is not part of an abstract-declarator, “...” is synonymous with “, ...”.

A parameter-declaration-clause of the form parameter-declaration-list ... is deprecated ([depr.ellipsis.comma]).

[Example 1:

The declaration int printf(const char*, ...); declares a function that can be called with varying numbers and types of arguments.

printf("hello world"); printf("a=%d b=%d", a, b);

However, the first argument must be of a type that can be converted to a const char*.

— end example]

[Note 2:

The standard header <cstdarg> contains a mechanism for accessing arguments passed using the ellipsis (see [expr.call] and [support.runtime]).

— end note]

The type of a function is determined using the following rules.

The type of each parameter (including function parameter packs) is determined from its own parameter-declaration ([dcl.decl]).

After determining the type of each parameter, any parameter of type “array of T” or of function type T is adjusted to be “pointer to T”.

After producing the list of parameter types, any top-level cv-qualifiers modifying a parameter type are deleted when forming the function type.

The resulting list of transformed parameter types and the presence or absence of the ellipsis or a function parameter pack is the function's parameter-type-list.

[Note 3:

This transformation does not affect the types of the parameters.

For example, int(*)(const int p, decltype(p)*) and int(*)(int, const int*) are identical types.

— end note]

[Example 2: void f(char*); // #1 void f(char[]) {} // defines #1 void f(const char*) {} // OK, another overload void f(char *const) {} // error: redefines #1 void g(char(*)[2]); // #2 void g(char[3][2]) {} // defines #2 void g(char[3][3]) {} // OK, another overload void h(int x(const int)); // #3 void h(int (*)(int)) {} // defines #3 — end example]

An explicit-object-parameter-declaration is a parameter-declaration with a this specifier.

An explicit-object-parameter-declaration shall appear only as the first parameter-declaration of a parameter-declaration-list of one of:

(5.1)
a declaration of a member function or member function template ([class.mem]), or
(5.2)
an explicit instantiation ([temp.explicit]) or explicit specialization ([temp.expl.spec]) of a templated member function, or
(5.3)
a lambda-declarator ([expr.prim.lambda]).

A member-declarator with an explicit-object-parameter-declaration shall not include a ref-qualifier or a cv-qualifier-seq and shall not be declared static or virtual.

[Example 3: struct C { void f(this C& self); template <typename Self> void g(this Self&& self, int); void h(this C) const; // error: const not allowed here }; void test(C c) { c.f(); // OK, calls C::f c.g(42); // OK, calls C::g<C&> std::move(c).g(42); // OK, calls C::g<C> } — end example]

A function parameter declared with an explicit-object-parameter-declaration is an explicit object parameter.

An explicit object parameter shall not be a function parameter pack ([temp.variadic]).

An explicit object member function is a non-static member function with an explicit object parameter.

An implicit object member function is a non-static member function without an explicit object parameter.

The object parameter of a non-static member function is either the explicit object parameter or the implicit object parameter ([over.match.funcs]).

A non-object parameter is a function parameter that is not the explicit object parameter.

The non-object-parameter-type-list of a member function is the parameter-type-list of that function with the explicit object parameter, if any, omitted.

[Note 4:

The non-object-parameter-type-list consists of the adjusted types of all the non-object parameters.

— end note]

A function type with a cv-qualifier-seq or a ref-qualifier (including a type named by typedef-name ([dcl.typedef], [temp.param])) shall appear only as:

(9.1)
the function type for a non-static member function,
(9.2)
the function type to which a pointer to member refers,
(9.3)
the top-level function type of a function typedef declaration or alias-declaration,
(9.4)
the type-id in the default argument of a type-parameter ([temp.param]), or
(9.5)
the type-id of a template-argument for a type-parameter ([temp.arg.type]).

[Example 4: typedef int FIC(int) const; FIC f; // error: does not declare a member function struct S { FIC f; // OK }; FIC S::*pm = &S::f; // OK — end example]

The effect of a cv-qualifier-seq in a function declarator is not the same as adding cv-qualification on top of the function type.

In the latter case, the cv-qualifiers are ignored.

[Note 5:

A function type that has a cv-qualifier-seq is not a cv-qualified type; there are no cv-qualified function types.

— end note]

[Example 5: typedef void F(); struct S { const F f; // OK, equivalent to: void f(); }; — end example]

The return type, the parameter-type-list, the ref-qualifier, the cv-qualifier-seq, and the exception specification, but not the default arguments ([dcl.fct.default]) or the trailing requires-clause ([dcl.decl]), are part of the function type.

[Note 6:

Function types are checked during the assignments and initializations of pointers to functions, references to functions, and pointers to member functions.

— end note]

[Example 6:

The declaration int fseek(FILE*, long, int); declares a function taking three arguments of the specified types, and returning int ([dcl.type]).

— end example]

[Note 7:

A single name can be used for several different functions in a single scope; this is function overloading ([over]).

— end note]

The return type shall be a non-array object type, a reference type, or cv void.

[Note 8:

An array of placeholder type is considered an array type.

— end note]

A volatile-qualified return type is deprecated; see [depr.volatile.type].

Types shall not be defined in return or parameter types.

A typedef of function type may be used to declare a function but shall not be used to define a function ([dcl.fct.def]).

[Example 7: typedef void F(); F fv; // OK, equivalent to void fv(); F fv { } // error void fv() { } // OK, definition of fv — end example]

An identifier can optionally be provided as a parameter name; if present in a function definition ([dcl.fct.def]), it names a parameter.

[Note 9:

In particular, parameter names are also optional in function definitions and names used for a parameter in different declarations and the definition of a function need not be the same.

— end note]

[Example 8:

The declaration int i, *pi, f(), *fpi(int), (*pif)(const char*, const char*), (*fpif(int))(int); declares an integer i, a pointer pi to an integer, a function f taking no arguments and returning an integer, a function fpi taking an integer argument and returning a pointer to an integer, a pointer pif to a function which takes two pointers to constant characters and returns an integer, a function fpif taking an integer argument and returning a pointer to a function that takes an integer argument and returns an integer.

It is especially useful to compare fpi and pif.

The binding of *fpi(int) is *(fpi(int)), so the declaration suggests, and the same construction in an expression requires, the calling of a function fpi, and then using indirection through the (pointer) result to yield an integer.

In the declarator (*pif)(const char*, const char*), the extra parentheses are necessary to indicate that indirection through a pointer to a function yields a function, which is then called.

— end example]

[Note 10:

Typedefs and trailing-return-types are sometimes convenient when the return type of a function is complex.

For example, the function fpif above can be declared typedef int IFUNC(int); IFUNC* fpif(int); or auto fpif(int)->int(*)(int);

A trailing-return-type is most useful for a type that would be more complicated to specify before the declarator-id: template <class T, class U> auto add(T t, U u) -> decltype(t + u); rather than template <class T, class U> decltype((*(T*)0) + (*(U*)0)) add(T t, U u);

— end note]

A non-template function is a function that is not a function template specialization.

[Note 11:

A function template is not a function.

— end note]

An abbreviated function template is a function declaration that has one or more generic parameter type placeholders ([dcl.spec.auto]).

An abbreviated function template is equivalent to a function template ([temp.fct]) whose template-parameter-list includes one invented type template-parameter for each generic parameter type placeholder of the function declaration, in order of appearance.

For a placeholder-type-specifier of the form auto, the invented parameter is an unconstrained type-parameter.

For a placeholder-type-specifier of the form type-constraint auto, the invented parameter is a type-parameter with that type-constraint.

The invented type template-parameter is a template parameter pack if the corresponding parameter-declaration declares a function parameter pack.

If the placeholder contains decltype(auto), the program is ill-formed.

The adjusted function parameters of an abbreviated function template are derived from the parameter-declaration-clause by replacing each occurrence of a placeholder with the name of the corresponding invented template-parameter.

[Example 9: template<typename T> concept C1 = /* ... */; template<typename T> concept C2 = /* ... */; template<typename... Ts> concept C3 = /* ... */; void g1(const C1 auto*, C2 auto&); void g2(C1 auto&...); void g3(C3 auto...); void g4(C3 auto);

The declarations above are functionally equivalent (but not equivalent) to their respective declarations below: template<C1 T, C2 U> void g1(const T*, U&); template<C1... Ts> void g2(Ts&...); template<C3... Ts> void g3(Ts...); template<C3 T> void g4(T);

Abbreviated function templates can be specialized like all function templates.

template<> void g1<int>(const int*, const double&); // OK, specialization of g1<int, const double> — end example]

An abbreviated function template can have a template-head.

The invented template-parameters are appended to the template-parameter-list after the explicitly declared template-parameters.

[Example 10: template<typename> concept C = /* ... */; template <typename T, C U> void g(T x, U y, C auto z);

This is functionally equivalent to each of the following two declarations.

template<typename T, C U, C W> void g(T x, U y, W z); template<typename T, typename U, typename W> requires C<U> && C<W> void g(T x, U y, W z); — end example]

A function declaration at block scope shall not declare an abbreviated function template.

A declarator-id or abstract-declarator containing an ellipsis shall only be used in a parameter-declaration.

When it is part of a parameter-declaration-clause, the parameter-declaration declares a function parameter pack ([temp.variadic]).

Otherwise, the parameter-declaration is part of a template-parameter-list and declares a template parameter pack; see [temp.param].

A function parameter pack is a pack expansion ([temp.variadic]).

[Example 11: template<typename... T> void f(T (* ...t)(int, int)); int add(int, int); float subtract(int, int); void g() { f(add, subtract); } — end example]

There is a syntactic ambiguity when an ellipsis occurs at the end of a parameter-declaration-clause without a preceding comma.

In this case, the ellipsis is parsed as part of the abstract-declarator if the type of the parameter either names a template parameter pack that has not been expanded or contains auto; otherwise, it is parsed as part of the parameter-declaration-clause.76

75)75)

As indicated by syntax, cv-qualifiers are a significant component in function return types.

76)76)

One can explicitly disambiguate the parse either by introducing a comma (so the ellipsis will be parsed as part of the parameter-declaration-clause) or by introducing a name for the parameter (so the ellipsis will be parsed as part of the declarator-id).

9.3.4.7 Default arguments [dcl.fct.default]

If an initializer-clause is specified in a parameter-declaration this initializer-clause is used as a default argument.

[Note 1:

Default arguments will be used in calls where trailing arguments are missing ([expr.call]).

— end note]

[Example 1:

The declaration void point(int = 3, int = 4); declares a function that can be called with zero, one, or two arguments of type int.

It can be called in any of these ways: point(1,2); point(1); point();

The last two calls are equivalent to point(1,4) and point(3,4), respectively.

— end example]

A default argument shall be specified only in the parameter-declaration-clause of a function declaration or lambda-declarator or in a template-parameter ([temp.param]).

A default argument shall not be specified for a template parameter pack or a function parameter pack.

If it is specified in a parameter-declaration-clause, it shall not occur within a declarator or abstract-declarator of a parameter-declaration.77

For non-template functions, default arguments can be added in later declarations of a function that inhabit the same scope.

Declarations that inhabit different scopes have completely distinct sets of default arguments.

That is, declarations in inner scopes do not acquire default arguments from declarations in outer scopes, and vice versa.

In a given function declaration, each parameter subsequent to a parameter with a default argument shall have a default argument supplied in this or a previous declaration, unless the parameter was expanded from a parameter pack, or shall be a function parameter pack.

[Note 2:

A default argument cannot be redefined by a later declaration (not even to the same value) ([basic.def.odr]).

— end note]

[Example 2: void g(int = 0, ...); // OK, ellipsis is not a parameter so it can follow // a parameter with a default argument void f(int, int); void f(int, int = 7); void h() { f(3); // OK, calls f(3, 7) void f(int = 1, int); // error: does not use default from surrounding scope } void m() { void f(int, int); // has no defaults f(4); // error: wrong number of arguments void f(int, int = 5); // OK f(4); // OK, calls f(4, 5); void f(int, int = 5); // error: cannot redefine, even to same value } void n() { f(6); // OK, calls f(6, 7) } template<class ... T> struct C { void f(int n = 0, T...); }; C<int> c; // OK, instantiates declaration void C::f(int n = 0, int) — end example]

For a given inline function defined in different translation units, the accumulated sets of default arguments at the end of the translation units shall be the same; no diagnostic is required.

If a friend declaration D specifies a default argument expression, that declaration shall be a definition and there shall be no other declaration of the function or function template which is reachable from D or from which D is reachable.

The default argument has the same semantic constraints as the initializer in a declaration of a variable of the parameter type, using the copy-initialization semantics ([dcl.init]).

The names in the default argument are looked up, and the semantic constraints are checked, at the point where the default argument appears, except that an immediate invocation ([expr.const]) that is a potentially-evaluated subexpression ([intro.execution]) of the initializer-clause in a parameter-declaration is neither evaluated nor checked for whether it is a constant expression at that point.

Name lookup and checking of semantic constraints for default arguments of templated functions are performed as described in [temp.inst].

[Example 3:

In the following code, g will be called with the value f(2): int a = 1; int f(int); int g(int x = f(a)); // default argument: f(::a) void h() { a = 2; { int a = 3; g(); // g(f(::a)) } }

— end example]

[Note 3:

A default argument is a complete-class context ([class.mem]).

Access checking applies to names in default arguments as described in [class.access].

— end note]

Except for member functions of templated classes, the default arguments in a member function definition that appears outside of the class definition are added to the set of default arguments provided by the member function declaration in the class definition; the program is ill-formed if a default constructor ([class.default.ctor]), copy or move constructor ([class.copy.ctor]), or copy or move assignment operator ([class.copy.assign]) is so declared.

Default arguments for a member function of a templated class shall be specified on the initial declaration of the member function within the templated class.

[Example 4: class C { void f(int i = 3); void g(int i, int j = 99); }; void C::f(int i = 3) {} // error: default argument already specified in class scope void C::g(int i = 88, int j) {} // in this translation unit, C::g can be called with no arguments — end example]

[Note 4:

A local variable cannot be odr-used ([basic.def.odr]) in a default argument.

— end note]

[Example 5: void f() { int i; extern void g(int x = i); // error extern void h(int x = sizeof(i)); // OK // ... } — end example]

[Note 5:

The keyword this cannot appear in a default argument of a member function; see [expr.prim.this].

[Example 6: class A { void f(A* p = this) { } // error }; — end example]

— end note]

A default argument is evaluated each time the function is called with no argument for the corresponding parameter.

A parameter shall not appear as a potentially-evaluated expression in a default argument.

[Note 6:

Parameters of a function declared before a default argument are in scope and can hide namespace and class member names.

— end note]

[Example 7: int a; int f(int a, int b = a); // error: parameter a used as default argument typedef int I; int g(float I, int b = I(2)); // error: parameter I found int h(int a, int b = sizeof(a)); // OK, unevaluated operand — end example]

A non-static member shall not appear in a default argument unless it appears as the id-expression of a class member access expression ([expr.ref]) or unless it is used to form a pointer to member ([expr.unary.op]).

[Example 8:

The declaration of X::mem1() in the following example is ill-formed because no object is supplied for the non-static member X::a used as an initializer.

int b; class X { int a; int mem1(int i = a); // error: non-static member a used as default argument int mem2(int i = b); // OK; use X::b static int b; };

The declaration of X::mem2() is meaningful, however, since no object is needed to access the static member X::b.

Classes, objects, and members are described in [class].

— end example]

A default argument is not part of the type of a function.

[Example 9: int f(int = 0); void h() { int j = f(1); int k = f(); // OK, means f(0) } int (*p1)(int) = &f; int (*p2)() = &f; // error: type mismatch — end example]

When an overload set contains a declaration of a function that inhabits a scope S, any default argument associated with any reachable declaration that inhabits S is available to the call.

[Note 7:

The candidate might have been found through a using-declarator from which the declaration that provides the default argument is not reachable.

— end note]

A virtual function call ([class.virtual]) uses the default arguments in the declaration of the virtual function determined by the static type of the pointer or reference denoting the object.

An overriding function in a derived class does not acquire default arguments from the function it overrides.

[Example 10: struct A { virtual void f(int a = 7); }; struct B : public A { void f(int a); }; void m() { B* pb = new B; A* pa = pb; pa->f(); // OK, calls pa->B::f(7) pb->f(); // error: wrong number of arguments for B::f() } — end example]

77)77)

This means that default arguments cannot appear, for example, in declarations of pointers to functions, references to functions, or typedef declarations.