\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

translation unit.

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

\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 nothing (in the case of an \grammarterm{empty-declaration}).

\end{itemize}

\end{note}

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

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

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

\end{note}

\begin{example}

Given

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

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

contains only $E$.

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

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

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

potential results of the second and third operands.

contains the potential results of the right operand.

\item Otherwise, the set is empty.

\end{itemize}

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

A local entity\iref{basic.pre}

Every program shall contain at least one definition of every

function or variable that is odr-used in that program

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

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

type \tcode{T} must be complete if

\begin{itemize}

\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

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

\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

\indextext{linkage!\idxcode{inline} and}%

\indextext{\idxcode{inline}!linkage of}%

The name of an entity

has internal linkage if it is the name of

\begin{itemize}

purposes\iref{dcl.typedef}; or

\indextext{enumeration!linkage of}%

in a typedef declaration in which the enumeration has the typedef name

for linkage purposes\iref{dcl.typedef}; or

\item an unnamed enumeration

\indextext{linkage!no}%

Names not covered by these rules have no linkage. Moreover, except as

linkage.

involve additional memory locations that are not accessible to programs but are

managed by the implementation.

\end{note}

locations without interfering with each other.

The constructs in a \Cpp{} program create, destroy, refer to, access, and

manipulate objects.

An \defn{object} is created

by a \grammarterm{new-expression}\iref{expr.new},

by an operation that implicitly creates objects (see below),

or

when a temporary object is created\iref{conv.rval,class.temporary}.

An object occupies a region of storage

in its period of construction\iref{class.cdtor},

and

in its period of destruction\iref{class.cdtor}.

\begin{note}

\begin{itemize}

\item a base class subobject, or

\item a non-static data member

\end{itemize}

are \impldef{which non-standard-layout objects

containing no data are considered empty}.

\indextext{most derived object!bit-field}%

an object with nonzero size

shall occupy one or more bytes of storage,

including every byte that is occupied in full or in part

is produced by the evaluation of:

\begin{itemize}

\item

\item

\item

the operand of a cast or conversion\iref{conv.integral,

expr.type.conv,expr.static.cast,expr.cast}

to an unsigned ordinary character type

or \tcode{std::byte} type\iref{cstddef.syn}, or

\item

\end{itemize}

then the result of the operation is an indeterminate value or

that erroneous value, respectively.

\indextext{storage duration!dynamic|(}

\indextext{\idxcode{new}}%

\grammarterm{new-expression}{s}\iref{expr.new}, and destroyed using

\indextext{\idxcode{delete}}%

\tcode{std::bad_alloc}\iref{bad.alloc}.

a coroutine state\iref{dcl.fct.def.coroutine},

or called indirectly through calls to the

functions in the \Cpp{} standard library.

impose requirements on implementations regarding the representation

of types.

There are two kinds of types: fundamental types and compound types.

\end{note}

pointer types, pointer-to-member types\iref{basic.compound},

\tcode{std::meta::\brk{}info}, \tcode{std::nullptr_t},

and

types are collectively called

\defnadjx{scalar}{types}{type}.

\label{term.trivially.copyable.type}%

\item a scalar type; or

\item a reference type; or

\item an array of literal type; or

has all of the following properties:

\begin{itemize}

\item it has a constexpr destructor\iref{dcl.constexpr},

Two types \cvqual{cv1} \tcode{T1} and \cvqual{cv2} \tcode{T2} are

\defnadjx{layout-compatible}{types}{type}

if \tcode{T1} and \tcode{T2} are the same type,

A type is \defn{consteval-only} if it is

which identify members of a given

type within objects of a given class, \ref{dcl.mptr}.

Pointers to data members and pointers to member functions are collectively

\end{itemize}

have the same value representation and alignment

requirements\iref{basic.align}.

\begin{note}

representation, but their range of valid values is restricted by the extended

alignment requirement.

\end{note}

\indextext{program execution|(}

block. Such an object exists and retains its last-stored value during

the execution of the block and while the block is suspended (by a call

of a function, suspension of a coroutine\iref{expr.await}, or receipt of a signal).

the initialization of the entities captured by copy and

the constituent expressions of the \grammarterm{initializer} of the \grammarterm{init-capture}{s},

the constituent expressions of each default argument\iref{dcl.fct.default}

used in the call, and

A \defn{full-expression} is

\begin{itemize}

a \grammarterm{constant-expression}\iref{expr.const.core},