\rSec0[dcl.dcl]{Declarations}%

\indextext{declaration|(}

\gramSec[gram.dcl]{Declarations}

\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

nodeclspec-function-declaration\br

function-definition\br

template-declaration\br

deduction-guide\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{nodeclspec-function-declaration}\br

attribute-specifier-seq\opt declarator \terminal{;}

\end{bnf}

\begin{bnf}

\nontermdef{alias-declaration}\br

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

\end{bnf}

\begin{bnf}

\nontermdef{simple-declaration}\br

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

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

attribute-specifier-seq\opt decl-specifier-seq ref-qualifier\opt{} \terminal{[} identifier-list \terminal{]} initializer \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}

\begin{note}

\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} and

\grammarterm{deduction-guide}{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}.

\end{note}

A

\grammarterm{simple-declaration} or

\grammarterm{nodeclspec-function-declaration} of the form

\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}

appertains to each of the entities declared by

the \grammarterm{declarator}{s}

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

\begin{note} 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.

\end{note} \begin{example}

\begin{codeblock}

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

\end{codeblock}

\end{example}

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{example}

\begin{codeblock}

enum { }; // ill-formed

typedef class { }; // ill-formed

\end{codeblock}

\end{example}

\indextext{\idxgram{static_assert}}%

In a \grammarterm{static_assert-declaration}, the

\grammarterm{constant-expression} shall be

a contextually converted constant expression

of type \tcode{bool}~(\ref{expr.const}).

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{example}

\begin{codeblock}

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

\end{codeblock}\end{example}

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

A \grammarterm{simple-declaration} with an \grammarterm{identifier-list} is called

a \defn{structured binding declaration}~(\ref{dcl.struct.bind}).

The \grammarterm{decl-specifier-seq} shall

contain only the \grammarterm{type-specifier} \tcode{auto}~(\ref{dcl.spec.auto})

and \grammarterm{cv-qualifier}{s}.

The \grammarterm{initializer} shall be

of the form ``\tcode{=} \grammarterm{assignment-expression}'',

of the form ``\tcode{\{} \grammarterm{assignment-expression} \tcode{\}}'',

or

of the form ``\tcode{(} \grammarterm{assignment-expression} \tcode{)}'',

where the

\grammarterm{assignment-expression} is of array or non-union class type.

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{defining-type-specifier}{s}~(\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.

A \grammarterm{nodeclspec-function-declaration} shall declare a

constructor, destructor, or conversion function.\footnote{The

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

\begin{note}

A \grammarterm{nodeclspec-function-declaration} can only be used in a

\grammarterm{template-declaration}~(Clause~\ref{temp}),

\grammarterm{explicit-instantiation} (\ref{temp.explicit}), or

\grammarterm{explicit-specialization}~(\ref{temp.expl.spec}).

\end{note}

\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

defining-type-specifier\br

function-specifier\br

\terminal{friend}\br

\terminal{typedef}\br

\terminal{constexpr}\br

\terminal{inline}

\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 a complete

\grammarterm{decl-specifier-seq}, 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{defining-type-specifier} other than a \grammarterm{cv-qualifier} in the

\grammarterm{decl-specifier-seq}.

The sequence shall be self-consistent as

described below.

\begin{example}

\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}

\end{example}

\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}%

\begin{note}

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{example}

\begin{codeblock}

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

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

\end{codeblock}

\end{example}

\end{note}

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

\indextext{specifier!storage class}%

\indextext{declaration!storage class}%

\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{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} or \grammarterm{member-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.anon})). 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.

\begin{note}

A variable declared without a \grammarterm{storage-class-specifier}

at block scope or declared as a function parameter

has automatic storage duration by default~(\ref{basic.stc.auto}).

\end{note}

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.anon}). 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}.

\begin{note}

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

\grammarterm{explicit-instantiation}{s} and

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

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

\end{note}

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.

\begin{example}

\indextext{example!linkage consistency}%

\begin{codeblock}

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

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

{ @\commentellip@ }

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

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

{ @\commentellip@ }

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}

\end{example}

\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{example}

\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}

\end{example}

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{example}

\begin{codeblock}

class X {

mutable const int* p; // OK

mutable int* const q; // ill-formed

};

\end{codeblock}

\end{example}

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-specifier}{s}

can be used only in function declarations.

\begin{bnf}

\nontermdef{function-specifier}\br

\terminal{virtual}\br

\terminal{explicit}

\end{bnf}

\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{defining-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}).

If a \tcode{typedef} specifier appears in a declaration without a \grammarterm{declarator},

the program is ill-formed.

\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.

\begin{example}

\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}''.

\end{example}

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}.

Such a \grammarterm{typedef-name} has the same

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

particular, it does not define a new type.

\begin{example}

\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}

\end{example}

The \grammarterm{defining-type-specifier-seq}

of the \grammarterm{defining-type-id} shall not define

a class or enumeration if the \grammarterm{alias-declaration}

is the \grammarterm{declaration} of a \grammarterm{template-declaration}.

\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{example}

\begin{codeblock}

typedef struct s { @\commentellip@ } s;

typedef int I;

typedef int I;

typedef I I;

\end{codeblock}

\end{example}

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{example}

\begin{codeblock}

struct S {

typedef struct A { } A; // OK

typedef struct B B; // OK

typedef A A; // error

};

\end{codeblock}

\end{example}

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. \begin{example}

\begin{codeblock}

struct S;

typedef struct S S;

int main() {

struct S* p; // OK

}

struct S { }; // OK

\end{codeblock}

\end{example}

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{example}

\begin{codeblock}

class complex { @\commentellip@ };

typedef int complex; // error: redefinition

\end{codeblock}

\end{example}

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{example}

\begin{codeblock}

typedef int complex;

class complex { @\commentellip@ }; // error: redefinition

\end{codeblock}

\end{example}

\begin{note}

\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.

\end{note}

\begin{example}

\begin{codeblock}

struct S {

S();

~S();

};

typedef struct S T;

S a = T(); // OK

struct T * p; // error

\end{codeblock}

\end{example}

\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{example}

\begin{codeblock}

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

\end{codeblock}

\end{example}

\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 or

the declaration of a

function or function template.

A function or static data member declared with the \tcode{constexpr}

specifier is implicitly an inline function or variable~(\ref{dcl.inline}).

If any declaration of a function or function template has

a \tcode{constexpr} specifier,

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

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

\tcode{constexpr} specifier. \end{note}

\begin{note}

Function parameters cannot be declared \tcode{constexpr}.\end{note}

\begin{example}

\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}

\end{example}

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}.

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

\indextext{constexpr function}

The definition of a constexpr function shall satisfy the following

requirements:

\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 an identifier label~(\ref{stmt.label}),

\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{example}

\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}

\end{example}

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

The definition of a constexpr constructor shall satisfy the

following requirements:

\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 requirements:

\begin{itemize}

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

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

constexpr function;

every non-variant non-static data member and base class subobject

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 subobjects shall be a constexpr constructor;

for a delegating constructor, the target constructor shall be a constexpr

constructor.

\end{itemize}

\begin{example}

\begin{codeblock}

struct Length {

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

private:

int val;

};

\end{codeblock}

\end{example}

For a constexpr function or constexpr constructor

that is neither defaulted nor a template,

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.static}),

the program is ill-formed, no diagnostic required.

\begin{example}

\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}

\end{example}

If the instantiated template specialization of a constexpr function

template

or member function of a class template

would fail to satisfy the requirements for a constexpr

function or constexpr constructor,

that specialization is still a constexpr function or 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 constexpr function or constexpr constructor

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

ill-formed, no diagnostic required.

A call to a constexpr function produces the same result as a call to an equivalent

non-constexpr function in all respects except that

\begin{itemize}

a call to a constexpr

function can appear in a constant expression~(\ref{expr.const}) and

copy elision is mandatory in a constant expression~(\ref{class.copy}).

\end{itemize}

The \tcode{constexpr} specifier has no

effect on the type of a constexpr function or a constexpr constructor. \begin{example}

\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}

\end{example}

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.

In any \tcode{constexpr} variable declaration,

the full-expression of the initialization

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

\begin{example}

\begin{codeblock}

struct pixel {

int x, y;

};

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

constexpr pixel origin; // error: initializer missing

\end{codeblock}

\end{example}

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

\indextext{specifier!\idxcode{inline}}

The \tcode{inline} specifier can be applied only to the declaration

or definition of a variable or function.

\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 specified in this section shall

still be respected.

A variable declaration with an \tcode{inline} specifier declares an

\term{inline variable}.

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

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

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

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

declaration shall be a definition or the function shall have previously

been declared inline.

An inline function or variable 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}).