\rSec0[dcl.dcl]{Declarations}%

\indextext{declaration|(}

\indextext{linkage specification|see{specification, linkage}}

Declarations generally specify how names are to be interpreted. Declarations have

the form

\begin{bnf}

\nontermdef{declaration-seq}\br

declaration\br

declaration-seq declaration

\end{bnf}

\begin{bnf}

\nontermdef{declaration}\br

block-declaration\br

function-definition\br

template-declaration\br

explicit-instantiation\br

explicit-specialization\br

linkage-specification\br

namespace-definition\br

empty-declaration\br

attribute-declaration

\end{bnf}

\begin{bnf}

\nontermdef{block-declaration}\br

simple-declaration\br

asm-definition\br

namespace-alias-definition\br

using-declaration\br

using-directive\br

static_assert-declaration\br

alias-declaration\br

opaque-enum-declaration

\end{bnf}

\begin{bnf}

\nontermdef{alias-declaration}\br

\terminal{using} identifier attribute-specifier-seq\opt \terminal{=} type-id \terminal{;}

\end{bnf}

\begin{bnf}

\nontermdef{simple-declaration}\br

decl-specifier-seq\opt init-declarator-list\opt \terminal{;}\br

attribute-specifier-seq decl-specifier-seq\opt init-declarator-list \terminal{;}

\end{bnf}

\begin{bnf}

\nontermdef{static_assert-declaration}\br

\terminal{static_assert} \terminal{(} constant-expression \terminal{)} \terminal{;}\br

\terminal{static_assert} \terminal{(} constant-expression \terminal{,} string-literal \terminal{)} \terminal{;}

\end{bnf}

\begin{bnf}

\nontermdef{empty-declaration}\br

\terminal{;}

\end{bnf}

\begin{bnf}

\nontermdef{attribute-declaration}\br

attribute-specifier-seq \terminal{;}

\end{bnf}

\grammarterm{asm-definition}{s} are described in~\ref{dcl.asm}, and

\grammarterm{linkage-specification}{s} are described in~\ref{dcl.link}.

\grammarterm{Function-definition}{s} are described in~\ref{dcl.fct.def} and

\grammarterm{template-declaration}{s} are described in Clause~\ref{temp}.

\grammarterm{Namespace-definition}{s} are described in~\ref{namespace.def},

\grammarterm{using-declaration}{s} are described in~\ref{namespace.udecl} and

\grammarterm{using-directive}{s} are described in~\ref{namespace.udir}.

The

\grammarterm{simple-declaration}

\begin{ncsimplebnf}

attribute-specifier-seq\opt decl-specifier-seq\opt init-declarator-list\opt \terminal{;}

\end{ncsimplebnf}

is divided into three parts.

Attributes are described in~\ref{dcl.attr}.

\grammarterm{decl-specifier}{s}, the principal components of

a \grammarterm{decl-specifier-seq}, are described in~\ref{dcl.spec}.

\grammarterm{declarator}{s}, the components of an

\grammarterm{init-declarator-list}, are described in Clause~\ref{dcl.decl}.

The \grammarterm{attribute-specifier-seq} in a

\grammarterm{simple-declaration} appertains to each of the entities declared by

the \grammarterm{declarator}{s}

of the \grammarterm{init-declarator-list}.

\enternote In the declaration for an entity, attributes appertaining to that

entity may appear at the start of the declaration and after the

\grammarterm{declarator-id} for that declaration.

\exitnote \enterexample

\begin{codeblock}

[[noreturn]] void f [[noreturn]] (); // OK

\end{codeblock}

Except where otherwise specified, the meaning of an \grammarterm{attribute-declaration}

is \impldef{meaning of attribute declaration}.

\indextext{declaration}%

\indextext{scope}%

A declaration occurs in a scope~(\ref{basic.scope}); the scope rules are

summarized in~\ref{basic.lookup}. A declaration that declares a function

or defines a class, namespace, template, or function also has one or

more scopes nested within it. These nested scopes, in turn, can have

declarations nested within them. Unless otherwise stated, utterances in

Clause~\ref{dcl.dcl} about components in, of, or contained by a

declaration or subcomponent thereof refer only to those components of

the declaration that are \emph{not} nested within scopes nested within

the declaration.

\indextext{identifier}%

\indextext{declarator}%

In a \grammarterm{simple-declaration}, the optional

\grammarterm{init-declarator-list} can be omitted only when declaring a

class (Clause~\ref{class}) or enumeration~(\ref{dcl.enum}), that is,

when the \grammarterm{decl-specifier-seq} contains either a

\grammarterm{class-specifier}, an \grammarterm{elaborated-type-specifier} with

a \grammarterm{class-key}~(\ref{class.name}), or an

\grammarterm{enum-specifier}. In these cases and whenever a

\grammarterm{class-specifier} or \grammarterm{enum-specifier} is present in

the \grammarterm{decl-specifier-seq}, the identifiers in these specifiers

are among the names being declared by the declaration (as

\grammarterm{class-name}{s}, \grammarterm{enum-name}{s}, or

\grammarterm{enumerator}{s}, depending on the syntax). In such cases,

the \grammarterm{decl-specifier-seq} shall introduce one or more names into

the program, or shall redeclare a name introduced by a previous

declaration.

\begin{codeblock}

enum { }; // ill-formed

typedef class { }; // ill-formed

\end{codeblock}

\indextext{\idxgram{static_assert}}%

In a \grammarterm{static_assert-declaration} the

\grammarterm{constant-expression} shall be a constant

expression~(\ref{expr.const}) that can be contextually converted to \tcode{bool}

(Clause~\ref{conv}). If the value of the expression when

so converted is \tcode{true}, the declaration has no

effect. Otherwise, the program is ill-formed, and the resulting

diagnostic message~(\ref{intro.compliance}) shall include the text of

the \grammarterm{string-literal}, if one is supplied,

except that characters not in the basic

source character set~(\ref{lex.charset}) are not required to appear in

the diagnostic message.

\begin{codeblock}

static_assert(char(-1) < 0, "this library requires plain 'char' to be signed");

\end{codeblock}\exitexample

An \grammarterm{empty-declaration} has no effect.

Each \grammarterm{init-declarator} in the \grammarterm{init-declarator-list}

contains exactly one \grammarterm{declarator-id}, which is the name

declared by that \grammarterm{init-declarator} and hence one of the names

declared by the declaration. The

\grammarterm{type-specifiers}~(\ref{dcl.type}) in the

\grammarterm{decl-specifier-seq} and the recursive \grammarterm{declarator}

structure of the \grammarterm{init-declarator} describe a

type~(\ref{dcl.meaning}), which is then associated with the name being

declared by the \grammarterm{init-declarator}.

If the \grammarterm{decl-specifier-seq} contains the \tcode{typedef}

specifier, the declaration is called a \term{typedef declaration} and the name

of each \grammarterm{init-declarator}

is declared to be a \grammarterm{typedef-name}, synonymous with its

associated type~(\ref{dcl.typedef}). If the

\grammarterm{decl-specifier-seq} contains no \tcode{typedef} specifier, the

declaration is called a \term{function declaration} if

the type associated with the name is a function type~(\ref{dcl.fct}) and

an \term{object declaration} otherwise.

\indextext{definition!declaration~as}%

Syntactic components beyond those found in the general form of

declaration are added to a function declaration to make a

\grammarterm{function-definition}. An object declaration, however, is also

a definition unless it contains the \tcode{extern} specifier and has no

initializer~(\ref{basic.def}).

\indextext{initialization!definition~and}%

A

definition causes the appropriate amount of storage to be reserved and

any appropriate initialization~(\ref{dcl.init}) to be done.

Only in function declarations for constructors, destructors, and type

conversions can the \grammarterm{decl-specifier-seq} be omitted.\footnote{The

``implicit int'' rule of C is no longer supported.}

\rSec1[dcl.spec]{Specifiers}%

\indextext{specifier|(}

\indextext{specifier!declaration}%

The specifiers that can be used in a declaration are

\begin{bnf}

\nontermdef{decl-specifier}\br

storage-class-specifier\br

type-specifier\br

function-specifier\br

\terminal{friend}\br

\terminal{typedef}\br

\terminal{constexpr}

\end{bnf}

\begin{bnf}

\nontermdef{decl-specifier-seq}\br

decl-specifier attribute-specifier-seq\opt\br

decl-specifier decl-specifier-seq

\end{bnf}

The optional \grammarterm{attribute-specifier-seq} in a \grammarterm{decl-specifier-seq}

appertains to the type determined by the preceding

\grammarterm{decl-specifier}{s}~(\ref{dcl.meaning}). The \grammarterm{attribute-specifier-seq}

affects the type only for the declaration it appears in, not other declarations involving the

same type.

Each \grammarterm{decl-specifier} shall appear at most once in the complete

\grammarterm{decl-specifier-seq} of a declaration, except that

\tcode{long} may appear twice.

\indextext{ambiguity!declaration type}%

If a \grammarterm{type-name} is encountered while parsing a \grammarterm{decl-specifier-seq},

it is interpreted as part of the \grammarterm{decl-specifier-seq} if and only if there is no

previous \grammarterm{type-specifier} other than a \grammarterm{cv-qualifier} in the

\grammarterm{decl-specifier-seq}.

The sequence shall be self-consistent as

described below.

\begin{codeblock}

typedef char* Pc;

static Pc; // error: name missing

\end{codeblock}

Here, the declaration \tcode{static} \tcode{Pc} is ill-formed because no

name was specified for the static variable of type \tcode{Pc}. To get a

variable called \tcode{Pc}, a \grammarterm{type-specifier} (other than

\tcode{const} or \tcode{volatile}) has to be present to indicate that

the \grammarterm{typedef-name} \tcode{Pc} is the name being (re)declared,

rather than being part of the \grammarterm{decl-specifier} sequence. For

another example,

\begin{codeblock}

void f(const Pc); // \tcode{void f(char* const)} (not \tcode{const char*})

void g(const int Pc); // \tcode{void g(const int)}

\end{codeblock}

\indextext{\idxcode{signed}!typedef@\tcode{typedef}~and}%

\indextext{\idxcode{unsigned}!typedef@\tcode{typedef}~and}%

\indextext{\idxcode{long}!typedef@\tcode{typedef}~and}%

\indextext{\idxcode{short}!typedef@\tcode{typedef}~and}%

Since \tcode{signed}, \tcode{unsigned}, \tcode{long}, and \tcode{short}

by default imply \tcode{int}, a \grammarterm{type-name} appearing after one

of those specifiers is treated as the name being (re)declared.

\begin{codeblock}

void h(unsigned Pc); // \tcode{void h(unsigned int)}

void k(unsigned int Pc); // \tcode{void k(unsigned int)}

\end{codeblock}

\rSec2[dcl.stc]{Storage class specifiers}%

\indextext{specifier!storage~class}%

\indextext{declaration!storage~class}%

\indextext{\idxcode{register}}%

\indextext{\idxcode{static}}%

\indextext{\idxcode{thread_local}}%

\indextext{\idxcode{extern}}%

\indextext{\idxcode{mutable}}

The storage class specifiers are

\begin{bnf}

\nontermdef{storage-class-specifier}\br

\terminal{register}\br

\terminal{static}\br

\terminal{thread_local}\br

\terminal{extern}\br

\terminal{mutable}

\end{bnf}

At most one \grammarterm{storage-class-specifier} shall appear in a given

\grammarterm{decl-specifier-seq}, except that \tcode{thread_local} may appear with \tcode{static} or

\tcode{extern}. If \tcode{thread_local} appears in any declaration of

a variable it shall be present in all declarations of that entity. If a

\grammarterm{storage-class-specifier}

appears in a \grammarterm{decl-specifier-seq}, there can be no

\tcode{typedef} specifier in the same \grammarterm{decl-specifier-seq} and

the \grammarterm{init-declarator-list} of the declaration shall not be

empty (except for an anonymous union declared in a named namespace or in the

global namespace, which shall be declared

\indextext{specifier!\idxcode{static}}%

\tcode{static}~(\ref{class.union})). The

\grammarterm{storage-class-specifier} applies to the name declared by each

\grammarterm{init-declarator} in the list and not to any names declared by

other specifiers. A \grammarterm{storage-class-specifier}

other than \tcode{thread_local}

shall not be

specified in an explicit specialization~(\ref{temp.expl.spec}) or an

explicit instantiation~(\ref{temp.explicit}) directive.

\indextext{restriction!\idxcode{register}}%

The \tcode{register} specifier shall be applied only to names of variables

declared in a block~(\ref{stmt.block}) or to function

parameters~(\ref{dcl.fct.def}). It specifies that the named variable has

automatic storage duration~(\ref{basic.stc.auto}). A variable declared

without a \grammarterm{storage-class-specifier} at block scope or declared

as a function parameter has automatic storage duration by default.

\indextext{declaration!\idxcode{register}}%

A \tcode{register} specifier is a hint to the implementation that the

variable so declared will be heavily used.

The hint can be ignored and in most implementations it will be ignored

if the address of the variable is taken. This use is deprecated (see~\ref{depr.register}).

The \tcode{thread_local} specifier

indicates that the named entity has thread storage duration~(\ref{basic.stc.thread}). It

shall be applied only

to the names of variables of namespace

or block scope and to the names of static data members.

When \tcode{thread_local} is applied to a variable of block scope the

\grammarterm{storage-class-specifier} \tcode{static} is implied if no other

\grammarterm{storage-class-specifier} appears in the

\grammarterm{decl-specifier-seq}.

\indextext{restriction!\idxcode{static}}%

The \tcode{static} specifier can be applied only to names of variables and

functions and to anonymous unions~(\ref{class.union}). There can be no

\tcode{static} function declarations within a block, nor any

\tcode{static} function parameters. A \tcode{static} specifier used in

the declaration of a variable declares the variable to have static storage

duration~(\ref{basic.stc.static}), unless accompanied by the

\tcode{thread_local} specifier, which declares the variable to have thread

storage duration~(\ref{basic.stc.thread}). A \tcode{static} specifier can be

used in declarations of class members;~\ref{class.static} describes its

effect.

\indextext{\idxcode{static}!linkage~of}%

For the linkage of a name declared with a \tcode{static} specifier,

see~\ref{basic.link}.

\indextext{restriction!\idxcode{extern}}%

The \tcode{extern} specifier can be applied only to the names of variables

and functions. The \tcode{extern} specifier cannot be used in the

declaration of class members or function parameters.

\indextext{\idxcode{extern}!linkage~of}%

\indextext{consistency!linkage}%

For the linkage of a name declared with an \tcode{extern} specifier,

see~\ref{basic.link}.

The \tcode{extern} keyword can also be used in

\nonterminal{explicit-instantiation}s and

\nonterminal{linkage-specification}s, but it is not a

\nonterminal{storage-class-specifier} in such contexts.

The linkages implied by successive declarations for a given entity shall

agree. That is, within a given scope, each declaration declaring the

same variable name or the same overloading of a function name shall imply

the same linkage. Each function in a given set of overloaded functions

can have a different linkage, however.

\indextext{example!linkage consistency}%

\begin{codeblock}

static char* f(); // \tcode{f()} has internal linkage

char* f() // \tcode{f()} still has internal linkage

{ /* ... */ }

char* g(); // \tcode{g()} has external linkage

static char* g() // error: inconsistent linkage

{ /* ... */ }

void h();

inline void h(); // external linkage

inline void l();

void l(); // external linkage

inline void m();

extern void m(); // external linkage

static void n();

inline void n(); // internal linkage

static int a; // \tcode{a} has internal linkage

int a; // error: two definitions

static int b; // \tcode{b} has internal linkage

extern int b; // \tcode{b} still has internal linkage

int c; // \tcode{c} has external linkage

static int c; // error: inconsistent linkage

extern int d; // \tcode{d} has external linkage

static int d; // error: inconsistent linkage

\end{codeblock}

\indextext{declaration!forward}%

The name of a declared but undefined class can be used in an

\tcode{extern} declaration. Such a declaration can only be used in ways

that do not require a complete class type.

\begin{codeblock}

struct S;

extern S a;

extern S f();

extern void g(S);

void h() {

g(a); // error: \tcode{S} is incomplete

f(); // error: \tcode{S} is incomplete

}

\end{codeblock}

The \tcode{mutable} specifier shall appear only in the declaration of

a non-static data member~(\ref{class.mem})

whose type is neither const-qualified nor a reference type.

\begin{codeblock}

class X {

mutable const int* p; // OK

mutable int* const q; // ill-formed

};

\end{codeblock}

The \tcode{mutable} specifier on a class data member nullifies a

\tcode{const} specifier applied to the containing class object and

permits modification of the mutable class member even though the rest of

the object is \tcode{const}~(\ref{dcl.type.cv}).

\rSec2[dcl.fct.spec]{Function specifiers}%

\indextext{specifier!function}%

\indextext{function|seealso{friend function; member~function; inline~function; virtual~function}}

\grammarterm{Function-specifiers}

can be used only in function declarations.

\begin{bnf}

\nontermdef{function-specifier}\br

\terminal{inline}\br

\terminal{virtual}\br

\terminal{explicit}

\end{bnf}

\indextext{specifier!\idxcode{inline}}%

\indextext{inline~function}%

A function declaration~(\ref{dcl.fct},~\ref{class.mfct},

\ref{class.friend}) with an \tcode{inline} specifier declares an

\term{inline function}. The inline specifier indicates to

the implementation that inline substitution of the function body at the

point of call is to be preferred to the usual function call mechanism.

An implementation is not required to perform this inline substitution at

the point of call; however, even if this inline substitution is omitted,

the other rules for inline functions defined by~\ref{dcl.fct.spec} shall

still be respected.

A function defined within a class definition is an inline function. The

\tcode{inline} specifier shall not appear on a block scope function

declaration.\footnote{The inline keyword has no effect on the linkage of a function.}

If the \tcode{inline} specifier is used in a friend declaration, that

declaration shall be a definition or the function shall have previously

been declared inline.

An inline function shall be defined in every translation unit in which

it is odr-used and shall have exactly the same definition in every

case~(\ref{basic.def.odr}).

A call to the inline function may be encountered before its definition

appears in the translation unit.

If the definition of a function appears in a translation unit before its

first declaration as inline, the program is ill-formed. If a function

with external linkage is declared inline in one translation unit, it

shall be declared inline in all translation units in which it appears;

no diagnostic is required. An \tcode{inline} function with external

linkage shall have the same address in all translation units. A

\tcode{static} local variable in an \tcode{extern} \tcode{inline}

function always refers to the same object.

A type defined within the body of an \tcode{extern inline} function is the

same type in every translation unit.

\indextext{specifier!\idxcode{virtual}}%

The \tcode{virtual} specifier shall be used only in the initial

declaration of a non-static class member function;

see~\ref{class.virtual}.

\indextext{specifier!\idxcode{explicit}}%

The \tcode{explicit} specifier shall be used only in the declaration of

a constructor or conversion function within its class definition;

see~\ref{class.conv.ctor} and~\ref{class.conv.fct}.

\rSec2[dcl.typedef]{The \tcode{typedef} specifier}%

\indextext{specifier!\idxcode{typedef}}

Declarations containing the \grammarterm{decl-specifier} \tcode{typedef}

declare identifiers that can be used later for naming

fundamental~(\ref{basic.fundamental}) or compound~(\ref{basic.compound})

types. The \tcode{typedef} specifier shall not be

combined in a \grammarterm{decl-specifier-seq} with any other kind of

specifier except a \grammarterm{type-specifier,} and it shall not be used in the

\grammarterm{decl-specifier-seq} of a

\grammarterm{parameter-declaration}~(\ref{dcl.fct}) nor in the

\grammarterm{decl-specifier-seq} of a

\grammarterm{function-definition}~(\ref{dcl.fct.def}).

\begin{bnf}

\nontermdef{typedef-name}\br

identifier

\end{bnf}

A name declared with the \tcode{typedef} specifier becomes a

\grammarterm{typedef-name}. Within the scope of its declaration, a

\grammarterm{typedef-name} is syntactically equivalent to a keyword and

names the type associated with the identifier in the way described in

Clause~\ref{dcl.decl}.

\indextext{declaration!typedef@\tcode{typedef}~as type}%

\indextext{equivalence!type}%

\indextext{synonym!type~name~as}%

A \grammarterm{typedef-name} is thus a synonym for another type. A

\grammarterm{typedef-name} does not introduce a new type the way a class

declaration~(\ref{class.name}) or enum declaration does.

\indextext{example!\idxcode{typedef}}%

after

\begin{codeblock}

typedef int MILES, *KLICKSP;

\end{codeblock}

the constructions

\begin{codeblock}

MILES distance;

extern KLICKSP metricp;

\end{codeblock}

are all correct declarations; the type of \tcode{distance} is

\tcode{int} and that of \tcode{metricp} is ``pointer to \tcode{int}''.

A \grammarterm{typedef-name} can also be introduced by an

\grammarterm{alias-declaration}. The \grammarterm{identifier} following the

\tcode{using} keyword becomes a \grammarterm{typedef-name}

and the optional \grammarterm{attribute-specifier-seq} following the

\grammarterm{identifier} appertains to that \grammarterm{typedef-name}.

It has the same

semantics as if it were introduced by the \tcode{typedef} specifier. In

particular, it does not define a new type.

\begin{codeblock}

using handler_t = void (*)(int);

extern handler_t ignore;

extern void (*ignore)(int); // redeclare \tcode{ignore}

using cell = pair<void*, cell*>; // ill-formed

\end{codeblock}

\indextext{redefinition!\idxcode{typedef}}%

In a given non-class scope, a \tcode{typedef} specifier can be used to

redefine the name of any type declared in that scope to refer to the

type to which it already refers.

\begin{codeblock}

typedef struct s { /* ... */ } s;

typedef int I;

typedef int I;

typedef I I;

\end{codeblock}

In a given class scope, a \tcode{typedef} specifier can be used to

redefine any \grammarterm{class-name} declared in that scope that is not

also a \grammarterm{typedef-name} to refer to the type to which it already

refers.

\begin{codeblock}

struct S {

typedef struct A { } A; // OK

typedef struct B B; // OK

typedef A A; // error

};

\end{codeblock}

If a \tcode{typedef} specifier is used to redefine in a given scope an

entity that can be referenced using an \grammarterm{elaborated-type-specifier},

the entity can continue to be referenced by an

\grammarterm{elaborated-type-specifier} or as an enumeration or class name

in an enumeration or class definition respectively. \enterexample

\begin{codeblock}

struct S;

typedef struct S S;

int main() {

struct S* p; // OK

}

struct S { }; // OK

\end{codeblock}

In a given scope, a \tcode{typedef} specifier shall not be used to

redefine the name of any type declared in that scope to refer to a

different type.

\begin{codeblock}

class complex { /* ... */ };

typedef int complex; // error: redefinition

\end{codeblock}

Similarly, in a given scope, a class or enumeration shall not be

declared with the same name as a \grammarterm{typedef-name} that is

declared in that scope and refers to a type other than the class or

enumeration itself.

\begin{codeblock}

typedef int complex;

class complex @\tcode{\{ /* ... */ \}}@; // error: redefinition

\end{codeblock}

\indextext{class~name!\idxcode{typedef}}%

A \grammarterm{typedef-name} that names a class type, or a cv-qualified

version thereof, is also a \grammarterm{class-name}~(\ref{class.name}). If

a \grammarterm{typedef-name} is used to identify the subject of an

\grammarterm{elaborated-type-specifier}~(\ref{dcl.type.elab}), a class

definition (Clause~\ref{class}), a constructor

declaration~(\ref{class.ctor}), or a destructor

declaration~(\ref{class.dtor}), the program is ill-formed.

\begin{codeblock}

struct S {

S();

~S();

};

typedef struct S T;

S a = T(); // OK

struct T * p; // error

\end{codeblock}

\indextext{class~name!\idxcode{typedef}}%

\indextext{enum~name!\idxcode{typedef}}%

\indextext{class!unnamed}%

If the typedef declaration defines an unnamed class (or enum), the first

\grammarterm{typedef-name} declared by the declaration to be that class

type (or enum type) is used to denote the class type (or enum type) for

linkage purposes only~(\ref{basic.link}).

\begin{codeblock}

typedef struct { } *ps, S; // \tcode{S} is the class name for linkage purposes

\end{codeblock}

\rSec2[dcl.friend]{The \tcode{friend} specifier}%

\indextext{specifier!\idxcode{friend}}

The \tcode{friend} specifier is used to specify access to class members;

see~\ref{class.friend}.

\rSec2[dcl.constexpr]{The \tcode{constexpr} specifier}%

\indextext{specifier!\idxcode{constexpr}}

The \tcode{constexpr} specifier shall be applied only to the definition of

a variable or variable template,

the declaration of a

function or function template, or the declaration of a static

data member of a literal type~(\ref{basic.types}).

If any declaration of a function or function template has

a \tcode{constexpr} specifier,

then all its declarations shall contain the \tcode{constexpr} specifier. \enternote An

explicit specialization can differ from the template declaration with respect to the

\tcode{constexpr} specifier. \exitnote

Function parameters cannot be declared \tcode{constexpr}.\exitnote

\begin{codeblock}

constexpr void square(int &x); // OK: declaration

constexpr int bufsz = 1024; // OK: definition

constexpr struct pixel { // error: \tcode{pixel} is a type

int x;

int y;

constexpr pixel(int); // OK: declaration

};

constexpr pixel::pixel(int a)

: x(a), y(x) // OK: definition

{ square(x); }

constexpr pixel small(2); // error: \tcode{square} not defined, so \tcode{small(2)}

// not constant~(\ref{expr.const}) so \tcode{constexpr} not satisfied

constexpr void square(int &x) { // OK: definition

x *= x;

}

constexpr pixel large(4); // OK: \tcode{square} defined

int next(constexpr int x) { // error: not for parameters

return x + 1;

}

extern constexpr int memsz; // error: not a definition

\end{codeblock}

A \tcode{constexpr} specifier used in the declaration of a function that is not a

constructor declares that

function to be a \defnx{constexpr function}{specifier!\idxcode{constexpr}!function}. Similarly, a

\tcode{constexpr} specifier used in

a constructor declaration declares that constructor to be a

\defnx{constexpr constructor}{specifier!\idxcode{constexpr}!constructor}.

\tcode{constexpr} functions and \tcode{constexpr} constructors are

implicitly \tcode{inline}~(\ref{dcl.fct.spec}).

\indextext{specifier!\idxcode{constexpr}!function}

\indextext{constexpr function}

The definition of a \tcode{constexpr} function shall satisfy the following

constraints:

\begin{itemize}

it shall not be virtual~(\ref{class.virtual});

its return type shall be a literal type;

each of its parameter types shall be a literal type;

its \grammarterm{function-body} shall be

\tcode{= delete}, \tcode{= default}, or

a \grammarterm{compound-statement}

that does not contain

\begin{itemize}

\item an \grammarterm{asm-definition},

\item a \tcode{goto} statement,

\item a \grammarterm{try-block}, or

\item a definition of a variable

of non-literal type or

of static or thread storage duration or

for which no initialization is performed.

\end{itemize}

\end{itemize}

\begin{codeblock}

constexpr int square(int x)

{ return x * x; } // OK

constexpr long long_max()

{ return 2147483647; } // OK

constexpr int abs(int x) {

if (x < 0)

x = -x;

return x; // OK

}

constexpr int first(int n) {

static int value = n; // error: variable has static storage duration

return value;

}

constexpr int uninit() {

int a; // error: variable is uninitialized

return a;

}

constexpr int prev(int x)

{ return --x; } // OK

constexpr int g(int x, int n) { // OK

int r = 1;

while (--n > 0) r *= x;

return r;

}

\end{codeblock}

\indextext{specifier!\idxcode{constexpr}!constructor}%

The definition of a \tcode{constexpr} constructor shall satisfy the

following constraints:

\begin{itemize}

the class shall not have any virtual base classes;

each of the parameter types shall be a literal type;

its \grammarterm{function-body} shall not be a \grammarterm{function-try-block};

\end{itemize}

In addition, either its \grammarterm{function-body} shall be

\tcode{= delete}, or it shall satisfy the following constraints:

\begin{itemize}

either its \grammarterm{function-body} shall be \tcode{= default}, or the \grammarterm{compound-statement} of its \grammarterm{function-body}

shall satisfy the constraints for a \grammarterm{function-body} of a

\tcode{constexpr} function;

every non-variant non-static data member and base class sub-object

shall be initialized~(\ref{class.base.init});

if the class is a union having variant members~(\ref{class.union}), exactly one of them

shall be initialized;

if the class is a union-like class, but is not a union, for each of its anonymous union

members having variant members, exactly one of them shall be initialized;

for a non-delegating constructor, every constructor selected to initialize non-static

data members and base class sub-objects shall be a \tcode{constexpr} constructor;

for a delegating constructor, the target constructor shall be a \tcode{constexpr}

constructor.

\end{itemize}

\begin{codeblock}

struct Length {

constexpr explicit Length(int i = 0) : val(i) { }

private:

int val;

};

\end{codeblock}

For a non-template, non-defaulted

\tcode{constexpr} function or a non-template, non-defaulted, non-inheriting

\tcode{constexpr} constructor, if no argument values exist such that

an invocation of the function or constructor could be an evaluated subexpression of a core

constant expression~(\ref{expr.const}), or,

for a constructor, a constant initializer for some object~(\ref{basic.start.init}),

the program is ill-formed; no diagnostic required.

\begin{codeblock}

constexpr int f(bool b)

{ return b ? throw 0 : 0; } // OK

constexpr int f() { return f(true); } // ill-formed, no diagnostic required

struct B {

constexpr B(int x) : i(0) { } // \tcode{x} is unused

int i;

};

int global;

struct D : B {

constexpr D() : B(global) { } // ill-formed, no diagnostic required

// lvalue-to-rvalue conversion on non-constant \tcode{global}

};

\end{codeblock}

If the instantiated template specialization of a \tcode{constexpr} function

template

or member function of a class template

would fail to satisfy the requirements for a \tcode{constexpr}

function or \tcode{constexpr} constructor,

that specialization is still a \tcode{constexpr} function or \tcode{constexpr}

constructor, even though a call to such a function cannot appear in a constant

expression. If no specialization of the template would satisfy the

requirements for a \tcode{constexpr} function or \tcode{constexpr} constructor

when considered as a non-template function or constructor, the template is

ill-formed; no diagnostic

required.

A call to a \tcode{constexpr} function produces the same result as a call to an equivalent

non-\tcode{constexpr} function in all respects except that a call to a \tcode{constexpr}

function can appear in a constant expression.

The \tcode{constexpr} specifier has no

effect on the type of a \tcode{constexpr} function or a \tcode{constexpr} constructor. \enterexample

\begin{codeblock}

constexpr int bar(int x, int y) // OK

{ return x + y + x*y; }

// ...

int bar(int x, int y) // error: redefinition of \tcode{bar}

{ return x * 2 + 3 * y; }

\end{codeblock}

A \tcode{constexpr} specifier used in an object

declaration declares the object as \tcode{const}.

Such an object

shall have literal type and

shall be initialized.

If it is initialized by a constructor call,

that call shall be a constant expression~(\ref{expr.const}).

Otherwise,

or if a \tcode{constexpr} specifier is used in a reference declaration,

every full-expression that appears in its initializer shall be a constant expression. \enternote Each

implicit conversion used in converting the initializer expressions and each constructor call

used for the initialization is part of such a full-expression. \exitnote

\begin{codeblock}

struct pixel {

int x, y;

};

constexpr pixel ur = { 1294, 1024 };// OK

constexpr pixel origin; // error: initializer missing

\end{codeblock}

\rSec2[dcl.type]{Type specifiers}%

\indextext{specifier!type|see{type~specifier}}

The type-specifiers are

\indextext{type!\idxcode{const}}%

\indextext{type!\idxcode{volatile}}%

\begin{bnf}