\rSec0[basic]{Basics}

\gramSec[gram.basic]{Basics}

\begin{note} This Clause presents the basic concepts of the \Cpp{} language.

It explains the difference between an object and a

name and how they relate to the value categories for expressions.

It introduces the concepts of a

declaration and a definition and presents \Cpp{}'s

notion of type, scope, linkage, and

storage duration. The mechanisms for starting and

terminating a program are discussed. Finally, this Clause presents the

fundamental types of the language and lists the ways of constructing

compound types from these.\end{note}

\begin{note} This Clause does not cover concepts that affect only a single

part of the language. Such concepts are discussed in the relevant

Clauses. \end{note}

\indextext{type}%

\indextext{object}%

\indextext{storage class}%

\indextext{scope}%

\indextext{linkage}%

\indextext{region!declarative}%

An \defn{entity} is a value, object, reference,

structured binding,

function, enumerator, type,

class member, bit-field, template, template specialization, namespace, or

pack.

A \defn{name} is a use of an \grammarterm{identifier}\iref{lex.name},

\grammarterm{operator-function-id}\iref{over.oper},

\grammarterm{literal-operator-id}\iref{over.literal},

\grammarterm{conversion-function-id}\iref{class.conv.fct}, or

\grammarterm{template-id}\iref{temp.names} that denotes an entity or

label~(\ref{stmt.goto}, \ref{stmt.label}).

Every name that denotes an entity is introduced by a

\defn{declaration}. Every name that denotes a label is introduced

either by a \tcode{goto} statement\iref{stmt.goto} or a

\grammarterm{labeled-statement}\iref{stmt.label}.

A \defn{variable} is introduced by the

declaration of

a reference other than a non-static data member or of

an object. The variable's name, if any, denotes the reference or object.

A \defnadj{local}{entity} is a variable with

automatic storage duration\iref{basic.stc.auto},

a structured binding\iref{dcl.struct.bind}

whose corresponding variable is such an entity,

or the \tcode{*this} object\iref{expr.prim.this}.

Some names denote types or templates. In general,

whenever a name is encountered it is necessary to determine whether that name denotes

one of these entities before continuing to parse the program that contains it. The

process that determines this is called

\defnx{name lookup}{lookup!name}\iref{basic.lookup}.

Two names are \defnx{the same}{name!same} if

\begin{itemize}

\item they are \grammarterm{identifier}{s} composed of the same character sequence, or

\item they are \grammarterm{operator-function-id}{s} formed with

the same operator, or

\item they are \grammarterm{conversion-function-id}{s} formed

with the same type, or

\item they are \grammarterm{template-id}{s} that refer to the same class,

function, or variable\iref{temp.type}, or

\item they are the names of literal operators\iref{over.literal} formed with

the same literal suffix identifier.

\end{itemize}

\indextext{translation unit!name and}%

\indextext{linkage}%

A name used in more than one translation unit can potentially

refer to the same entity in these translation units depending on the

linkage\iref{basic.link} of the name specified in each

translation unit.

\rSec1[basic.def]{Declarations and definitions}

\indextext{declaration!definition versus}%

\indextext{declaration}%

\indextext{declaration!name}%

A declaration\iref{dcl.dcl} may introduce

one or more names into a translation

unit or redeclare names introduced by previous declarations.

If so, the

declaration specifies the interpretation and semantic properties of these names.

A declaration may also have effects including:

\begin{itemize}

\item a static assertion\iref{dcl.dcl},

\item controlling template instantiation\iref{temp.explicit},

\item guiding template argument deduction for constructors\iref{temp.deduct.guide},

\item use of attributes\iref{dcl.dcl}, and

\item nothing (in the case of an \grammarterm{empty-declaration}).

\end{itemize}

\indextext{declaration!function}%

\indextext{definition}%

Each entity declared by a \grammarterm{declaration} is

also \defnx{defined}{define} by that declaration unless:

\begin{itemize}

it declares a function

without specifying the function's body\iref{dcl.fct.def},

it contains

the

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

\tcode{extern} specifier\iref{dcl.stc} or a

\grammarterm{linkage-specification}\footnote{Appearing inside the brace-enclosed

\grammarterm{declaration-seq} in a \grammarterm{linkage-specification} does

not affect whether a declaration is a definition.}\iref{dcl.link}

and neither an \grammarterm{initializer} nor a

\grammarterm{function-body},

\indextext{declaration!static member@\tcode{static} member}%

it declares a non-inline static data member in a class

definition~(\ref{class.mem}, \ref{class.static}),

it declares a static data member outside a class definition

and the variable was defined within the class with the \tcode{constexpr}

specifier (this usage is deprecated; see \ref{depr.static.constexpr}),

\indextext{declaration!class name}%

it is introduced by an \grammarterm{elaborated-type-specifier}\iref{class.name},

it is an

\indextext{declaration!opaque enum}%

\grammarterm{opaque-enum-declaration}\iref{dcl.enum},

it is a

\indextext{parameter!template}\indextext{template parameter}%

\grammarterm{template-parameter}\iref{temp.param},

it is a

\indextext{declaration!parameter}\indextext{parameter declaration}%

\grammarterm{parameter-declaration}\iref{dcl.fct} in a function

\indextext{declarator}%

declarator that is not the \grammarterm{declarator} of a

\grammarterm{function-definition},

it is a

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

\tcode{typedef} declaration\iref{dcl.typedef},

\item it is

an \grammarterm{alias-declaration}\iref{dcl.typedef},

\item it is

a

\grammarterm{using-declaration}\iref{namespace.udecl},

\item it is

a \grammarterm{deduction-guide}\iref{temp.deduct.guide},

\item it is

a \grammarterm{static_assert-declaration}\iref{dcl.dcl},

it is an

\grammarterm{attribute-declaration}\iref{dcl.dcl},

it is an

\grammarterm{empty-declaration}\iref{dcl.dcl},

\item it is

a \grammarterm{using-directive}\iref{namespace.udir},

\item it is

an explicit instantiation declaration\iref{temp.explicit}, or

\item it is

an explicit specialization\iref{temp.expl.spec} whose

\grammarterm{declaration} is not a definition.

\end{itemize}

A declaration is said to be a \defn{definition} of each entity that it defines.

\begin{example} All but one of the following are definitions:

\begin{codeblock}

int a; // defines \tcode{a}

extern const int c = 1; // defines \tcode{c}

int f(int x) { return x+a; } // defines \tcode{f} and defines \tcode{x}

struct S { int a; int b; }; // defines \tcode{S}, \tcode{S::a}, and \tcode{S::b}

struct X { // defines \tcode{X}

int x; // defines non-static data member \tcode{x}

static int y; // declares static data member \tcode{y}

X(): x(0) { } // defines a constructor of \tcode{X}

};

int X::y = 1; // defines \tcode{X::y}

enum { up, down }; // defines \tcode{up} and \tcode{down}

namespace N { int d; } // defines \tcode{N} and \tcode{N::d}

namespace N1 = N; // defines \tcode{N1}

X anX; // defines \tcode{anX}

\end{codeblock}

whereas these are just declarations:

\begin{codeblock}

extern int a; // declares \tcode{a}

extern const int c; // declares \tcode{c}

int f(int); // declares \tcode{f}

struct S; // declares \tcode{S}

typedef int Int; // declares \tcode{Int}

extern X anotherX; // declares \tcode{anotherX}

using N::d; // declares \tcode{d}

\end{codeblock}

\end{example}

\begin{note}

\indextext{implementation-generated}%

In some circumstances, \Cpp{} implementations implicitly define the

default constructor\iref{class.default.ctor},

copy constructor, move constructor\iref{class.copy.ctor},

copy assignment operator, move assignment operator\iref{class.copy.assign},

or destructor\iref{class.dtor} member functions.

\end{note}

\begin{example} Given

\begin{codeblock}

#include <string>

struct C {

std::string s; // \tcode{std::string} is the standard library class\iref{strings}

};

int main() {

C a;

C b = a;

b = a;

}

\end{codeblock}

the implementation will implicitly define functions to make the

definition of \tcode{C} equivalent to

\begin{codeblock}

struct C {

std::string s;

C() : s() { }

C(const C& x): s(x.s) { }

C(C&& x): s(static_cast<std::string&&>(x.s)) { }

@\rlap{\normalfont\itshape //}@ : s(std::move(x.s)) { }

C& operator=(const C& x) { s = x.s; return *this; }

C& operator=(C&& x) { s = static_cast<std::string&&>(x.s); return *this; }

@\rlap{\normalfont\itshape //}@ { s = std::move(x.s); return *this; }

~C() { }

};

\end{codeblock}

\end{example}

\begin{note}

A class name can also be implicitly declared by an

\grammarterm{elaborated-type-specifier}\iref{dcl.type.elab}.

\end{note}

\indextext{type!incomplete}%

In the definition of an object,

the type of that object shall not be

an incomplete type\iref{basic.types},

an abstract class type\iref{class.abstract}, or

a (possibly multi-dimensional) array thereof.

\indextext{object!definition}%

\indextext{function!definition}%

\indextext{class!definition}%

\indextext{enumerator!definition}%

\indextext{one-definition rule|(}%

\rSec1[basic.def.odr]{One-definition rule}

A variable, function, class type, enumeration type, or template

shall not be defined where a prior definition is necessarily reachable\iref{module.reach};

no diagnostic is required if the prior declaration is in another translation unit.

\indextext{expression!potentially evaluated}%

An expression or conversion is \defn{potentially evaluated} unless it is

an unevaluated operand\iref{expr.prop},

a subexpression thereof, or

a conversion in an initialization or conversion sequence in such a context.

The set of \defn{potential results} of an expression \tcode{e} is

defined as follows:

\begin{itemize}

\item If \tcode{e} is an

\grammarterm{id-expression}\iref{expr.prim.id}, the set

contains only \tcode{e}.

\item If \tcode{e} is a subscripting operation\iref{expr.sub} with

an array operand, the set contains the potential results of that operand.

\item If \tcode{e} is a class member access

expression\iref{expr.ref} of the form

\tcode{e1 . \opt{template} e2}

naming a non-static data member,

the set contains the potential results of \tcode{e1}.

\item If \tcode{e} is a class member access expression

naming a static data member,

the set contains the \grammarterm{id-expression} designating the data member.

\item If \tcode{e} is a pointer-to-member

expression\iref{expr.mptr.oper} of the form

\tcode{e1 .* e2},

the set contains the potential results of \tcode{e1}.

\item If \tcode{e} has the form \tcode{(e1)}, the set contains the

potential results of \tcode{e1}.

\item If \tcode{e} is a glvalue conditional

expression\iref{expr.cond}, the set is the union of the sets of

potential results of the second and third operands.

\item If \tcode{e} is a comma expression\iref{expr.comma}, the set

contains the potential results of the right operand.

\item Otherwise, the set is empty.

\end{itemize}

\begin{note}

This set is a (possibly-empty) set of \grammarterm{id-expression}{s},

each of which is either \tcode{e} or a subexpression of \tcode{e}.

\begin{example}

In the following example, the set of potential results of the initializer

of \tcode{n} contains the first \tcode{S::x} subexpression, but not the second

\tcode{S::x} subexpression.

\begin{codeblock}

struct S { static const int x = 0; };

const int &f(const int &r);

int n = b ? (1, S::x) // \tcode{S::x} is not odr-used here

: f(S::x); // \tcode{S::x} is odr-used here, so a definition is required

\end{codeblock}

\end{example}

\end{note}

A function is \defnx{named by}{function!named by expression or conversion}

an expression or conversion as follows:

\begin{itemize}

A function is named by an expression or conversion

if it is the unique result of a name lookup or the selected member

of a set of overloaded functions~(\ref{basic.lookup}, \ref{over.match}, \ref{over.over})

in an overload resolution performed

as part of forming that expression or conversion,

unless it is a pure virtual function and either

the expression is not an \grammarterm{id-expression} naming the function with

an explicitly qualified name or

the expression forms a pointer to member\iref{expr.unary.op}.

\begin{note} This covers

taking the address of functions~(\ref{conv.func}, \ref{expr.unary.op}),

calls to named functions\iref{expr.call},

operator overloading\iref{over},

user-defined conversions\iref{class.conv.fct},

allocation functions for \grammarterm{new-expression}{s}\iref{expr.new}, as well as

non-default initialization\iref{dcl.init}.

A constructor selected to copy or move an object of class type

is considered to be named by an expression or conversion

even if the call is actually elided by the implementation\iref{class.copy.elision}. \end{note}

A deallocation function for a class

is named by a \grammarterm{new-expression}

if it is the single matching deallocation function

for the allocation function selected by overload resolution,

as specified in~\ref{expr.new}.

A deallocation function for a class

is named by a \grammarterm{delete-expression}

if it is the selected usual deallocation function

as specified in~\ref{expr.delete} and~\ref{class.free}.

\end{itemize}

A variable \tcode{x} whose name appears as a

potentially-evaluated expression \tcode{e}

is \defnx{odr-used}{odr-use} by \tcode{e} unless

\begin{itemize}

\tcode{x} is a reference that is

usable in constant expressions\iref{expr.const}, or

\tcode{x} is a variable of non-reference type that is

usable in constant expressions and has no mutable subobjects, and

\tcode{e} is an element of the set of potential results of an expression

of non-volatile-qualified non-class type

to which the lvalue-to-rvalue conversion\iref{conv.lval} is applied, or

\tcode{x} is a variable of non-reference type, and

\tcode{e} is an element of the set of potential results

of a discarded-value expression\iref{expr.prop}

to which the lvalue-to-rvalue conversion is not applied.

\end{itemize}

A structured binding is odr-used if it appears as a potentially-evaluated expression.

\tcode{*this} is odr-used if \tcode{this} appears as a potentially-evaluated expression

(including as the result of the implicit transformation in the body of a non-static

member function~(\ref{class.mfct.non-static})).

A virtual member

function is odr-used if it is not pure.

A function is odr-used if it is named by

a potentially-evaluated expression or conversion.

A non-placement allocation or deallocation

function for a class is odr-used by the definition of a constructor of that

class. A non-placement deallocation function for a class is odr-used by the

definition of the destructor of that class, or by being selected by the

lookup at the point of definition of a virtual

destructor\iref{class.dtor}.\footnote{An implementation is not required

to call allocation and

deallocation functions from constructors or destructors; however, this

is a permissible implementation technique.}

An assignment operator function in a class is odr-used by an

implicitly-defined

copy-assignment or move-assignment function for another class as specified

in~\ref{class.copy.assign}.

A constructor for a class is odr-used as specified

in~\ref{dcl.init}. A destructor for a class is odr-used if it is potentially

invoked\iref{class.dtor}.

A local entity\iref{basic}

is \defn{odr-usable} in a declarative region\iref{basic.scope.declarative} if:

\begin{itemize}

\item either the local entity is not \tcode{*this}, or

an enclosing class or non-lambda function parameter scope exists and,

if the innermost such scope is a function parameter scope,

it corresponds to a non-static member function, and

for each intervening declarative region\iref{basic.scope.declarative}

between the point at which the entity is introduced and the region

(where \tcode{*this} is considered to be introduced

within the innermost enclosing class or non-lambda function definition scope),

either:

\begin{itemize}

\item the intervening declarative region is a block scope, or

\item the intervening declarative region is the function parameter scope of a \grammarterm{lambda-expression}

that has a \grammarterm{simple-capture}

naming the entity or has a \grammarterm{capture-default}, and

the block scope of the \grammarterm{lambda-expression}

is also an intervening declarative region.

\end{itemize}

\end{itemize}

If a local entity is odr-used

in a declarative region in which it is not odr-usable,

the program is ill-formed.

\begin{example}

\begin{codeblock}

void f(int n) {

[] { n = 1; }; // error: \tcode{n} is not odr-usable due to intervening lambda-expression

struct A {

void f() { n = 2; } // error: \tcode{n} is not odr-usable due to intervening function definition scope

};

void g(int = n); // error: \tcode{n} is not odr-usable due to intervening function parameter scope

[=](int k = n) {}; // error: \tcode{n} is not odr-usable due to being

// outside the block scope of the \grammarterm{lambda-expression}

[&] { [n]{ return n; }; }; // OK

}

\end{codeblock}

\end{example}

Every program shall contain exactly one definition of every non-inline

function or variable that is odr-used in that program

outside of a discarded statement\iref{stmt.if}; no diagnostic required.

The definition can appear explicitly in the program, it can be found in

the standard or a user-defined library, or (when appropriate) it is

implicitly defined (see~\ref{class.default.ctor}, \ref{class.copy.ctor},

\ref{class.dtor}, and \ref{class.copy.assign}).

A definition of an inline function or variable shall be reachable in every

translation unit in which it is odr-used outside of a discarded statement.

\begin{example}

\begin{codeblock}

auto f() {

struct A {};

return A{};

}

decltype(f()) g();

auto x = g();

\end{codeblock}

A program containing this translation unit is ill-formed

because \tcode{g} is odr-used but not defined,

and cannot be defined in any other translation unit

because the local class \tcode{A} cannot be named outside this

translation unit.

\end{example}

\indextext{type!incomplete}%

A definition of a class is required to be reachable in every context in which

the class is used in a way that requires the class type to be complete.

\begin{example} The following complete translation unit is well-formed,

even though it never defines \tcode{X}:

\begin{codeblock}

struct X; // declare \tcode{X} as a struct type

struct X* x1; // use \tcode{X} in pointer formation

X* x2; // use \tcode{X} in pointer formation

\end{codeblock}

\end{example}

\begin{note} The rules for declarations and expressions

describe in which contexts complete class types are required. A class

type \tcode{T} must be complete if:

\begin{itemize}

\item an object of type \tcode{T} is defined\iref{basic.def}, or

\item a non-static class data member of type \tcode{T} is

declared\iref{class.mem}, or

\item \tcode{T} is used as the allocated type or array element type in a

\grammarterm{new-expression}\iref{expr.new}, or

\item an lvalue-to-rvalue conversion is applied to

a glvalue referring

to an object of type \tcode{T}\iref{conv.lval}, or

\item an expression is converted (either implicitly or explicitly) to

type \tcode{T} (\ref{conv}, \ref{expr.type.conv},

\ref{expr.dynamic.cast}, \ref{expr.static.cast}, \ref{expr.cast}), or

\item an expression that is not a null pointer constant, and has type

other than \cv{}~\tcode{void*}, is converted to the type pointer to \tcode{T}

or reference to \tcode{T} using a standard conversion\iref{conv},

a \tcode{dynamic_cast}\iref{expr.dynamic.cast} or

a \tcode{static_cast}\iref{expr.static.cast}, or

\item a class member access operator is applied to an expression of type

\tcode{T}\iref{expr.ref}, or

\item the \tcode{typeid} operator\iref{expr.typeid} or the

\tcode{sizeof} operator\iref{expr.sizeof} is applied to an operand of

type \tcode{T}, or

\item a function with a return type or argument type of type \tcode{T}

is defined\iref{basic.def} or called\iref{expr.call}, or

\item a class with a base class of type \tcode{T} is

defined\iref{class.derived}, or

\item an lvalue of type \tcode{T} is assigned to\iref{expr.ass}, or

\item the type \tcode{T} is the subject of an

\tcode{alignof} expression\iref{expr.alignof}, or

\item an \grammarterm{exception-declaration} has type \tcode{T}, reference to

\tcode{T}, or pointer to \tcode{T}\iref{except.handle}.

\end{itemize}

\end{note}

There can be more than one definition of a class type\iref{class},

enumeration type\iref{dcl.enum}, inline function

with external linkage\iref{dcl.inline}, inline variable with external

linkage\iref{dcl.inline}, class template\iref{temp},

non-static function template\iref{temp.fct},

concept\iref{temp.concept},

static data member of a class template\iref{temp.static}, member

function of a class template\iref{temp.mem.func}, or template

specialization for which some template parameters are not

specified~(\ref{temp.spec}, \ref{temp.class.spec}) in a program

provided that

no prior definition is necessarily reachable\iref{module.reach}

at the point where a definition appears, and

provided the definitions satisfy the following requirements.

There shall not be more than one definition

of an entity

that is attached to a named module\iref{module.unit};

no diagnostic is required unless a prior definition

is reachable at a point where a later definition appears.

Given such

an entity named \tcode{D} defined in more than one translation unit,

then

\begin{itemize}

\item each definition of \tcode{D} shall consist of the same sequence of

tokens; and

\item in each definition of \tcode{D}, corresponding names, looked up

according to~\ref{basic.lookup}, shall refer to an entity defined within

the definition of \tcode{D}, or shall refer to the same entity, after

overload resolution\iref{over.match} and after matching of partial

template specialization\iref{temp.over}, except that a name can refer to

\begin{itemize}

a non-volatile const object with internal or no linkage if the object

\begin{itemize}

\item has the same literal type in all definitions of \tcode{D},

\item is initialized with a constant expression\iref{expr.const},

\item is not odr-used in any definition of \tcode{D}, and

\item has the same value in all definitions of \tcode{D},

\end{itemize}

or

a reference with internal or no linkage

initialized with a constant expression such that

the reference refers to the same entity in all definitions of \tcode{D};

\end{itemize}

and

\item in each definition of \tcode{D}, corresponding entities shall have the

same language linkage; and

\item in each definition of \tcode{D}, the overloaded operators referred

to, the implicit calls to conversion functions, constructors, operator

new functions and operator delete functions, shall refer to the same

function, or to a function defined within the definition of \tcode{D};

and

\item in each definition of \tcode{D}, a default argument used by an

(implicit or explicit) function call is treated as if its token sequence

were present in the definition of \tcode{D}; that is, the default

argument is subject to the requirements described in this paragraph (and, if

the default argument has subexpressions with default arguments, this

requirement applies recursively)\footnote{\ref{dcl.fct.default}

describes how default argument names are looked up.}; and

\item if \tcode{D} invokes a function with a precondition,

or is a function

that contains an assertion or has a contract condition\iref{dcl.attr.contract},

it is \impldef{consistency of build level and violation continuation mode}

under which conditions all definitions of \tcode{D}

shall be translated using the same build level

and violation continuation mode; and

\item if \tcode{D} is a class with an implicitly-declared

constructor (\ref{class.default.ctor}, \ref{class.copy.ctor}),

it is as if the constructor was

implicitly defined in every translation unit where it is odr-used, and the

implicit definition in every translation unit shall call the same

constructor for a subobject of \tcode{D}.

\begin{example}

\begin{codeblock}

// translation unit 1:

struct X {

X(int, int);

X(int, int, int);

};

X::X(int, int = 0) { }

class D {

X x = 0;

};

D d1; // \tcode{X(int, int)} called by \tcode{D()}

// translation unit 2:

struct X {

X(int, int);

X(int, int, int);

};

X::X(int, int = 0, int = 0) { }

class D {

X x = 0;

};

D d2; // \tcode{X(int, int, int)} called by \tcode{D()};

// \tcode{D()}'s implicit definition violates the ODR

\end{codeblock}

\end{example}

\end{itemize}

If \tcode{D} is a template and is defined in more than one

translation unit, then the preceding requirements

shall apply both to names from the template's enclosing scope used in the

template definition\iref{temp.nondep}, and also to dependent names at

the point of instantiation\iref{temp.dep}. If the definitions of

\tcode{D} satisfy all these requirements, then the behavior is

as if there were a single definition of \tcode{D}.

\begin{note}

The entity is still declared in multiple translation units, and \ref{basic.link}

still applies to these declarations. In particular,

\grammarterm{lambda-expression}{s}\iref{expr.prim.lambda}

appearing in the type of \tcode{D} may result

in the different declarations having distinct types.

\end{note}

If the definitions of

\tcode{D} do not satisfy these requirements, then the behavior is

undefined.%

\indextext{one-definition rule|)}

\rSec1[basic.scope]{Scope}%

\indextext{scope|(}

\rSec2[basic.scope.declarative]{Declarative regions and scopes}%

\indextext{scope!declarations and|(}

\indextext{name!scope of}%

Every name is introduced in some portion of program text called a

\indextext{region!declarative}%

\indextext{scope!potential}%

\defn{declarative region}, which is the largest part of the program

in which that name is valid, that is, in which that name may

be used as an unqualified name to refer to the same entity. In general,

each particular name is valid only within some possibly discontiguous

portion of program text called its \defn{scope}. To determine the

scope of a declaration, it is sometimes convenient to refer to the

\defn{potential scope} of a declaration. The scope of a declaration

is the same as its potential scope unless the potential scope contains

another declaration of the same name. In that case, the potential scope

of the declaration in the inner (contained) declarative region is

excluded from the scope of the declaration in the outer (containing)

declarative region.

\begin{example}

In

\begin{codeblock}

int j = 24;

int main() {

int i = j, j;

j = 42;

}

\end{codeblock}

the identifier \tcode{j} is declared twice as a name (and used twice).

The declarative region of the first \tcode{j} includes the entire

example. The potential scope of the first \tcode{j} begins immediately

after that \tcode{j} and extends to the end of the program, but its

(actual) scope excludes the text between the \tcode{,} and the

\tcode{\}}. The declarative region of the second declaration of

\tcode{j} (the \tcode{j} immediately before the semicolon) includes all

the text between \tcode{\{} and \tcode{\}}, but its potential scope

excludes the declaration of \tcode{i}. The scope of the second

declaration of \tcode{j} is the same as its potential scope.

\end{example}

The names declared by a declaration are introduced into the scope in

which the declaration occurs, except that the presence of a

\tcode{friend} specifier\iref{class.friend}, certain uses of the

\grammarterm{elaborated-type-specifier}\iref{dcl.type.elab}, and

\grammarterm{using-directive}{s}\iref{namespace.udir} alter this general

behavior.

Given a set of declarations in a single declarative region, each of

which specifies the same unqualified name,

\begin{itemize}

\item they shall all refer to the same entity, or all refer to functions

and function templates; or

\item exactly one declaration shall declare a class name or enumeration

name that is not a typedef name and the other declarations shall

all refer to the same variable, non-static data member, or enumerator,

or all refer to functions and function templates;

in this case the class name or enumeration name is

hidden\iref{basic.scope.hiding}.

\begin{note}

A structured binding\iref{dcl.struct.bind},

namespace name\iref{basic.namespace}, or

class template name\iref{temp}

must be unique in its declarative region.

\end{note}

\end{itemize}

\begin{note} These restrictions apply to the declarative region into which

a name is introduced, which is not necessarily the same as the region in

which the declaration occurs. In particular,

\grammarterm{elaborated-type-specifier}{s}\iref{dcl.type.elab} and

friend declarations\iref{class.friend} may introduce a (possibly not

visible) name into an enclosing namespace; these restrictions apply to

that region. Local extern declarations\iref{basic.link} may introduce

a name into the declarative region where the declaration appears and

also introduce a (possibly not visible) name into an enclosing

namespace; these restrictions apply to both regions. \end{note}

For a given declarative region \placeholder{R}

and a point \placeholder{P} outside \placeholder{R},

the set of \defnx{intervening}{region!declarative!intervening} declarative regions

between \placeholder{P} and \placeholder{R}

comprises all declarative regions

that are or enclose \placeholder{R} and do not enclose \placeholder{P}.

\begin{note} The name lookup rules are summarized in~\ref{basic.lookup}.

\end{note}

\rSec2[basic.scope.pdecl]{Point of declaration}

\indextext{name!point of declaration}%

The \defn{point of declaration} for a name is immediately after its

complete declarator\iref{dcl.decl} and before its

\grammarterm{initializer} (if any), except as noted below. \begin{example}

\begin{codeblock}

unsigned char x = 12;

{ unsigned char x = x; }

\end{codeblock}

Here the second \tcode{x} is initialized with its own (indeterminate)

value. \end{example}

\begin{note}

\indextext{name hiding}%

A name from an outer scope remains visible up

to the point of declaration of the name that hides it. \begin{example}

\begin{codeblock}

const int i = 2;

{ int i[i]; }

\end{codeblock}

declares a block-scope array of two integers. \end{example} \end{note}

The point of declaration for a class or class template first declared by a

\grammarterm{class-specifier} is immediately after the \grammarterm{identifier} or

\grammarterm{simple-template-id} (if any) in its \grammarterm{class-head}\iref{class}.

The point of declaration for an enumeration is

immediately after the \grammarterm{identifier} (if any) in either its

\grammarterm{enum-specifier}\iref{dcl.enum} or its first

\grammarterm{opaque-enum-declaration}\iref{dcl.enum}, whichever comes first.

The point of declaration of an alias or alias template immediately

follows the \grammarterm{defining-type-id} to which the

alias refers.

The point of declaration of a \grammarterm{using-declarator} that does not name a

constructor is immediately after the \grammarterm{using-declarator}\iref{namespace.udecl}.

\indextext{declaration!enumerator point of}%

The point of declaration for an enumerator is immediately after its

\grammarterm{enumerator-definition}. \begin{example}

\begin{codeblock}

const int x = 12;

{ enum { x = x }; }

\end{codeblock}

Here, the enumerator \tcode{x} is initialized with the value of the

constant \tcode{x}, namely 12. \end{example}

After the point of declaration of a class member, the member name can be

looked up in the scope of its class. \begin{note}

\indextext{type!incomplete}%

This is true even if the class is an incomplete class. For example,

\begin{codeblock}

struct X {

enum E { z = 16 };

int b[X::z]; // OK

};

\end{codeblock}

\end{note}

The point of declaration of a class first declared in an

\grammarterm{elaborated-type-specifier} is as follows:

\begin{itemize}

\item for a declaration of the form

\begin{ncbnf}

class-key \opt{attribute-specifier-seq} identifier \terminal{;}

\end{ncbnf}

the \grammarterm{identifier} is declared to be a

\grammarterm{class-name} in the scope that contains the declaration,

otherwise

\item for an \grammarterm{elaborated-type-specifier} of the form

\begin{ncbnf}

class-key identifier

\end{ncbnf}

if the

\grammarterm{elaborated-type-specifier} is used in the

\grammarterm{decl-specifier-seq} or \grammarterm{parameter-declaration-clause}

of a function defined in namespace scope, the \grammarterm{identifier} is

declared as a \grammarterm{class-name} in the namespace that contains the

declaration; otherwise, except as a friend declaration, the

\grammarterm{identifier} is declared in the smallest namespace or block

scope that contains the declaration. \begin{note}

These rules also apply within templates. \end{note} \begin{note} Other

forms of \grammarterm{elaborated-type-specifier} do not declare a new name,

and therefore must refer to an existing \grammarterm{type-name}.

See~\ref{basic.lookup.elab} and~\ref{dcl.type.elab}. \end{note}

\end{itemize}

The point of declaration for an

injected-class-name\iref{class} is immediately following

the opening brace of the class definition.

The point of declaration for a function-local predefined

variable\iref{dcl.fct.def.general} is immediately before the

\grammarterm{function-body} of a function definition.

The point of declaration of a structured binding\iref{dcl.struct.bind}

is immediately after

the \grammarterm{identifier-list} of the structured binding declaration.

The point of declaration for the variable or the structured bindings

declared in the \grammarterm{for-range-declaration}

of a range-based \tcode{for} statement\iref{stmt.ranged}

is immediately after the \grammarterm{for-range-initializer}.

The point of declaration for a template parameter is immediately after its complete

\grammarterm{template-parameter}. \begin{example}

\begin{codeblock}

typedef unsigned char T;

template<class T

= T // lookup finds the typedef name of \tcode{unsigned char}

, T // lookup finds the template parameter

N = 0> struct A { };

\end{codeblock}

\end{example}

\begin{note} Friend declarations refer to functions or classes that are

members of the nearest enclosing namespace, but they do not introduce

new names into that namespace\iref{namespace.memdef}. Function

declarations at block scope and variable declarations with the

\tcode{extern} specifier at block scope refer to declarations that are

members of an enclosing namespace, but they do not introduce new names

into that scope.

\end{note}

\begin{note} For point of instantiation of a template,

see~\ref{temp.point}.\end{note}%

\indextext{scope!declarations and|)}

\rSec2[basic.scope.block]{Block scope}

\indextext{scope!block}%

\indextext{local scope|see{block scope}}%

A name declared in a block\iref{stmt.block} is local to that block; it has

\defn{block scope}.

Its potential scope begins at its point of

declaration\iref{basic.scope.pdecl} and ends at the end of its block.

A variable declared at block scope is a \defn{local variable}.

\indextext{scope!exception declaration}%

The name declared in an \grammarterm{exception-declaration}

is local to the

\grammarterm{handler} and shall not be redeclared in the outermost block of the

\grammarterm{handler}.

Names declared in the \grammarterm{init-statement}, the \grammarterm{for-range-declaration}, and in the

\grammarterm{condition} of \tcode{if}, \tcode{while}, \tcode{for}, and

\tcode{switch} statements are local to the \tcode{if}, \tcode{while},

\tcode{for}, or \tcode{switch} statement (including the controlled

statement), and shall not be redeclared in a subsequent condition of

that statement nor in the outermost block (or, for the \tcode{if}

statement, any of the outermost blocks) of the controlled statement.

\begin{example}

\begin{codeblock}

if (int x = f()) {

int x; // ill-formed, redeclaration of \tcode{x}

}

else {

int x; // ill-formed, redeclaration of \tcode{x}

}

\end{codeblock}

\end{example}

\rSec2[basic.scope.param]{Function parameter scope}

\indextext{scope!function parameter}%

\indextext{scope!function prototype|see{scope, function parameter}}%

\indextext{parameter!scope of}%

A function parameter

(including one appearing in a

\grammarterm{lambda-declarator})

or function-local predefined variable\iref{dcl.fct.def}

has \defn{function parameter scope}.

The potential scope of a parameter

or function-local predefined variable

begins at its point of declaration. If

the nearest enclosing function declarator

is not the declarator of a function definition,

the potential scope ends at the end of that function declarator.

Otherwise, if

the function has a \grammarterm{function-try-block} the potential scope

ends at the end of the last associated handler.

Otherwise the potential scope ends

at the end of the outermost block of the function definition. A

parameter name shall not be redeclared in the outermost block of the

function definition nor in the outermost block of any handler associated

with a \grammarterm{function-try-block}.

\rSec2[basic.funscope]{Function scope}

\indextext{label!scope of}%

Labels\iref{stmt.label} have \defnx{function scope}{scope!function} and

may be used anywhere in the function in which they are declared. Only

labels have function scope.

\rSec2[basic.scope.namespace]{Namespace scope}

\indextext{scope!namespace}%

The declarative region of a \grammarterm{namespace-definition} is its

\grammarterm{namespace-body}. Entities declared in a

\grammarterm{namespace-body} are said to be \defn{members} of the

namespace, and names introduced by these declarations into the

declarative region of the namespace are said to be \defn{member

names} of the namespace. A namespace member name has namespace scope.

Its potential scope includes its namespace from the name's point of