\rSec0[basic]{Basics}

\gramSec[gram.basic]{Basics}

\rSec1[basic.pre]{Preamble}

\indextext{type}%

\indextext{object}%

\indextext{storage class}%

\indextext{scope}%

\indextext{linkage}%

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

A \defn{name} is

\begin{itemize}

\item an \grammarterm{identifier} token\iref{lex.token, lex.name} other than

\begin{itemize}

\item

the \grammarterm{identifier} of a

\grammarterm{label}\iref{stmt.label} or

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

\item

the \grammarterm{identifier} following a \keyword{goto} in a

\grammarterm{jump-statement}\iref{stmt.jump.general},

\item

any \grammarterm{identifier} in a

\grammarterm{module-name}\iref{module.unit} or

\grammarterm{attribute-token}\iref{dcl.attr.grammar}, or

\end{itemize}

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

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

\item a \grammarterm{literal-operator-id}\iref{over.literal}.

\end{itemize}

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{conversion-function-id}{s} formed with

equivalent\iref{temp.over.link} types, or

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

the same operator, or

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

the same literal suffix identifier.

\end{itemize}

Every name is introduced by a \defn{declaration}, which is a

\begin{itemize}

\grammarterm{name-declaration},

\grammarterm{block-declaration}, or

\grammarterm{member-declaration}\iref{dcl.pre,class.mem},

\grammarterm{init-declarator}\iref{dcl.decl},

\grammarterm{identifier}

in a structured binding declaration\iref{dcl.struct.bind},

\grammarterm{identifier}

in a \grammarterm{result-name-introducer}

in a postcondition assertion\iref{dcl.contract.res},

\grammarterm{init-capture}\iref{expr.prim.lambda.capture},

\grammarterm{condition} with a \grammarterm{declarator}\iref{stmt.pre},

\grammarterm{member-declarator}\iref{class.mem},

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

\grammarterm{parameter-declaration}\iref{dcl.fct,temp.param},

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

\grammarterm{type-tt-parameter}\iref{temp.param},

\grammarterm{variable-tt-parameter}\iref{temp.param},

\grammarterm{concept-tt-parameter}\iref{temp.param},

\grammarterm{elaborated-type-specifier}

that introduces a name\iref{dcl.type.elab},

\grammarterm{class-specifier}\iref{class.pre},

\grammarterm{enum-specifier} or

\grammarterm{enumerator-definition}\iref{dcl.enum},

\grammarterm{exception-declaration}\iref{except.pre}, or

implicit declaration of an injected-class-name\iref{class.pre}.

\end{itemize}

\begin{note}

The term declaration is not a synonym for the grammar non-terminal \grammarterm{declaration}\iref{dcl.pre}.

\end{note}

\begin{note}

The interpretation of a \grammarterm{for-range-declaration} produces

one or more of the above\iref{stmt.ranged}.

\end{note}

\begin{note}

Some names denote types or templates.

In general, whenever a name is encountered

it is necessary to look it up\iref{basic.lookup}

to determine whether that name denotes one of these entities

before continuing to parse the program that contains it.

\end{note}

A \defn{variable} is introduced by the

declaration $D$ of

\begin{itemize}

a reference other than a non-static data member or

an object,

\end{itemize}

where $D$ is not the \grammarterm{parameter-declaration} of

a \grammarterm{template-parameter}.

An \defn{entity} is a

variable,

structured binding,

result binding,

function,

enumerator,

type,

type alias,

non-static data member,

bit-field,

template,

namespace,

namespace alias,

template parameter,

function parameter, or

\grammarterm{init-capture}.

The \defnadj{underlying}{entity} of an entity is that entity

unless otherwise specified.

A name \defnx{denotes}{denote} the underlying entity of

the entity declared by each declaration that introduces the name.

\begin{note}

Type aliases and namespace aliases have underlying entities

that are distinct from themselves.

\end{note}

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,

a result binding\iref{dcl.contract.res},

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

\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

\link{linkage}{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{basic.pre} may (re)introduce

one or more names and/or entities into a translation

unit.

If so, the

declaration specifies the interpretation and semantic properties of these names.

A declaration of an entity $X$ is

a \defn{redeclaration} of $X$

if another declaration of $X$ is reachable from it\iref{module.reach};

otherwise, it is a \defnadj{first}{declaration}.

\begin{note}

A declaration can also have effects including:

\begin{itemize}

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

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

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

\item use of \link{attributes}{dcl.attr}, and

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

\end{itemize}

\end{note}

\indextext{declaration!function}%

\indextext{definition}%

Each entity declared by a 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}}%

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

\grammarterm{linkage-specification}

\begin{footnote}

Appearing inside the brace-enclosed

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

not affect whether a declaration is a definition.

\end{footnote}\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\iref{class.mem,class.static},

it declares a static data member outside a class definition

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

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

\indextext{declaration!class name}%

it is 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}}%

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

\item it is

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

\item it is

a \grammarterm{namespace-alias-definition}\iref{namespace.alias},

\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.pre},

\item it is

a \grammarterm{consteval-block-declaration},

it is an

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

it is an

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

\item it is

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

\item it is

a \grammarterm{using-enum-declaration}\iref{enum.udecl},

\item it is

a \grammarterm{template-declaration}\iref{temp.pre}

whose \grammarterm{template-head} is not followed by

either a \grammarterm{concept-definition} or a \grammarterm{declaration}

that defines a function, a class, a variable, or a static data member,

\item it is

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

\item it is

an \grammarterm{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}

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}

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

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 \link{destructor}{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{string.classes}

};

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{\textnormal{\textit{//}}}@ : 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{\textnormal{\textit{//}}}@ { 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{term.incomplete.type},

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

a (possibly multidimensional) array thereof.

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

\indextext{object!definition}%

\indextext{function!definition}%

\indextext{class!definition}%

\indextext{enumerator!definition}%

\indextext{one-definition rule|(}%

Each of the following is termed a \defnadj{definable}{item}:

\begin{itemize}

\item a class type\iref{class},

\item an enumeration type\iref{dcl.enum},

\item a function\iref{dcl.fct},

\item a variable\iref{basic.pre},

\item a templated entity\iref{temp.pre},

\item a default argument for a parameter

(for a function in a given scope)\iref{dcl.fct.default}, or

\item a default template argument\iref{temp.param}.

\end{itemize}

No translation unit shall contain more than one definition of any

definable item.

\indextext{expression!potentially evaluated}%

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

an unevaluated operand\iref{expr.context},

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 $E$ is

defined as follows:

\begin{itemize}

\item If $E$ is

an \grammarterm{id-expression}\iref{expr.prim.id} or

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

contains only $E$.

\item If $E$ is a \link{subscripting}{expr.sub} operation with

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

\item If $E$ is a class member access

expression\iref{expr.ref} of the form

$E_1$ \tcode{.} \opt{\keyword{template}} $E_2$,

where $E_2$ designates a non-static data member or

a direct base class relationship,

the set contains the potential results of $E_1$.

\item If $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 $E$ is a \link{pointer-to-member expression}{expr.mptr.oper} of the form

$E_1$ \tcode{.*} $E_2$,

the set contains the potential results of $E_1$.

\item If $E$ has the form \tcode{($E_1$)}, the set contains the

potential results of $E_1$.

\item If $E$ is a glvalue \link{conditional expression}{expr.cond},

the set is the union of the sets of

potential results of the second and third operands.

\item If $E$ is a \link{comma expression}{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} and \grammarterm{splice-expression}s,

each of which is either $E$ or a subexpression of $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.

The set of potential results of the initializer of \tcode{o} contains

the subexpression \tcode{[:\caret\caret S::x:]}.

\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

int o = [:^^S::x:];

\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 selected member

of an overload set\iref{basic.lookup,over.match,over.over}

in an overload resolution performed

as part of forming that expression or conversion,

and either

it is not a pure virtual function or

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

an explicitly qualified name

that does not form a pointer to member\iref{expr.unary.op}.

\begin{note}

This covers

taking the address of functions\iref{conv.func,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}

\label{term.odr.use}%

A variable is named by an expression

if the expression is an \grammarterm{id-expression} or

\grammarterm{splice-expression}\iref{expr.prim.splice}

that designates it.

A variable \tcode{x} that is named by a

potentially evaluated expression $N$

that appears at a point $P$

is \defnx{odr-used}{odr-use} by $N$ unless

\begin{itemize}

\tcode{x} is a reference

that is usable in constant expressions at $P$\iref{expr.const.init}, or

$N$ is an element of the set of potential results of an expression $E$, where

\begin{itemize}

$E$ is a discarded-value expression\iref{expr.context}

to which the lvalue-to-rvalue conversion is not applied, or

\tcode{x} is a non-volatile object

that is usable in constant expressions at $P$ and

has no mutable subobjects, and

\begin{itemize}

$E$ is a class member access expression\iref{expr.ref}

naming a non-static data member of reference type and

whose object expression has non-volatile-qualified type, or

the lvalue-to-rvalue conversion\iref{conv.lval} is applied to $E$ and

$E$ has non-volatile-qualified non-class type.

\end{itemize}

\end{itemize}

\end{itemize}

\begin{example}

\begin{codeblock}

int f(int);

int g(int&);

struct A {

int x;

};

struct B {

int& r;

};

int h(bool cond) {

constexpr A a = {1};

constexpr const volatile A& r = a; // odr-uses \tcode{a}

int _ = f(cond ? a.x : r.x); // does not odr-use \tcode{a} or \tcode{r}

int x, y;

constexpr B b1 = {x}, b2 = {y}; // odr-uses \tcode{x} and \tcode{y}

int _ = g(cond ? b1.r : b2.r); // does not odr-use \tcode{b1} or \tcode{b2}

int _ = ((cond ? x : y), 0); // does not odr-use \tcode{x} or \tcode{y}

return [] {

return b1.r; // error: \tcode{b1} is odr-used here because the object

// referred to by \tcode{b1.r} is not constexpr-referenceable here

}();

}

\end{codeblock}

\end{example}

A structured binding is named by an expression

if that expression is either an \grammarterm{id-expression} or

a \grammarterm{splice-expression}

that designates that structured binding.

A structured binding is odr-used

if it is named by a potentially evaluated expression.

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

(including as the result of any implicit transformation to

a class member access expression\iref{expr.prim.id.general}).

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

\begin{footnote}

An implementation is not required

to call allocation and

deallocation functions from constructors or destructors; however, this

is a permissible implementation technique.

\end{footnote}

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

\deflink{potentially invoked}{class.dtor}.

A local entity\iref{basic.pre}

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

\begin{itemize}

\item either the local entity is not \tcode{*\keyword{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 scope\iref{basic.scope.scope}

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

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

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

either

\begin{itemize}

\item the intervening scope is a block scope,

\item the intervening scope is a contract-assertion scope\iref{basic.scope.contract},

\item the intervening scope is the function parameter scope of

a \grammarterm{lambda-expression} or \grammarterm{requires-expression}, or

\item the intervening scope is the lambda 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 scope.

\end{itemize}

\end{itemize}

If a local entity is odr-used

in a scope 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 \grammarterm{lambda-expression}

struct A {

void f() { n = 2; } // error: \tcode{n} is not odr-usable due to intervening function parameter 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}

\begin{example}

\begin{codeblock}

void g() {

constexpr int x = 1;

auto lambda = [] <typename T, int = ((T)x, 0)> {}; // OK

lambda.operator()<int, 1>(); // OK, does not consider \tcode{x} at all

lambda.operator()<int>(); // OK, does not odr-use \tcode{x}

lambda.operator()<const int&>(); // error: odr-uses \tcode{x} from a context where \tcode{x} is not odr-usable

}

void h() {

constexpr int x = 1;

auto lambda = [] <typename T> { (T)x; }; // OK

lambda.operator()<int>(); // OK, does not odr-use \tcode{x}

lambda.operator()<void>(); // OK, does not odr-use \tcode{x}

lambda.operator()<const int&>(); // error: odr-uses \tcode{x} from a context where \tcode{x} is not odr-usable

}

\end{codeblock}

\end{example}

Every program shall contain at least one definition of every

function or variable that is odr-used in that program

outside of a \deflink{discarded statement}{stmt.if}; no diagnostic required\ifndrdef{basic.def.odr.minimum.one.def}.

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

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

A \defn{definition domain} is

a \grammarterm{private-module-fragment} or

the portion of a translation unit

excluding its \grammarterm{private-module-fragment} (if any).

A definition of an inline function or variable shall be reachable

from the end of every definition domain

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

\indextext{type!incomplete}%

A definition of a class shall 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 \link{defined}{basic.def}, or

\item a non-static class \deflink{data member}{class.mem} of

type \tcode{T} is declared, 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}\iref{conv,expr.type.conv,

expr.dynamic.cast,expr.static.cast,expr.cast}, or

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

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

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

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

a \keyword{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 \keyword{typeid} operator\iref{expr.typeid} or the

\keyword{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 \link{called}{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.assign}, or

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

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

If a definable item \tcode{D} is defined in a translation unit

by an injected declaration $X$\iref{expr.const.reflect} and

another translation unit contains a definition of \tcode{D},

that definition shall be an injected declaration

having the same characteristic sequence as $X$;

a diagnostic is required only if \tcode{D} is attached to a named module and

a prior definition is reachable

at the point where a later definition occurs\ifndrdef{basic.def.odr.injected.match}.

For any other definable item \tcode{D} with definitions in multiple translation units,

\begin{itemize}

if \tcode{D} is a non-inline non-templated function or variable\ifndrdef{basic.def.odr.maximum.one.def}, or

if the definitions in different translation units

do not satisfy the following requirements\ifndrdef{basic.def.odr.definition.matches},

\end{itemize}

the program is ill-formed;

a diagnostic is required only

if the definable item is attached to a named module and

a prior definition is reachable

at the point where a later definition occurs.

Given such an item,

for all definitions of \tcode{D}, or,

if \tcode{D} is an unnamed enumeration,

for all definitions of \tcode{D} that are reachable at any given program point,

the following requirements shall be satisfied.

\begin{itemize}

\item Each such definition

shall not be attached to a named module\iref{module.unit}.

\item Each such definition shall consist of

the same sequence of tokens,

where the definition of a closure type

is considered to consist of the sequence of tokens of

the corresponding \grammarterm{lambda-expression}.

\item In each such definition, corresponding names, looked up

according to~\ref{basic.lookup}, shall denote the same entity, after

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

template specializations\iref{temp.spec.partial.match}, 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.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 object or function in all definitions of \tcode{D}.

\end{itemize}

\item In each such definition, except within

the default arguments and default template arguments of \tcode{D},

corresponding \grammarterm{lambda-expression}{s} shall have

the same closure type (see below).

\item In each such definition, corresponding entities shall have the

same language linkage.

\item In each such definition,

const objects with static or thread storage duration

shall be constant-initialized if

the object is constant-initialized in any such definition.

\item In each such definition,

corresponding manifestly constant-evaluated expressions

that are not value-dependent

shall have the same value\iref{expr.const,temp.dep.constexpr}.

\item In each such definition, 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.

\item In each such definition,

a default argument used by an (implicit or explicit) function call or

a default template argument used by an (implicit or explicit)

\grammarterm{template-id},

\grammarterm{simple-template-id}, or

\grammarterm{splice-specialization-specifier}

is treated as if its token sequence

were present in the definition of \tcode{D};

that is, the default argument or default template argument

is subject to the requirements described in this paragraph (recursively).

\item In each such definition,

corresponding \grammarterm{reflect-expression}s\iref{expr.reflect}

compute equivalent values\iref{expr.eq}.

\end{itemize}

For the purposes of the preceding requirements:

\begin{itemize}

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

constructor\iref{class.default.ctor,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}

\item If \tcode{D} is a class with

a defaulted three-way comparison operator function\iref{class.spaceship},

it is as if the operator was

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

implicit definition in every translation unit shall call the same

comparison operators for each subobject of \tcode{D}.

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

translation unit, the requirements

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

template definition, and also to dependent names at

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

\end{itemize}

These requirements also apply to corresponding entities

defined within each definition of \tcode{D}

(including the closure types of \grammarterm{lambda-expression}{s},

but excluding entities defined within default arguments or

default template arguments of either \tcode{D} or

an entity not defined within \tcode{D}).

For each such entity and for \tcode{D} itself,

the behavior is as if there is a single entity with a single definition,

including in the application of these requirements to other entities.

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

in the different declarations having distinct types, and

\grammarterm{lambda-expression}{s} appearing in a default argument of \tcode{D}

might still denote different types in different translation units.

\end{note}

\begin{example}

\begin{codeblock}

inline void f(bool cond, void (*p)()) {

if (cond) f(false, []{});

}

inline void g(bool cond, void (*p)() = []{}) {

if (cond) g(false);

}

struct X {

void h(bool cond, void (*p)() = []{}) {

if (cond) h(false);

}

};

\end{codeblock}

If the definition of \tcode{f} appears in multiple translation units,

the behavior of the program is as if

there is only one definition of \tcode{f}.

If the definition of \tcode{g} appears in multiple translation units,

the program is ill-formed (no diagnostic required) because

each such definition uses a default argument that

refers to a distinct \grammarterm{lambda-expression} closure type.

The definition of \tcode{X} can appear

in multiple translation units of a valid program;

the \grammarterm{lambda-expression}{s} defined within

the default argument of \tcode{X::h} within the definition of \tcode{X}

denote the same closure type in each translation unit.

\end{example}

If, at any point in the program,

there is more than one

reachable unnamed enumeration definition in the same scope

that have the same first enumerator name and

do not have typedef names for linkage purposes\iref{dcl.enum},

those unnamed enumeration types shall be the same; no diagnostic required\ifndrdef{basic.def.odr.unnamed.enum.same.type}.

\indextext{one-definition rule|)}

\rSec1[basic.scope]{Scope}%

\indextext{scope|(}

\rSec2[basic.scope.scope]{General}

The declarations in a program appear in a number of \defnx{scopes}{scope}

that are in general discontiguous.

The \defnadj{global}{scope} contains the entire program;

every other scope $S$ is introduced by a

declaration,

\grammarterm{parameter-declaration-clause},

\grammarterm{statement},

\grammarterm{handler},

\grammarterm{lambda-expression}, or

contract assertion

(as described in the following subclauses of \ref{basic.scope})

appearing in another scope, which thereby contains $S$.

An \defnadj{enclosing}{scope} at a program point is any scope that contains it;

the smallest such scope is said to be the \defnadj{immediate}{scope}

at that point.

A scope \defnx{intervenes}{scope!intervene}

between a program point $P$ and a scope $S$

(that does not contain $P$) if it is or contains $S$ but does not contain $P$.

Unless otherwise specified:

\begin{itemize}

The smallest scope that contains a scope $S$ is

the \defnadj{parent}{scope} of $S$.

No two declarations (re)introduce the same entity.

A declaration \defnx{inhabits}{scope!inhabit}

the immediate scope at its locus\iref{basic.scope.pdecl}.

A declaration's \defnadj{target}{scope} is the scope it inhabits.