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

type \tcode{T} must be complete if:

When \tcode{D} is the type of a complete object, it will have a subobject of

type \tcode{B}, so it must be aligned appropriately for a \tcode{\keyword{long} \keyword{double}}.

as a virtual base class, the \tcode{B} subobject might be part of a different

The intended reading is that there must exist an

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.

An explicit destructor call must always be written using

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.

To use \tcode{U}, some or all of these member functions

must be user-provided.

would make class \tcode{circle} non-abstract and a definition of

\tcode{circle::draw()} must be provided.

must be deferred until it is determined that this use of

must be deferred until the entire \grammarterm{base-specifier-list} has been seen.

f(c); // error on implementations where \tcode{sizeof(int) > 1}: must be \tcode{int}-sized

and its usability in constant expressions\iref{expr.const}. As

described in~\ref{dcl.init}, the definition of an object or subobject

of const-qualified type must specify an initializer or be subject to

default-initialization.

However, the first argument must be of a type

that can be converted to a

\keyword{const}

\tcode{char*}.

Otherwise, the initializer list must be \tcode{\{\}},

The cast and assignment operators must still perform their specific

it must have a volatile copy constructor to initialize the temporary object

it must have an accessible and non-deleted destructor;

``\tcode{x = std::move(x)}''; the second ``\tcode{x}'' must bind to a

// The inner closure type must be a literal type regardless of how reference captures are represented.

Although class \tcode{B} need not contain the original member, the

dynamic type of the object with which indirection through the pointer

to member is performed must contain the original member;

used in limited ways (to initialize a reference, for example); this

lvalue must not be converted to a prvalue, see~\ref{conv.lval}.

When the allocation function returns a value other than null, it must be

This means that the syntax of the \grammarterm{delete-expression} must

match the type of the object allocated by \keyword{new}, not the syntax of the

\grammarterm{new-expression}.

char array[1 + int(1 + 0.2 - 0.1 - 0.1)]; // Must be evaluated during translation

int size = 1 + int(1 + 0.2 - 0.1 - 0.1); // May be evaluated at runtime

must appear\iref{basic.def.odr,dcl.inline,temp.pre},

which must be functions or function templates,

the \grammarterm{defining-type-id} of \tcode{A} must be of the form

instantiation\iref{temp.decls} and must obey the one-definition rule\iref{basic.def.odr}.

The member class must be defined before its first use that requires

If such a non-template function is odr-used\iref{term.odr.use} in a program, it must be defined;

it will not be implicitly instantiated using the function template definition.

a.f(16); // \tcode{A<int>::f} must be defined somewhere

cannot be deduced from a function call and the

must be explicitly specified.

// \tcode{T} deduced as \tcode{int}; \tcode{a.xm} must be convertible to \tcode{A<int>::X}

// \tcode{i} is explicitly specified to be \tcode{77}; \tcode{b.ym} must be convertible to \tcode{B<77>::Y}