classes.tex

%!TEX root = std.tex
\rSec0[class]{Classes}%
\indextext{class|(}

\gramSec[gram.class]{Classes}

\indextext{class!member function|see{member function, class}}

\pnum
\indextext{\idxcode{\{\}}!class declaration}%
\indextext{\idxcode{\{\}}!class definition}%
\indextext{type!class and}%
\indextext{object class|see{class object}}%
A class is a type.
\indextext{name class|see{class name}}%
Its name becomes a \grammarterm{class-name}\iref{class.name} within its
scope.

\begin{bnf}
\nontermdef{class-name}\br
    identifier\br
    simple-template-id
\end{bnf}

A \grammarterm{class-specifier} or
an \grammarterm{elaborated-type-specifier}\iref{dcl.type.elab} is used to
make a \grammarterm{class-name}. An object of a class consists of a
(possibly empty) sequence of members and base class objects.

\begin{bnf}
\nontermdef{class-specifier}\br
    class-head \terminal{\{} \opt{member-specification} \terminal{\}}
\end{bnf}

\begin{bnf}
\nontermdef{class-head}\br
    class-key \opt{attribute-specifier-seq} class-head-name \opt{class-virt-specifier} \opt{base-clause}\br
    class-key \opt{attribute-specifier-seq} \opt{base-clause}
\end{bnf}

\begin{bnf}
\nontermdef{class-head-name}\br
    \opt{nested-name-specifier} class-name
\end{bnf}

\begin{bnf}
\nontermdef{class-virt-specifier}\br
    \keyword{final}
\end{bnf}

\begin{bnf}
\nontermdef{class-key}\br
    \keyword{class}\br
    \keyword{struct}\br
    \keyword{union}
\end{bnf}

A class declaration where the \grammarterm{class-name}
in the \grammarterm{class-head-name} is a \grammarterm{simple-template-id}
shall be an explicit specialization\iref{temp.expl.spec} or
a partial specialization\iref{temp.class.spec}.
A \grammarterm{class-specifier} whose
\grammarterm{class-head} omits the
\grammarterm{class-head-name} defines an unnamed class. \begin{note} An unnamed class thus can't
be \tcode{final}. \end{note}

\pnum
A \grammarterm{class-name} is inserted into the scope in which it is
declared immediately after the \grammarterm{class-name} is seen. The
\grammarterm{class-name} is also inserted into the scope of the class
itself; this is known as the \defn{injected-class-name}.
For purposes of access checking, the injected-class-name is treated as
if it were a public member name.
A \grammarterm{class-specifier} is commonly referred to as a \defnx{class
definition}{definition!class}.
A class is considered defined after the closing brace of its
\grammarterm{class-specifier} has been seen even though its member
functions are in general not yet defined.
The optional \grammarterm{attribute-specifier-seq} appertains to the class; the attributes in
the \grammarterm{attribute-specifier-seq} are thereafter considered attributes of the class
whenever it is named.

\pnum
If a \grammarterm{class-head-name} contains a \grammarterm{nested-name-specifier},
the \grammarterm{class-specifier} shall refer to a class that was
previously declared directly in the class or namespace to which the
\grammarterm{nested-name-specifier} refers,
or in an element of the inline namespace set\iref{namespace.def} of that namespace
(i.e., not merely inherited or
introduced by a \grammarterm{using-declaration}), and the
\grammarterm{class-specifier} shall appear in a namespace enclosing the
previous declaration.
In such cases, the \grammarterm{nested-name-specifier} of the
\grammarterm{class-head-name} of the
definition shall not begin with a \grammarterm{decltype-specifier}.

\pnum
If a class is marked with the \grammarterm{class-virt-specifier} \tcode{final} and it appears
as a \grammarterm{class-or-decltype} in a \grammarterm{base-clause}\iref{class.derived},
the program is ill-formed. Whenever a
\grammarterm{class-key} is followed by a \grammarterm{class-head-name}, the
\grammarterm{identifier} \tcode{final}, and a colon or left brace, \tcode{final} is
interpreted as a \grammarterm{class-virt-specifier}. \begin{example}
\begin{codeblock}
struct A;
struct A final {};      // OK: definition of \tcode{struct A},
                        // not value-initialization of variable \tcode{final}

struct X {
 struct C { constexpr operator int() { return 5; } };
 struct B final : C{};  // OK: definition of nested class \tcode{B},
                        // not declaration of a bit-field member \tcode{final}
};
\end{codeblock}
\end{example}

\pnum
\begin{note}
Complete objects of class type have nonzero size.
Base class subobjects and
members declared with the \tcode{no_unique_address} attribute\iref{dcl.attr.nouniqueaddr}
are not so constrained.
\end{note}

\pnum
\begin{note}
Class objects can be assigned~(\ref{expr.ass}, \ref{over.ass}, \ref{class.copy.assign}),
passed as arguments to functions~(\ref{dcl.init}, \ref{class.copy.ctor}), and
returned by functions (except objects of classes for which copying or moving has
been restricted; see~\ref{dcl.fct.def.delete} and \ref{class.access}).
Other plausible operators, such as equality comparison,
can be defined by the user; see~\ref{over.oper}.
\end{note}

\pnum
A \defn{union} is a class defined with the \grammarterm{class-key}
\tcode{union};
it holds at most one data member at a time\iref{class.union}.
\begin{note}
Aggregates of class type are described in~\ref{dcl.init.aggr}.
\end{note}

\rSec1[class.prop]{Properties of classes}

\pnum
A \defnadj{trivially copyable}{class} is a class:

\begin{itemize}
\item where each copy constructor, move constructor, copy assignment operator,
and move assignment operator~(\ref{class.copy.ctor}, \ref{class.copy.assign})
is either deleted or trivial,
\item that has at least one non-deleted copy constructor, move constructor,
copy assignment operator, or move assignment operator, and
\item that has a trivial, non-deleted destructor\iref{class.dtor}.
\end{itemize}

\pnum
A \defnadj{trivial}{class} is a class that is trivially copyable and
has one or more default constructors\iref{class.default.ctor},
all of which are either trivial or deleted and
at least one of which is not deleted.
\begin{note} In particular, a trivially copyable or trivial class does not have
virtual functions or virtual base classes.\end{note}

\pnum
A class \tcode{S} is a \defnadj{standard-layout}{class} if it:
\begin{itemize}
\item has no non-static data members of type non-standard-layout class
(or array of such types) or reference,

\item has no virtual functions\iref{class.virtual} and no
virtual base classes\iref{class.mi},

\item has the same access control\iref{class.access}
for all non-static data members,

\item has no non-standard-layout base classes,

\item has at most one base class subobject of any given type,

\item has all non-static data members and bit-fields in the class and
its base classes first declared in the same class, and

\item has no element of the set $M(\mathtt{S})$ of types
as a base class,
where for any type \tcode{X}, $M(\mathtt{X})$ is defined as follows.\footnote{
This ensures that two subobjects that have the same class type and that
belong to the same most derived object are not allocated at the same
address\iref{expr.eq}.}
\begin{note} $M(\mathtt{X})$ is the set of the types of all non-base-class subobjects
that may be at a zero offset in \tcode{X}. \end{note}

\begin{itemize}
\item If \tcode{X} is a non-union class type with no (possibly
inherited\iref{class.derived}) non-static data members, the set
$M(\mathtt{X})$ is empty.

\item If \tcode{X} is a non-union class type with a non-static data
member of type $\mathtt{X}_0$
that is either of zero size or
is the first non-static data member of \tcode{X}
(where said member may be an anonymous union),
the set $M(\mathtt{X})$ consists of $\mathtt{X}_0$ and the elements of
$M(\mathtt{X}_0)$.

\item If \tcode{X} is a union type, the set $M(\mathtt{X})$ is
the union of all $M(\mathtt{U}_i)$ and the set containing all $\mathtt{U}_i$,
where each $\mathtt{U}_i$ is the type of the $i^\text{th}$ non-static data member
of \tcode{X}.

\item If \tcode{X} is an array type with element type $\mathtt{X}_e$,
the set $M(\mathtt{X})$ consists of $\mathtt{X}_e$
and the elements of $M(\mathtt{X}_e)$.

\item If \tcode{X} is a non-class, non-array type, the set $M(\mathtt{X})$ is empty.
\end{itemize}
\end{itemize}

\pnum
\begin{example}
\begin{codeblock}
   struct B { int i; };         // standard-layout class
   struct C : B { };            // standard-layout class
   struct D : C { };            // standard-layout class
   struct E : D { char : 4; };  // not a standard-layout class

   struct Q {};
   struct S : Q { };
   struct T : Q { };
   struct U : S, T { };         // not a standard-layout class
\end{codeblock}
\end{example}

\pnum
A \defnadj{standard-layout}{struct} is a standard-layout class
defined with the \grammarterm{class-key} \tcode{struct} or the
\grammarterm{class-key} \tcode{class}.
A \defnadj{standard-layout}{union} is a standard-layout class
defined with the
\grammarterm{class-key} \tcode{union}.

\pnum
\begin{note} Standard-layout classes are useful for communicating with
code written in other programming languages. Their layout is specified
in~\ref{class.mem}.\end{note}

\pnum
\begin{example}
\begin{codeblock}
struct N {          // neither trivial nor standard-layout
  int i;
  int j;
  virtual ~N();
};

struct T {          // trivial but not standard-layout
  int i;
private:
  int j;
};

struct SL {         // standard-layout but not trivial
  int i;
  int j;
  ~SL();
};

struct POD {        // both trivial and standard-layout
  int i;
  int j;
};
\end{codeblock}
\end{example}

\rSec1[class.name]{Class names}
\indextext{definition!class name as type}%
\indextext{structure tag|see{class name}}%
\indextext{equivalence!type}%

\pnum
A class definition introduces a new type.
\begin{example}

\begin{codeblock}
struct X { int a; };
struct Y { int a; };
X a1;
Y a2;
int a3;
\end{codeblock}

declares three variables of three different types. This implies that

\begin{codeblock}
a1 = a2;                        // error: \tcode{Y} assigned to \tcode{X}
a1 = a3;                        // error: \tcode{int} assigned to \tcode{X}
\end{codeblock}

are type mismatches, and that

\begin{codeblock}
int f(X);
int f(Y);
\end{codeblock}

\indextext{overloading}%
declare an overloaded\iref{over} function \tcode{f()} and not
simply a single function \tcode{f()} twice. For the same reason,

\begin{codeblock}
struct S { int a; };
struct S { int a; };            // error, double definition
\end{codeblock}

is ill-formed because it defines \tcode{S} twice.
\end{example}

\pnum
\indextext{definition!scope of class}%
\indextext{class name!scope of}%
A class declaration introduces the class name into the scope where
\indextext{name hiding!class definition}%
it is declared and hides any
class, variable, function, or other declaration of that name in an
enclosing scope\iref{basic.scope}. If a class name is declared in a
scope where a variable, function, or enumerator of the same name is also
declared, then when both declarations are in scope, the class can be
referred to only using an
\grammarterm{elaborated-type-specifier}\iref{basic.lookup.elab}.
\begin{example}
\begin{codeblock}
struct stat {
  // ...
};

stat gstat;                     // use plain \tcode{stat} to define variable

int stat(struct stat*);         // redeclare \tcode{stat} as function

void f() {
  struct stat* ps;              // \tcode{struct} prefix needed to name \tcode{struct stat}
  stat(ps);                     // call \tcode{stat()}
}
\end{codeblock}
\end{example}
\indextext{class name!elaborated}%
\indextext{declaration!forward class}%
A \grammarterm{declaration} consisting solely of \grammarterm{class-key}
\grammarterm{identifier}\tcode{;} is either a redeclaration of the name in the current scope
or a forward declaration of the identifier as a class name. It
introduces the class name into the current scope.
\begin{example}
\begin{codeblock}
struct s { int a; };

void g() {
  struct s;                     // hide global \tcode{struct s} with a block-scope declaration
  s* p;                         // refer to local \tcode{struct s}
  struct s { char* p; };        // define local \tcode{struct s}
  struct s;                     // redeclaration, has no effect
}
\end{codeblock}
\end{example}
\begin{note}
Such declarations allow definition of classes that refer to each other.
\begin{example}
\begin{codeblock}
class Vector;

class Matrix {
  // ...
  friend Vector operator*(const Matrix&, const Vector&);
};

class Vector {
  // ...
  friend Vector operator*(const Matrix&, const Vector&);
};
\end{codeblock}
Declaration of friends is described in~\ref{class.friend},
operator functions in~\ref{over.oper}.
\end{example}
\end{note}

\pnum
\indextext{class name!elaborated}%
\indextext{elaborated type specifier|see{class name, elaborated}}%
\begin{note}
An \grammarterm{elaborated-type-specifier}\iref{dcl.type.elab} can also
be used as a \grammarterm{type-specifier} as part of a declaration. It
differs from a class declaration in that if a class of the elaborated
name is in scope the elaborated name will refer to it.
\end{note}
\begin{example}

\begin{codeblock}
struct s { int a; };

void g(int s) {
  struct s* p = new struct s;   // global \tcode{s}
  p->a = s;                     // parameter \tcode{s}
}
\end{codeblock}
\end{example}

\pnum
\indextext{class name!point of declaration}%
\begin{note}
The declaration of a class name takes effect immediately after the
\grammarterm{identifier} is seen in the class definition or
\grammarterm{elaborated-type-specifier}. For example,

\begin{codeblock}
class A * A;
\end{codeblock}

first specifies \tcode{A} to be the name of a class and then redefines
it as the name of a pointer to an object of that class. This means that
the elaborated form \tcode{class} \tcode{A} must be used to refer to the
class. Such artistry with names can be confusing and is best avoided.
\end{note}

\pnum
\indextext{class name!\idxcode{typedef}}%
A \grammarterm{simple-template-id} is only a \grammarterm{class-name}
if its \grammarterm{template-name} names a class template.

\rSec1[class.mem]{Class members}%
\indextext{declaration!member}%
\indextext{data member|see{member}}

\begin{bnf}
\nontermdef{member-specification}\br
    member-declaration \opt{member-specification}\br
    access-specifier \terminal{:} \opt{member-specification}
\end{bnf}

\begin{bnf}
\nontermdef{member-declaration}\br
    \opt{attribute-specifier-seq} \opt{decl-specifier-seq} \opt{member-declarator-list} \terminal{;}\br
    function-definition\br
    using-declaration\br
    static_assert-declaration\br
    template-declaration\br
    deduction-guide\br
    alias-declaration\br
    opaque-enum-declaration\br
    empty-declaration
\end{bnf}

\begin{bnf}
\nontermdef{member-declarator-list}\br
    member-declarator\br
    member-declarator-list \terminal{,} member-declarator
\end{bnf}

\begin{bnf}
\nontermdef{member-declarator}\br
    declarator \opt{virt-specifier-seq} \opt{pure-specifier}\br
    declarator requires-clause\br
    declarator \opt{brace-or-equal-initializer}\br
    \opt{identifier} \opt{attribute-specifier-seq} \terminal{:} constant-expression \opt{brace-or-equal-initializer}
\end{bnf}

\begin{bnf}
\nontermdef{virt-specifier-seq}\br
    virt-specifier\br
    virt-specifier-seq virt-specifier
\end{bnf}

\begin{bnf}
\nontermdef{virt-specifier}\br
    \keyword{override}\br
    \keyword{final}
\end{bnf}

\begin{bnf}
\nontermdef{pure-specifier}\br
    \terminal{=} \terminal{0}
\end{bnf}

\pnum
\indextext{definition!class}%
The \grammarterm{member-specification} in a class definition declares the
full set of members of the class; no member can be added elsewhere.
A \defn{direct member} of a class \tcode{X} is a member of \tcode{X}
that was first declared within the \grammarterm{member-specification} of \tcode{X},
including anonymous union objects\iref{class.union.anon} and direct members thereof.
Members of a class are data members, member
functions\iref{class.mfct}, nested types, enumerators,
and member templates\iref{temp.mem} and specializations thereof.
\begin{note}
A specialization of a static data member template is a static data member.
A specialization of a member function template is a member function.
A specialization of a member class template is a nested class.
\end{note}

\pnum
A \grammarterm{member-declaration} does not declare new members of the class
if it is
\begin{itemize}
\item a friend declaration\iref{class.friend},
\item a \grammarterm{static_assert-declaration},
\item a \grammarterm{using-declaration}\iref{namespace.udecl}, or
\item an \grammarterm{empty-declaration}.
\end{itemize}
For any other \grammarterm{member-declaration},
each declared entity
that is not an unnamed bit-field\iref{class.bit}
is a member of the class,
and each such \grammarterm{member-declaration}
shall either
declare at least one member name of the class
or declare at least one unnamed bit-field.

\pnum
A \defn{data member} is a non-function member introduced by a
\grammarterm{member-declarator}.
A \defn{member function} is a member that is a function.
Nested types are classes~(\ref{class.name}, \ref{class.nest}) and
enumerations\iref{dcl.enum} declared in the class and arbitrary types
declared as members by use of a typedef declaration\iref{dcl.typedef}
or \grammarterm{alias-declaration}.
The enumerators of an unscoped enumeration\iref{dcl.enum} defined in the class
are members of the class.

\indextext{member!static}%
\indextext{member function!static}%
\indextext{data member!static}%
\pnum
A data member or member function
may be declared \tcode{static} in its \grammarterm{member-declaration},
in which case it is a \defn{static member} (see~\ref{class.static})
(a \defn{static data member}\iref{class.static.data} or
\defn{static member function}\iref{class.static.mfct}, respectively)
of the class.
Any other data member or member function is a \defn{non-static member}
(a \defn{non-static data member} or
\defn{non-static member function}~(\ref{class.mfct.non-static}), respectively).
\begin{note} A non-static data member of non-reference
type is a member subobject of a class object\iref{intro.object}.\end{note}

\pnum
A member shall not be declared twice in the
\grammarterm{member-specification}, except that
\begin{itemize}
\item a nested class or member
class template can be declared and then later defined, and
\item an
enumeration can be introduced with an \grammarterm{opaque-enum-declaration} and later
redeclared with an \grammarterm{enum-specifier}{}.
\end{itemize}
\begin{note}
A single name can denote several member functions provided their types
are sufficiently different\iref{over}.
\end{note}

\pnum
\indextext{completely defined}%
A \defn{complete-class context} of a class is a
\begin{itemize}
\item function body\iref{dcl.fct.def.general},
\item default argument\iref{dcl.fct.default},
\item \grammarterm{noexcept-specifier}\iref{except.spec},
\item contract condition\iref{dcl.attr.contract}, or
\item default member initializer
\end{itemize}
within the \grammarterm{member-specification} of the class.
\begin{note}
A complete-class context of a nested class is also a complete-class
context of any enclosing class, if the nested class is defined within
the \grammarterm{member-specification} of the enclosing class.
\end{note}

\pnum
A class is considered a completely-defined object
type\iref{basic.types} (or complete type) at the closing \tcode{\}} of
the \grammarterm{class-specifier}.
The class is regarded as complete within its complete-class contexts;
otherwise it is regarded as incomplete within its own class
\grammarterm{member-specification}.

\pnum
In a \grammarterm{member-declarator},
an \tcode{=} immediately following the \grammarterm{declarator}
is interpreted as introducing a \grammarterm{pure-specifier}
if the \grammarterm{declarator-id} has function type,
otherwise it is interpreted as introducing
a \grammarterm{brace-or-equal-initializer}.
\begin{example}
\begin{codeblock}
struct S {
  using T = void();
  T * p = 0;        // OK: \grammarterm{brace-or-equal-initializer}
  virtual T f = 0;  // OK: \grammarterm{pure-specifier}
};
\end{codeblock}
\end{example}

\pnum
In a \grammarterm{member-declarator} for a bit-field,
the \grammarterm{constant-expression} is parsed as
the longest sequence of tokens
that could syntactically form a \grammarterm{constant-expression}.
\begin{example}
\begin{codeblock}
int a;
const int b = 0;
struct S {
  int x1 : 8 = 42;               // OK, \tcode{"= 42"} is \grammarterm{brace-or-equal-initializer}
  int x2 : 8 { 42 };             // OK, \tcode{"\{ 42 \}"} is \grammarterm{brace-or-equal-initializer}
  int y1 : true ? 8 : a = 42;    // OK, \grammarterm{brace-or-equal-initializer} is absent
  int y2 : true ? 8 : b = 42;    // error: cannot assign to \tcode{const int}
  int y3 : (true ? 8 : b) = 42;  // OK, \tcode{"= 42"} is \grammarterm{brace-or-equal-initializer}
  int z : 1 || new int { 0 };    // OK, \grammarterm{brace-or-equal-initializer} is absent
};
\end{codeblock}
\end{example}

\pnum
A \grammarterm{brace-or-equal-initializer} shall appear only in the
declaration of a data member. (For static data members,
see~\ref{class.static.data}; for non-static data members,
see~\ref{class.base.init} and~\ref{dcl.init.aggr}).
A \grammarterm{brace-or-equal-initializer} for a non-static data member
\indextext{member!default initializer}%
specifies a \defn{default member initializer} for the member, and
shall not directly or indirectly cause the implicit definition of a
defaulted default constructor for the enclosing class or the
exception specification of that constructor.

\pnum
A member shall not be declared with the \tcode{extern}
\grammarterm{storage-class-specifier}. Within a class definition, a member shall not be declared with the \tcode{thread_local} \grammarterm{storage-class-specifier} unless also declared \tcode{static}.

\pnum
The \grammarterm{decl-specifier-seq} may be omitted in constructor, destructor,
and conversion function declarations only;
when declaring another kind of member the \grammarterm{decl-specifier-seq}
shall contain a \grammarterm{type-specifier} that is not a \grammarterm{cv-qualifier}.
The
\grammarterm{member-declarator-list} can be omitted only after a
\grammarterm{class-specifier} or an \grammarterm{enum-specifier} or in a
friend declaration\iref{class.friend}. A
\grammarterm{pure-specifier} shall be used only in the declaration of a
virtual function\iref{class.virtual}
that is not a friend declaration.

\pnum
The optional \grammarterm{attribute-specifier-seq} in a \grammarterm{member-declaration}
appertains to each of the entities declared by the \grammarterm{member-declarator}{s};
it shall not appear if the optional \grammarterm{member-declarator-list} is omitted.

\pnum
A \grammarterm{virt-specifier-seq} shall contain at most one of each
\grammarterm{virt-specifier}.
A \grammarterm{virt-specifier-seq}
shall appear only in the first declaration of a virtual member
function\iref{class.virtual}.

\pnum
\indextext{class object!member}%
The type of a non-static data member shall not be an
incomplete type\iref{basic.types},
an abstract class type\iref{class.abstract},
or a (possibly multi-dimensional) array thereof.
\begin{note}
In particular, a class \tcode{C} cannot contain
a non-static member of class \tcode{C},
but it can contain a pointer or reference to an object of class \tcode{C}.
\end{note}

\pnum
\begin{note}
See~\ref{expr.prim.id} for restrictions on the use of non-static data
members and non-static member functions.
\end{note}

\pnum
\begin{note}
The type of a non-static member function is an ordinary function type,
and the type of a non-static data member is an ordinary object type.
There are no special member function types or data member types.
\end{note}

\pnum
\begin{example}
A simple example of a class definition is

\begin{codeblock}
struct tnode {
  char tword[20];
  int count;
  tnode* left;
  tnode* right;
};
\end{codeblock}

which contains an array of twenty characters, an integer, and two
pointers to objects of the same type. Once this definition has been
given, the declaration

\begin{codeblock}
tnode s, *sp;
\end{codeblock}

declares \tcode{s} to be a \tcode{tnode} and \tcode{sp} to be a pointer
to a \tcode{tnode}. With these declarations, \tcode{sp->count} refers to
the \tcode{count} member of the object to which \tcode{sp} points;
\tcode{s.left} refers to the \tcode{left} subtree pointer of the object
\tcode{s}; and \tcode{s.right->tword[0]} refers to the initial character
of the \tcode{tword} member of the \tcode{right} subtree of \tcode{s}.
\end{example}

\pnum
\begin{note}
\indextext{layout!class object}%
Non-static data members of a (non-union) class
with the same access control\iref{class.access} and
non-zero size\iref{intro.object}
are allocated so that later
members have higher addresses within a class object.
\indextext{allocation!unspecified}%
The order of allocation of non-static data members
with different access control
is unspecified.
Implementation alignment requirements might cause two adjacent members
not to be allocated immediately after each other; so might requirements
for space for managing virtual functions\iref{class.virtual} and
virtual base classes\iref{class.mi}.
\end{note}

\pnum
If \tcode{T} is the name of a class, then each of the following shall
have a name different from \tcode{T}:

\begin{itemize}
\item every static data member of class \tcode{T};

\item every member function of class \tcode{T}
\begin{note}
This restriction does not apply to constructors, which do not have
names\iref{class.ctor}
\end{note};

\item every member of class \tcode{T} that is itself a type;

\item every member template of class \tcode{T};

\item every enumerator of every member of class \tcode{T} that is an
unscoped enumerated type; and

\item every member of every anonymous union that is a member of class
\tcode{T}.
\end{itemize}

\pnum
In addition, if class \tcode{T} has a user-declared
constructor\iref{class.ctor}, every non-static data member of class
\tcode{T} shall have a name different from \tcode{T}.

\pnum
The \defn{common initial sequence} of two standard-layout struct\iref{class.prop}
types is the longest sequence of non-static data
members and bit-fields in declaration order, starting with the first
such entity in each of the structs, such that corresponding entities
have layout-compatible types,
either both entities are declared with
the \tcode{no_unique_address} attribute\iref{dcl.attr.nouniqueaddr}
or neither is,
and either both entities are bit-fields with the same width
or neither is a bit-field.
\begin{example}
\begin{codeblock}
  struct A { int a; char b; };
  struct B { const int b1; volatile char b2; };
  struct C { int c; unsigned : 0; char b; };
  struct D { int d; char b : 4; };
  struct E { unsigned int e; char b; };
\end{codeblock}
The common initial sequence of \tcode{A} and \tcode{B} comprises all members
of either class. The common initial sequence of \tcode{A} and \tcode{C} and
of \tcode{A} and \tcode{D} comprises the first member in each case.
The common initial sequence of \tcode{A} and \tcode{E} is empty.
\end{example}

\pnum
Two standard-layout struct\iref{class.prop} types are
\defnx{layout-compatible classes}{layout-compatible!class} if
their common initial sequence comprises all members and bit-fields of
both classes\iref{basic.types}.

\pnum
Two standard-layout unions are layout-compatible if they
have the same number of non-static data members and corresponding
non-static data members (in any order) have layout-compatible
types\iref{basic.types}.

\pnum
In a standard-layout union with an active member\iref{class.union}
of struct type \tcode{T1}, it is permitted to read a non-static
data member \tcode{m} of another union member of struct type \tcode{T2}
provided \tcode{m} is part of the common initial sequence of \tcode{T1} and \tcode{T2};
the behavior is as if the corresponding member of \tcode{T1} were nominated.
\begin{example}
\begin{codeblock}
struct T1 { int a, b; };
struct T2 { int c; double d; };
union U { T1 t1; T2 t2; };
int f() {
  U u = { { 1, 2 } };   // active member is \tcode{t1}
  return u.t2.c;        // OK, as if \tcode{u.t1.a} were nominated
}
\end{codeblock}
\end{example}
\begin{note}
Reading a volatile object through a glvalue of non-volatile type has
undefined behavior\iref{dcl.type.cv}.
\end{note}

\pnum
If a standard-layout class object has any non-static data members, its address
is the same as the address of its first non-static data member
if that member is not a bit-field. Its
address is also the same as the address of each of its base class subobjects.
\begin{note}
There might therefore be unnamed padding within a standard-layout struct object
inserted by an implementation, but
not at its beginning, as necessary to achieve appropriate alignment.
\end{note}
\begin{note}
The object and its first subobject are
pointer-interconvertible~(\ref{basic.compound}, \ref{expr.static.cast}).
\end{note}

\rSec2[class.mfct]{Member functions}%
\indextext{member function!class}

\pnum
\indextext{member function!inline}%
\indextext{definition!member function}%
A member function may be defined\iref{dcl.fct.def} in its class
definition, in which case it is an inline member
function\iref{dcl.inline}, or it may be defined outside of its class
definition if it has already been declared but not defined in its class
definition. A member function definition that appears outside of the
class definition shall appear in a namespace scope enclosing the class
definition. Except for member function definitions that appear outside
of a class definition, and except for explicit specializations of member
functions of class templates and member function
templates\iref{temp.spec} appearing outside of the class definition, a
member function shall not be redeclared.

\pnum
An inline member function (whether static or non-static) may
also be defined outside of its class definition provided either its
declaration in the class definition or its definition outside of the
class definition declares the function as \tcode{inline} or \tcode{constexpr}.
\begin{note}
Member functions of a class have the linkage of the name of the class.
See~\ref{basic.link}.
\end{note}

\pnum
\begin{note}
There can be at most one definition of a non-inline member function in
a program. There may be more than one
inline member function definition in a program.
See~\ref{basic.def.odr} and~\ref{dcl.inline}.
\end{note}

\pnum
\indextext{operator!scope resolution}%
If the definition of a member function is lexically outside its class
definition, the member function name shall be qualified by its class
name using the \tcode{::} operator.
\begin{note}
A name used in a member function definition (that is, in the
\grammarterm{parameter-declaration-clause} including the default
arguments\iref{dcl.fct.default} or in the member function body) is looked up
as described in~\ref{basic.lookup}.
\end{note}
\begin{example}

\begin{codeblock}
struct X {
  typedef int T;
  static T count;
  void f(T);
};
void X::f(T t = count) { }
\end{codeblock}

The member function \tcode{f} of class \tcode{X} is defined in global
scope; the notation \tcode{X::f} specifies that the function \tcode{f}
is a member of class \tcode{X} and in the scope of class \tcode{X}. In
the function definition, the parameter type \tcode{T} refers to the
typedef member \tcode{T} declared in class \tcode{X} and the default
argument \tcode{count} refers to the static data member \tcode{count}
declared in class \tcode{X}.
\end{example}

\pnum
\begin{note}
A \tcode{static} local variable or local type in a member function always refers to
the same entity, whether or not the member function is inline.
\end{note}

\pnum
Previously declared member functions may be mentioned in friend declarations.

\pnum
\indextext{local class!member function in}%
Member functions of a local class shall be defined inline in their class
definition, if they are defined at all.

\pnum
\begin{note}
A member function can be declared (but not defined) using a typedef for
a function type. The resulting member function has exactly the same type
as it would have if the function declarator were provided explicitly,
see~\ref{dcl.fct}. For example,

\begin{codeblock}
typedef void fv();
typedef void fvc() const;
struct S {
  fv memfunc1;      // equivalent to: \tcode{void memfunc1();}
  void memfunc2();
  fvc memfunc3;     // equivalent to: \tcode{void memfunc3() const;}
};
fv  S::* pmfv1 = &S::memfunc1;
fv  S::* pmfv2 = &S::memfunc2;
fvc S::* pmfv3 = &S::memfunc3;
\end{codeblock}

Also see~\ref{temp.arg}.
\end{note}

\rSec2[class.mfct.non-static]{Non-static member functions}%
\indextext{member function!non-static}

\pnum
A non-static member function may be called for an object of
its class type, or for an object of a class derived\iref{class.derived}
from its class type, using the class member
access syntax~(\ref{expr.ref}, \ref{over.match.call}). A non-static
member function may also be called directly using the function call
syntax~(\ref{expr.call}, \ref{over.match.call}) from within
the body of a member function of its class or of a class derived from
its class.

\pnum
\indextext{member function!call undefined}%
If a non-static member function of a class \tcode{X} is called for an
object that is not of type \tcode{X}, or of a type derived from
\tcode{X}, the behavior is undefined.

\pnum
When an \grammarterm{id-expression}\iref{expr.prim.id} that is not part of a
class member access syntax\iref{expr.ref} and not used to form a
pointer to member\iref{expr.unary.op} is used in
a member of class \tcode{X} in a context where \tcode{this} can be
used\iref{expr.prim.this},
if name
lookup\iref{basic.lookup} resolves the name in the
\grammarterm{id-expression} to a non-static non-type member of some class
\tcode{C},
and if either the \grammarterm{id-expression} is potentially evaluated or
\tcode{C} is \tcode{X} or a base class of \tcode{X},
the \grammarterm{id-expression} is transformed into a class
member access expression\iref{expr.ref} using
\tcode{(*this)}\iref{class.this} as the \grammarterm{postfix-expression}
to the left of the \tcode{.} operator.
\begin{note}
If \tcode{C} is not \tcode{X} or a base class of \tcode{X}, the class
member access expression is ill-formed.
\end{note}
Similarly during name lookup, when an
\grammarterm{unqualified-id}\iref{expr.prim.id.unqual} used in the definition of a
member function for class \tcode{X} resolves to a static member,
an enumerator or a nested type of class \tcode{X} or of a base class of
\tcode{X}, the \grammarterm{unqualified-id} is transformed into a
\grammarterm{qualified-id}\iref{expr.prim.id.qual} in which the
\grammarterm{nested-name-specifier} names the class of the member function.
These transformations do not apply in the
template definition context\iref{temp.dep.type}.
\begin{example}

\begin{codeblock}
struct tnode {
  char tword[20];
  int count;
  tnode* left;
  tnode* right;
  void set(const char*, tnode* l, tnode* r);
};

void tnode::set(const char* w, tnode* l, tnode* r) {
  count = strlen(w)+1;
  if (sizeof(tword)<=count)
      perror("tnode string too long");
  strcpy(tword,w);
  left = l;
  right = r;
}

void f(tnode n1, tnode n2) {
  n1.set("abc",&n2,0);
  n2.set("def",0,0);
}
\end{codeblock}

In the body of the member function \tcode{tnode::set}, the member names
\tcode{tword}, \tcode{count}, \tcode{left}, and \tcode{right} refer to
members of the object for which the function is called. Thus, in the
call \tcode{n1.set("abc",\&n2,0)}, \tcode{tword} refers to
\tcode{n1.tword}, and in the call \tcode{n2.set("def",0,0)}, it refers
to \tcode{n2.tword}. The functions \tcode{strlen}, \tcode{perror}, and
\tcode{strcpy} are not members of the class \tcode{tnode} and should be
declared elsewhere.\footnote{See, for example, \tcode{<cstring>}\iref{c.strings}.}
\end{example}

\pnum
\indextext{member function!const}%
\indextext{member function!volatile}%
\indextext{member function!const volatile}%
A non-static member function may be declared \tcode{const},
\tcode{volatile}, or \tcode{const} \tcode{volatile}. These
\grammarterm{cv-qualifier}{s} affect the type of the \tcode{this}
pointer\iref{class.this}. They also affect the function
type\iref{dcl.fct} of the member function; a member function declared
\tcode{const} is a \defn{const member function}, a member function
declared \tcode{volatile} is a \defn{volatile member function} and a
member function declared \tcode{const} \tcode{volatile} is a
\defn{const volatile member function}.
\begin{example}

\begin{codeblock}
struct X {
  void g() const;
  void h() const volatile;
};
\end{codeblock}

\tcode{X::g} is a const member function and \tcode{X::h} is a
const volatile member function.
\end{example}

\pnum
A non-static member function may be declared with a \grammarterm{ref-qualifier}\iref{dcl.fct}; see~\ref{over.match.funcs}.

\pnum
A non-static member function may be declared
virtual\iref{class.virtual} or pure virtual\iref{class.abstract}.

\rSec3[class.this]{The \tcode{this} pointer}%
\indextext{\idxcode{this}}
\indextext{member function!\idxcode{this}}

\pnum
\indextext{this pointer@\tcode{this} pointer|see{\tcode{this}}}%
In the body of a non-static\iref{class.mfct} member function, the
keyword \tcode{this} is a prvalue whose value is
a pointer to the object for which the function is called.
\indextext{\idxcode{this}!type of}%
The type of \tcode{this} in a member function of a class \tcode{X} is
\tcode{X*}.
If the member function is declared \tcode{const}, the type of
\tcode{this} is \tcode{const} \tcode{X*},
if the member function is declared \tcode{volatile}, the type of
\tcode{this} is \tcode{volatile} \tcode{X*}, and if the member function
is declared \tcode{const} \tcode{volatile}, the type of \tcode{this} is
\tcode{const} \tcode{volatile} \tcode{X*}.
\begin{note} Thus in a const member function, the object for which the function is
called is accessed through a const access path. \end{note}
\begin{example}

\begin{codeblock}
struct s {
  int a;
  int f() const;
  int g() { return a++; }
  int h() const { return a++; } // error
};

int s::f() const { return a; }
\end{codeblock}

The \tcode{a++} in the body of \tcode{s::h} is ill-formed because it
tries to modify (a part of) the object for which \tcode{s::h()} is
called. This is not allowed in a const member function because
\tcode{this} is a pointer to \tcode{const}; that is, \tcode{*this} has
\tcode{const} type.
\end{example}

\pnum
Similarly, \tcode{volatile} semantics\iref{dcl.type.cv} apply in
volatile member functions when accessing the object and its
non-static data members.

\pnum
A cv-qualified member function can be called on an
object-expression\iref{expr.ref} only if the object-expression is as
cv-qualified or less-cv-qualified than the member function.
\begin{example}

\begin{codeblock}
void k(s& x, const s& y) {
  x.f();
  x.g();
  y.f();
  y.g();                        // error
}
\end{codeblock}

The call \tcode{y.g()} is ill-formed because \tcode{y} is \tcode{const}
and \tcode{s::g()} is a non-const member function, that is,
\tcode{s::g()} is less-qualified than the object-expression \tcode{y}.
\end{example}

\pnum
\indextext{\idxcode{const}!constructor and}%
\indextext{\idxcode{const}!destructor and}%
\indextext{\idxcode{volatile}!constructor and}%
\indextext{\idxcode{volatile}!destructor and}%
\begin{note}
Constructors and destructors
cannot be declared \tcode{const}, \tcode{volatile}, or \tcode{const}
\tcode{volatile}.
However, these functions can be invoked
to create and destroy objects with cv-qualified types;
see~\ref{class.ctor} and~\ref{class.dtor}.
\end{note}

\rSec2[special]{Special member functions}

\indextext{\idxcode{X(X\&)}|see{constructor, copy}}%
\indextext{~@\tcode{\~}|see{destructor}}%
\indextext{assignment!copy|see{assignment operator, copy}}%
\indextext{assignment!move|see{assignment operator, move}}%
\indextext{implicitly-declared default constructor|see{constructor, default}}

\pnum
\indextext{constructor!default}%
\indextext{constructor!copy}%
\indextext{constructor!move}%
\indextext{assignment operator!copy}%
\indextext{assignment operator!move}%
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},
and destructor\iref{class.dtor} are
\term{special member functions}.
\begin{note} The implementation will implicitly declare these member functions for some class
types when the program does not explicitly declare them.
The implementation will implicitly define them
if they are odr-used\iref{basic.def.odr} or
needed for constant evaluation\iref{expr.const}.
\end{note}
An implicitly-declared special member function is declared at the closing
\tcode{\}} of the \grammarterm{class-specifier}.
Programs shall not define implicitly-declared special member functions.

\pnum
Programs may explicitly refer to implicitly-declared special member functions.
\begin{example}
A program may explicitly call or form a pointer to member
to an implicitly-declared special member function.

\begin{codeblock}
struct A { };                   // implicitly declared \tcode{A::operator=}
struct B : A {
  B& operator=(const B &);
};
B& B::operator=(const B& s) {
  this->A::operator=(s);        // well-formed
  return *this;
}
\end{codeblock}
\end{example}

\pnum
\begin{note}
The special member functions affect the way objects of class type are created,
copied, moved, and destroyed, and how values can be converted to values of other types.
Often such special member functions are called implicitly.
\end{note}

\pnum
\indextext{access control!member function and}%
Special member functions obey the usual access rules\iref{class.access}.
\begin{example}
Declaring a constructor protected
ensures that only derived classes and friends can create objects using it.
\end{example}

\pnum
For a class, its non-static data members, its non-virtual direct base classes,
and, if the class is not abstract\iref{class.abstract}, its virtual base
classes are called its \term{potentially constructed subobjects}.

\rSec2[class.ctor]{Constructors}%
\indextext{constructor}%
\indextext{special member function|see{constructor}}%

\pnum
Constructors do not have names.
In a declaration of a constructor, the \grammarterm{declarator} is a
function declarator\iref{dcl.fct} of the form

\begin{ncbnf}
ptr-declarator \terminal{(} parameter-declaration-clause \terminal{)} \opt{noexcept-specifier} \opt{attribute-specifier-seq}
\end{ncbnf}

where the \grammarterm{ptr-declarator} consists solely of an
\grammarterm{id-expression}, an optional \grammarterm{attribute-specifier-seq},
and optional surrounding parentheses, and the \grammarterm{id-expression} has
one of the following forms:

\begin{itemize}
\item
in a \grammarterm{member-declaration} that belongs to the
\grammarterm{member-specification} of a class or class template
but is not a friend
declaration\iref{class.friend}, the \grammarterm{id-expression} is the
injected-class-name\iref{class} of the immediately-enclosing entity or

\item
in a declaration at namespace scope or in a friend declaration, the
\grammarterm{id-expression} is a \grammarterm{qualified-id} that names a
constructor\iref{class.qual}.
\end{itemize}

In a constructor declaration, each \grammarterm{decl-specifier} in the optional
\grammarterm{decl-specifier-seq} shall be \tcode{friend}, \tcode{inline},
\tcode{constexpr}, or an \grammarterm{explicit-specifier}.
\begin{example}

\begin{codeblock}
struct S {
  S();              // declares the constructor
};

S::S() { }          // defines the constructor
\end{codeblock}
\end{example}

\pnum
\indextext{constructor!explicit call}%
A constructor is used to initialize objects of its class type.
Because constructors do not have names, they are never found during
name lookup; however an explicit type conversion using the functional
notation\iref{expr.type.conv} will cause a constructor to be called to
initialize an object.
\begin{note}
The syntax looks like an explicit call of the constructor.
\end{note}
\begin{example}
\begin{codeblock}
complex zz = complex(1,2.3);
cprint( complex(7.8,1.2) );
\end{codeblock}
\end{example}
\begin{note}
For initialization of objects of class type see~\ref{class.init}.
\end{note}

\pnum
\indextext{object!unnamed}%
An object created in this way is unnamed.
\begin{note}
\ref{class.temporary} describes the lifetime of temporary objects.
\end{note}
\begin{note}
Explicit constructor calls do not yield lvalues, see~\ref{basic.lval}.
\end{note}

\pnum
\begin{note}
\indextext{member function!constructor and}%
Some language constructs have special semantics when used during construction;
see~\ref{class.base.init} and~\ref{class.cdtor}.
\end{note}

\pnum
\indextext{\idxcode{const}!constructor and}%
\indextext{\idxcode{volatile}!constructor and}%
A constructor can be invoked for a
\tcode{const},
\tcode{volatile}
or
\tcode{const}
\tcode{volatile}
object.
\indextext{restriction!constructor}%
\tcode{const}
and
\tcode{volatile}
semantics\iref{dcl.type.cv} are not applied on an object under construction.
They come into effect when the constructor for the
most derived object\iref{intro.object} ends.

\pnum
\indextext{restriction!constructor}%
A
\tcode{return}
statement in the body of a constructor shall not specify a return value.
\indextext{constructor!address of}%
The address of a constructor shall not be taken.

\pnum
A constructor shall not be a coroutine.

\rSec3[class.default.ctor]{Default constructors}

\pnum
\indextext{constructor!inheritance of}%
\indextext{constructor!non-trivial}%
A \defnadj{default}{constructor} for a class \tcode{X}
is a constructor of class \tcode{X}
for which each parameter
that is not a function parameter pack
has a default argument
(including the case of a constructor with no parameters).
\indextext{implicitly-declared default constructor}%
If there is no user-declared constructor for class
\tcode{X},
a non-explicit constructor having no parameters is implicitly declared
as defaulted\iref{dcl.fct.def}.
An implicitly-declared default constructor is an
inline public member of its class.

\pnum
A defaulted default constructor for class \tcode{X} is defined as deleted if:

\begin{itemize}
\item \tcode{X} is a union that has a variant member
with a non-trivial default constructor and
no variant member of \tcode{X} has a default member initializer,

\item \tcode{X} is a non-union class that has a variant member \tcode{M}
with a non-trivial default constructor and
no variant member of the anonymous union containing \tcode{M}
has a default member initializer,

\item any non-static data member with no default member initializer\iref{class.mem} is
of reference type,

\item any non-variant non-static data member of const-qualified type (or array
thereof) with no \grammarterm{brace-or-equal-initializer}
is not const-default-constructible\iref{dcl.init}.

\item \tcode{X} is a union and all of its variant members are of const-qualified
type (or array thereof),

\item \tcode{X} is a non-union class and all members of any anonymous union member are
of const-qualified type (or array thereof),

\item any potentially constructed subobject, except for a non-static data member
with a \grammarterm{brace-or-equal-initializer}, has
class type \tcode{M} (or array thereof) and either \tcode{M}
has no default constructor or overload resolution\iref{over.match}
as applied to find \tcode{M}'s corresponding
constructor results in an ambiguity or in a function that is deleted or
inaccessible from the defaulted default constructor, or

\item any potentially constructed subobject has a type
with a destructor that is deleted or inaccessible from the defaulted default
constructor.
\end{itemize}

\pnum
A default constructor is
\defnx{trivial}{constructor!default!trivial}
if it is not user-provided and if:

\begin{itemize}
\item
its class has no virtual functions\iref{class.virtual} and no virtual base
classes\iref{class.mi}, and

\item no non-static data member of its class has
a default member initializer\iref{class.mem}, and

\item
all the direct base classes of its class have trivial default constructors, and

\item
for all the non-static data members of its class that are of class
type (or array thereof), each such class has a trivial default constructor.
\end{itemize}

Otherwise, the default constructor is
\defnx{non-trivial}{constructor!default!non-trivial}.

\pnum
A default constructor
that is defaulted and not defined as deleted
is
\defnx{implicitly defined}{constructor!implicitly defined}
when it is odr-used\iref{basic.def.odr}
to create an object of its class type\iref{intro.object},
when it is needed for constant evaluation\iref{expr.const}, or
when it is explicitly defaulted after its first declaration.
The implicitly-defined default constructor performs the set of
initializations of the class that would be performed by a user-written default
constructor for that class with no
\grammarterm{ctor-initializer}\iref{class.base.init} and an empty
\grammarterm{compound-statement}.
If that user-written default constructor would be ill-formed,
the program is ill-formed.
If that user-written default constructor would satisfy the requirements
of a constexpr constructor\iref{dcl.constexpr}, the implicitly-defined
default constructor is \tcode{constexpr}.
Before the defaulted default constructor for a class is
implicitly defined,
all the non-user-provided default constructors for its base classes and
its non-static data members shall have been implicitly defined.
\begin{note}
An implicitly-declared default constructor has an
exception specification\iref{except.spec}.
An explicitly-defaulted definition might have an
implicit exception specification, see~\ref{dcl.fct.def}.
\end{note}

\pnum
\indextext{constructor!implicitly called}%
Default constructors are called implicitly to create class objects of static, thread,
or automatic storage duration~(\ref{basic.stc.static}, \ref{basic.stc.thread}, \ref{basic.stc.auto}) defined
without an initializer\iref{dcl.init},
are called to create class objects of dynamic storage duration\iref{basic.stc.dynamic} created by a
\grammarterm{new-expression}
in which the
\grammarterm{new-initializer}
is omitted\iref{expr.new}, or
are called when the explicit type conversion syntax\iref{expr.type.conv} is
used.
A program is ill-formed if the default constructor for an object
is implicitly used and the constructor is not accessible\iref{class.access}.

\pnum
\begin{note}
\indextext{order of execution!base class constructor}%
\indextext{order of execution!member constructor}%
\ref{class.base.init} describes the order in which constructors for base
classes and non-static data members are called and
describes how arguments can be specified for the calls to these constructors.
\end{note}

\rSec3[class.copy.ctor]{Copy/move constructors}%

\pnum
\indextext{constructor!copy|(}%
\indextext{constructor!move|(}%
\indextext{copy!class object|see{constructor, copy}}%
\indextext{move!class object|see{constructor, move}}%
A non-template constructor for class
\tcode{X}
is
a
copy
constructor if its first parameter is of type
\tcode{X\&},
\tcode{const X\&},
\tcode{volatile X\&}
or
\tcode{const volatile X\&},
and either there are no other parameters
or else all other parameters have default arguments\iref{dcl.fct.default}.
\begin{example}
\tcode{X::X(const X\&)}
and
\tcode{X::X(X\&,int=1)}
are copy constructors.

\begin{codeblock}
struct X {
  X(int);
  X(const X&, int = 1);
};
X a(1);             // calls \tcode{X(int);}
X b(a, 0);          // calls \tcode{X(const X\&, int);}
X c = b;            // calls \tcode{X(const X\&, int);}
\end{codeblock}
\end{example}

\pnum
A non-template constructor for class \tcode{X} is a move constructor if its
first parameter is of type \tcode{X\&\&}, \tcode{const X\&\&},
\tcode{volatile X\&\&}, or \tcode{const volatile X\&\&}, and either there are
no other parameters or else all other parameters have default
arguments\iref{dcl.fct.default}.
\begin{example} \tcode{Y::Y(Y\&\&)} is a move constructor.
\begin{codeblock}
struct Y {
  Y(const Y&);
  Y(Y&&);
};
extern Y f(int);
Y d(f(1));          // calls \tcode{Y(Y\&\&)}
Y e = d;            // calls \tcode{Y(const Y\&)}
\end{codeblock}
\end{example}

\pnum
\begin{note}
All forms of copy/move constructor may be declared for a class.
\begin{example}

\begin{codeblock}
struct X {
  X(const X&);
  X(X&);            // OK
  X(X&&);
  X(const X&&);     // OK, but possibly not sensible
};
\end{codeblock}
\end{example}
\end{note}

\pnum
\begin{note}
If a class
\tcode{X}
only has a copy constructor with a parameter of type
\tcode{X\&},
an initializer of type
\tcode{const}
\tcode{X}
or
\tcode{volatile}
\tcode{X}
cannot initialize an object of type
(possibly
cv-qualified)
\tcode{X}.
\begin{example}

\begin{codeblock}
struct X {
  X();              // default constructor
  X(X&);            // copy constructor with a non-const parameter
};
const X cx;
X x = cx;           // error: \tcode{X::X(X\&)} cannot copy \tcode{cx} into \tcode{x}
\end{codeblock}
\end{example}
\end{note}

\pnum
A declaration of a constructor for a class
\tcode{X}
is ill-formed if its first parameter is of type (optionally cv-qualified)
\tcode{X}
and either there are no other parameters or else all other parameters have
default arguments.
A member function template is never instantiated to
produce such a constructor signature.
\begin{example}
\begin{codeblock}
struct S {
  template<typename T> S(T);
  S();
};

S g;

void h() {
  S a(g);           // does not instantiate the member template to produce \tcode{S::S<S>(S)};
                    // uses the implicitly declared copy constructor
}
\end{codeblock}
\end{example}

\pnum
If the class definition does not explicitly declare a copy constructor,
a non-explicit one is declared \defnx{implicitly}{constructor!copy!implicitly declared}.
If the class definition declares a move
constructor or move assignment operator, the implicitly declared copy
constructor is defined as deleted; otherwise, it is defined as
defaulted\iref{dcl.fct.def}.
The latter case is deprecated if the class has a user-declared copy assignment
operator or a user-declared destructor \iref{depr.impldec}.

\pnum
The implicitly-declared copy constructor for a class
\tcode{X}
will have the form

\begin{codeblock}
X::X(const X&)
\end{codeblock}

if each potentially constructed subobject of a class type
\tcode{M}
(or array thereof)
has a copy constructor whose first parameter is of type
\tcode{const}
\tcode{M\&}
or
\tcode{const}
\tcode{volatile}
\tcode{M\&}.\footnote{This implies that the reference parameter of the
implicitly-declared copy constructor
cannot bind to a
\tcode{volatile}
lvalue; see~\ref{diff.class}.}
Otherwise, the implicitly-declared copy constructor will have the form

\begin{codeblock}
X::X(X&)
\end{codeblock}

\pnum
\indextext{constructor!move!implicitly declared}%
If the definition of a class \tcode{X} does not explicitly declare
a move constructor, a non-explicit one will be
implicitly declared as defaulted if and only if

\begin{itemize}
\item
\tcode{X} does not have a user-declared copy constructor,

\item
\tcode{X} does not have a user-declared copy assignment operator,

\item
\tcode{X} does not have a user-declared move assignment operator, and

\item
\tcode{X} does not have a user-declared destructor.
\end{itemize}

\begin{note} When the move constructor is not implicitly declared or explicitly supplied,
expressions that otherwise would have invoked the move constructor may instead invoke
a copy constructor. \end{note}

\pnum
The implicitly-declared move constructor for class \tcode{X} will have the form
\begin{codeblock}
X::X(X&&)
\end{codeblock}

\pnum
An implicitly-declared copy/move constructor is an
inline public member of its class.
A defaulted copy/\brk{}move constructor for a class
  \tcode{X} is defined as deleted\iref{dcl.fct.def.delete} if \tcode{X} has:
\begin{itemize}
\item a potentially constructed subobject type
  \tcode{M} (or array thereof) that cannot be copied/moved because
  overload resolution\iref{over.match}, as applied to find
  \tcode{M}'s
  corresponding constructor, results in an ambiguity or
  a function that is deleted or inaccessible from the
  defaulted constructor,

\item a variant member whose corresponding constructor
  as selected by overload resolution is non-trivial,

\item any potentially constructed subobject of a type
  with a destructor that is deleted or inaccessible from the defaulted
  constructor, or,

\item for the copy constructor, a non-static data member of rvalue reference type.
\end{itemize}

A defaulted move constructor that is defined as deleted is ignored by overload
resolution~(\ref{over.match}, \ref{over.over}).
\begin{note}
A deleted move constructor would otherwise interfere with initialization from
an rvalue which can use the copy constructor instead.
\end{note}

\pnum
\indextext{constructor!copy!trivial}%
\indextext{constructor!move!trivial}%
A copy/move constructor for class
\tcode{X}
is
trivial
if it is not user-provided and if:

\begin{itemize}
\item
class
\tcode{X}
has no virtual functions\iref{class.virtual}
and no virtual base classes\iref{class.mi}, and

\item
the constructor selected to copy/move each direct base class subobject is trivial, and

\item
for each non-static data member of
\tcode{X}
that is of class type (or array thereof),
the constructor selected to copy/move that member is trivial;
\end{itemize}

\indextext{constructor!move!non-trivial}%
otherwise the copy/move constructor is
\defnx{non-trivial}{constructor!copy!nontrivial}.

\pnum
\indextext{constructor!copy!implicitly defined}%
\indextext{constructor!move!implicitly defined}%
A copy/move constructor
that is defaulted and not defined as deleted
is
\term{implicitly defined}
when it is odr-used\iref{basic.def.odr},
when it is needed for constant evaluation\iref{expr.const}, or
when it is explicitly defaulted after its first declaration.
\begin{note}
The copy/move constructor is implicitly defined even if the implementation elided
its odr-use~(\ref{basic.def.odr}, \ref{class.temporary}).
\end{note}
If the implicitly-defined constructor would satisfy the requirements of a
constexpr constructor\iref{dcl.constexpr}, the implicitly-defined
constructor is \tcode{constexpr}.

\pnum
Before the defaulted copy/move constructor for a class is
implicitly defined,
all non-user-provided copy/move constructors for its
potentially constructed subobjects
shall have been implicitly defined.
\begin{note}
An implicitly-declared copy/move constructor has an
implied exception specification\iref{except.spec}.
\end{note}

\pnum
The implicitly-defined copy/move constructor for a non-union class
\tcode{X}
performs a memberwise copy/move of its bases and members.
\begin{note} Default member initializers of non-static data members are ignored. See also the example in~\ref{class.base.init}. \end{note}
The order of initialization is the same as the order of initialization of bases
and members in a user-defined constructor (see~\ref{class.base.init}).
Let \tcode{x} be either the parameter of the constructor or, for the move constructor, an
xvalue referring to the parameter.
Each base or non-static data member
is copied/moved in the manner appropriate to its type:

\begin{itemize}
\item
if the member is an array, each element is
direct-initialized with the corresponding subobject of \tcode{x};

\item
if a member \tcode{m} has rvalue reference type \tcode{T\&\&}, it is direct-initialized with
\tcode{static_cast<T\&\&>(x.m)};

\item
otherwise, the base or member is direct-initialized with the corresponding base or member of \tcode{x}.
\end{itemize}

\indextext{initialization!virtual base class}%
Virtual base class subobjects shall be initialized only once by
the implicitly-defined copy/move constructor (see~\ref{class.base.init}).

\pnum
The implicitly-defined copy/move constructor for a union
\tcode{X} copies the object representation\iref{basic.types} of \tcode{X}.%
\indextext{constructor!move|)}%
\indextext{constructor!copy|)}

\rSec2[class.copy.assign]{Copy/move assignment operator}%

\pnum
\indextext{assignment operator!copy|(}%
\indextext{assignment operator!move|(}%
\indextext{special member function|see{assignment operator}}%
\indextext{copy!class object|see{assignment operator, copy}}%
\indextext{move!class object|see{assignment operator, move}}%
\indextext{operator!copy assignment|see{assignment operator, copy}}%
\indextext{operator!move assignment|see{assignment operator, move}}%
A user-declared \term{copy} assignment operator \tcode{X::operator=} is a
non-static non-template member function of class \tcode{X} with exactly one
parameter of type \tcode{X}, \tcode{X\&}, \tcode{const X\&},
\tcode{volatile X\&}, or \tcode{const volatile X\&}.\footnote{Because
a template assignment operator or an assignment operator
taking an rvalue reference parameter is never a copy assignment operator,
the presence of such an assignment operator does not suppress the
implicit declaration of a copy assignment operator. Such assignment operators
participate in overload resolution with other assignment operators, including
copy assignment operators, and, if selected, will be used to assign an object.}
\begin{note}
An overloaded assignment operator must be declared to have only one parameter;
see~\ref{over.ass}.
\end{note}
\begin{note}
More than one form of copy assignment operator may be declared for a class.
\end{note}
\begin{note}
If a class
\tcode{X}
only has a copy assignment operator with a parameter of type
\tcode{X\&},
an expression of type const
\tcode{X}
cannot be assigned to an object of type
\tcode{X}.
\begin{example}

\begin{codeblock}
struct X {
  X();
  X& operator=(X&);
};
const X cx;
X x;
void f() {
  x = cx;           // error: \tcode{X::operator=(X\&)} cannot assign \tcode{cx} into \tcode{x}
}
\end{codeblock}
\end{example}
\end{note}

\pnum
If the class definition does not explicitly declare a copy assignment operator,
one is declared \defnx{implicitly}{assignment operator!copy!implicitly declared}.
If the class definition declares a move
constructor or move assignment operator, the implicitly declared copy
assignment operator is defined as deleted; otherwise, it is defined as
defaulted\iref{dcl.fct.def}.
The latter case is deprecated if the class has a user-declared copy constructor
or a user-declared destructor \iref{depr.impldec}.
The implicitly-declared copy assignment operator for a class
\tcode{X}
will have the form

\begin{codeblock}
X& X::operator=(const X&)
\end{codeblock}

if

\begin{itemize}
\item
each direct base class \tcode{B} of \tcode{X}
has a copy assignment operator whose parameter is of type
\tcode{const B\&}, \tcode{const volatile B\&}, or \tcode{B}, and
\item
for all the non-static data members of \tcode{X}
that are of a class type \tcode{M} (or array thereof),
each such class type has a copy assignment operator whose parameter is of type
\tcode{const M\&}, \tcode{const volatile M\&},
or \tcode{M}.\footnote{This implies that the reference parameter of the
implicitly-declared copy assignment operator cannot bind to a
\tcode{volatile} lvalue; see~\ref{diff.class}.}
\end{itemize}

Otherwise, the implicitly-declared copy assignment operator
will have the form

\begin{codeblock}
X& X::operator=(X&)
\end{codeblock}

\pnum
A user-declared move assignment operator \tcode{X::operator=} is
a non-static non-template member function of class \tcode{X} with exactly
one parameter of type \tcode{X\&\&}, \tcode{const X\&\&}, \tcode{volatile X\&\&}, or
\tcode{const volatile X\&\&}. \begin{note} An overloaded assignment operator must be
declared to have only one parameter; see~\ref{over.ass}. \end{note}{}
\begin{note} More
than one form of move assignment operator may be declared for a class. \end{note}

\pnum
\indextext{assignment operator!move!implicitly declared}%
If the definition of a class \tcode{X} does not explicitly declare a
move assignment operator, one
will be implicitly declared as defaulted if and only if

\begin{itemize}
\item
\tcode{X} does not have a user-declared copy constructor,

\item
\tcode{X} does not have a user-declared move constructor,

\item
\tcode{X} does not have a user-declared copy assignment operator, and

\item
\tcode{X} does not have a user-declared destructor.
\end{itemize}

\begin{example} The class definition
\begin{codeblock}
struct S {
  int a;
  S& operator=(const S&) = default;
};
\end{codeblock}

will not have a default move assignment operator implicitly declared because the
copy assignment operator has been user-declared. The move assignment operator may
be explicitly defaulted.

\begin{codeblock}
struct S {
  int a;
  S& operator=(const S&) = default;
  S& operator=(S&&) = default;
};
\end{codeblock}
\end{example}

\pnum
The implicitly-declared move assignment operator for a class \tcode{X} will have the form
\begin{codeblock}
X& X::operator=(X&&);
\end{codeblock}

\pnum
The implicitly-declared copy/move assignment operator for class
\tcode{X}
has the return type
\tcode{X\&};
it returns the object for which the assignment operator is invoked, that is,
the object assigned to.
An implicitly-declared copy/move assignment operator is an
inline public member of its class.

\pnum
A defaulted copy/move assignment operator for
class \tcode{X} is defined as deleted if \tcode{X} has:
\begin{itemize}
\item a variant member with a non-trivial corresponding assignment operator and
  \tcode{X} is a union-like class, or

\item a non-static data member of \tcode{const} non-class
  type (or array thereof), or

\item a non-static data member of reference type, or

\item a direct non-static data member of class type \tcode{M}
  (or array thereof) or a direct base class \tcode{M}
  that cannot be copied/moved because overload resolution
 \iref{over.match}, as applied to find \tcode{M}'s corresponding
  assignment operator, results in an ambiguity or
  a function that is deleted or inaccessible from the
  defaulted assignment operator.
\end{itemize}

A defaulted move assignment operator that is defined as deleted is ignored by
overload resolution~(\ref{over.match}, \ref{over.over}).

\pnum
\indextext{assignment operator!copy!hidden}%
\indextext{assignment operator!move!hidden}%
Because a copy/move assignment operator is implicitly declared for a class
if not declared by the user,
a base class copy/move assignment operator is always hidden
by the corresponding assignment operator of a derived class\iref{over.ass}.
A
\grammarterm{using-declaration}\iref{namespace.udecl} that brings in from a base class an assignment operator
with a parameter type that could be that of a
copy/move assignment operator for the
derived class is not considered an explicit declaration of such an
operator and does not suppress the implicit declaration of the derived class
operator;
the operator introduced by the
\grammarterm{using-declaration}
is hidden by the implicitly-declared operator in the derived
class.

\pnum
\indextext{assignment operator!copy!trivial}%
\indextext{assignment operator!move!trivial}%
A copy/move assignment operator for class
\tcode{X}
is
trivial
if it is not user-provided and if:

\begin{itemize}
\item
class
\tcode{X}
has no virtual functions\iref{class.virtual}
and no virtual base classes\iref{class.mi}, and

\item the assignment operator selected to copy/move each direct
base class subobject is trivial, and

\item
for each non-static data member of
\tcode{X}
that is of class type (or array thereof),
the assignment operator selected to copy/move that member is trivial;
\end{itemize}

\indextext{assignment operator!move!non-trivial}%
otherwise the copy/move assignment operator is
\defnx{non-trivial}{assignment operator!copy!non-trivial}.

\pnum
\indextext{assignment operator!copy!implicitly defined}%
\indextext{assignment operator!move!implicitly defined}%
A copy/move assignment operator for a class \tcode{X}
that is defaulted and not defined as deleted
is
\term{implicitly defined}
when it is odr-used\iref{basic.def.odr}
(e.g., when it is selected by overload resolution
to assign to an object of its class type),
when it is needed for constant evaluation\iref{expr.const}, or
when it is explicitly defaulted after its first declaration.
The implicitly-defined copy/move assignment operator is \tcode{constexpr} if
\begin{itemize}
\item
\tcode{X} is a literal type, and

\item
the assignment operator selected to copy/move each direct base class subobject
is a constexpr function, and

\item
for each non-static data member of \tcode{X} that is of class type (or array
thereof), the assignment operator selected to copy/move that member is a
constexpr function.
\end{itemize}

\pnum
Before the defaulted copy/move assignment operator for a class is
implicitly defined,
all non-user-provided copy/move assignment operators for
its direct base classes and
its non-static data members shall have been implicitly defined.
\begin{note}
An implicitly-declared copy/move assignment operator has an
implied exception specification\iref{except.spec}.
\end{note}

\pnum
The implicitly-defined copy/move assignment operator for a
non-union class \tcode{X} performs memberwise copy/move assignment of its subobjects. The direct
base classes of \tcode{X} are assigned first, in the order of their declaration in the
\grammarterm{base-specifier-list}, and then the immediate non-static data members of
\tcode{X} are assigned, in the order in which they were declared in the class
definition.
Let \tcode{x} be either the parameter of the function or, for the move operator, an
xvalue referring to the parameter.
Each subobject is assigned in the manner appropriate to its type:

\begin{itemize}
\item
if the subobject is of class type,
as if by a call to \tcode{operator=} with the subobject as the object expression
and the corresponding subobject of \tcode{x} as a single function argument
(as if by explicit qualification; that is,
ignoring any possible virtual overriding functions in more derived classes);
\item
if the subobject is an array, each element is assigned,
in the manner appropriate to the element type;
\item
if the subobject is of scalar type,
the built-in assignment operator is used.
\end{itemize}

\indextext{assignment operator!copy!virtual bases and}%
It is unspecified whether subobjects representing virtual base classes
are assigned more than once by the implicitly-defined copy/move assignment
operator.
\begin{example}

\begin{codeblock}
struct V { };
struct A : virtual V { };
struct B : virtual V { };
struct C : B, A { };
\end{codeblock}

It is unspecified whether the virtual base class subobject
\tcode{V}
is assigned twice by the implicitly-defined copy/move assignment operator for
\tcode{C}.
\end{example}

\pnum
The implicitly-defined copy assignment operator for a
union \tcode{X} copies the object representation\iref{basic.types} of \tcode{X}.%
\indextext{assignment operator!move|)}%
\indextext{assignment operator!copy|)}

\rSec2[class.dtor]{Destructors}%
\indextext{destructor}%
\indextext{special member function|see{destructor}}%

\pnum
In a declaration of a destructor, the \grammarterm{declarator} is a
function declarator\iref{dcl.fct} of the form

\begin{ncbnf}
ptr-declarator \terminal{(} parameter-declaration-clause \terminal{)} \opt{noexcept-specifier} \opt{attribute-specifier-seq}
\end{ncbnf}

where the \grammarterm{ptr-declarator} consists solely of an
\grammarterm{id-expression}, an optional \grammarterm{attribute-specifier-seq},
and optional surrounding parentheses, and the \grammarterm{id-expression} has
one of the following forms:

\begin{itemize}
\item
in a \grammarterm{member-declaration} that belongs to the
\grammarterm{member-specification} of a class or class template
but is not a friend
declaration\iref{class.friend}, the \grammarterm{id-expression} is
\tcode{\~}\grammarterm{class-name} and the \grammarterm{class-name} is the
injected-class-name\iref{class} of the immediately-enclosing entity or

\item
in a declaration at namespace scope or in a friend declaration, the
\grammarterm{id-expression} is \grammarterm{nested-name-specifier}
\tcode{\~}\grammarterm{class-name} and the \grammarterm{class-name} names the
same class as the \grammarterm{nested-name-specifier}.
\end{itemize}

A destructor shall take no arguments\iref{dcl.fct}.
Each \grammarterm{decl-specifier} of the \grammarterm{decl-specifier-seq}
of a destructor declaration (if any) shall be \tcode{friend}, \tcode{inline}, or
\tcode{virtual}.

\pnum
\indextext{restriction!destructor}%
The address of a destructor shall not be taken.
\indextext{\idxcode{const}!destructor and}%
\indextext{\idxcode{volatile}!destructor and}%
A destructor can be invoked for a
\tcode{const},
\tcode{volatile}
or
\tcode{const}
\tcode{volatile}
object.
\tcode{const}
and
\tcode{volatile}
semantics\iref{dcl.type.cv} are not applied on an object under destruction.
They stop being in effect when the destructor for the
most derived object\iref{intro.object} starts.

\pnum
\begin{note}
A declaration of a destructor that does not have a \grammarterm{noexcept-specifier}
has the same exception specification as if it had been implicitly declared\iref{except.spec}.
\end{note}

\pnum
\indextext{generated destructor|see{destructor, default}}%
\indextext{destructor!default}%
If a class has no user-declared
destructor, a destructor is implicitly
declared as defaulted\iref{dcl.fct.def}.
An implicitly-declared destructor is an
inline public member of its class.

\pnum
A defaulted destructor for a class
  \tcode{X} is defined as deleted if:
\begin{itemize}
\item \tcode{X} is a union-like class that has a variant
  member with a non-trivial destructor,

\item any potentially constructed subobject has class type
  \tcode{M} (or array thereof) and
  \tcode{M} has a deleted destructor or a destructor
  that is inaccessible from the defaulted destructor,

\item or, for a virtual destructor, lookup of the non-array deallocation
  function results in an ambiguity or in a function that is deleted or
  inaccessible from the defaulted destructor.
\end{itemize}

\pnum
A destructor is trivial if it is not user-provided and if:

\begin{itemize}
\item the destructor is not \tcode{virtual},

\item all of the direct base classes of its class have trivial destructors, and

\item for all of the non-static data members of its class that are of class
type (or array thereof), each such class has a trivial destructor.
\end{itemize}

Otherwise, the destructor is
\defnx{non-trivial}{destructor!non-trivial}.

\pnum
A destructor
that is defaulted and not defined as deleted
is
\defnx{implicitly defined}{destructor!implicitly defined}
when it is odr-used\iref{basic.def.odr}
or when it is explicitly defaulted after its first declaration.

\pnum
Before the
defaulted destructor for a class is implicitly defined, all the non-user-provided
destructors for its base classes and its non-static data members shall have been
implicitly defined.

\pnum
\indextext{order of execution!destructor}%
\indextext{order of execution!base class destructor}%
\indextext{order of execution!member destructor}%
After executing the body of the destructor and destroying
any automatic objects allocated within the body, a
destructor for class
\tcode{X}
calls the destructors for
\tcode{X}'s
direct non-variant non-static data members, the destructors for
\tcode{X}'s
non-virtual direct base classes and, if
\tcode{X}
is the most derived class\iref{class.base.init},
its destructor calls the destructors for
\tcode{X}'s
virtual base classes.
All destructors are called as if they were referenced with a qualified name,
that is, ignoring any possible virtual overriding destructors in more
derived classes.
Bases and members are destroyed in the reverse order of the completion of
their constructor (see~\ref{class.base.init}).
A
\tcode{return}
statement\iref{stmt.return} in a destructor might not directly return to the
caller; before transferring control to the caller, the destructors for the
members and bases are called.
\indextext{order of execution!destructor and array}%
Destructors for elements of an array are called in reverse order of their
construction (see~\ref{class.init}).

\pnum
\indextext{destructor!virtual}%
\indextext{destructor!pure virtual}%
A destructor can be declared
\tcode{virtual}\iref{class.virtual}
or pure
\tcode{virtual}\iref{class.abstract};
if any objects of that class or any derived class are created in the program,
the destructor shall be defined.
If a class has a base class with a virtual destructor, its  destructor
(whether user- or implicitly-declared) is virtual.

\pnum
\begin{note}
\indextext{member function!destructor and}%
Some language constructs have special semantics when used during destruction;
see~\ref{class.cdtor}.
\end{note}

\pnum
\indextext{destructor!implicit call}%
\indextext{destructor!program termination and}%
A destructor is invoked implicitly

\begin{itemize}

\item for a constructed object with static storage duration\iref{basic.stc.static} at program termination\iref{basic.start.term},

\item for a constructed object with thread storage duration\iref{basic.stc.thread} at thread exit,

\item for a constructed object with automatic storage duration\iref{basic.stc.auto} when the block in which an object is created exits\iref{stmt.dcl},

\item for a constructed temporary object when its lifetime ends~(\ref{conv.rval}, \ref{class.temporary}).
\end{itemize}

\indextext{\idxcode{delete}!destructor and}%
\indextext{destructor!explicit call}%
In each case, the context of the invocation is the context of the construction of
the object. A destructor may also be invoked implicitly through use of a
\grammarterm{delete-expression}\iref{expr.delete} for a constructed object allocated
by a \grammarterm{new-expression}\iref{expr.new}; the context of the invocation is the
\grammarterm{delete-expression}.
\begin{note} An array of class type contains several subobjects for each of which
the destructor is invoked. \end{note}
A destructor can also be invoked explicitly. A destructor is \term{potentially invoked}
if it is invoked or as specified in~\ref{expr.new}, \ref{dcl.init.aggr},
\ref{class.base.init}, and~\ref{except.throw}.
A program is ill-formed if a destructor that is potentially invoked is deleted
or not accessible from the context of the invocation.

\pnum
At the point of definition of a virtual destructor (including an implicit
definition\iref{class.dtor}), the non-array deallocation function is
determined as if for the expression \tcode{delete this} appearing in a
non-virtual destructor of the destructor's class (see~\ref{expr.delete}).
If the lookup fails or if the deallocation function has
a deleted definition\iref{dcl.fct.def}, the program is ill-formed.
\begin{note}
This assures that a deallocation function corresponding to the dynamic type of an
object is available for the
\grammarterm{delete-expression}\iref{class.free}.
\end{note}

\pnum
\indextext{destructor!explicit call}%
In an explicit destructor call, the destructor is specified by a
\tcode{\~{}}
followed by a
\grammarterm{type-name} or \grammarterm{decltype-specifier}
that denotes the destructor's class type.
The invocation of a destructor is subject to the usual rules for member
functions\iref{class.mfct};
that is, if the object is not of the destructor's class type and
not of a class derived from the destructor's class type (including when
the destructor is invoked via a null pointer value), the program has
undefined behavior.
\begin{note} Invoking \tcode{delete} on a null pointer does not call the
destructor; see \ref{expr.delete}. \end{note}
\begin{example}

\begin{codeblock}
struct B {
  virtual ~B() { }
};
struct D : B {
  ~D() { }
};

D D_object;
typedef B B_alias;
B* B_ptr = &D_object;

void f() {
  D_object.B::~B();             // calls \tcode{B}'s destructor
  B_ptr->~B();                  // calls \tcode{D}'s destructor
  B_ptr->~B_alias();            // calls \tcode{D}'s destructor
  B_ptr->B_alias::~B();         // calls \tcode{B}'s destructor
  B_ptr->B_alias::~B_alias();   // calls \tcode{B}'s destructor
}
\end{codeblock}
\end{example}
\begin{note}
An explicit destructor call must always be written using
a member access operator\iref{expr.ref} or a \grammarterm{qualified-id}\iref{expr.prim.id.qual};
in particular, the
\grammarterm{unary-expression}
\tcode{\~{}X()}
in a member function is not an explicit destructor call\iref{expr.unary.op}.
\end{note}

\pnum
\begin{note}
\indextext{object!destructor and placement of}%
Explicit calls of destructors are rarely needed.
One use of such calls is for objects placed at specific
addresses using a placement
\grammarterm{new-expression}.
Such use of explicit placement and destruction of objects can be necessary
to cope with dedicated hardware resources and for writing memory management
facilities.
For example,
\begin{codeblock}
void* operator new(std::size_t, void* p) { return p; }
struct X {
  X(int);
  ~X();
};
void f(X* p);

void g() {                      // rare, specialized use:
  char* buf = new char[sizeof(X)];
  X* p = new(buf) X(222);       // use \tcode{buf[]} and initialize
  f(p);
  p->X::~X();                   // cleanup
}
\end{codeblock}
\end{note}

\pnum
Once a destructor is invoked for an object, the object no longer exists;
the behavior is undefined if the destructor is invoked
for an object whose lifetime has ended\iref{basic.life}.
\begin{example}
If the destructor for an automatic object is explicitly invoked,
and the block is subsequently left in a manner that would ordinarily
invoke implicit destruction of the object, the behavior is undefined.
\end{example}

\pnum
\begin{note}
\indextext{fundamental type!destructor and}%
The notation for explicit call of a destructor can be used for any scalar type
name\iref{expr.prim.id.dtor}.
Allowing this makes it possible to write code without having to know if a
destructor exists for a given type.
For example:
\begin{codeblock}
typedef int I;
I* p;
p->I::~I();
\end{codeblock}
\end{note}

\pnum
A destructor shall not be a coroutine.

\rSec2[class.conv]{Conversions}

\pnum
\indextext{conversion!class}%
\indextext{constructor, conversion by|see{conversion, user-defined}}%
\indextext{conversion function|see{conversion, user-defined}}%
\indextext{conversion!implicit}%
Type conversions of class objects can be specified by constructors and
by conversion functions.
These conversions are called
\defnx{user-defined conversions}{conversion!user-defined}
and are used for implicit type conversions\iref{conv},
for initialization\iref{dcl.init},
and for explicit type conversions~(\ref{expr.cast}, \ref{expr.static.cast}).

\pnum
User-defined conversions are applied only where they are unambiguous~(\ref{class.member.lookup}, \ref{class.conv.fct}).
Conversions obey the access control rules\iref{class.access}.
Access control is applied after ambiguity resolution\iref{basic.lookup}.

\pnum
\begin{note}
See~\ref{over.match} for a discussion of the use of conversions in function calls
as well as examples below.
\end{note}

\pnum
\indextext{conversion!implicit user-defined}%
At most one user-defined conversion (constructor or conversion function)
is implicitly applied to a single value.
\begin{example}
\begin{codeblock}
struct X {
  operator int();
};

struct Y {
  operator X();
};

Y a;
int b = a;          // error, \tcode{a.operator X().operator int()} not tried
int c = X(a);       // OK: \tcode{a.operator X().operator int()}
\end{codeblock}
\end{example}

\pnum
User-defined conversions are used implicitly only if they are unambiguous.
\indextext{name hiding!user-defined conversion and}%
A conversion function in a derived class does not hide a conversion function
in a base class unless the two functions convert to the same type.
Function overload resolution\iref{over.match.best} selects the best
conversion function to perform the conversion.
\begin{example}
\begin{codeblock}
struct X {
  operator int();
};

struct Y : X {
    operator char();
};

void f(Y& a) {
  if (a) {          // ill-formed: \tcode{X::operator int()} or \tcode{Y::operator char()}
  }
}
\end{codeblock}
\end{example}

\rSec3[class.conv.ctor]{Conversion by constructor}%
\indextext{conversion!user-defined}%

\pnum
A constructor that is not explicit\iref{dcl.fct.spec}
specifies a conversion from
the types of its parameters (if any)
to the type of its class.
Such a constructor is called a
\defnadj{converting}{constructor}.
\begin{example}

\indextext{Jessie}%
\begin{codeblock}
struct X {
    X(int);
    X(const char*, int =0);
    X(int, int);
};

void f(X arg) {
  X a = 1;          // \tcode{a = X(1)}
  X b = "Jessie";   // \tcode{b = X("Jessie",0)}
  a = 2;            // \tcode{a = X(2)}
  f(3);             // \tcode{f(X(3))}
  f({1, 2});        // \tcode{f(X(1,2))}
}
\end{codeblock}
\end{example}

\pnum
\begin{note}
An explicit constructor constructs objects just like non-explicit
constructors, but does so only where the direct-initialization syntax\iref{dcl.init}
or where casts~(\ref{expr.static.cast}, \ref{expr.cast}) are explicitly
used; see also~\ref{over.match.copy}.
A default constructor may be an explicit constructor; such a constructor
will be used to perform default-initialization
or value-initialization\iref{dcl.init}.
\begin{example}
\begin{codeblock}
struct Z {
  explicit Z();
  explicit Z(int);
  explicit Z(int, int);
};

Z a;                            // OK: default-initialization performed
Z b{};                          // OK: direct initialization syntax used
Z c = {};                       // error: copy-list-initialization
Z a1 = 1;                       // error: no implicit conversion
Z a3 = Z(1);                    // OK: direct initialization syntax used
Z a2(1);                        // OK: direct initialization syntax used
Z* p = new Z(1);                // OK: direct initialization syntax used
Z a4 = (Z)1;                    // OK: explicit cast used
Z a5 = static_cast<Z>(1);       // OK: explicit cast used
Z a6 = { 3, 4 };                // error: no implicit conversion
\end{codeblock}
\end{example}
\end{note}

\pnum
A non-explicit copy/move constructor\iref{class.copy.ctor} is
a converting constructor.
\begin{note}
An implicitly-declared copy/move constructor is not an explicit constructor;
it may be called for implicit type conversions.
\end{note}

\rSec3[class.conv.fct]{Conversion functions}%
\indextext{function!conversion}%
\indextext{fundamental type conversion|see{conversion, user-defined}}%
\indextext{conversion!user-defined}%

\pnum
A member function of a class \tcode{X} having no parameters with a name of the form

\begin{bnf}
\nontermdef{conversion-function-id}\br
    \keyword{operator} conversion-type-id
\end{bnf}

\begin{bnf}
\nontermdef{conversion-type-id}\br
    type-specifier-seq \opt{conversion-declarator}
\end{bnf}

\begin{bnf}
\nontermdef{conversion-declarator}\br
    ptr-operator \opt{conversion-declarator}
\end{bnf}

specifies a conversion from
\tcode{X}
to the type specified by the
\grammarterm{conversion-type-id}.
Such functions are called \defnx{conversion functions}{conversion function}.
A \grammarterm{decl-specifier} in the \grammarterm{decl-specifier-seq}
of a conversion function (if any) shall be neither
a \grammarterm{defining-type-specifier} nor \tcode{static}.
\indextext{conversion!type of}%
The type of the conversion function\iref{dcl.fct} is
``function taking no parameter returning
\grammarterm{conversion-type-id}''.
A conversion function is never used to convert a (possibly cv-qualified) object
to the (possibly cv-qualified) same object type (or a reference to it),
to a (possibly cv-qualified) base class of that type (or a reference to it),
or to (possibly cv-qualified) void.\footnote{These conversions are considered
as standard conversions for the purposes of overload resolution~(\ref{over.best.ics}, \ref{over.ics.ref}) and therefore initialization\iref{dcl.init} and explicit casts\iref{expr.static.cast}. A conversion to \tcode{void} does not invoke any conversion function\iref{expr.static.cast}.
Even though never directly called to perform a conversion,
such conversion functions can be declared and can potentially
be reached through a call to a virtual conversion function in a base class.}
\begin{example}
\begin{codeblock}
struct X {
  operator int();
  operator auto() -> short;     // error: trailing return type
};

void f(X a) {
  int i = int(a);
  i = (int)a;
  i = a;
}
\end{codeblock}
In all three cases the value assigned will be converted by
\tcode{X::operator int()}.
\end{example}

\pnum
A conversion function may be explicit\iref{dcl.fct.spec}, in which case it is only considered as a user-defined conversion for direct-initialization\iref{dcl.init}. Otherwise, user-defined conversions are not restricted to use in assignments and initializations.
\begin{example}
\begin{codeblock}
class Y { };
struct Z {
  explicit operator Y() const;
};

void h(Z z) {
  Y y1(z);          // OK: direct-initialization
  Y y2 = z;         // ill-formed: copy-initialization
  Y y3 = (Y)z;      // OK: cast notation
}

void g(X a, X b) {
  int i = (a) ? 1+a : 0;
  int j = (a&&b) ? a+b : i;
  if (a) {
  }
}
\end{codeblock}
\end{example}

\pnum
The
\grammarterm{conversion-type-id}
shall not represent a function type nor an array type.
The
\grammarterm{conversion-type-id}
in a
\grammarterm{conversion-function-id}
is the longest sequence of
tokens that could possibly form a \grammarterm{conversion-type-id}.
\begin{note}
This prevents ambiguities between the declarator operator \tcode{*} and its expression
counterparts.
\begin{example}
\begin{codeblock}
&ac.operator int*i; // syntax error:
                    // parsed as: \tcode{\&(ac.operator int *)i}
                    // not as: \tcode{\&(ac.operator int)*i}
\end{codeblock}
The \tcode{*} is the pointer declarator and not the multiplication operator.
\end{example}
This rule also prevents ambiguities for attributes.
\begin{example}
\begin{codeblock}
operator int [[noreturn]] ();   // error: \tcode{noreturn} attribute applied to a type
\end{codeblock}
\end{example}
\end{note}

\pnum
\indextext{conversion!inheritance of user-defined}%
Conversion functions are inherited.

\pnum
\indextext{conversion!virtual user-defined}%
Conversion functions can be virtual.

\pnum
\indextext{conversion!deduced return type of user-defined}%
A conversion function template shall not have a
deduced return type\iref{dcl.spec.auto}.
\begin{example}
\begin{codeblock}
struct S {
  operator auto() const { return 10; }      // OK
  template<class T>
  operator auto() const { return 1.2; }     // error: conversion function template
};
\end{codeblock}
\end{example}

\rSec2[class.static]{Static members}%
\indextext{member!static}%

\pnum
A static member \tcode{s} of class \tcode{X} may be referred to
using the \grammarterm{qualified-id} expression \tcode{X::s}; it is not
necessary to use the class member access syntax\iref{expr.ref} to
refer to a static member. A static member may be
referred to using the class member access syntax, in which case the
object expression is evaluated.
\begin{example}

\begin{codeblock}
struct process {
  static void reschedule();
};
process& g();

void f() {
  process::reschedule();        // OK: no object necessary
  g().reschedule();             // \tcode{g()} is called
}
\end{codeblock}
\end{example}

\pnum
A static member may be referred to directly in the scope of its
class or in the scope of a class derived\iref{class.derived}
from its class; in this case, the static member is referred to
as if a \grammarterm{qualified-id} expression was used, with the
\grammarterm{nested-name-specifier} of the \grammarterm{qualified-id} naming
the class scope from which the static member is referenced.
\begin{example}

\begin{codeblock}
int g();
struct X {
  static int g();
};
struct Y : X {
  static int i;
};
int Y::i = g();                 // equivalent to \tcode{Y::g();}
\end{codeblock}
\end{example}

\pnum
If an \grammarterm{unqualified-id}\iref{expr.prim.id.unqual} is used in the
definition of a static member following the member's
\grammarterm{declarator-id}, and name lookup\iref{basic.lookup.unqual}
finds that the \grammarterm{unqualified-id} refers to a static
member, enumerator, or nested type of the member's class (or of a base
class of the member's class), the \grammarterm{unqualified-id} is
transformed into a \grammarterm{qualified-id} expression in which the
\grammarterm{nested-name-specifier} names the class scope from which the
member is referenced.
\begin{note}
See~\ref{expr.prim.id} for restrictions on the use of non-static data
members and non-static member functions.
\end{note}


\pnum
Static members obey the usual class member access rules\iref{class.access}.
When used in the declaration of a class
member, the \tcode{static} specifier shall only be used in the member
declarations that appear within the \grammarterm{member-specification} of
the class definition.
\begin{note}
It cannot be specified in member declarations that appear in namespace scope.
\end{note}

\rSec3[class.static.mfct]{Static member functions}
\indextext{member function!static}%

\pnum
\begin{note}
The rules described in~\ref{class.mfct} apply to static member
functions.
\end{note}

\pnum
\begin{note}
A static member function does not have a \tcode{this}
pointer\iref{class.this}.
\end{note}
A static member function shall not be \tcode{virtual}. There
shall not be a static and a non-static member function with the
same name and the same parameter types\iref{over.load}. A
static member function shall not be declared \tcode{const},
\tcode{volatile}, or \tcode{const volatile}.

\rSec3[class.static.data]{Static data members}
\indextext{member data!static}%

\pnum
A static data member is not part of the subobjects of a class. If a
static data member is declared \tcode{thread_local} there is one copy of
the member per thread. If a static data member is not declared
\tcode{thread_local} there is one copy of the data member that is shared by all
the objects of the class.

\pnum
\indextext{initialization!static member}%
\indextext{definition!static member}%
The declaration of a non-inline
static data member in its class definition
is not a definition and may be of an incomplete type other than
\cv{}~\tcode{void}. The definition for a static data
member that is not defined inline in the class definition
shall appear in a namespace scope enclosing the member's class
definition.
\indextext{operator use!scope resolution}%
In the definition at namespace scope, the name of the static
data member shall be qualified by its class name using the \tcode{::}
operator. The \grammarterm{initializer} expression in the definition of a
static data member is in the scope of its
class\iref{basic.scope.class}.
\begin{example}

\begin{codeblock}
class process {
  static process* run_chain;
  static process* running;
};

process* process::running = get_main();
process* process::run_chain = running;
\end{codeblock}

The static data member \tcode{run_chain} of class
\tcode{process} is defined in global scope; the notation
\tcode{process::run_chain} specifies that the member \tcode{run_chain}
is a member of class \tcode{process} and in the scope of class
\tcode{process}. In the static data member definition, the
\grammarterm{initializer} expression refers to the static data
member \tcode{running} of class \tcode{process}.
\end{example}

\begin{note}
Once the static data member has been defined, it exists even if
no objects of its class have been created.
\begin{example}
In the example above, \tcode{run_chain} and \tcode{running} exist even
if no objects of class \tcode{process} are created by the program.
\end{example}
\end{note}

\pnum
If a non-volatile non-inline \tcode{const} static data member is
of integral or enumeration type,
its declaration in the class definition can specify a
\grammarterm{brace-or-equal-initializer} in which every
\grammarterm{initializer-clause} that is an \grammarterm{assignment-expression}
is a constant expression\iref{expr.const}.
The member shall still be defined in a namespace scope if
it is odr-used\iref{basic.def.odr} in the program and the
namespace scope definition shall not contain an \grammarterm{initializer}.
An inline static data member may be defined in the class definition
and may specify a \grammarterm{brace-or-equal-initializer}. If the
member is declared with the \tcode{constexpr} specifier, it may be
redeclared in namespace scope with no initializer (this usage is
deprecated; see \ref{depr.static.constexpr}). Declarations of other
static data members shall not specify a \grammarterm{brace-or-equal-initializer}.

\pnum
\begin{note}
There shall be exactly one definition of a static data member
that is odr-used\iref{basic.def.odr} in a program; no diagnostic is required.
\end{note}
Unnamed classes and classes contained directly
or indirectly within unnamed classes shall not contain static
data members.

\pnum
\begin{note}
Static data members of a class in namespace scope have the linkage of the name of the class\iref{basic.link}.
A local class cannot have static data members\iref{class.local}.
\end{note}

\pnum
Static data members are initialized and destroyed exactly like
non-local variables~(\ref{basic.start.static}, \ref{basic.start.dynamic},
\ref{basic.start.term}).

\pnum
A static data member shall not be
\tcode{mutable}\iref{dcl.stc}.

\rSec2[class.bit]{Bit-fields}%
\indextext{bit-field}

\pnum
A \grammarterm{member-declarator} of the form

\begin{ncsimplebnf}
\opt{identifier} \opt{attribute-specifier-seq} \terminal{:} constant-expression \opt{brace-or-equal-initializer}
\end{ncsimplebnf}

\indextext{\idxcode{:}!bit-field declaration}%
\indextext{declaration!bit-field}%
specifies a bit-field.
The optional \grammarterm{attribute-specifier-seq} appertains
to the entity being declared.
A bit-field shall not be a static member.
\indextext{bit-field!type of}%
A bit-field shall have integral or enumeration type;
the bit-field semantic property is not part of the type of the class member.
The \grammarterm{constant-expression} shall be an integral constant expression
with a value greater than or equal to zero and
is called the \defn{width} of the bit-field.
If the width of a bit-field is larger than
the width of the bit-field's type
(or, in case of an enumeration type, of its underlying type),
the extra bits are padding bits\iref{basic.types}.
\indextext{allocation!implementation-defined bit-field}%
Allocation of bit-fields within a class object is
\impldef{allocation of bit-fields within a class object}.
\indextext{bit-field!implementation-defined alignment of}%
Alignment of bit-fields is \impldef{alignment of bit-fields within a class object}.
\indextext{layout!bit-field}%
Bit-fields are packed into some addressable allocation unit.
\begin{note}
Bit-fields straddle allocation units on some machines and not on others.
Bit-fields are assigned right-to-left on some machines, left-to-right on
others.
\end{note}

\pnum
\indextext{bit-field!unnamed}%
A declaration for a bit-field that omits the \grammarterm{identifier}
declares an \defn{unnamed bit-field}. Unnamed bit-fields are not
members and cannot be initialized.
An unnamed bit-field shall not be declared with a cv-qualified type.
\begin{note}
An unnamed bit-field is useful for padding to conform to
externally-imposed layouts.
\end{note}
\indextext{bit-field!zero width of}%
\indextext{bit-field!alignment of}%
As a special case, an unnamed bit-field with a width of zero specifies
alignment of the next bit-field at an allocation unit boundary. Only
when declaring an unnamed bit-field may the width be zero.

\pnum
\indextext{bit-field!address of}%
The address-of operator \tcode{\&} shall not be applied to a bit-field,
so there are no pointers to bit-fields.
\indextext{restriction!bit-field}%
\indextext{restriction!address of bit-field}%
\indextext{restriction!pointer to bit-field}%
A non-const reference shall not be bound to a
bit-field\iref{dcl.init.ref}.
\begin{note}
If the initializer for a reference of type \tcode{const} \tcode{T\&} is
an lvalue that refers to a bit-field, the reference is bound to a
temporary initialized to hold the value of the bit-field; the reference
is not bound to the bit-field directly. See~\ref{dcl.init.ref}.
\end{note}

\pnum
If a value of integral type (other than \tcode{bool}) is stored
into a bit-field of width $N$ and the value would be representable
in a hypothetical signed or unsigned integer type
with width $N$ and the same signedness as the bit-field's type,
the original value and the value of the bit-field compare equal.
If the value \tcode{true} or \tcode{false} is stored into a bit-field of
type \tcode{bool} of any size (including a one bit bit-field), the
original \tcode{bool} value and the value of the bit-field compare
equal. If a value of an enumeration type is stored into a bit-field of the
same type and the width is large
enough to hold all the values of that enumeration type\iref{dcl.enum},
the original value and the value of the bit-field compare equal.
\begin{example}

\begin{codeblock}
enum BOOL { FALSE=0, TRUE=1 };
struct A {
  BOOL b:1;
};
A a;
void f() {
  a.b = TRUE;
  if (a.b == TRUE)              // yields \tcode{true}
    { @\commentellip@ }
}
\end{codeblock}
\end{example}

\rSec2[class.nest]{Nested class declarations}%
\indextext{definition!nested class}%
\indextext{class!nested|see{nested class}}

\pnum
A class can be declared within another class. A class declared within
another is called a \defnadj{nested}{class}. The name of a nested class
is local to its enclosing class.
\indextext{nested class!scope of}%
The nested class is in the scope of its enclosing class.
\begin{note}
See~\ref{expr.prim.id} for restrictions on the use of non-static data
members and non-static member functions.
\end{note}

\begin{example}
\begin{codeblock}
int x;
int y;

struct enclose {
  int x;
  static int s;

  struct inner {
    void f(int i) {
      int a = sizeof(x);        // OK: operand of sizeof is an unevaluated operand
      x = i;                    // error: assign to \tcode{enclose::x}
      s = i;                    // OK: assign to \tcode{enclose::s}
      ::x = i;                  // OK: assign to global \tcode{x}
      y = i;                    // OK: assign to global \tcode{y}
    }
    void g(enclose* p, int i) {
      p->x = i;                 // OK: assign to \tcode{enclose::x}
    }
  };
};

inner* p = 0;                   // error: \tcode{inner} not in scope
\end{codeblock}
\end{example}

\pnum
Member functions and static data members of a nested class can be
defined in a namespace scope enclosing the definition of their class.
\begin{example}
\begin{codeblock}
struct enclose {
  struct inner {
    static int x;
    void f(int i);
  };
};

int enclose::inner::x = 1;

void enclose::inner::f(int i) { @\commentellip@ }
\end{codeblock}
\end{example}

\pnum
If class \tcode{X} is defined in a namespace scope, a nested class
\tcode{Y} may be declared in class \tcode{X} and later defined in the
definition of class \tcode{X} or be later defined in a namespace scope
enclosing the definition of class \tcode{X}.
\begin{example}
\begin{codeblock}
class E {
  class I1;                     // forward declaration of nested class
  class I2;
  class I1 { };                 // definition of nested class
};
class E::I2 { };                // definition of nested class
\end{codeblock}
\end{example}

\pnum
\indextext{friend function!nested class}%
Like a member function, a friend function\iref{class.friend} defined
within a nested class is in the lexical scope of that class; it obeys
the same rules for name binding as a static member function of that
class\iref{class.static}, but it has no special access rights to
members of an enclosing class.

\rSec2[class.nested.type]{Nested type names}
\indextext{type name!nested}%
\indextext{type name!nested!scope of}%

\pnum
Type names obey exactly the same scope rules as other names. In
particular, type names defined within a class definition cannot be used
outside their class without qualification.
\begin{example}
\begin{codeblock}
struct X {
  typedef int I;
  class Y { @\commentellip@ };
  I a;
};

I b;                            // error
Y c;                            // error
X::Y d;                         // OK
X::I e;                         // OK
\end{codeblock}
\end{example}%
\indextext{class|)}

\rSec1[class.union]{Unions}%
\indextext{\idxcode{union}}

\pnum
In a union,
a non-static data member is \defnx{active}{active!union member}
if its name refers to an object
whose lifetime has begun and has not ended\iref{basic.life}.
At most one of the non-static data members of an object of union type
can be active at any
time, that is, the value of at most one of the non-static data members can be
stored in a union at any time. \begin{note} One special guarantee is made in order to
simplify the use of unions: If a standard-layout union contains several standard-layout
structs that share a common initial sequence\iref{class.mem}, and
if a non-static data member of an object of this standard-layout union type
is active and is one of the standard-layout structs,
it is permitted to inspect the common initial sequence
of any of the standard-layout struct members;
see~\ref{class.mem}.
\end{note}

\pnum
The size of a union is sufficient to contain the largest
of its non-static data members. Each non-static data member is allocated
as if it were the sole member of a non-union class.
\begin{note}
A union object and its non-static data members are
pointer-interconvertible~(\ref{basic.compound}, \ref{expr.static.cast}).
As a consequence, all non-static data members of a
union object have the same address.
\end{note}

\pnum
\indextext{member function!\idxcode{union}}%
\indextext{constructor!\idxcode{union}}%
\indextext{destructor!\idxcode{union}}%
A union can have member functions (including constructors and destructors),
\indextext{restriction!\idxcode{union}}%
but it shall not have virtual\iref{class.virtual} functions. A union shall not have
base classes. A union shall not be used as a base class.
\indextext{restriction!\idxcode{union}}%
If a union contains a non-static data member of
reference type the program is ill-formed.
\begin{note} Absent default member initializers\iref{class.mem},
if any non-static data member of a union has a non-trivial
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}, the corresponding member function
of the union must be user-provided or it will
be implicitly deleted\iref{dcl.fct.def.delete} for the union. \end{note}

\pnum
\begin{example} Consider the following union:

\begin{codeblock}
union U {
  int i;
  float f;
  std::string s;
};
\end{codeblock}

Since \tcode{std::string}\iref{string.classes} declares non-trivial versions of all of the special
member functions, \tcode{U} will have an implicitly deleted default constructor,
copy/move constructor,
copy/move assignment operator, and destructor.
To use \tcode{U}, some or all of these member functions
must be user-provided.\end{example}

\pnum
When the left operand of an assignment operator
involves a member access expression\iref{expr.ref}
that nominates a union member,
it may begin the lifetime of that union member,
as described below.
For an expression \tcode{E},
define the set $S(\mathtt{E})$
of subexpressions of \tcode{E}
as follows:
\begin{itemize}
\item
If \tcode{E} is of the form \tcode{A.B},
$S(\mathtt{E})$ contains the elements of $S(\mathtt{A})$,
and also contains \tcode{A.B}
if \tcode{B} names a union member of a non-class, non-array type,
or of a class type with a trivial default constructor that is not deleted,
or an array of such types.
\item
If \tcode{E} is of the form \tcode{A[B]}
and is interpreted as a built-in array subscripting operator,
$S(\mathtt{E})$ is $S(\mathtt{A})$ if \tcode{A} is of array type,
$S(\mathtt{B})$ if \tcode{B} is of array type,
and empty otherwise.
\item
Otherwise, $S(\mathtt{E})$ is empty.
\end{itemize}
In an assignment expression of the form \tcode{E1 = E2}
that uses either the built-in assignment operator\iref{expr.ass}
or a trivial assignment operator\iref{class.copy.assign},
for each element \tcode{X} of $S($\tcode{E1}$)$,
if modification of \tcode{X} would have undefined behavior under~\ref{basic.life},
an object of the type of \tcode{X} is implicitly created
in the nominated storage;
no initialization is performed and
the beginning of its lifetime is sequenced after
the value computation of the left and right operands
and before the assignment.
\begin{note}
This ends the lifetime of the previously-active
member of the union, if any\iref{basic.life}.
\end{note}
\begin{example}
\begin{codeblock}
union A { int x; int y[4]; };
struct B { A a; };
union C { B b; int k; };
int f() {
  C c;                  // does not start lifetime of any union member
  c.b.a.y[3] = 4;       // OK: $S($\tcode{c.b.a.y[3]}$)$ contains \tcode{c.b} and \tcode{c.b.a.y};
                        // creates objects to hold union members \tcode{c.b} and \tcode{c.b.a.y}
  return c.b.a.y[3];    // OK: \tcode{c.b.a.y} refers to newly created object (see \ref{basic.life})
}

struct X { const int a; int b; };
union Y { X x; int k; };
void g() {
  Y y = { { 1, 2 } };   // OK, \tcode{y.x} is active union member\iref{class.mem}
  int n = y.x.a;
  y.k = 4;              // OK: ends lifetime of \tcode{y.x}, \tcode{y.k} is active member of union
  y.x.b = n;            // undefined behavior: \tcode{y.x.b} modified outside its lifetime,
                        // $S($\tcode{y.x.b}$)$ is empty because \tcode{X}'s default constructor is deleted,
                        // so union member \tcode{y.x}'s lifetime does not implicitly start
}
\end{codeblock}
\end{example}

\pnum
\begin{note} In general, one must use explicit destructor calls and placement
\grammarterm{new-expression} to change the active member of a union. \end{note}
\begin{example}
Consider an object \tcode{u} of a \tcode{union} type \tcode{U} having non-static data members
\tcode{m} of type \tcode{M} and \tcode{n} of type \tcode{N}. If \tcode{M} has a non-trivial
destructor and \tcode{N} has a non-trivial constructor (for instance, if they declare or inherit
virtual functions), the active member of \tcode{u} can be safely switched from \tcode{m} to
\tcode{n} using the destructor and placement \grammarterm{new-expression} as follows:

\begin{codeblock}
u.m.~M();
new (&u.n) N;
\end{codeblock}
\end{example}

\rSec2[class.union.anon]{Anonymous unions}
\indextext{\idxcode{union}!anonymous}%

\pnum
A union of the form

\begin{ncsimplebnf}
\keyword{union} \terminal{\{} member-specification \terminal{\}} \terminal{;}
\end{ncsimplebnf}

is called an \defn{anonymous union}; it defines an unnamed type and
an unnamed object of that type called an \defn{anonymous union object}.
Each \grammarterm{member-declaration} in the \grammarterm{member-specification}
of an anonymous union shall either define a non-static data member or be a
\grammarterm{static_assert-declaration}.
\begin{note}
Nested types, anonymous unions, and functions cannot be declared within an anonymous
union.
\end{note}
The names of the members of an anonymous union shall be distinct from
the names of any other entity in the scope in which the anonymous union
is declared. For the purpose of name lookup, after the anonymous union
definition, the members of the anonymous union are considered to have
been defined in the scope in which the anonymous union is declared.
\indextext{initialization!\idxcode{union}}%
\begin{example}

\begin{codeblock}
void f() {
  union { int a; const char* p; };
  a = 1;
  p = "Jennifer";
}
\end{codeblock}

Here \tcode{a} and \tcode{p} are used like ordinary (non-member)
variables, but since they are union members they have the same address.
\end{example}

\pnum
\indextext{\idxcode{union}!global anonymous}%
\indextext{scope!anonymous \tcode{union} at namespace}%
Anonymous unions declared in a named namespace or in the global
namespace shall be declared \tcode{static}. Anonymous unions declared at
block scope shall be declared with any storage class allowed for a
block-scope variable, or with no storage class. A storage class is not
allowed in a declaration of an anonymous union in a class scope.
\indextext{access control!anonymous \tcode{union}}%
\indextext{restriction!anonymous \tcode{union}}%
An anonymous union shall not have private or protected
members\iref{class.access}. An anonymous union shall not have
member functions.

\pnum
A union for which objects, pointers, or references are declared is not an anonymous union.
\begin{example}

\begin{codeblock}
void f() {
  union { int aa; char* p; } obj, *ptr = &obj;
  aa = 1;           // error
  ptr->aa = 1;      // OK
}
\end{codeblock}

The assignment to plain \tcode{aa} is ill-formed since the member name
is not visible outside the union, and even if it were visible, it is not
associated with any particular object.
\end{example}
\begin{note}
Initialization of unions with no user-declared constructors is described
in~\ref{dcl.init.aggr}.
\end{note}

\pnum
\indextext{class!union-like}%
\indextext{class!variant member of}%
A \defn{union-like class} is a union or a class that has an anonymous union as a direct
member. A union-like class \tcode{X} has a set of \defnx{variant members}{variant member}.
If \tcode{X} is a union, a non-static data member of \tcode{X} that is not an anonymous
union is a variant member of \tcode{X}. In addition, a non-static data member of an
anonymous union that is a member of \tcode{X} is also a variant member of \tcode{X}.
At most one variant member of a union may have a default member initializer.
\begin{example}
\begin{codeblock}
union U {
  int x = 0;
  union {
    int k;
  };
  union {
    int z;
    int y = 1;      // error: initialization for second variant member of \tcode{U}
  };
};
\end{codeblock}
\end{example}

\rSec1[class.local]{Local class declarations}
\indextext{declaration!local class}%
\indextext{definition!local class}%
\indextext{class!local|see{local class}}%

\pnum
A class can be declared within a function definition; such a class is
called a \defnadj{local}{class}. The name of a local class is local to
its enclosing scope.
\indextext{local class!scope of}%
The local class is in the scope of the enclosing scope, and has the same
access to names outside the function as does the enclosing function.
\begin{note}
A declaration in a local class
cannot odr-use\iref{basic.def.odr}
a local entity
from an
enclosing scope.
\end{note}
\begin{example}
\begin{codeblock}
int x;
void f() {
  static int s;
  int x;
  const int N = 5;
  extern int q();
  int arr[2];
  auto [y, z] = arr;

  struct local {
    int g() { return x; }       // error: odr-use of non-odr-usable variable \tcode{x}
    int h() { return s; }       // OK
    int k() { return ::x; }     // OK
    int l() { return q(); }     // OK
    int m() { return N; }       // OK: not an odr-use
    int* n() { return &N; }     // error: odr-use of non-odr-usable variable \tcode{N}
    int p() { return y; }       // error: odr-use of non-odr-usable structured binding \tcode{y}
  };
}

local* p = 0;                   // error: \tcode{local} not in scope
\end{codeblock}
\end{example}

\pnum
An enclosing function has no special access to members of the local
class; it obeys the usual access rules\iref{class.access}.
\indextext{member function!local class}%
Member functions of a local class shall be defined within their class
definition, if they are defined at all.

\pnum
\indextext{nested class!local class}%
If class \tcode{X} is a local class a nested class \tcode{Y} may be
declared in class \tcode{X} and later defined in the definition of class
\tcode{X} or be later defined in the same scope as the definition of
class \tcode{X}.
\indextext{restriction!local class}%
A class nested within
a local class is a local class.

\pnum
\indextext{restriction!static member local class}%
A local class shall not have static data members.

\rSec1[class.derived]{Derived classes}%
\indextext{derived class|(}

\indextext{virtual base class|see{base class, virtual}}
\indextext{virtual function|see{function, virtual}}
\indextext{dynamic binding|see{function, virtual}}

\pnum
\indextext{base class}%
\indextext{inheritance}%
\indextext{multiple inheritance}%
A list of base classes can be specified in a class definition using
the notation:

\begin{bnf}
\nontermdef{base-clause}\br
    \terminal{:} base-specifier-list
\end{bnf}


\begin{bnf}
\nontermdef{base-specifier-list}\br
    base-specifier \opt{\terminal{...}}\br
    base-specifier-list \terminal{,} base-specifier \opt{\terminal{...}}
\end{bnf}

\begin{bnf}
\nontermdef{base-specifier}\br
    \opt{attribute-specifier-seq} class-or-decltype\br
    \opt{attribute-specifier-seq} \keyword{virtual} \opt{access-specifier} class-or-decltype\br
    \opt{attribute-specifier-seq} access-specifier \opt{\keyword{virtual}} class-or-decltype
\end{bnf}

\begin{bnf}
\nontermdef{class-or-decltype}\br
    \opt{nested-name-specifier} type-name\br
    nested-name-specifier \keyword{template} simple-template-id\br
    decltype-specifier
\end{bnf}

\indextext{specifier access|see{access specifier}}%
%
\begin{bnf}
\nontermdef{access-specifier}\br
    \keyword{private}\br
    \keyword{protected}\br
    \keyword{public}
\end{bnf}

The optional \grammarterm{attribute-specifier-seq} appertains to the \grammarterm{base-specifier}.

\pnum
\indextext{type!incomplete}%
A \grammarterm{class-or-decltype} shall denote
a (possibly cv-qualified) class type that is not
an incompletely defined class\iref{class.mem};
any cv-qualifiers are ignored.
The class denoted by the \grammarterm{class-or-decltype} of
a \grammarterm{base-specifier} is called a
\defnadj{direct}{base class}
for the class being defined.
\indextext{base class}%
\indextext{derivation|see{inheritance}}%
During the lookup for a base class name, non-type names are
ignored\iref{basic.scope.hiding}.
A class \tcode{B} is a
base class of a class \tcode{D} if it is a direct base class of
\tcode{D} or a direct base class of one of \tcode{D}'s base classes.
A class is an \defnadj{indirect}{base class} of another if it is a base
class but not a direct base class. A class is said to be (directly or
indirectly) \term{derived} from its (direct or indirect) base
classes.
\begin{note}
See \ref{class.access} for the meaning of
\grammarterm{access-specifier}.
\end{note}
\indextext{access control!base class member}%
Unless redeclared in the derived class, members of a base class are also
considered to be members of the derived class.
Members of a base class other than constructors are said to be
\defnx{inherited}{inheritance}
by the derived class. Constructors of a base class
can also be inherited as described in~\ref{namespace.udecl}.
Inherited members can be referred to in
expressions in the same manner as other members of the derived class,
unless their names are hidden or ambiguous\iref{class.member.lookup}.
\indextext{operator!scope resolution}%
\begin{note}
The scope resolution operator \tcode{::}\iref{expr.prim.id.qual} can be used
to refer to a direct or indirect base member explicitly. This allows
access to a name that has been redeclared in the derived class. A
derived class can itself serve as a base class subject to access
control; see~\ref{class.access.base}. A pointer to a derived class can be
implicitly converted to a pointer to an accessible unambiguous base
class\iref{conv.ptr}. An lvalue of a derived class type can be bound
to a reference to an accessible unambiguous base
class\iref{dcl.init.ref}.
\end{note}

\pnum
The \grammarterm{base-specifier-list} specifies the type of the
\term{base class subobjects} contained in an
object of the derived class type.
\begin{example}
\begin{codeblock}
struct Base {
  int a, b, c;
};
\end{codeblock}

\begin{codeblock}
struct Derived : Base {
  int b;
};
\end{codeblock}

\begin{codeblock}
struct Derived2 : Derived {
  int c;
};
\end{codeblock}

Here, an object of class \tcode{Derived2} will have a subobject of class
\tcode{Derived} which in turn will have a subobject of class
\tcode{Base}.
\end{example}

\pnum
A \grammarterm{base-specifier} followed by an ellipsis is a pack
expansion\iref{temp.variadic}.

\pnum
The order in which the base class subobjects are allocated in the most
derived object\iref{intro.object} is unspecified.
\begin{note}
\indextext{directed acyclic graph|see{DAG}}%
\indextext{lattice|see{DAG, subobject}}%
A derived class and its base class subobjects can be represented by a
directed acyclic graph (DAG) where an arrow means ``directly derived
from''. An arrow need not have a physical representation in memory.
A DAG of subobjects is often referred to as a ``subobject lattice''.

\begin{importgraphic}
{Directed acyclic graph}
{class.dag}
{figdag.pdf}
\end{importgraphic}
\end{note}

\pnum
\begin{note}
Initialization of objects representing base classes can be specified in
constructors; see~\ref{class.base.init}.
\end{note}

\pnum
\begin{note}
A base class subobject might have a layout\iref{basic.stc} different
from the layout of a most derived object of the same type. A base class
subobject might have a polymorphic behavior\iref{class.cdtor}
different from the polymorphic behavior of a most derived object of the
same type. A base class subobject may be of zero size\iref{class};
however, two subobjects that have the same class type and that belong to
the same most derived object must not be allocated at the same
address\iref{expr.eq}.
\end{note}

\rSec2[class.mi]{Multiple base classes}
\indextext{multiple inheritance}%
\indextext{base class}%

\pnum
A class can be derived from any number of base classes.
\begin{note}
The use of more than one direct base class is often called multiple inheritance.
\end{note}
\begin{example}
\begin{codeblock}
class A { @\commentellip@ };
class B { @\commentellip@ };
class C { @\commentellip@ };
class D : public A, public B, public C { @\commentellip@ };
\end{codeblock}
\end{example}

\pnum
\indextext{layout!class object}%
\indextext{initialization!order of}%
\begin{note}
The order of derivation is not significant except as specified by the
semantics of initialization by constructor\iref{class.base.init},
cleanup\iref{class.dtor}, and storage
layout~(\ref{class.mem}, \ref{class.access.spec}).
\end{note}

\pnum
A class shall not be specified as a direct base class of a derived class
more than once.
\begin{note}
A class can be an indirect base class more than once and can be a direct
and an indirect base class. There are limited things that can be done
with such a class. The non-static data members and member functions of
the direct base class cannot be referred to in the scope of the derived
class. However, the static members, enumerations and types can be
unambiguously referred to.
\end{note}
\begin{example}
\begin{codeblock}
class X { @\commentellip@ };
class Y : public X, public X { @\commentellip@ };             // ill-formed

\end{codeblock}
\begin{codeblock}
class L { public: int next;  @\commentellip@ };
class A : public L { @\commentellip@ };
class B : public L { @\commentellip@ };
class C : public A, public B { void f(); @\commentellip@ };   // well-formed
class D : public A, public L { void f(); @\commentellip@ };   // well-formed
\end{codeblock}
\end{example}

\pnum
\indextext{base class!virtual}%
A base class specifier that does not contain the keyword
\tcode{virtual} specifies a \defnadj{non-virtual}{base class}. A base
class specifier that contains the keyword \tcode{virtual} specifies a
\defnadj{virtual}{base class}. For each distinct occurrence of a
non-virtual base class in the class lattice of the most derived class,
the most derived object\iref{intro.object} shall contain a
corresponding distinct base class subobject of that type. For each
distinct base class that is specified virtual, the most derived object
shall contain a single base class subobject of that type.

\pnum
\begin{note}
For an object of class type \tcode{C}, each distinct occurrence of a
(non-virtual) base class \tcode{L} in the class lattice of \tcode{C}
corresponds one-to-one with a distinct \tcode{L} subobject within the
object of type \tcode{C}. Given the class \tcode{C} defined above, an
object of class \tcode{C} will have two subobjects of class \tcode{L} as
shown in \fref{class.nonvirt}.

\begin{importgraphic}
{Non-virtual base}
{class.nonvirt}
{fignonvirt.pdf}
\end{importgraphic}

In such lattices, explicit qualification can be used to specify which
subobject is meant. The body of function \tcode{C::f} could refer to the
member \tcode{next} of each \tcode{L} subobject:
\begin{codeblock}
void C::f() { A::next = B::next; }      // well-formed
\end{codeblock}
Without the \tcode{A::} or \tcode{B::} qualifiers, the definition of
\tcode{C::f} above would be ill-formed because of
ambiguity\iref{class.member.lookup}.
\end{note}

\pnum
\begin{note}
In contrast, consider the case with a virtual base class:
\begin{codeblock}
class V { @\commentellip@ };
class A : virtual public V { @\commentellip@ };
class B : virtual public V { @\commentellip@ };
class C : public A, public B { @\commentellip@ };
\end{codeblock}
\begin{importgraphic}
{Virtual base}
{class.virt}
{figvirt.pdf}
\end{importgraphic}
For an object \tcode{c} of class type \tcode{C}, a single subobject of
type \tcode{V} is shared by every base class subobject of \tcode{c} that has a
\tcode{virtual} base class of type \tcode{V}. Given the class \tcode{C}
defined above, an object of class \tcode{C} will have one subobject of
class \tcode{V}, as shown in \fref{class.virt}.
\indextext{DAG!multiple inheritance}%
\indextext{DAG!virtual base class}%
\end{note}

\pnum
\begin{note}
A class can have both virtual and non-virtual base classes of a given
type.
\begin{codeblock}
class B { @\commentellip@ };
class X : virtual public B { @\commentellip@ };
class Y : virtual public B { @\commentellip@ };
class Z : public B { @\commentellip@ };
class AA : public X, public Y, public Z { @\commentellip@ };
\end{codeblock}
For an object of class \tcode{AA}, all \tcode{virtual} occurrences of
base class \tcode{B} in the class lattice of \tcode{AA} correspond to a
single \tcode{B} subobject within the object of type \tcode{AA}, and
every other occurrence of a (non-virtual) base class \tcode{B} in the
class lattice of \tcode{AA} corresponds one-to-one with a distinct
\tcode{B} subobject within the object of type \tcode{AA}. Given the
class \tcode{AA} defined above, class \tcode{AA} has two subobjects of
class \tcode{B}: \tcode{Z}'s \tcode{B} and the virtual \tcode{B} shared
by \tcode{X} and \tcode{Y}, as shown in \fref{class.virtnonvirt}.

\indextext{DAG!virtual base class}%
\indextext{DAG!non-virtual base class}%
\indextext{DAG!multiple inheritance}%
\begin{importgraphic}
{Virtual and non-virtual base}
{class.virtnonvirt}
{figvirtnonvirt.pdf}
\end{importgraphic}
\end{note}

\rSec2[class.virtual]{Virtual functions}%
\indextext{function!virtual|(}%
\indextext{type!polymorphic}%

\pnum
A non-static member function is a \defnadj{virtual}{function}
if it is first declared with the keyword \tcode{virtual} or
if it overrides a virtual member function declared in a base class
(see below).\footnote{The use of the \tcode{virtual} specifier in the
declaration of an overriding function is valid but redundant (has empty
semantics).}
\begin{note}
Virtual functions support dynamic binding and object-oriented
programming. \end{note} A class that declares or inherits a virtual function is
called a \defnadj{polymorphic}{class}.\footnote{If
all virtual functions are immediate functions,
the class is still polymorphic even though
its internal representation might not otherwise require
any additions for that polymorphic behavior.}

\pnum
If a virtual member function \tcode{vf} is declared in a class
\tcode{Base} and in a class \tcode{Derived}, derived directly or
indirectly from \tcode{Base}, a member function \tcode{vf} with the same
name, parameter-type-list\iref{dcl.fct}, cv-qualification, and ref-qualifier
(or absence of same) as \tcode{Base::vf} is declared,
then \tcode{Derived::vf} \term{overrides}\footnote{A function
with the same name but a different parameter list\iref{over}
as a virtual function is not necessarily virtual and
does not override. Access control\iref{class.access} is not considered in
determining overriding.}
\tcode{Base::vf}. For convenience we say that any virtual function
overrides itself.
\indextext{overrider!final}%
A virtual member function \tcode{C::vf} of a class object \tcode{S} is a \defn{final
overrider} unless the most derived class\iref{intro.object} of which \tcode{S} is a
base class subobject (if any) declares or inherits another member function that overrides
\tcode{vf}. In a derived class, if a virtual member function of a base class subobject
has more than one final overrider the program is ill-formed.
\begin{example}
\begin{codeblock}
struct A {
  virtual void f();
};
struct B : virtual A {
  virtual void f();
};
struct C : B , virtual A {
  using A::f;
};

void foo() {
  C c;
  c.f();              // calls \tcode{B::f}, the final overrider
  c.C::f();           // calls \tcode{A::f} because of the using-declaration
}
\end{codeblock}
\end{example}

\begin{example}
\begin{codeblock}
struct A { virtual void f(); };
struct B : A { };
struct C : A { void f(); };
struct D : B, C { };  // OK: \tcode{A::f} and \tcode{C::f} are the final overriders
                      // for the \tcode{B} and \tcode{C} subobjects, respectively
\end{codeblock}
\end{example}

\pnum
\begin{note}
A virtual member function does not have to be visible to be overridden,
for example,
\begin{codeblock}
struct B {
  virtual void f();
};
struct D : B {
  void f(int);
};
struct D2 : D {
  void f();
};
\end{codeblock}
the function \tcode{f(int)} in class \tcode{D} hides the virtual
function \tcode{f()} in its base class \tcode{B}; \tcode{D::f(int)} is
not a virtual function. However, \tcode{f()} declared in class
\tcode{D2} has the same name and the same parameter list as
\tcode{B::f()}, and therefore is a virtual function that overrides the
function \tcode{B::f()} even though \tcode{B::f()} is not visible in
class \tcode{D2}.
\end{note}

\pnum
If a virtual function \tcode{f} in some class \tcode{B} is marked with the
\grammarterm{virt-specifier} \tcode{final} and in a class \tcode{D} derived from \tcode{B}
a function \tcode{D::f} overrides \tcode{B::f}, the program is ill-formed. \begin{example}
\begin{codeblock}
struct B {
  virtual void f() const final;
};

struct D : B {
  void f() const;     // error: \tcode{D::f} attempts to override \tcode{final} \tcode{B::f}
};
\end{codeblock}
\end{example}

\pnum
If a virtual function is marked with the \grammarterm{virt-specifier} \tcode{override} and
does not override a member function of a base class, the program is ill-formed. \begin{example}
\begin{codeblock}
struct B {
  virtual void f(int);
};

struct D : B {
  virtual void f(long) override;  // error: wrong signature overriding \tcode{B::f}
  virtual void f(int) override;   // OK
};
\end{codeblock}
\end{example}

\pnum
A virtual function shall not have a trailing \grammarterm{requires-clause}\iref{dcl.decl}.
\begin{example}
\begin{codeblock}
struct A {
  virtual void f() requires true; // error: virtual function cannot be constrained\iref{temp.constr.decl}
};
\end{codeblock}
\end{example}

\pnum
Even though destructors are not inherited, a destructor in a derived
class overrides a base class destructor declared virtual;
see~\ref{class.dtor} and~\ref{class.free}.

\pnum
The return type of an overriding function shall be either identical to
the return type of the overridden function or \defnx{covariant}{return type!covariant} with
the classes of the functions. If a function \tcode{D::f} overrides a
function \tcode{B::f}, the return types of the functions are covariant
if they satisfy the following criteria:
\begin{itemize}
\item both are pointers to classes, both are lvalue references to
classes, or both are rvalue references to classes\footnote{Multi-level pointers to classes or references to multi-level pointers to
classes are not allowed.%
}

\item the class in the return type of \tcode{B::f} is the same class as
the class in the return type of \tcode{D::f}, or is an unambiguous and
accessible direct or indirect base class of the class in the return type
of \tcode{D::f}

\item both pointers or references have the same cv-qualification and the
class type in the return type of \tcode{D::f} has the same
cv-qualification as or less cv-qualification than the class type in the
return type of \tcode{B::f}.
\end{itemize}

\pnum
If the class type in the covariant return type of \tcode{D::f} differs from that of
\tcode{B::f}, the class type in the return type of \tcode{D::f} shall be
complete at the point of declaration of \tcode{D::f} or shall be the
class type \tcode{D}. When the overriding function is called as the
final overrider of the overridden function, its result is converted to
the type returned by the (statically chosen) overridden
function\iref{expr.call}.
\begin{example}
\begin{codeblock}
class B { };
class D : private B { friend class Derived; };
struct Base {
  virtual void vf1();
  virtual void vf2();
  virtual void vf3();
  virtual B*   vf4();
  virtual B*   vf5();
  void f();
};

struct No_good : public Base {
  D*  vf4();        // error: \tcode{B} (base class of \tcode{D}) inaccessible
};

class A;
struct Derived : public Base {
    void vf1();     // virtual and overrides \tcode{Base::vf1()}
    void vf2(int);  // not virtual, hides \tcode{Base::vf2()}
    char vf3();     // error: invalid difference in return type only
    D*   vf4();     // OK: returns pointer to derived class
    A*   vf5();     // error: returns pointer to incomplete class
    void f();
};

void g() {
  Derived d;
  Base* bp = &d;                // standard conversion:
                                // \tcode{Derived*} to \tcode{Base*}
  bp->vf1();                    // calls \tcode{Derived::vf1()}
  bp->vf2();                    // calls \tcode{Base::vf2()}
  bp->f();                      // calls \tcode{Base::f()} (not virtual)
  B*  p = bp->vf4();            // calls \tcode{Derived::vf4()} and converts the
                                // result to \tcode{B*}
  Derived*  dp = &d;
  D*  q = dp->vf4();            // calls \tcode{Derived::vf4()} and does not
                                // convert the result to \tcode{B*}
  dp->vf2();                    // ill-formed: argument mismatch
}
\end{codeblock}
\end{example}

\pnum
\begin{note}
The interpretation of the call of a virtual function depends on the type
of the object for which it is called (the dynamic type), whereas the
interpretation of a call of a non-virtual member function depends only
on the type of the pointer or reference denoting that object (the static
type)\iref{expr.call}.
\end{note}

\pnum
\begin{note}
The \tcode{virtual} specifier implies membership, so a virtual function
cannot be a non-member\iref{dcl.fct.spec} function. Nor can a virtual
function be a static member, since a virtual function call relies on a
specific object for determining which function to invoke. A virtual
function declared in one class can be declared a friend~(\ref{class.friend}) in
another class.
\end{note}

\pnum
\indextext{definition!virtual function}%
A virtual function declared in a class shall be defined, or declared
pure\iref{class.abstract} in that class, or both; no diagnostic is
required\iref{basic.def.odr}.
\indextext{friend!\tcode{virtual} and}%

\pnum
\indextext{multiple inheritance!\tcode{virtual} and}%
\begin{example}
Here are some uses of virtual functions with multiple base classes:
\begin{codeblock}
struct A {
  virtual void f();
};

struct B1 : A {                 // note non-virtual derivation
  void f();
};

struct B2 : A {
  void f();
};

struct D : B1, B2 {             // \tcode{D} has two separate \tcode{A} subobjects
};

void foo() {
  D   d;
//\tcode{   A*  ap = \&d;}                  // would be ill-formed: ambiguous
  B1*  b1p = &d;
  A*   ap = b1p;
  D*   dp = &d;
  ap->f();                      // calls \tcode{D::B1::f}
  dp->f();                      // ill-formed: ambiguous
}
\end{codeblock}
In class \tcode{D} above there are two occurrences of class \tcode{A}
and hence two occurrences of the virtual member function \tcode{A::f}.
The final overrider of \tcode{B1::A::f} is \tcode{B1::f} and the final
overrider of \tcode{B2::A::f} is \tcode{B2::f}.
\end{example}

\pnum
\begin{example}
The following example shows a function that does not have a unique final
overrider:
\begin{codeblock}
struct A {
  virtual void f();
};

struct VB1 : virtual A {        // note virtual derivation
  void f();
};

struct VB2 : virtual A {
  void f();
};

struct Error : VB1, VB2 {       // ill-formed
};

struct Okay : VB1, VB2 {
  void f();
};
\end{codeblock}
Both \tcode{VB1::f} and \tcode{VB2::f} override \tcode{A::f} but there
is no overrider of both of them in class \tcode{Error}. This example is
therefore ill-formed. Class \tcode{Okay} is well-formed, however,
because \tcode{Okay::f} is a final overrider.
\end{example}

\pnum
\begin{example}
The following example uses the well-formed classes from above.
\begin{codeblock}
struct VB1a : virtual A {       // does not declare \tcode{f}
};

struct Da : VB1a, VB2 {
};

void foe() {
  VB1a*  vb1ap = new Da;
  vb1ap->f();                   // calls \tcode{VB2::f}
}
\end{codeblock}
\end{example}

\pnum
\indextext{operator!scope resolution}%
\indextext{virtual function call}%
Explicit qualification with the scope operator\iref{expr.prim.id.qual}
suppresses the virtual call mechanism.
\begin{example}
\begin{codeblock}
class B { public: virtual void f(); };
class D : public B { public: void f(); };

void D::f() { @\commentellip@ B::f(); }
\end{codeblock}

Here, the function call in
\tcode{D::f}
really does call
\tcode{B::f}
and not
\tcode{D::f}.
\end{example}

\pnum
A function with a deleted definition\iref{dcl.fct.def} shall
not override a function that does not have a deleted definition. Likewise,
a function that does not have a deleted definition shall not override a
function with a deleted definition.%
\indextext{function!virtual|)}

\pnum
A \tcode{consteval} virtual function shall not override
a virtual function that is not \tcode{consteval}.
A \tcode{consteval} virtual function shall not be overridden by
a virtual function that is not \tcode{consteval}.

\pnum
If an overriding function specifies contract conditions\iref{dcl.attr.contract},
it shall specify the same list of contract conditions as
its overridden functions;
no diagnostic is required
if corresponding conditions will always evaluate to the same value.
Otherwise, it is considered to have
the list of contract conditions from one of its overridden functions;
the names in the contract conditions are bound,
and the semantic constraints are checked,
at the point where the contract conditions appear.
Given a virtual function \tcode{f}
with a contract condition that odr-uses \tcode{*this}\iref{basic.def.odr},
the class of which \tcode{f} is a direct member
shall be be an unambiguous and accessible base class of any class
in which \tcode{f} is overridden.
If a function overrides more than one function,
all of the overridden functions shall have
the same list of contract conditions\iref{dcl.attr.contract};
no diagnostic is required
if corresponding conditions will always evaluate to the same value.
\begin{example}
\begin{codeblock}
struct A {
  virtual void g() [[expects: x == 0]];
  int x = 42;
};

int x = 42;
struct B {
  virtual void g() [[expects: x == 0]];
}

struct C : A, B {
  virtual void g();             // error: preconditions of overridden functions are not the same
};
\end{codeblock}
\end{example}

\rSec2[class.abstract]{Abstract classes}%

\pnum
\begin{note}
The abstract class mechanism supports the notion of a general concept,
such as a \tcode{shape}, of which only more concrete variants, such as
\tcode{circle} and \tcode{square}, can actually be used. An abstract
class can also be used to define an interface for which derived classes
provide a variety of implementations.
\end{note}

\pnum
A virtual function is specified as
a \defnx{pure virtual function}{function!virtual!pure} by using a
\grammarterm{pure-specifier}\iref{class.mem} in the function declaration
in the class definition.
\begin{note}
Such a function might be inherited: see below.
\end{note}
A class is an \defnadj{abstract}{class}
if it has at least one pure virtual function.
\begin{note}
An abstract class can be used only as a base class of some other class;
no objects of an abstract class can be created
except as subobjects of a class
derived from it~(\ref{basic.def}, \ref{class.mem}).
\end{note}
\indextext{definition!pure virtual function}%
A pure virtual function need be defined only if called with, or as if
with\iref{class.dtor}, the \grammarterm{qualified-id}
syntax\iref{expr.prim.id.qual}.
\begin{example}
\begin{codeblock}
class point { @\commentellip@ };
class shape {                   // abstract class
  point center;
public:
  point where() { return center; }
  void move(point p) { center=p; draw(); }
  virtual void rotate(int) = 0; // pure virtual
  virtual void draw() = 0;      // pure virtual
};
\end{codeblock}
\end{example}
\begin{note}
A function declaration cannot provide both a \grammarterm{pure-specifier}
and a definition
\end{note}
\begin{example}
\begin{codeblock}
struct C {
  virtual void f() = 0 { };     // ill-formed
};
\end{codeblock}
\end{example}

\pnum
\begin{note}
An abstract class type cannot be used
as a parameter or return type of
a function being defined\iref{dcl.fct} or called\iref{expr.call},
except as specified in \ref{dcl.type.simple}.
Further, an abstract class type cannot be used as
the type of an explicit type conversion~(\ref{expr.static.cast},
\ref{expr.reinterpret.cast}, \ref{expr.const.cast}),
because the resulting prvalue would be of abstract class type\iref{basic.lval}.
However, pointers and references to abstract class types
can appear in such contexts.
\end{note}

\pnum
\indextext{function!virtual!pure}%
A class is abstract if it contains or inherits at least one pure virtual
function for which the final overrider is pure virtual.
\begin{example}
\begin{codeblock}
class ab_circle : public shape {
  int radius;
public:
  void rotate(int) { }
  // \tcode{ab_circle::draw()} is a pure virtual
};
\end{codeblock}

Since \tcode{shape::draw()} is a pure virtual function
\tcode{ab_circle::draw()} is a pure virtual by default. The alternative
declaration,
\begin{codeblock}
class circle : public shape {
  int radius;
public:
  void rotate(int) { }
  void draw();                  // a definition is required somewhere
};
\end{codeblock}
would make class \tcode{circle} non-abstract and a definition of
\tcode{circle::draw()} must be provided.
\end{example}

\pnum
\begin{note}
An abstract class can be derived from a class that is not abstract, and
a pure virtual function may override a virtual function which is not
pure.
\end{note}

\pnum
\indextext{class!constructor and abstract}%
Member functions can be called from a constructor (or destructor) of an
abstract class;
\indextext{virtual function call!undefined pure}%
the effect of making a virtual call\iref{class.virtual} to a pure
virtual function directly or indirectly for the object being created (or
destroyed) from such a constructor (or destructor) is undefined.%
\indextext{derived class|)}

\rSec1[class.member.lookup]{Member name lookup}%
\indextext{lookup!member name}%
\indextext{ambiguity!base class member}%
\indextext{ambiguity!member access}

\pnum
Member name lookup determines the meaning of a name
(\grammarterm{id-expression}) in a class scope\iref{basic.scope.class}.
Name lookup can result in an ambiguity, in which case the
program is ill-formed. For an \grammarterm{unqualified-id}, name lookup
begins in the class scope of \tcode{this}; for a
\grammarterm{qualified-id}, name lookup begins in the scope of the
\grammarterm{nested-name-specifier}. Name lookup takes place before access
control~(\ref{basic.lookup}, \ref{class.access}).

\pnum
The following steps define the result of name lookup for a member name
\tcode{f} in a class scope \tcode{C}.

\pnum
The \term{lookup set} for \tcode{f} in \tcode{C}, called $S(f,C)$,
consists of two component sets: the \term{declaration set}, a set of
members named \tcode{f}; and the \term{subobject set}, a set of
subobjects where declarations of these members (possibly including
\grammarterm{using-declaration}{s}) were found. In the declaration set,
\grammarterm{using-declaration}{s} are replaced by the
set of designated members that are not hidden or overridden by members of the
derived class\iref{namespace.udecl},
and type declarations (including injected-class-names) are
replaced by the types they designate. $S(f,C)$ is calculated as follows:

\pnum
If \tcode{C} contains a declaration of the name \tcode{f}, the
declaration set contains every declaration of \tcode{f} declared in
\tcode{C} that satisfies the requirements of the language construct in
which the lookup occurs.
\begin{note}
Looking up a name in an
\grammarterm{elaborated-type-specifier}\iref{basic.lookup.elab} or
\grammarterm{base-specifier}\iref{class.derived}, for instance,
ignores all non-type declarations, while looking up a name in a
\grammarterm{nested-name-specifier}\iref{basic.lookup.qual} ignores
function, variable, and enumerator declarations. As another example,
looking up a name in a
\grammarterm{using-declaration}\iref{namespace.udecl} includes the
declaration of a class or enumeration that would ordinarily be hidden by
another declaration of that name in the same scope.
\end{note}
If the resulting declaration set is not empty, the subobject set
contains \tcode{C} itself, and calculation is complete.

\pnum
Otherwise (i.e., \tcode{C} does not contain a declaration of \tcode{f}
or the resulting declaration set is empty), $S(f,C)$ is initially empty.
If \tcode{C} has base classes, calculate the lookup set for \tcode{f} in
each direct base class subobject $B_i$, and merge each such lookup set
$S(f,B_i)$ in turn into $S(f,C)$.

\pnum
The following steps define the result of merging lookup set $S(f,B_i)$
into the intermediate $S(f,C)$:

\begin{itemize}
\item If each of the subobject members of $S(f,B_i)$ is a base class
subobject of at least one of the subobject members of $S(f,C)$, or if
$S(f,B_i)$ is empty, $S(f,C)$ is unchanged and the merge is complete.
Conversely, if each of the subobject members of $S(f,C)$ is a base class
subobject of at least one of the subobject members of $S(f,B_i)$, or if
$S(f,C)$ is empty, the new $S(f,C)$ is a copy of $S(f,B_i)$.

\item Otherwise, if the declaration sets of $S(f,B_i)$ and $S(f,C)$
differ, the merge is ambiguous: the new $S(f,C)$ is a lookup set with an
invalid declaration set and the union of the subobject sets. In
subsequent merges, an invalid declaration set is considered different
from any other.

\item Otherwise, the new $S(f,C)$ is a lookup set with the shared set of
declarations and the union of the subobject sets.
\end{itemize}

\pnum
The result of name lookup for \tcode{f} in \tcode{C} is the declaration
set of $S(f,C)$. If it is an invalid set, the program is ill-formed.
\begin{example}
\begin{codeblock}
struct A { int x; };                    // S(x,A) = \{ \{ \tcode{A::x} \}, \{ \tcode{A} \} \}
struct B { float x; };                  // S(x,B) = \{ \{ \tcode{B::x} \}, \{ \tcode{B} \} \}
struct C: public A, public B { };       // S(x,C) = \{ invalid, \{ \tcode{A} in \tcode{C}, \tcode{B} in \tcode{C} \} \}
struct D: public virtual C { };         // S(x,D) = S(x,C)
struct E: public virtual C { char x; }; // S(x,E) = \{ \{ \tcode{E::x} \}, \{ \tcode{E} \} \}
struct F: public D, public E { };       // S(x,F) = S(x,E)
int main() {
  F f;
  f.x = 0;                              // OK, lookup finds \tcode{E::x}
}
\end{codeblock}

$S(x,F)$ is unambiguous because the \tcode{A} and \tcode{B} base
class subobjects of \tcode{D} are also base class subobjects of \tcode{E}, so
$S(x,D)$ is discarded in the first merge step.
\end{example}

\pnum
\indextext{access control!overload resolution and}%
If the name of an overloaded function is unambiguously found,
overload resolution\iref{over.match} also takes place before access
control.
\indextext{overloading!resolution!scoping ambiguity}%
Ambiguities can often be resolved by qualifying a name with its class name.
\begin{example}
\begin{codeblock}
struct A {
  int f();
};

\end{codeblock}
\begin{codeblock}
struct B {
  int f();
};

\end{codeblock}
\begin{codeblock}
struct C : A, B {
  int f() { return A::f() + B::f(); }
};
\end{codeblock}
\end{example}

\pnum
\begin{note}
A static member, a nested type or an enumerator defined in a base class
\tcode{T} can unambiguously be found even if an object has more than one
base class subobject of type \tcode{T}. Two base class subobjects share
the non-static member subobjects of their common virtual base classes.
\end{note}
\begin{example}
\begin{codeblock}
struct V {
  int v;
};
struct A {
  int a;
  static int   s;
  enum { e };
};
struct B : A, virtual V { };
struct C : A, virtual V { };
struct D : B, C { };

void f(D* pd) {
  pd->v++;          // OK: only one \tcode{v} (virtual)
  pd->s++;          // OK: only one \tcode{s} (static)
  int i = pd->e;    // OK: only one \tcode{e} (enumerator)
  pd->a++;          // error, ambiguous: two \tcode{a}{s} in \tcode{D}
}
\end{codeblock}
\end{example}

\pnum
\begin{note}
\indextext{dominance!virtual base class}%
When virtual base classes are used, a hidden declaration can be reached
along a path through the subobject lattice that does not pass through
the hiding declaration. This is not an ambiguity. The identical use with
non-virtual base classes is an ambiguity; in that case there is no
unique instance of the name that hides all the others.
\end{note}
\begin{example}
\begin{codeblock}
struct V { int f();  int x; };
struct W { int g();  int y; };
struct B : virtual V, W {
  int f();  int x;
  int g();  int y;
};
struct C : virtual V, W { };

struct D : B, C { void glorp(); };
\end{codeblock}

\begin{importgraphic}
{Name lookup}
{class.lookup}
{figname.pdf}
\end{importgraphic}

The names declared in \tcode{V} and the left-hand instance of \tcode{W}
are hidden by those in \tcode{B}, but the names declared in the
right-hand instance of \tcode{W} are not hidden at all.
\begin{codeblock}
void D::glorp() {
  x++;              // OK: \tcode{B::x} hides \tcode{V::x}
  f();              // OK: \tcode{B::f()} hides \tcode{V::f()}
  y++;              // error: \tcode{B::y} and \tcode{C}'s \tcode{W::y}
  g();              // error: \tcode{B::g()} and \tcode{C}'s \tcode{W::g()}
}
\end{codeblock}
\end{example}
\indextext{ambiguity!class conversion}%

\pnum
An explicit or implicit conversion from a pointer to or
an expression designating an object
of a
derived class to a pointer or reference to one of its base classes shall
unambiguously refer to a unique object representing the base class.
\begin{example}
\begin{codeblock}
struct V { };
struct A { };
struct B : A, virtual V { };
struct C : A, virtual V { };
struct D : B, C { };

void g() {
  D d;
  B* pb = &d;
  A* pa = &d;       // error, ambiguous: \tcode{C}'s \tcode{A} or \tcode{B}'s \tcode{A}?
  V* pv = &d;       // OK: only one \tcode{V} subobject
}
\end{codeblock}
\end{example}

\pnum
\begin{note}
Even if the result of name lookup is unambiguous, use of a name found in
multiple subobjects might still be
ambiguous~(\ref{conv.mem}, \ref{expr.ref}, \ref{class.access.base}).\end{note}
\begin{example}
\begin{codeblock}
struct B1 {
  void f();
  static void f(int);
  int i;
};
struct B2 {
  void f(double);
};
struct I1: B1 { };
struct I2: B1 { };

struct D: I1, I2, B2 {
  using B1::f;
  using B2::f;
  void g() {
    f();                        // Ambiguous conversion of \tcode{this}
    f(0);                       // Unambiguous (static)
    f(0.0);                     // Unambiguous (only one \tcode{B2})
    int B1::* mpB1 = &D::i;     // Unambiguous
    int D::* mpD = &D::i;       // Ambiguous conversion
  }
};
\end{codeblock}\end{example}

\rSec1[class.access]{Member access control}%
\indextext{access control|(}

\indextext{protection|see{access control}}
\indextext{\idxcode{private}|see{access control, \tcode{private}}}
\indextext{\idxcode{protected}|see{access control, \tcode{protected}}}
\indextext{\idxcode{public}|see{access control, \tcode{public}}}

\pnum
A member of a class can be
\begin{itemize}
\item
\indextext{access control!\idxcode{private}}%
private;
that is, its name can be used only by members and friends
of the class in which it is declared.
\item
\indextext{access control!\idxcode{protected}}%
protected;
that is, its name can be used only by members and friends
of the class in which it is declared, by classes derived from that class, and by their
friends (see~\ref{class.protected}).
\item
\indextext{access control!\idxcode{public}}%
public;
that is, its name can be used anywhere without access restriction.
\end{itemize}

\pnum
A member of a class can also access all the names to which the class has access.
A local class of a member function may access
the same names that the member function itself may access.\footnote{Access
permissions are thus transitive and cumulative to nested
and local classes.}

\pnum
\indextext{access control!member name}%
\indextext{default access control|see{access control, default}}%
\indextext{access control!default}%
Members of a class defined with the keyword
\tcode{class}
are
\tcode{private}
by default.
Members of a class defined with the keywords
\tcode{struct} or \tcode{union}
are public by default.
\begin{example}

\begin{codeblock}
class X {
  int a;            // \tcode{X::a} is private by default
};

struct S {
  int a;            // \tcode{S::a} is public by default
};
\end{codeblock}
\end{example}

\pnum
Access control is applied uniformly to all names, whether the names are
referred to from declarations or expressions.
\begin{note}
Access control applies to names nominated by
friend declarations\iref{class.friend} and
\grammarterm{using-declaration}{s}\iref{namespace.udecl}.
\end{note}
In the case of overloaded function names, access control is applied to
the function selected by overload resolution.
\begin{note}
Because access control applies to names, if access control is applied to a
typedef name, only the accessibility of the typedef name itself is considered.
The accessibility of the entity referred to by the typedef is not considered.
For example,

\begin{codeblock}
class A {
  class B { };
public:
  typedef B BB;
};

void f() {
  A::BB x;          // OK, typedef name \tcode{A::BB} is public
  A::B y;           // access error, \tcode{A::B} is private
}
\end{codeblock}
\end{note}

\pnum
\begin{note}
Access to members and base classes is controlled, not their
visibility\iref{basic.scope.hiding}.
Names of members are still visible, and implicit conversions to base
classes are still considered, when those members and base classes are
inaccessible.
\end{note}
The interpretation of a given construct is
established without regard to access control.
If the interpretation
established makes use of inaccessible member names or base classes,
the construct is ill-formed.

\pnum
All access controls in \ref{class.access} affect the ability to access a class member
name from the declaration of a particular
entity, including parts of the declaration preceding the name of the entity
being declared and, if the entity is a class, the definitions of members of
the class appearing outside the class's \grammarterm{member-specification}{.}
\begin{note} This access also applies to implicit references to constructors,
conversion functions, and destructors. \end{note}

\pnum
\begin{example}
\begin{codeblock}
class A {
  typedef int I;    // private member
  I f();
  friend I g(I);
  static I x;
  template<int> struct Q;
  template<int> friend struct R;
protected:
    struct B { };
};

A::I A::f() { return 0; }
A::I g(A::I p = A::x);
A::I g(A::I p) { return 0; }
A::I A::x = 0;
template<A::I> struct A::Q { };
template<A::I> struct R { };

struct D: A::B, A { };
\end{codeblock}

Here, all the uses of
\tcode{A::I}
are well-formed because
\tcode{A::f},
\tcode{A::x}, and \tcode{A::Q}
are members of class
\tcode{A}
and
\tcode{g}
and \tcode{R} are friends of class
\tcode{A}.
This implies, for example, that access checking on the first use of
\tcode{A::I}
must be deferred until it is determined that this use of
\tcode{A::I}
is as the return type of a member of class
\tcode{A}.
Similarly, the use of \tcode{A::B} as a
\grammarterm{base-specifier} is well-formed because \tcode{D}
is derived from \tcode{A}, so checking of \grammarterm{base-specifier}{s}
must be deferred until the entire \grammarterm{base-specifier-list} has been seen.
\end{example}

\pnum
\indextext{argument!access checking and default}%
\indextext{access control!default argument}%
The names in a default argument\iref{dcl.fct.default} are
bound at the point of declaration, and access is checked at that
point rather than at any points of use of the default argument.
Access checking for default arguments in function templates and in
member functions of class templates is performed as described in~\ref{temp.inst}.

\pnum
The names in a default \grammarterm{template-argument}\iref{temp.param}
have their access checked in the context in which they appear rather than at any
points of use of the default \grammarterm{template-argument}. \begin{example}
\begin{codeblock}
class B { };
template <class T> class C {
protected:
  typedef T TT;
};

template <class U, class V = typename U::TT>
class D : public U { };

D <C<B> >* d;       // access error, \tcode{C::TT} is protected
\end{codeblock}
\end{example}

\rSec2[class.access.spec]{Access specifiers}%
\indextext{access specifier}

\pnum
Member declarations can be labeled by an
\grammarterm{access-specifier}
(\ref{class.derived}):

\begin{ncsimplebnf}
access-specifier \terminal{:} \opt{member-specification}
\end{ncsimplebnf}

An
\grammarterm{access-specifier}
specifies the access rules for members following it
until the end of the class or until another
\grammarterm{access-specifier}
is encountered.
\begin{example}

\begin{codeblock}
class X {
  int a;            // \tcode{X::a} is private by default: \tcode{class} used
public:
  int b;            // \tcode{X::b} is public
  int c;            // \tcode{X::c} is public
};
\end{codeblock}
\end{example}

\pnum
Any number of access specifiers is allowed and no particular order is required.
\begin{example}

\begin{codeblock}
struct S {
  int a;            // \tcode{S::a} is public by default: \tcode{struct} used
protected:
  int b;            // \tcode{S::b} is protected
private:
  int c;            // \tcode{S::c} is private
public:
  int d;            // \tcode{S::d} is public
};
\end{codeblock}
\end{example}

\pnum
\begin{note} The effect of access control on the order of allocation
of data members is described in~\ref{class.mem}.\end{note}

\pnum
When a member is redeclared within its class definition,
the access specified at its redeclaration shall
be the same as at its initial declaration.
\begin{example}

\begin{codeblock}
struct S {
  class A;
  enum E : int;
private:
  class A { };        // error: cannot change access
  enum E: int { e0 }; // error: cannot change access
};
\end{codeblock}
\end{example}

\pnum
\begin{note}
In a derived class, the lookup of a base class name will find the
injected-class-name instead of the name of the base class in the scope
in which it was declared. The injected-class-name might be less accessible
than the name of the base class in the scope in which it was declared.
\end{note}

\begin{example}
\begin{codeblock}
class A { };
class B : private A { };
class C : public B {
  A* p;             // error: injected-class-name \tcode{A} is inaccessible
  ::A* q;           // OK
};
\end{codeblock}
\end{example}

\rSec2[class.access.base]{Accessibility of base classes and base class members}%
\indextext{access control!base class}%
\indextext{access specifier}%
\indextext{base class!\idxcode{private}}%
\indextext{base class!\idxcode{protected}}%
\indextext{base class!\idxcode{public}}

\pnum
If a class is declared to be a base class\iref{class.derived} for another class using the
\tcode{public}
access specifier, the
public members of the base class are accessible as
public members of the derived class and
protected members of the base class are accessible as
protected members of the derived class.
If a class is declared to be a base class for another class using the
\tcode{protected}
access specifier, the
public and protected members of the base class are accessible as
protected members of the derived class.
If a class is declared to be a base class for another class using the
private
access specifier, the
public and protected
members of the base class are accessible as private
members of the derived class.\footnote{As specified previously in \ref{class.access},
private members of a base class remain inaccessible even to derived classes
unless friend
declarations within the base class definition are used to grant access explicitly.}

\pnum
In the absence of an
\grammarterm{access-specifier}
for a base class,
\tcode{public}
is assumed when the derived class is
defined with the \grammarterm{class-key}
\tcode{struct}
and
\tcode{private}
is assumed when the class is
defined with the \grammarterm{class-key}
\tcode{class}.
\begin{example}

\begin{codeblock}
class B { @\commentellip@ };
class D1 : private B { @\commentellip@ };
class D2 : public B { @\commentellip@ };
class D3 : B { @\commentellip@ };             // \tcode{B} private by default
struct D4 : public B { @\commentellip@ };
struct D5 : private B { @\commentellip@ };
struct D6 : B { @\commentellip@ };            // \tcode{B} public by default
class D7 : protected B { @\commentellip@ };
struct D8 : protected B { @\commentellip@ };
\end{codeblock}

Here
\tcode{B}
is a public base of
\tcode{D2},
\tcode{D4},
and
\tcode{D6},
a private base of
\tcode{D1},
\tcode{D3},
and
\tcode{D5},
and a protected base of
\tcode{D7}
and
\tcode{D8}.
\end{example}

\pnum
\begin{note}
A member of a private base class might be inaccessible as an inherited
member name, but accessible directly.
Because of the rules on pointer conversions\iref{conv.ptr} and explicit casts\iref{expr.cast}, a conversion from a pointer to a derived class to a pointer
to an inaccessible base class might be ill-formed if an implicit conversion
is used, but well-formed if an explicit cast is used.
For example,

\begin{codeblock}
class B {
public:
  int mi;                       // non-static member
  static int si;                // static member
};
class D : private B {
};
class DD : public D {
  void f();
};

void DD::f() {
  mi = 3;                       // error: \tcode{mi} is private in \tcode{D}
  si = 3;                       // error: \tcode{si} is private in \tcode{D}
  ::B  b;
  b.mi = 3;                     // OK (\tcode{b.mi} is different from \tcode{this->mi})
  b.si = 3;                     // OK (\tcode{b.si} is different from \tcode{this->si})
  ::B::si = 3;                  // OK
  ::B* bp1 = this;              // error: \tcode{B} is a private base class
  ::B* bp2 = (::B*)this;        // OK with cast
  bp2->mi = 3;                  // OK: access through a pointer to \tcode{B}.
}
\end{codeblock}
\end{note}

\pnum
A base class
\tcode{B}
of
\tcode{N}
is
\defn{accessible}
at
\placeholder{R},
if
\begin{itemize}
\item
an invented public member of
\tcode{B}
would be a public member of
\tcode{N}, or
\item
\placeholder{R}
occurs in a member or friend of class
\tcode{N},
and an invented public member of
\tcode{B}
would be a private or protected member of
\tcode{N}, or
\item
\placeholder{R}
occurs in a member or friend of a class
\tcode{P}
derived from
\tcode{N},
and an invented public member of
\tcode{B}
would be a private or protected member of
\tcode{P}, or
\item
there exists a class
\tcode{S}
such that
\tcode{B}
is a base class of
\tcode{S}
accessible at
\placeholder{R}
and
\tcode{S}
is a base class of
\tcode{N}
accessible at
\placeholder{R}.
\end{itemize}

\begin{example}
\begin{codeblock}
class B {
public:
  int m;
};

class S: private B {
  friend class N;
};

class N: private S {
  void f() {
    B* p = this;    // OK because class \tcode{S} satisfies the fourth condition above: \tcode{B} is a base class of \tcode{N}
                    // accessible in \tcode{f()} because \tcode{B} is an accessible base class of \tcode{S} and \tcode{S} is an accessible
                    // base class of \tcode{N}.
  }
};
\end{codeblock}
\end{example}

\pnum
If a base class is accessible, one can implicitly convert a pointer to
a derived class to a pointer to that base class~(\ref{conv.ptr}, \ref{conv.mem}).
\begin{note}
It follows that
members and friends of a class
\tcode{X}
can implicitly convert an
\tcode{X*}
to a pointer to a private or protected immediate base class of
\tcode{X}.
\end{note}
The access to a member is affected by the class in which the member is
named.
This naming class is the class in which the member name was looked
up and found.
\begin{note}
This class can be explicit, e.g., when a
\grammarterm{qualified-id}
is used, or implicit, e.g., when a class member access operator\iref{expr.ref} is used (including cases where an implicit
``\tcode{this->}''
is
added).
If both a class member access operator and a
\grammarterm{qualified-id}
are used to name the member (as in
\tcode{p->T::m}),
the class naming the member is the class denoted by the
\grammarterm{nested-name-specifier}
of the
\grammarterm{qualified-id}
(that is,
\tcode{T}).
\end{note}
A member
\tcode{m}
is accessible at the point
\placeholder{R}
when named in class
\tcode{N}
if
\begin{itemize}
\item
\tcode{m}
as a member of
\tcode{N}
is public, or
\item
\tcode{m}
as a member of
\tcode{N}
is private, and
\placeholder{R}
occurs in a member or friend of class
\tcode{N},
or
\item
\tcode{m}
as a member of
\tcode{N}
is protected, and
\placeholder{R}
occurs in a member or friend of class
\tcode{N},
or in a member of a class
\tcode{P}
derived from
\tcode{N},
where
\tcode{m}
as a member of
\tcode{P}
is public, private, or protected, or
\item
there exists a base class
\tcode{B}
of
\tcode{N}
that is accessible at
\placeholder{R},
and
\tcode{m}
is accessible at
\placeholder{R}
when named in class
\tcode{B}.
\begin{example}

\begin{codeblock}
class B;
class A {
private:
  int i;
  friend void f(B*);
};
class B : public A { };
void f(B* p) {
  p->i = 1;         // OK: \tcode{B*} can be implicitly converted to \tcode{A*}, and \tcode{f} has access to \tcode{i} in \tcode{A}
}
\end{codeblock}
\end{example}
\end{itemize}

\pnum
If a class member access operator, including an implicit
``\tcode{this->}'',
is used to access a non-static data member or non-static
member function, the reference is ill-formed if the
left operand (considered as a pointer in the
``\tcode{.}''
operator case) cannot be implicitly converted to a
pointer to the naming class of the right operand.
\begin{note}
This requirement is in addition to the requirement that
the member be accessible as named.
\end{note}

\rSec2[class.friend]{Friends}%
\indextext{friend function!access and}%
\indextext{access control!friend function}

\pnum
A friend of a class is a function or class that is
given permission to use the private and protected member names from the class.
A class specifies its friends, if any, by way of friend declarations.
Such declarations give special access rights to the friends, but they
do not make the nominated friends members of the befriending class.
\begin{example}
The following example illustrates the differences between
members and friends:
\indextext{friend function!member function and}%

\begin{codeblock}
class X {
  int a;
  friend void friend_set(X*, int);
public:
  void member_set(int);
};

void friend_set(X* p, int i) { p->a = i; }
void X::member_set(int i) { a = i; }

void f() {
  X obj;
  friend_set(&obj,10);
  obj.member_set(10);
}
\end{codeblock}
\end{example}

\pnum
\indextext{friend!class access and}%
Declaring a class to be a friend implies that the names of private and
protected members from the class granting friendship can be accessed in the
\grammarterm{base-specifier}{s} and member declarations of the befriended
class. \begin{example}

\begin{codeblock}
class A {
  class B { };
  friend class X;
};

struct X : A::B {               // OK: \tcode{A::B} accessible to friend
  A::B mx;                      // OK: \tcode{A::B} accessible to member of friend
  class Y {
    A::B my;                    // OK: \tcode{A::B} accessible to nested member of friend
  };
};
\end{codeblock}
\end{example}
\begin{example}

\begin{codeblock}
class X {
  enum { a=100 };
  friend class Y;
};

class Y {
  int v[X::a];                  // OK, \tcode{Y} is a friend of \tcode{X}
};

class Z {
  int v[X::a];                  // error: \tcode{X::a} is private
};
\end{codeblock}
\end{example}

A class shall not be defined in a friend declaration. \begin{example}
\begin{codeblock}
class A {
  friend class B { };           // error: cannot define class in friend declaration
};
\end{codeblock}
\end{example}

\pnum
A friend declaration that does not declare a function
shall have one of the following forms:

\begin{ncsimplebnf}
\keyword{friend} elaborated-type-specifier \terminal{;}\br
\keyword{friend} simple-type-specifier \terminal{;}\br
\keyword{friend} typename-specifier \terminal{;}
\end{ncsimplebnf}

\begin{note} A friend declaration may be the
\grammarterm{declaration} in a \grammarterm{template-declaration}
(\ref{temp}, \ref{temp.friend}).\end{note} If the
type specifier in a \tcode{friend} declaration designates a (possibly
cv-qualified) class type, that class is declared as a friend; otherwise, the
friend declaration is ignored. \begin{example}

\begin{codeblock}
class C;
typedef C Ct;

class X1 {
  friend C;                     // OK: \tcode{class C} is a friend
};

class X2 {
  friend Ct;                    // OK: \tcode{class C} is a friend
  friend D;                     // error: no type-name \tcode{D} in scope
  friend class D;               // OK: elaborated-type-specifier declares new class
};

template <typename T> class R {
  friend T;
};

R<C> rc;                        // \tcode{class C} is a friend of \tcode{R<C>}
R<int> Ri;                      // OK: \tcode{"friend int;"} is ignored
\end{codeblock}
\end{example}

\pnum
\indextext{friend function!linkage of}%
A function first declared in a friend declaration
has the linkage of the namespace of which it is a member\iref{basic.link}.
Otherwise, the function retains its previous linkage\iref{dcl.stc}.

\pnum
\indextext{declaration!overloaded name and \tcode{friend}}%
When a friend
declaration refers to an overloaded name or operator, only the function specified
by the parameter types becomes a friend.
A member function of a class
\tcode{X}
can be a friend of
a class
\tcode{Y}.
\indextext{member function!friend}%
\begin{example}

\begin{codeblock}
class Y {
  friend char* X::foo(int);
  friend X::X(char);            // constructors can be friends
  friend X::~X();               // destructors can be friends
};
\end{codeblock}
\end{example}

\pnum
\indextext{friend function!inline}%
A function can be defined in a friend declaration of a class if and only if the
class is a non-local class\iref{class.local}, the function name is unqualified,
and the function has namespace scope.
\begin{example}

\begin{codeblock}
class M {
  friend void f() { }           // definition of global \tcode{f}, a friend of \tcode{M},
                                // not the definition of a member function
};
\end{codeblock}
\end{example}

\pnum
Such a function is implicitly an inline function\iref{dcl.inline}.
A friend
function defined in a class is in the (lexical) scope of the class in which it is defined.
A friend function defined outside the class is not\iref{basic.lookup.unqual}.

\pnum
No
\grammarterm{storage-class-specifier}
shall appear in the
\grammarterm{decl-specifier-seq}
of a friend declaration.

\pnum
\indextext{friend!access specifier and}%
A name nominated by a friend declaration shall be accessible in the scope of the
class containing the friend declaration.
The meaning of the friend declaration is the same whether the friend declaration
appears in the private, protected, or public\iref{class.mem}
portion of the class
\grammarterm{member-specification}.

\pnum
\indextext{friend!inheritance and}%
Friendship is neither inherited nor transitive.
\begin{example}

\begin{codeblock}
class A {
  friend class B;
  int a;
};

class B {
  friend class C;
};

class C  {
  void f(A* p) {
    p->a++;         // error: \tcode{C} is not a friend of \tcode{A} despite being a friend of a friend
  }
};

class D : public B  {
  void f(A* p) {
    p->a++;         // error: \tcode{D} is not a friend of \tcode{A} despite being derived from a friend
  }
};
\end{codeblock}
\end{example}

\pnum
\indextext{local class!friend}%
\indextext{friend!local class and}%
If a friend declaration appears in a local class\iref{class.local} and the
name specified is an unqualified name, a prior declaration is looked
up without considering scopes that are outside the innermost enclosing
non-class scope.
For a friend function declaration, if there is no
prior declaration, the program is ill-formed.
For a friend class
declaration, if there is no prior declaration, the class that is
specified belongs to the innermost enclosing non-class scope, but if it is
subsequently referenced, its name is not found by name lookup
until a matching declaration is provided in the innermost enclosing
non-class scope.
\begin{example}

\begin{codeblock}
class X;
void a();
void f() {
  class Y;
  extern void b();
  class A {
  friend class X;   // OK, but \tcode{X} is a local class, not \tcode{::X}
  friend class Y;   // OK
  friend class Z;   // OK, introduces local class \tcode{Z}
  friend void a();  // error, \tcode{::a} is not considered
  friend void b();  // OK
  friend void c();  // error
  };
  X* px;            // OK, but \tcode{::X} is found
  Z* pz;            // error, no \tcode{Z} is found
}
\end{codeblock}
\end{example}

\rSec2[class.protected]{Protected member access}
\indextext{access control!\idxcode{protected}}%

\pnum
An additional access check beyond those described earlier in \ref{class.access}
is applied when a non-static data member or non-static member function is a
protected member of its naming class\iref{class.access.base}.\footnote{This
additional check does not apply to other members,
e.g., static data members or enumerator member constants.}
As described earlier, access to a protected member is granted because the
reference occurs in a friend or member of some class \tcode{C}. If the access is
to form a pointer to member\iref{expr.unary.op}, the
\grammarterm{nested-name-specifier} shall denote \tcode{C} or a class derived from
\tcode{C}. All other accesses involve a (possibly implicit) object
expression\iref{expr.ref}. In this case, the class of the object expression shall be
\tcode{C} or a class derived from \tcode{C}.
\begin{example}

\begin{codeblock}
class B {
protected:
  int i;
  static int j;
};

class D1 : public B {
};

class D2 : public B {
  friend void fr(B*,D1*,D2*);
  void mem(B*,D1*);
};

void fr(B* pb, D1* p1, D2* p2) {
  pb->i = 1;                    // ill-formed
  p1->i = 2;                    // ill-formed
  p2->i = 3;                    // OK (access through a \tcode{D2})
  p2->B::i = 4;                 // OK (access through a \tcode{D2}, even though naming class is \tcode{B})
  int B::* pmi_B = &B::i;       // ill-formed
  int B::* pmi_B2 = &D2::i;     // OK (type of \tcode{\&D2::i} is \tcode{int B::*})
  B::j = 5;                     // ill-formed (not a friend of naming class \tcode{B})
  D2::j = 6;                    // OK (because refers to static member)
}

void D2::mem(B* pb, D1* p1) {
  pb->i = 1;                    // ill-formed
  p1->i = 2;                    // ill-formed
  i = 3;                        // OK (access through \tcode{this})
  B::i = 4;                     // OK (access through \tcode{this}, qualification ignored)
  int B::* pmi_B = &B::i;       // ill-formed
  int B::* pmi_B2 = &D2::i;     // OK
  j = 5;                        // OK (because \tcode{j} refers to static member)
  B::j = 6;                     // OK (because \tcode{B::j} refers to static member)
}

void g(B* pb, D1* p1, D2* p2) {
  pb->i = 1;                    // ill-formed
  p1->i = 2;                    // ill-formed
  p2->i = 3;                    // ill-formed
}
\end{codeblock}
\end{example}

\rSec2[class.access.virt]{Access to virtual functions}%
\indextext{access control!virtual function}

\pnum
The access rules\iref{class.access} for a virtual function are determined by its declaration
and are not affected by the rules for a function that later overrides it.
\begin{example}

\begin{codeblock}
class B {
public:
  virtual int f();
};

class D : public B {
private:
  int f();
};

void f() {
  D d;
  B* pb = &d;
  D* pd = &d;

  pb->f();                      // OK: \tcode{B::f()} is public, \tcode{D::f()} is invoked
  pd->f();                      // error: \tcode{D::f()} is private
}
\end{codeblock}
\end{example}

\pnum
Access is checked at the call point using the type of the expression used
to denote the object for which the member function is called
(\tcode{B*}
in the example above).
The access of the member function in the class in which it was defined
(\tcode{D}
in the example above) is in general not known.

\rSec2[class.paths]{Multiple access}%
\indextext{access control!multiple access}

\pnum
If a name can be reached by several paths through a multiple inheritance
graph, the access is that of the path that gives most access.
\begin{example}

\begin{codeblock}
class W { public: void f(); };
class A : private virtual W { };
class B : public virtual W { };
class C : public A, public B {
  void f() { W::f(); }          // OK
};
\end{codeblock}

Since
\tcode{W::f()}
is available to
\tcode{C::f()}
along the public path through
\tcode{B},
access is allowed.
\end{example}

\rSec2[class.access.nest]{Nested classes}%
\indextext{access control!nested class}%
\indextext{member function!nested class}

\pnum
A nested class is a member and as such has the same access rights as any other member.
The members of an enclosing class have no special access to members of a nested
class; the usual access rules\iref{class.access} shall be obeyed.
\begin{example}
\begin{codeblock}
class E {
  int x;
  class B { };

  class I {
    B b;                        // OK: \tcode{E::I} can access \tcode{E::B}
    int y;
    void f(E* p, int i) {
      p->x = i;                 // OK: \tcode{E::I} can access \tcode{E::x}
    }
  };

  int g(I* p) {
    return p->y;                // error: \tcode{I::y} is private
  }
};
\end{codeblock}
\end{example}%
\indextext{access control|)}

\rSec1[class.init]{Initialization}%
\indextext{initialization!class object|(}%
\indextext{initialization!default constructor and}%
\indextext{initialization!constructor and}

\pnum
When no initializer is specified for an object of (possibly
cv-qualified) class type (or array thereof), or the initializer has
the form
\tcode{()},
the object is initialized as specified in~\ref{dcl.init}.

\pnum
An object of class type (or array thereof) can be explicitly initialized;
see~\ref{class.expl.init} and~\ref{class.base.init}.

\pnum
\indextext{order of execution!constructor and array}%
When an array of class objects is initialized
(either explicitly or implicitly) and the elements are initialized by constructor,
the constructor shall be called for each element of the array,
following the subscript order; see~\ref{dcl.array}.
\begin{note}
Destructors for the array elements are called in reverse order of their
construction.
\end{note}

\rSec2[class.expl.init]{Explicit initialization}%
\indextext{initialization!explicit}%
\indextext{initialization!constructor and}%

\pnum
An object of class type can be initialized with a parenthesized
\grammarterm{expression-list},
where the
\grammarterm{expression-list}
is construed as an argument list for a constructor
that is called to initialize the object.
Alternatively, a single
\grammarterm{assignment-expression}
can be specified as an
\grammarterm{initializer}
using the
\tcode{=}
form of initialization.
Either direct-initialization semantics or copy-initialization semantics apply;
see~\ref{dcl.init}.
\begin{example}
\begin{codeblock}
struct complex {
  complex();
  complex(double);
  complex(double,double);
};

complex sqrt(complex,complex);

complex a(1);                   // initialized by calling \tcode{complex(double)} with argument \tcode{1}
complex b = a;                  // initialized as a copy of \tcode{a}
complex c = complex(1,2);       // initialized by calling \tcode{complex(double,double)} with arguments \tcode{1} and \tcode{2}
complex d = sqrt(b,c);          // initialized by calling \tcode{sqrt(complex,complex)} with \tcode{d} as its result object
complex e;                      // initialized by calling \tcode{complex()}
complex f = 3;                  // initialized by calling \tcode{complex(double)} with argument \tcode{3}
complex g = { 1, 2 };           // initialized by calling \tcode{complex(double, double)} with arguments \tcode{1} and \tcode{2}
\end{codeblock}
\end{example}
\begin{note}
\indextext{initialization!overloaded assignment and}%
Overloading of the assignment operator\iref{over.ass}
has no effect on initialization.
\end{note}

\pnum
\indextext{initialization!array of class objects}%
\indextext{constructor!array of class objects and}%
An object of class type can also be initialized by a
\grammarterm{braced-init-list}. List-initialization semantics apply;
see~\ref{dcl.init} and~\ref{dcl.init.list}. \begin{example}

\begin{codeblock}
complex v[6] = { 1, complex(1,2), complex(), 2 };
\end{codeblock}

Here,
\tcode{complex::complex(double)}
is called for the initialization of
\tcode{v[0]}
and
\tcode{v[3]},
\tcode{complex::complex(\brk{}double, double)}
is called for the initialization of
\tcode{v[1]},
\tcode{complex::complex()}
is called for the initialization
\tcode{v[2]},
\tcode{v[4]},
and
\tcode{v[5]}.
For another example,

\begin{codeblock}
struct X {
  int i;
  float f;
  complex c;
} x = { 99, 88.8, 77.7 };
\end{codeblock}

Here,
\tcode{x.i}
is initialized with 99,
\tcode{x.f}
is initialized with 88.8, and
\tcode{complex::complex(double)}
is called for the initialization of
\tcode{x.c}.
\end{example}
\begin{note}
Braces can be elided in the
\grammarterm{initializer-list}
for any aggregate, even if the aggregate has members of a class type with
user-defined type conversions; see~\ref{dcl.init.aggr}.
\end{note}

\pnum
\begin{note}
If
\tcode{T}
is a class type with no default constructor,
any declaration of an object of type
\tcode{T}
(or array thereof) is ill-formed if no
\grammarterm{initializer}
is explicitly specified (see~\ref{class.init} and~\ref{dcl.init}).
\end{note}

\pnum
\begin{note}
\indextext{order of execution!constructor and \tcode{static} objects}%
The order in which objects with static or thread storage duration
are initialized is described in~\ref{basic.start.dynamic} and~\ref{stmt.dcl}.
\end{note}

\rSec2[class.base.init]{Initializing bases and members}%
\indextext{initialization!base class}%
\indextext{initialization!member}

\pnum
In the definition of a constructor for a class,
initializers for direct and virtual base class subobjects and
non-static data members can be specified by a
\grammarterm{ctor-initializer},
which has the form

\begin{bnf}
\nontermdef{ctor-initializer}\br
    \terminal{:} mem-initializer-list
\end{bnf}

\begin{bnf}
\nontermdef{mem-initializer-list}\br
    mem-initializer \opt{\terminal{...}}\br
    mem-initializer-list \terminal{,} mem-initializer \opt{\terminal{...}}
\end{bnf}

\begin{bnf}
\nontermdef{mem-initializer}\br
    mem-initializer-id \terminal{(} \opt{expression-list} \terminal{)}\br
    mem-initializer-id braced-init-list
\end{bnf}

\begin{bnf}
\nontermdef{mem-initializer-id}\br
    class-or-decltype\br
    identifier
\end{bnf}

\pnum
In a \grammarterm{mem-initializer-id} an initial unqualified
\grammarterm{identifier} is looked up in the scope of the constructor's class
and, if not found in that scope, it is looked up in the scope containing the
constructor's definition.
\begin{note}
If the constructor's class contains a member with the same name as a direct
or virtual base class of the class, a
\grammarterm{mem-initializer-id}
naming the member or base class and composed of a single identifier
refers to the class member.
A
\grammarterm{mem-initializer-id}
for the hidden base class may be specified using a qualified name.
\end{note}
Unless the
\grammarterm{mem-initializer-id}
names the constructor's class,
a non-static data member of the constructor's class, or
a direct or virtual base of that class,
the
\grammarterm{mem-initializer}
is ill-formed.

\pnum
A
\grammarterm{mem-initializer-list}
can initialize a base class using any \grammarterm{class-or-decltype} that denotes that base class type.
\begin{example}

\begin{codeblock}
struct A { A(); };
typedef A global_A;
struct B { };
struct C: public A, public B { C(); };
C::C(): global_A() { }          // mem-initializer for base \tcode{A}
\end{codeblock}
\end{example}

\pnum
If a
\grammarterm{mem-initializer-id}
is ambiguous because it designates both a direct non-virtual base class and
an inherited virtual base class, the
\grammarterm{mem-initializer}
is ill-formed.
\begin{example}

\begin{codeblock}
struct A { A(); };
struct B: public virtual A { };
struct C: public A, public B { C(); };
C::C(): A() { }                 // ill-formed: which \tcode{A}?
\end{codeblock}
\end{example}

\pnum
A
\grammarterm{ctor-initializer}
may initialize a variant member of the
constructor's class.
If a
\grammarterm{ctor-initializer}
specifies more than one
\grammarterm{mem-initializer}
for the same member or for the same base class,
the
\grammarterm{ctor-initializer}
is ill-formed.

\pnum
A \grammarterm{mem-initializer-list} can delegate to another
constructor of the constructor's class using any
\grammarterm{class-or-decltype} that denotes the constructor's class itself. If a
\grammarterm{mem-initializer-id} designates the constructor's class,
it shall be the only \grammarterm{mem-initializer}; the constructor
is a \term{delegating constructor}, and the constructor selected by the
\grammarterm{mem-initializer} is the \term{target constructor}.
The target constructor is selected by overload resolution.
Once the target constructor returns, the body of the delegating constructor
is executed. If a constructor delegates to itself directly or indirectly,
the program is ill-formed, no diagnostic required. \begin{example}

\begin{codeblock}
struct C {
  C( int ) { }                  // \#1: non-delegating constructor
  C(): C(42) { }                // \#2: delegates to \#1
  C( char c ) : C(42.0) { }     // \#3: ill-formed due to recursion with \#4
  C( double d ) : C('a') { }    // \#4: ill-formed due to recursion with \#3
};
\end{codeblock}
\end{example}

\pnum
\indextext{initialization!base class}%
\indextext{initialization!member object}%
The
\grammarterm{expression-list}
or \grammarterm{braced-init-list}
in a
\grammarterm{mem-initializer}
is used to initialize the
designated subobject (or, in the case of a delegating constructor, the complete class object)
according to the initialization rules of~\ref{dcl.init} for direct-initialization.
\begin{example}
\begin{codeblock}
struct B1 { B1(int); @\commentellip@ };
struct B2 { B2(int); @\commentellip@ };
struct D : B1, B2 {
  D(int);
  B1 b;
  const int c;
};

D::D(int a) : B2(a+1), B1(a+2), c(a+3), b(a+4) { @\commentellip@ }
D d(10);
\end{codeblock}
\end{example}
\begin{note}
\setlength{\emergencystretch}{1em}
The initialization
performed by each \grammarterm{mem-initializer}
constitutes a full-expres\-sion\iref{intro.execution}.
Any expression in
a
\grammarterm{mem-initializer}
is evaluated as part of the full-expression that performs the initialization.
\end{note}
A \grammarterm{mem-initializer} where the \grammarterm{mem-initializer-id} denotes
a virtual base class is ignored during execution of a constructor of any class that is
not the most derived class.

\pnum
A temporary expression bound to a reference member in a \grammarterm{mem-initializer}
is ill-formed.
\begin{example}
\begin{codeblock}
struct A {
  A() : v(42) { }   // error
  const int& v;
};
\end{codeblock}
\end{example}

\pnum
In a non-delegating constructor, if
a given potentially constructed subobject is not designated by a
\grammarterm{mem-initializer-id}
(including the case where there is no
\grammarterm{mem-initializer-list}
because the constructor has no
\grammarterm{ctor-initializer}),
then

\begin{itemize}
\item if the entity is a non-static data member that has
a default member initializer\iref{class.mem} and either

\begin{itemize}
\item the constructor's class is a union\iref{class.union}, and no other variant
member of that union is designated by a \grammarterm{mem-initializer-id} or

\item the constructor's class is not a union, and, if the entity is a member of an
anonymous union, no other member of that union is designated by a
\grammarterm{mem-initializer-id},
\end{itemize}

the entity is initialized from its default member initializer
as specified in~\ref{dcl.init};

\item otherwise, if the entity is an anonymous union or a variant member\iref{class.union.anon}, no initialization is performed;

\item otherwise, the entity is default-initialized\iref{dcl.init}.
\end{itemize}

\begin{note} An abstract class\iref{class.abstract} is never a most derived
class, thus its constructors never initialize virtual base classes, therefore the
corresponding \grammarterm{mem-initializer}{s} may be omitted. \end{note}
An attempt to initialize more than one non-static data member of a union renders the
program ill-formed.
\indextext{initialization!const member}%
\indextext{initialization!reference member}%
\begin{note}
After the call to a constructor for class
\tcode{X}
for an object with automatic or dynamic storage duration
has completed, if
the constructor was not invoked as part of value-initialization and
a member of
\tcode{X}
is neither initialized nor
given a value
during execution of the \grammarterm{compound-statement} of the body of the constructor,
the member has an indeterminate value.
\end{note}
\begin{example}
\begin{codeblock}
struct A {
  A();
};

struct B {
  B(int);
};

struct C {
  C() { }               // initializes members as follows:
  A a;                  // OK: calls \tcode{A::A()}
  const B b;            // error: \tcode{B} has no default constructor
  int i;                // OK: \tcode{i} has indeterminate value
  int j = 5;            // OK: \tcode{j} has the value \tcode{5}
};
\end{codeblock}
\end{example}

\pnum
If a given non-static data member has both a default member initializer
and a \grammarterm{mem-initializer}, the initialization specified by the
\grammarterm{mem-initializer} is performed, and the non-static data member's
default member initializer is ignored.
\begin{example} Given
% The comment below is misrendered with an overly large space before 'effects'
% if left to listings (see NB US-26 (C++17 CD)) (possibly due to the ff
% ligature), so we fix it up manually.
\begin{codeblock}
struct A {
  int i = /* some integer expression with side effects */ ;
  A(int arg) : i(arg) { }
  // ...
};
\end{codeblock}

the \tcode{A(int)} constructor will simply initialize \tcode{i} to the value of
\tcode{arg}, and the
\indextext{side effects}%
side effects in \tcode{i}'s default member initializer
will not take place.
\end{example}

\pnum
A temporary expression bound to a reference member from a
default member initializer is ill-formed.
\begin{example}
\begin{codeblock}
struct A {
  A() = default;        // OK
  A(int v) : v(v) { }   // OK
  const int& v = 42;    // OK
};
A a1;                   // error: ill-formed binding of temporary to reference
A a2(1);                // OK, unfortunately
\end{codeblock}
\end{example}

\pnum
In a non-delegating constructor, the destructor for each potentially constructed
subobject of class type is potentially invoked\iref{class.dtor}.
\begin{note} This provision ensures that destructors can be called for fully-constructed
subobjects in case an exception is thrown\iref{except.ctor}. \end{note}

\pnum
In a non-delegating constructor, initialization
proceeds in the following order:
\begin{itemize}
\item
\indextext{initialization!order of virtual base class}%
First, and only for the constructor of the most derived class\iref{intro.object},
virtual base classes are initialized in the order they appear on a
depth-first left-to-right traversal of the directed acyclic graph of
base classes,
where ``left-to-right'' is the order of appearance of the base classes
in the derived class
\grammarterm{base-specifier-list}.
\item
\indextext{initialization!order of base class}%
Then, direct base classes are initialized in declaration order
as they appear in the
\grammarterm{base-specifier-list}
(regardless of the order of the
\grammarterm{mem-initializer}{s}).
\item
\indextext{initialization!order of member}%
Then, non-static data members are initialized in the order
they were declared in the class definition
(again regardless of the order of the
\grammarterm{mem-initializer}{s}).
\item
Finally, the \grammarterm{compound-statement} of the constructor
body  is executed.
\end{itemize}

\begin{note}
The declaration order is mandated to ensure that base and member
subobjects are destroyed in the reverse order of initialization.
\end{note}

\pnum
\begin{example}
\begin{codeblock}
struct V {
  V();
  V(int);
};

struct A : virtual V {
  A();
  A(int);
};

struct B : virtual V {
  B();
  B(int);
};

struct C : A, B, virtual V {
  C();
  C(int);
};

A::A(int i) : V(i) { @\commentellip@ }
B::B(int i) { @\commentellip@ }
C::C(int i) { @\commentellip@ }

V v(1);             // use \tcode{V(int)}
A a(2);             // use \tcode{V(int)}
B b(3);             // use \tcode{V()}
C c(4);             // use \tcode{V()}
\end{codeblock}
\end{example}

\pnum
\indextext{initializer!scope of member}%
Names in the
\grammarterm{expression-list}
or \grammarterm{braced-init-list}
of a
\grammarterm{mem-initializer}
are evaluated in the scope of the constructor for which the
\grammarterm{mem-initializer}
is specified.
\begin{example}

\begin{codeblock}
class X {
  int a;
  int b;
  int i;
  int j;
public:
  const int& r;
  X(int i): r(a), b(i), i(i), j(this->i) { }
};
\end{codeblock}

initializes
\tcode{X::r}
to refer to
\tcode{X::a},
initializes
\tcode{X::b}
with the value of the constructor parameter
\tcode{i},
initializes
\tcode{X::i}
with the value of the constructor parameter
\tcode{i},
and initializes
\tcode{X::j}
with the value of
\tcode{X::i};
this takes place each time an object of class
\tcode{X}
is created.
\end{example}
\begin{note}
Because the
\grammarterm{mem-initializer}
are evaluated in the scope of the constructor, the
\tcode{this}
pointer can be used in the
\grammarterm{expression-list}
of a
\grammarterm{mem-initializer}
to refer to the object being initialized.
\end{note}

\pnum
\indextext{initialization!member function call during}%
Member functions (including virtual member functions, \ref{class.virtual}) can be
called for an object under construction.
Similarly, an object under construction can be the operand of the
\tcode{typeid}
operator\iref{expr.typeid} or of a
\tcode{dynamic_cast}\iref{expr.dynamic.cast}.
However, if these operations are performed in a
\grammarterm{ctor-initializer}
(or in a function called directly or indirectly from a
\grammarterm{ctor-initializer})
before all the
\grammarterm{mem-initializer}{s}
for base classes have completed, the program has undefined behavior.
\begin{example}
\begin{codeblock}
class A {
public:
  A(int);
};

class B : public A {
  int j;
public:
  int f();
  B() : A(f()),     // undefined: calls member function but base \tcode{A} not yet initialized
  j(f()) { }        // well-defined: bases are all initialized
};

class C {
public:
  C(int);
};

class D : public B, C {
  int i;
public:
  D() : C(f()),     // undefined: calls member function but base \tcode{C} not yet initialized
  i(f()) { }        // well-defined: bases are all initialized
};
\end{codeblock}
\end{example}

\pnum
\begin{note}
\ref{class.cdtor} describes the result of virtual function calls,
\tcode{typeid}
and
\tcode{dynamic_cast}s
during construction for the well-defined cases;
that is, describes the
\term{polymorphic behavior}
of an object under construction.
\end{note}

\pnum
\indextext{initializer!pack expansion}%
A \grammarterm{mem-initializer} followed by an ellipsis is
a pack expansion\iref{temp.variadic} that initializes the base
classes specified by a pack expansion in the \grammarterm{base-specifier-list}
for the class. \begin{example}

\begin{codeblock}
template<class... Mixins>
class X : public Mixins... {
public:
  X(const Mixins&... mixins) : Mixins(mixins)... { }
};
\end{codeblock}

\end{example}

\rSec2[class.inhctor.init]{Initialization by inherited constructor}%
\indextext{initialization!by inherited constructor}

\pnum
When a constructor for type \tcode{B} is invoked
to initialize an object of a different type \tcode{D}
(that is, when the constructor was inherited\iref{namespace.udecl}),
initialization proceeds as if a defaulted default constructor
were used to initialize the \tcode{D} object and
each base class subobject from which the constructor was inherited,
except that the \tcode{B} subobject is initialized
by the invocation of the inherited constructor.
The complete initialization is considered to be a single function call;
in particular, the initialization of the inherited constructor's parameters
is sequenced before the initialization of any part of the \tcode{D} object.
\begin{example}
\begin{codeblock}
struct B1 {
  B1(int, ...) { }
};

struct B2 {
  B2(double) { }
};

int get();

struct D1 : B1 {
  using B1::B1;     // inherits \tcode{B1(int, ...)}
  int x;
  int y = get();
};

void test() {
  D1 d(2, 3, 4);    // OK: \tcode{B1} is initialized by calling \tcode{B1(2, 3, 4)},
                    // then \tcode{d.x} is default-initialized (no initialization is performed),
                    // then \tcode{d.y} is initialized by calling \tcode{get()}
  D1 e;             // error: \tcode{D1} has a deleted default constructor
}

struct D2 : B2 {
  using B2::B2;
  B1 b;
};

D2 f(1.0);          // error: \tcode{B1} has a deleted default constructor

struct W { W(int); };
struct X : virtual W { using W::W; X() = delete; };
struct Y : X { using X::X; };
struct Z : Y, virtual W { using Y::Y; };
Z z(0);             // OK: initialization of \tcode{Y} does not invoke default constructor of \tcode{X}

template<class T> struct Log : T {
  using T::T;       // inherits all constructors from class \tcode{T}
  ~Log() { std::clog << "Destroying wrapper" << std::endl; }
};
\end{codeblock}
Class template \tcode{Log} wraps any class and forwards all of its constructors,
while writing a message to the standard log
whenever an object of class \tcode{Log} is destroyed.
\end{example}

\pnum
If the constructor was inherited from multiple base class subobjects
of type \tcode{B}, the program is ill-formed.
\begin{example}
\begin{codeblock}
struct A { A(int); };
struct B : A { using A::A; };

struct C1 : B { using B::B; };
struct C2 : B { using B::B; };

struct D1 : C1, C2 {
  using C1::C1;
  using C2::C2;
};

struct V1 : virtual B { using B::B; };
struct V2 : virtual B { using B::B; };

struct D2 : V1, V2 {
  using V1::V1;
  using V2::V2;
};

D1 d1(0);           // ill-formed: ambiguous
D2 d2(0);           // OK: initializes virtual \tcode{B} base class, which initializes the \tcode{A} base class
                    // then initializes the \tcode{V1} and \tcode{V2} base classes as if by a defaulted default constructor

struct M { M(); M(int); };
struct N : M { using M::M; };
struct O : M {};
struct P : N, O { using N::N; using O::O; };
P p(0);             // OK: use \tcode{M(0)} to initialize \tcode{N}{'s} base class,
                    // use \tcode{M()} to initialize \tcode{O}{'s} base class
\end{codeblock}
\end{example}

\pnum
When an object is initialized by an inherited constructor,
initialization of the object is complete
when the initialization of all subobjects is complete.%
\indextext{initialization!class object|)}

\rSec2[class.cdtor]{Construction and destruction}%
\indextext{construction|(}%
\indextext{destruction|(}%

\pnum
\indextext{construction!member access}%
\indextext{destruction!member access}%
For an object with a non-trivial constructor, referring to any non-static member
or base class of the object before the constructor begins execution results in
undefined behavior. For an object with a non-trivial destructor, referring to
any non-static member or base class of the object after the destructor finishes
execution results in undefined behavior.
\begin{example}
\begin{codeblock}
struct X { int i; };
struct Y : X { Y(); };                  // non-trivial
struct A { int a; };
struct B : public A { int j; Y y; };    // non-trivial

extern B bobj;
B* pb = &bobj;                          // OK
int* p1 = &bobj.a;                      // undefined, refers to base class member
int* p2 = &bobj.y.i;                    // undefined, refers to member's member

A* pa = &bobj;                          // undefined, upcast to a base class type
B bobj;                                 // definition of \tcode{bobj}

extern X xobj;
int* p3 = &xobj.i;                      // OK, \tcode{X} is a trivial class
X xobj;
\end{codeblock}
For another example,
\begin{codeblock}
struct W { int j; };
struct X : public virtual W { };
struct Y {
  int* p;
  X x;
  Y() : p(&x.j) {   // undefined, \tcode{x} is not yet constructed
    }
};
\end{codeblock}
\end{example}

\pnum
During the construction of an object,
if the value of the object or any of its subobjects is
accessed through a glvalue that is not obtained, directly or indirectly, from
the constructor's
\tcode{this}
pointer, the value of the object or subobject thus obtained is unspecified.
\begin{example}

\begin{codeblock}
struct C;
void no_opt(C*);

struct C {
  int c;
  C() : c(0) { no_opt(this); }
};

const C cobj;

void no_opt(C* cptr) {
  int i = cobj.c * 100;         // value of \tcode{cobj.c} is unspecified
  cptr->c = 1;
  cout << cobj.c * 100          // value of \tcode{cobj.c} is unspecified
       << '\n';
}

extern struct D d;
struct D {
  D(int a) : a(a), b(d.a) {}
  int a, b;
};
D d = D(1);                     // value of \tcode{d.b} is unspecified
\end{codeblock}
\end{example}

\pnum
\indextext{construction!pointer to member or base}%
\indextext{destruction!pointer to member or base}%
To explicitly or implicitly convert a pointer (a glvalue) referring to
an object of class
\tcode{X}
to a pointer (reference) to a direct or indirect base class
\tcode{B}
of
\tcode{X},
the construction of
\tcode{X}
and the construction of all of its direct or indirect bases that directly or
indirectly derive from
\tcode{B}
shall have started and the destruction of these classes shall not have
completed, otherwise the conversion results in undefined behavior.
To form a pointer to (or access the value of) a direct non-static member of
an object
\tcode{obj},
the construction of
\tcode{obj}
shall have started and its destruction shall not have completed,
otherwise the computation of the pointer value (or accessing the member
value) results in undefined behavior.
\begin{example}
\begin{codeblock}
struct A { };
struct B : virtual A { };
struct C : B { };
struct D : virtual A { D(A*); };
struct X { X(A*); };

struct E : C, D, X {
  E() : D(this),    // undefined: upcast from \tcode{E*} to \tcode{A*} might use path \tcode{E*} $\rightarrow$ \tcode{D*} $\rightarrow$ \tcode{A*}
                    // but \tcode{D} is not constructed

                    // ``\tcode{D((C*)this)}\!'' would be defined: \tcode{E*} $\rightarrow$ \tcode{C*} is defined because \tcode{E()} has started,
                    // and \tcode{C*} $\rightarrow$ \tcode{A*} is defined because \tcode{C} is fully constructed

  X(this) {}        // defined: upon construction of \tcode{X}, \tcode{C/B/D/A} sublattice is fully constructed
};
\end{codeblock}
\end{example}

\pnum
\indextext{virtual function call!constructor and}%
\indextext{virtual function call!destructor and}%
\indextext{construction!virtual function call}%
\indextext{destruction!virtual function call}%
Member functions, including virtual functions\iref{class.virtual}, can be called
during construction or destruction\iref{class.base.init}.
When a virtual function is called directly or indirectly from a constructor
or from a destructor,
including during the construction or destruction of the class's non-static data
members,
and the object to which the call applies is the object (call it \tcode{x}) under construction or
destruction,
the function called is the
final overrider in the constructor's or destructor's class and not one
overriding it in a more-derived class.
If the virtual function call uses an explicit class member access\iref{expr.ref}
and the object expression refers to
the complete object of \tcode{x} or one of that object's base class subobjects
but not \tcode{x} or one of its base class subobjects, the behavior
is undefined.
\begin{example}

\begin{codeblock}
struct V {
  virtual void f();
  virtual void g();
};

struct A : virtual V {
  virtual void f();
};

struct B : virtual V {
  virtual void g();
  B(V*, A*);
};

struct D : A, B {
  virtual void f();
  virtual void g();
  D() : B((A*)this, this) { }
};

B::B(V* v, A* a) {
  f();              // calls \tcode{V::f}, not \tcode{A::f}
  g();              // calls \tcode{B::g}, not \tcode{D::g}
  v->g();           // \tcode{v} is base of \tcode{B}, the call is well-defined, calls \tcode{B::g}
  a->f();           // undefined behavior, \tcode{a}'s type not a base of \tcode{B}
}
\end{codeblock}
\end{example}

\pnum
\indextext{construction!\idxcode{typeid} operator}%
\indextext{destruction!\idxcode{typeid} operator}%
\indextext{\idxcode{typeid}!construction and}%
\indextext{\idxcode{typeid}!destruction and}%
The
\tcode{typeid}
operator\iref{expr.typeid} can be used during construction or destruction\iref{class.base.init}.
When
\tcode{typeid}
is used in a constructor (including the
\grammarterm{mem-initializer} or default member initializer\iref{class.mem}
for a non-static data member)
or in a destructor, or used in a function called (directly or indirectly) from
a constructor or destructor, if the operand of
\tcode{typeid}
refers to the object under construction or destruction,
\tcode{typeid}
yields the
\tcode{std::type_info}
object representing the constructor or destructor's class.
If the operand of
\tcode{typeid}
refers to the object under construction or destruction and the static type of
the operand is neither the constructor or destructor's class nor one of its
bases, the behavior is undefined.

\pnum
\indextext{construction!dynamic cast and}%
\indextext{destruction!dynamic cast and}%
\indextext{cast!dynamic!construction and}%
\indextext{cast!dynamic!destruction and}%
\tcode{dynamic_cast}s\iref{expr.dynamic.cast} can be used during construction
or destruction\iref{class.base.init}. When a
\tcode{dynamic_cast}
is used in a constructor (including the
\grammarterm{mem-initializer} or default member initializer
for a non-static data member)
or in a destructor, or used in a function called (directly or indirectly) from
a constructor or destructor, if the operand of the
\tcode{dynamic_cast}
refers to the object under construction or destruction, this object is
considered to be a most derived object that has the type of the constructor or
destructor's class.
If the operand of the
\tcode{dynamic_cast}
refers to the object under construction or destruction and the static type of
the operand is not a pointer to or object of the constructor or destructor's
own class or one of its bases, the
\tcode{dynamic_cast}
results in undefined behavior.
\begin{example}
\begin{codeblock}
struct V {
  virtual void f();
};

struct A : virtual V { };

struct B : virtual V {
  B(V*, A*);
};

struct D : A, B {
  D() : B((A*)this, this) { }
};

B::B(V* v, A* a) {
  typeid(*this);                // \tcode{type_info} for \tcode{B}
  typeid(*v);                   // well-defined: \tcode{*v} has type \tcode{V}, a base of \tcode{B} yields \tcode{type_info} for \tcode{B}
  typeid(*a);                   // undefined behavior: type \tcode{A} not a base of \tcode{B}
  dynamic_cast<B*>(v);          // well-defined: \tcode{v} of type \tcode{V*}, \tcode{V} base of \tcode{B} results in \tcode{B*}
  dynamic_cast<B*>(a);          // undefined behavior, \tcode{a} has type \tcode{A*}, \tcode{A} not a base of \tcode{B}
}
\end{codeblock}
\end{example}
\indextext{destruction|)}%
\indextext{construction|)}%

\rSec2[class.copy.elision]{Copy/move elision}%

\pnum
\indextext{temporary!elimination of}%
\indextext{elision!copy constructor|see{constructor, copy, elision}}%
\indextext{elision!move constructor|see{constructor, move, elision}}%
\indextext{constructor!copy!elision}%
\indextext{constructor!move!elision}%
When certain criteria are met, an implementation is
allowed to omit the copy/move construction of a class object,
even if the constructor selected for the copy/move operation and/or the
destructor for the object have
\indextext{side effects}%
side effects.  In such cases, the
implementation treats the source and target of the
omitted copy/move operation as simply two different ways of
referring to the same object. If the first parameter of the
selected constructor is an rvalue reference to the object's type,
the destruction of that object occurs when the target would have been destroyed;
otherwise, the destruction occurs at the later of the times when the
two objects would have been destroyed without the
optimization.\footnote{Because only one object is destroyed instead of two,
and one copy/move constructor
is not executed, there is still one object destroyed for each one constructed.}
This elision of copy/move operations, called
\indexdefn{copy elision|see{constructor, copy, elision}}%
\indexdefn{elision!copy|see{constructor, copy, elision}}%
\indexdefn{constructor!copy!elision}\indexdefn{constructor!move!elision}\term{copy elision},
is permitted in the
following circumstances (which may be combined to
eliminate multiple copies):

\begin{itemize}
\item in a \tcode{return} statement in a function with a class return type,
when the \grammarterm{expression} is the name of a non-volatile
automatic object (other than a function parameter or a variable
introduced by the \grammarterm{exception-declaration} of a
\grammarterm{handler}\iref{except.handle})
with the same type (ignoring cv-qualification) as
the function return type, the copy/move operation can be
omitted by constructing the automatic object directly
into the function call's return object

\item in a \grammarterm{throw-expression}\iref{expr.throw}, when the operand
is the name of a non-volatile automatic object
(other than a function or catch-clause parameter)
whose scope does not extend beyond the end of the innermost enclosing
\grammarterm{try-block} (if there is one), the copy/move operation from the
operand to the exception object\iref{except.throw} can be omitted by
constructing the automatic object directly into the exception object

\item in a coroutine\iref{dcl.fct.def.coroutine}, a copy of a coroutine parameter
can be omitted and references to that copy replaced with references to the
corresponding parameter if the meaning of the program will be unchanged except for
the execution of a constructor and destructor for the parameter copy object

\item when the \grammarterm{exception-declaration} of an
exception handler\iref{except} declares an object of the same
type (except for cv-qualification) as the exception
object\iref{except.throw}, the copy operation can be omitted by treating
the \grammarterm{exception-declaration} as an alias for the exception
object if the meaning of the program will be unchanged except for the execution
of constructors and destructors for the object declared by the
\grammarterm{exception-declaration}.
\begin{note} There cannot be a move from the exception object because it is
always an lvalue.  \end{note}
\end{itemize}
Copy elision is not permitted
where an expression is evaluated in a context
requiring a constant expression\iref{expr.const}
and in constant initialization\iref{basic.start.static}.
\begin{note}
Copy elision might be performed
if the same expression
is evaluated in another context.
\end{note}

\pnum
\begin{example}
\begin{codeblock}
class Thing {
public:
  Thing();
  ~Thing();
  Thing(const Thing&);
};

Thing f() {
  Thing t;
  return t;
}

Thing t2 = f();

struct A {
  void *p;
  constexpr A(): p(this) {}
};

constexpr A g() {
  A a;
  return a;
}

constexpr A a;          // well-formed, \tcode{a.p} points to \tcode{a}
constexpr A b = g();    // well-formed, \tcode{b.p} points to \tcode{b}

void h() {
  A c = g();            // well-formed, \tcode{c.p} may point to \tcode{c} or to an ephemeral temporary
}
\end{codeblock}
Here the criteria for elision can
eliminate
the copying of the local automatic object
\tcode{t}
into the result object for the function call
\tcode{f()},
which is the global object
\tcode{t2}.
Effectively, the construction of the local object
\tcode{t}
can be viewed as directly initializing the global
object
\tcode{t2},
and that object's destruction will occur at program
exit.
Adding a move constructor to \tcode{Thing} has the same effect, but it is the
move construction from the local automatic object to \tcode{t2} that is elided.
\end{example}

\pnum
In the following copy-initialization contexts, a move operation might be used instead of a copy operation:
\begin{itemize}
\item If the \grammarterm{expression} in a \tcode{return} or \tcode{co_return} statement\iref{stmt.return}
is a (possibly parenthesized) \grammarterm{id-expression}
that names an object with automatic storage duration declared in the body
or \grammarterm{parameter-declaration-clause} of the innermost enclosing
function or \grammarterm{lambda-expression}, or

\item if the operand of a \grammarterm{throw-expression}\iref{expr.throw}
is the name of a non-volatile automatic object
(other than a function or catch-clause parameter)
whose scope does not extend beyond the end of the innermost enclosing
\grammarterm{try-block} (if there is one),
\end{itemize}
overload resolution to select the constructor
for the copy or the \tcode{return_value} overload to call
is first performed as if the object were designated by an
rvalue.
If the first overload resolution fails or was not performed,
or if the type of the first parameter of the selected
constructor or the \tcode{return_value} overload
is not an rvalue reference to the object's type (possibly cv-qualified),
overload resolution is performed again, considering the object as an lvalue.
\begin{note}
This two-stage overload resolution must be performed regardless
of whether copy elision will occur. It determines the constructor
or the \tcode{return_value} overload to be called if
elision is not performed, and the selected constructor
or the \tcode{return_value} overload must be accessible even if
the call is elided.
\end{note}

\pnum
\begin{example}
\begin{codeblock}
class Thing {
public:
  Thing();
  ~Thing();
  Thing(Thing&&);
private:
  Thing(const Thing&);
};

Thing f(bool b) {
  Thing t;
  if (b)
    throw t;            // OK: \tcode{Thing(Thing\&\&)} used (or elided) to throw \tcode{t}
  return t;             // OK: \tcode{Thing(Thing\&\&)} used (or elided) to return \tcode{t}
}

Thing t2 = f(false);    // OK: no extra copy/move performed, \tcode{t2} constructed by call to \tcode{f}

struct Weird {
  Weird();
  Weird(Weird&);
};

Weird g() {
  Weird w;
  return w;             // OK: first overload resolution fails, second overload resolution selects \tcode{Weird(Weird\&)}
}
\end{codeblock}
\end{example}

\rSec1[class.compare]{Comparisons}%

\rSec2[class.compare.default]{Defaulted comparison operator functions}%

\pnum
A defaulted comparison operator function (\ref{expr.spaceship}, \ref{expr.rel}, \ref{expr.eq})
for some class \tcode{C}
shall be a non-template function
declared in the \grammarterm{member-specification} of \tcode{C}
that is
\begin{itemize}
\item a non-static const member of \tcode{C} having one parameter of type \tcode{const C\&}, or
\item a friend of \tcode{C} having two parameters of type \tcode{const C\&}.
\end{itemize}

\pnum
If the class definition
does not explicitly declare an \tcode{==} operator function,
but declares a defaulted three-way comparison operator function,
an \tcode{==} operator function is declared implicitly
with the same access as the three-way comparison operator function.
The implicitly-declared \tcode{==} operator for a class \tcode{X}
is an inline member and is defined as defaulted in the definition of \tcode{X}.
If the three-way comparison operator function
is declared as a non-static const member,
the implicitly-declared \tcode{==} operator function is a member of the form
\begin{codeblock}
bool X::operator==(const X&) const;
\end{codeblock}
Otherwise, the implicitly-declared \tcode{==} operator function is of the form
\begin{codeblock}
friend bool operator==(const X&, const X&);
\end{codeblock}
\begin{note}
Such a friend function is visible
to argument-dependent lookup\iref{basic.lookup.argdep}
only\iref{namespace.memdef}.
\end{note}
The operator is a \tcode{constexpr} function if its definition
would satisfy the requirements for a \tcode{constexpr} function.
\begin{note}
The \tcode{==} operator function is declared implicitly even if
the defaulted three-way comparison operator function is defined as deleted.
\end{note}

\pnum
\indextext{structural comparison operator|see{operator, structural comparison}}%
A type \tcode{C} has \defnadj{strong structural}{equality} if,
given a glvalue \tcode{x} of type \tcode{const C}, either:
\begin{itemize}
\item
  \tcode{C} is a non-class type and \tcode{x <=> x} is a valid expression
  of type \tcode{std::strong_ordering} or \tcode{std::strong_equality}, or
\item
  \tcode{C} is a class type with an \tcode{==} operator
  defined as defaulted in the definition of \tcode{C},
  \tcode{x == x} is well-formed when contextually converted to \tcode{bool},
  all of \tcode{C}'s base class subobjects and non-static data members
  have strong structural equality, and
  \tcode{C} has no \tcode{mutable} or \tcode{volatile} subobjects.
\end{itemize}

\pnum
The direct base class subobjects of \tcode{C},
in the order of their declaration in the \grammarterm{base-specifier-list} of \tcode{C},
followed by the non-static data members of \tcode{C},
in the order of their declaration in the \grammarterm{member-specification} of \tcode{C},
form a list of subobjects.
In that list, any subobject of array type is recursively expanded
to the sequence of its elements, in the order of increasing subscript.
Let $\tcode{x}_i$ be an lvalue denoting the $i^\text{th}$ element
in the expanded list of subobjects for an object \tcode{x}
(of length $n$),
where $\tcode{x}_i$ is
formed by a sequence of
derived-to-base conversions\iref{over.best.ics},
class member access expressions\iref{expr.ref}, and
array subscript expressions\iref{expr.sub} applied to \tcode{x}.
It is unspecified whether virtual base class subobjects
appear more than once in the expanded list of subobjects.

\rSec2[class.eq]{Equality operators}
\indextext{operator!equality!defaulted}%
\indextext{operator!inequality!defaulted}%

\pnum
A defaulted equality operator\iref{expr.eq} function
shall have a declared return type \tcode{bool}.

\pnum
A defaulted \tcode{==} operator function for a class \tcode{C}
is defined as deleted
unless, for each $\tcode{x}_i$ in the expanded list of subobjects
for an object \tcode{x} of type \tcode{C},
$\tcode{x}_i\tcode{ == }\tcode{x}_i$ is a valid expression and
contextually convertible to \tcode{bool}.

\pnum
The return value \tcode{V} of a defaulted \tcode{==} operator function
with parameters \tcode{x} and \tcode{y} is determined
by comparing corresponding elements $\tcode{x}_i$ and $\tcode{y}_i$
in the expanded lists of subobjects for \tcode{x} and \tcode{y}
(in increasing index order)
until the first index $i$
where $\tcode{x}_i\tcode{ == }\tcode{y}_i$ yields a result value which,
when contextually converted to \tcode{bool}, yields \tcode{false}.
If no such index exists, \tcode{V} is \tcode{true}.
Otherwise, \tcode{V} is \tcode{false}.

\pnum
A defaulted \tcode{!=} operator function for a class \tcode{C}
with parameters \tcode{x} and \tcode{y} is defined as deleted if
\begin{itemize}
\item
  overload resolution\iref{over.match}, as applied to \tcode{x == y}
  (also considering synthesized candidates
  with reversed order of parameters\iref{over.match.oper}),
  results in an ambiguity or a function
  that is deleted or inaccessible from the operator function, or
\item
  \tcode{x == y} cannot be contextually converted to \tcode{bool}.
\end{itemize}
Otherwise, the operator function yields \tcode{(x == y) ?\ false :\ true}.

\pnum
\begin{example}
\begin{codeblock}
struct D {
  int i;
  friend bool operator==(const D& x, const D& y) = default;
                                                // OK, returns \tcode{x.i == y.i}
  bool operator!=(const D& z) const = default;  // OK, returns \tcode{(*this == z) ?\ false :\ true}
};
\end{codeblock}
\end{example}

\rSec2[class.spaceship]{Three-way comparison}
\indextext{operator!three-way comparison!defaulted}%

\pnum
Given an expanded list of subobjects for an object \tcode{x} of type \tcode{C},
the type of the expression $\tcode{x}_i$ \tcode{<=>} $\tcode{x}_i$
is denoted by $\tcode{R}_i$.
If the declared return type
of a defaulted three-way comparison operator function
is \tcode{auto},
then the return type is deduced as
the common comparison type (see below) of
$\tcode{R}_0$, $\tcode{R}_1$, $\dotsc$, $\tcode{R}_{n-1}$.
\begin{note}
Otherwise,
the program will be ill-formed
if the expression $\tcode{x}_i$ \tcode{<=>} $\tcode{x}_i$
is not implicitly convertible to the declared return type for any $i$.
\end{note}
If the return type is deduced as \tcode{void},
the operator function is defined as deleted.

\pnum
The return value \tcode{V} of type \tcode{R}
of the defaulted three-way comparison operator function
with parameters \tcode{x} and \tcode{y} of the same type
is determined by comparing corresponding elements
$\tcode{x}_i$ and $\tcode{y}_i$
in the expanded lists of subobjects for \tcode{x} and \tcode{y}
(in increasing index order)
until the first index $i$
where $\tcode{x}_i$ \tcode{<=>} $\tcode{y}_i$
yields a result value $\tcode{v}_i$ where $\tcode{v}_i \mathrel{\tcode{!=}} 0$,
contextually converted to \tcode{bool}, yields \tcode{true};
\tcode{V} is $\tcode{v}_i$ converted to \tcode{R}.
If no such index exists, \tcode{V} is
\tcode{std::strong_ordering::equal} converted to \tcode{R}.

\pnum
The \defn{common comparison type} \tcode{U}
of a possibly-empty list of $n$ types
$\tcode{T}_0$, $\tcode{T}_1$, $\dotsc$, $\tcode{T}_{n-1}$
is defined as follows:

\begin{itemize}
\item
If any $\tcode{T}_i$
is not a comparison category type\iref{cmp.categories},
\tcode{U} is \tcode{void}.

\item
Otherwise, if
at least one $\tcode{T}_i$ is \tcode{std::weak_equality}, or
at least one $\tcode{T}_i$ is \tcode{std::strong_equality} and
at least one $\tcode{T}_j$ is \tcode{std::partial_ordering} or
                              \tcode{std::weak_ordering},
\tcode{U} is \tcode{std::weak_equality}\iref{cmp.weakeq}.

\item
Otherwise, if at least one $\tcode{T}_i$ is \tcode{std::strong_equality},
\tcode{U} is \tcode{std::strong_equality}\iref{cmp.strongeq}.

\item
Otherwise, if at least one $\tcode{T}_i$ is \tcode{std::partial_ordering},
\tcode{U} is \tcode{std::partial_ordering}\iref{cmp.partialord}.

\item
Otherwise, if at least one $\tcode{T}_i$ is \tcode{std::weak_ordering},
\tcode{U} is \tcode{std::weak_ordering}\iref{cmp.weakord}.

\item
Otherwise, \tcode{U} is \tcode{std::strong_ordering}\iref{cmp.strongord}.
\begin{note}
In particular, this is the result when $n$ is 0.
\end{note}
\end{itemize}

\rSec2[class.rel]{Relational operators}
\indextext{operator!relational!defaulted}%

\pnum
A defaulted relational\iref{expr.rel} operator function
for some operator \tcode{@}
shall have a declared return type \tcode{bool}.

\pnum
The operator function with parameters \tcode{x} and \tcode{y}
is defined as deleted if

\begin{itemize}
\item
overload resolution\iref{over.match},
as applied to \tcode{x <=> y}
results in an ambiguity
or a function that is deleted or inaccessible from the operator function,
or

\item
the operator \tcode{@}
cannot be applied to the return type of \tcode{x <=> y}.
\end{itemize}

Otherwise, the operator function yields
\tcode{x <=> y @ 0}.

\pnum
\begin{example}
\begin{codeblock}
struct C {
  friend std::strong_equality operator<=>(const C&, const C&);
  bool operator<(const C&) const = default;             // OK, function is deleted
};
\end{codeblock}
\end{example}

\rSec1[class.free]{Free store}%
\indextext{free store}%

\pnum
\indextext{\idxcode{new}!type of}
Any allocation function for a class
\tcode{T}
is a static member (even if not explicitly declared
\tcode{static}).

\pnum
\begin{example}
\begin{codeblock}
class Arena;
struct B {
  void* operator new(std::size_t, Arena*);
};
struct D1 : B {
};

Arena*  ap;
void foo(int i) {
  new (ap) D1;      // calls \tcode{B::operator new(std::size_t, Arena*)}
  new D1[i];        // calls \tcode{::operator new[](std::size_t)}
  new D1;           // ill-formed: \tcode{::operator new(std::size_t)} hidden
}
\end{codeblock}
\end{example}

\pnum
\indextext{\idxcode{delete}}%
When an object is deleted with a
\grammarterm{delete-expression}\iref{expr.delete},
a deallocation function
\indextext{function!deallocation}%
(\tcode{operator delete()}
\indextext{\idxcode{operator delete}}%
for non-array objects or
\tcode{operator delete[]()}
\indextext{\idxcode{operator delete}}%
for arrays) is (implicitly) called to reclaim the storage occupied by
the object\iref{basic.stc.dynamic.deallocation}.

\pnum
Class-specific deallocation function lookup is a part of general deallocation
function lookup\iref{expr.delete} and occurs as follows.
If the \grammarterm{delete-expression}
is used to deallocate a class object whose static type has a virtual
destructor, the deallocation function is the one selected at the point
of definition of the dynamic type's virtual
destructor\iref{class.dtor}.\footnote{A similar provision is not needed for
the array version of \tcode{operator} \tcode{delete} because~\ref{expr.delete}
requires that in this situation, the static type of the object to be deleted be
the same as its dynamic type.
}
Otherwise, if the
\grammarterm{delete-expression}
is used to deallocate an object of class
\tcode{T}
or array thereof,
the deallocation function's name is looked up in the scope of
\tcode{T}.
If this lookup fails to find the name, general deallocation function
lookup\iref{expr.delete} continues.
If the result of the lookup is ambiguous or inaccessible, or if the lookup
selects a placement deallocation function, the program is ill-formed.

\pnum
\indextext{\idxcode{delete}!type of}%
Any deallocation function for a class
\tcode{X}
is a static member (even if not explicitly declared
\tcode{static}).
\begin{example}
\begin{codeblock}
class X {
  void operator delete(void*);
  void operator delete[](void*, std::size_t);
};

class Y {
  void operator delete(void*, std::size_t);
  void operator delete[](void*);
};
\end{codeblock}
\end{example}

\pnum
Since member allocation and deallocation functions are
\tcode{static}
they cannot be virtual.
\begin{note}
However, when the
\grammarterm{cast-expression}
of a
\grammarterm{delete-expression}
refers to an object of class type,
because the deallocation function actually called is looked up in the scope of
the class that is the dynamic type of the object
if the destructor is virtual, the effect is the same in that case.
For example,
\begin{codeblock}
struct B {
  virtual ~B();
  void operator delete(void*, std::size_t);
};

struct D : B {
  void operator delete(void*);
};

struct E : B {
  void log_deletion();
  void operator delete(E *p, std::destroying_delete_t) {
    p->log_deletion();
    p->~E();
    ::operator delete(p);
  }
};

void f() {
  B* bp = new D;
  delete bp;        // 1: uses \tcode{D::operator delete(void*)}
  bp = new E;
  delete bp;        // 2: uses \tcode{E::operator delete(E*, std::destroying_delete_t)}
}
\end{codeblock}
Here, storage for the object of class
\tcode{D}
is deallocated by
\tcode{D::operator delete()},
and
the object of class \tcode{E} is destroyed
and its storage is deallocated
by \tcode{E::operator delete()},
due to the virtual destructor.
\end{note}
\begin{note}
Virtual destructors have no effect on the deallocation function actually
called when the
\grammarterm{cast-expression}
of a
\grammarterm{delete-expression}
refers to an array of objects of class type.
For example,
\begin{codeblock}
struct B {
  virtual ~B();
  void operator delete[](void*, std::size_t);
};

struct D : B {
  void operator delete[](void*, std::size_t);
};

void f(int i) {
  D* dp = new D[i];
  delete [] dp;     // uses \tcode{D::operator delete[](void*, std::size_t)}
  B* bp = new D[i];
  delete[] bp;      // undefined behavior
}
\end{codeblock}
\end{note}

\pnum
Access to the deallocation function is checked statically.
Hence, even though a different one might actually be executed,
the statically visible deallocation function is required to be accessible.
\begin{example}
For the call on line ``// 1'' above,
if
\tcode{B::operator delete()}
had been private, the delete expression would have been ill-formed.
\end{example}

\pnum
\begin{note}
If a deallocation function has no explicit \grammarterm{noexcept-specifier}, it
has a non-throwing exception specification\iref{except.spec}.
\end{note}