%!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

\indextext{layout!class object}%

Non-static data members of a (non-union) class

with the same access control\iref{class.access}

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\iref{class.access}.

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

\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);