\rSec0[class]{Classes}%

\indextext{class|(}

\gramSec[gram.class]{Classes}

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

\rSec1[class.pre]{Preamble}

\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.spec.partial}.

A \grammarterm{class-specifier} whose

\grammarterm{class-head} omits the

\grammarterm{class-head-name} defines an \defnadj{unnamed}{class}.

\begin{note}

An unnamed class thus can't

be \tcode{final}.

\end{note}

Otherwise, the \grammarterm{class-name} is an \grammarterm{identifier};

it is not looked up, and the \grammarterm{class-specifier} introduces it.

The

\grammarterm{class-name} is also bound in the scope of the class (template)

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.

If a \grammarterm{class-head-name} contains a \grammarterm{nested-name-specifier},

the \grammarterm{class-specifier} shall not inhabit a class scope.

If its \grammarterm{class-name} is an \grammarterm{identifier},

the \grammarterm{class-specifier} shall correspond to

one or more declarations nominable in

the class, class template, or namespace to which the

\grammarterm{nested-name-specifier} refers;

they shall all have the same target scope, and the target scope of the

\grammarterm{class-specifier} is that scope.

\begin{example}

\begin{codeblock}

namespace N {

template<class>

struct A {

struct B;

};

}

using N::A;

template<class T> struct A<T>::B {}; // OK

template<> struct A<void> {}; // OK

\end{codeblock}

\end{example}

\begin{note}

The \grammarterm{class-key} determines

whether the class is a union\iref{class.union} and

whether access is public or private by default\iref{class.access}.

A union holds the value of at most one data member at a time.

\end{note}

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}

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

\begin{note}

Class objects can be assigned\iref{over.ass,class.copy.assign},

passed as arguments to functions\iref{dcl.init,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}

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

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

\begin{itemize}

\item that has at least one eligible

copy constructor, move constructor,

copy assignment operator, or

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

\item where each eligible copy constructor, move constructor, copy assignment operator,

and move assignment operator is trivial, and

\item that has a trivial, non-deleted destructor\iref{class.dtor}.

\end{itemize}

A \defnadj{trivial}{class} is a class that is trivially copyable and

has one or more eligible default constructors\iref{class.default.ctor},

all of which are trivial.

\begin{note}

In particular, a trivially copyable or trivial class does not have

virtual functions or virtual base classes.

\end{note}

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.

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

\end{footnote}

\begin{note}

$M(\mathtt{X})$ is the set of the types of all non-base-class subobjects

that can be at a zero offset in \tcode{X}.

\end{note}

\begin{itemize}

\item If \tcode{X} is a non-union class type with no 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}

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

A \defnadj{standard-layout}{struct} is a standard-layout class

defined with the \grammarterm{class-key} \keyword{struct} or the

\grammarterm{class-key} \keyword{class}.

A \defnadj{standard-layout}{union} is a standard-layout class

defined with the

\grammarterm{class-key} \keyword{union}.

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

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

\begin{note}

Aggregates of class type are described in~\ref{dcl.init.aggr}.

\end{note}

A class \tcode{S} is an \defnadj{implicit-lifetime}{class} if

\begin{itemize}

it is an aggregate whose destructor is not user-provided or

it has at least one trivial eligible constructor and

a trivial, non-deleted destructor.

\end{itemize}

\rSec1[class.name]{Class names}

\indextext{definition!class name as type}%

\indextext{structure tag|see{class name}}%

\indextext{equivalence!type}%

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 overloads\iref{over} named \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}

\indextext{definition!scope of class}%

\begin{note}

It can be necessary to use an \grammarterm{elaborated-type-specifier}

to refer to a class

that belongs to a scope in which its name is also bound to

a variable, function, or enumerator\iref{basic.lookup.elab}.

\begin{example}

\begin{codeblock}

struct stat {

// ...

};

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

int stat(struct stat*); // \tcode{stat} now also names a function

void f() {

struct stat* ps; // \keyword{struct} prefix needed to name \tcode{struct stat}

stat(ps); // call \tcode{stat} function

}

\end{codeblock}

\end{example}

\indextext{class name!elaborated}%

\indextext{declaration!forward class}%

An \grammarterm{elaborated-type-specifier} can also be used to declare

an \grammarterm{identifier} as a \grammarterm{class-name}.

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

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}

\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 it can refer to

an existing class of the given name.

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

\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 \keyword{class} \tcode{A} must be used to refer to the

class. Such artistry with names can be confusing and is best avoided.

\end{note}

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

\rSec2[class.mem.general]{General}%

\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

using-enum-declaration\br

static_assert-declaration\br

template-declaration\br

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

\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 \defnadj{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 members\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}

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{deduction-guide}\iref{temp.deduct.guide},

\item a \grammarterm{template-declaration} whose \grammarterm{declaration} is one of the above,

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

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\iref{class.name,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.

A data member or member function

may be declared \keyword{static} in its \grammarterm{member-declaration},

in which case it is a \defnadj{static}{member} (see~\ref{class.static})

(a \defnadj{static}{data member}\iref{class.static.data} or

\defnadj{static}{member function}\iref{class.static.mfct}, respectively)

of the class.

Any other data member or member function is a \defnadj{non-static}{member}

(a \defnadj{non-static}{data member} or

\defnadj{non-static}{member function}\iref{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}

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{basic.scope.scope}.

\end{note}

A redeclaration of a class member outside its class definition shall be

a definition,

an explicit specialization, or

an explicit instantiation\iref{temp.expl.spec,temp.explicit}.

The member shall not be a non-static data member.

\indextext{completely defined}%

A \defn{complete-class context} of a class (template) is a

\begin{itemize}

\item function body\iref{dcl.fct.def.general},

\item default argument\iref{dcl.fct.default},

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

\item \grammarterm{noexcept-specifier}\iref{except.spec}, or

\item default member initializer

\end{itemize}

within the \grammarterm{member-specification} of the class or class template.

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

A class \tcode{C} is complete at a program point $P$

if the definition of \tcode{C} is reachable from $P$\iref{module.reach}

or if $P$ is in a complete-class context of \tcode{C}.

Otherwise, \tcode{C} is incomplete at $P$.

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}

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}

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.

An immediate invocation\iref{expr.const} that

is a potentially-evaluated subexpression\iref{intro.execution}

of a default member initializer

is neither evaluated nor checked for whether it

is a constant expression at the point where the subexpression appears.

A member shall not be declared with the \keyword{extern}

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

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.

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.

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

\indextext{class object!member}%

The type of a non-static data member shall not be an

incomplete type\iref{term.incomplete.type},

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

or a (possibly multidimensional) 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}

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

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

\begin{note}

\indextext{layout!class object}%

Non-variant non-static data members of

non-zero size\iref{intro.object}

are allocated so that later

members have higher addresses within a class object\iref{expr.rel}.

Implementation alignment requirements can cause two adjacent members

not to be allocated immediately after each other; so can requirements

for space for managing virtual functions\iref{class.virtual} and

virtual base classes\iref{class.mi}.

\end{note}

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 enumeration type; and

\item every member of every anonymous union that is a member of class

\tcode{T}.

\end{itemize}

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

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

\begin{itemize}

corresponding entities

have layout-compatible types\iref{basic.types},

corresponding entities have the same alignment requirements\iref{basic.align},

if a \grammarterm{has-attribute-expression}\iref{cpp.cond}

is not \tcode{0} for the \tcode{no_unique_address} attribute,

then neither entity is declared with

the \tcode{no_unique_address} attribute\iref{dcl.attr.nouniqueaddr}, and

either both entities are bit-fields with the same width

or neither is a bit-field.

\end{itemize}

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

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

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{term.layout.compatible.type}.

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}

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 can 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\iref{basic.compound,expr.static.cast}.

\end{note}

\rSec2[class.mfct]{Member functions}%

\indextext{member function!class}

\indextext{member function!inline}%

\indextext{definition!member function}%

If a member function is attached to the global module and is defined\iref{dcl.fct.def} in its class definition,

it is inline\iref{dcl.inline}.

\begin{note}

A member function is also inline if it is declared

\keyword{inline}, \keyword{constexpr}, or \keyword{consteval}.

\end{note}

\indextext{operator!scope resolution}%

\begin{example}

\begin{codeblock}

struct X {

typedef int T;

static T count;

void f(T);

};

void X::f(T t = count) { }

\end{codeblock}

The definition of the member function \tcode{f} of class \tcode{X} inhabits the global

scope; the notation \tcode{X::f} indicates 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}

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

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

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\iref{expr.ref,over.match.call}. A non-static

member function may also be called directly using the function call

syntax\iref{expr.call,over.match.call} from within

its class or a class derived from its class, or

a member thereof, as described below.

When an \grammarterm{id-expression}\iref{expr.prim.id} that is

neither part of a class member access syntax\iref{expr.ref}

nor the unparenthesized operand of

the unary \tcode{\&} operator\iref{expr.unary.op} is used

where the current class is \tcode{X}\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)} 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}

This transformation does 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.