enum { up, down }; // defines \tcode{up} and \tcode{down}

namespace N { int d; } // defines \tcode{N} and \tcode{N::d}

X anX; // defines \tcode{anX}

\end{codeblock}

whereas these are just declarations:

\begin{codeblock}

For the purposes of the preceding requirements:

\begin{itemize}

\item If \tcode{D} is a class with an implicitly-declared

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

Every integer type has an \term{integer conversion rank} defined as follows:

\begin{itemize}

\item No two signed integer types other than \keyword{char} and \tcode{\keyword{signed}

\keyword{char}} (if \keyword{char} is signed) have the same rank, even if they have

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

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;

\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

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

X(const Mixins&... mixins) : Mixins(mixins)... { }

};

\end{codeblock}

\end{example}

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

A binary operator expression \tcode{a @ b} is

\defnx{usable}{usable!binary operator expression}

if either

\begin{itemize}

\tcode{a} or \tcode{b} is of class or enumeration type and

of type \tcode{R}\iref{cmp.categories}

of glvalues \tcode{a} and \tcode{b} of the same type

is defined as follows:

\begin{itemize}

If \tcode{a <=> b} is usable\iref{class.compare.default} and

of a possibly-empty list of $n$ comparison category types

$\tcode{T}_0$, $\tcode{T}_1$, $\dotsc$, $\tcode{T}_{n-1}$

is defined as follows:

\begin{itemize}

If at least one $\tcode{T}_i$ is \tcode{std::partial_ordering},

The signatures of the following member functions changed from taking an

\tcode{iterator} to taking a \tcode{const_iterator}:

\begin{itemize}

\item \tcode{insert(iter, val)} for \tcode{vector}, \tcode{deque}, \tcode{list},

\tcode{set}, \tcode{multiset}, \tcode{map}, \tcode{multimap}

Valid \CppIII{} code that relies on implicit boolean conversions will fail to

compile with this revision of \Cpp{}. Such conversions occur in the

following conditions:

\begin{itemize}

\item passing a value to a function that takes an argument of type \tcode{bool};

\item using \tcode{operator==} to compare to \tcode{false} or \tcode{true};

Header \libheaderref{cstring}:

The following functions have different declarations:

\begin{itemize}

\item \tcode{strchr}

\item \tcode{strpbrk}

Header \libheaderref{cwchar}:

The following functions have different declarations:

\begin{itemize}

\item \tcode{wcschr}

\item \tcode{wcspbrk}

Header \libheaderref{cstdlib}:

The following functions have different behavior:

\begin{itemize}

\item \tcode{atexit}

\item \tcode{exit}

The following type \tcode{T} meets the explicitly stated syntactic requirements

of concept \tcode{C} above but does not meet the additional implicit

requirements:

\begin{codeblock}

struct T {

bool operator==(const T&) const { return true; }

such that \tcode{f()} is equality-preserving.

Types \tcode{From} and \tcode{To} model \tcode{\libconcept{convertible_to}<From, To>}

only if:

\begin{itemize}

\tcode{To} is not an object or reference-to-object type, or

\tcode{static_cast<To>(f())} is equal to \tcode{test(f)}.

\tcode{FromR} is not a reference-to-object type, or

\begin{itemize}

If \tcode{FromR} is an rvalue reference to a non const-qualified type, the

Users can customize the behavior of \libconcept{common_with} by specializing the

\tcode{common_type} class template\iref{meta.trans.other}.

\end{note}

\end{itemdescr}

\rSec2[concepts.arithmetic]{Arithmetic concepts}

\end{itemize}

\tcode{LHS} and \tcode{RHS} model

\tcode{\libconcept{assignable_from}<LHS, RHS>} only if

\begin{itemize}

\item \tcode{addressof(lhs = rhs) == addressof(lcopy)}.

\item After evaluating \tcode{lhs = rhs}:

\begin{itemize}

\item \tcode{lhs} is equal to \tcode{rcopy}, unless \tcode{rhs} is a non-const

xvalue that refers to \tcode{lcopy}.

\tcode{ranges::swap(E1, E2)} for subexpressions \tcode{E1}

and \tcode{E2} is expression-equivalent to an expression

\tcode{S} determined as follows:

\begin{itemize}

\tcode{S} is \tcode{(void)swap(E1, E2)}

If \tcode{T} is an object type, then let \tcode{rv} be an rvalue of type

\tcode{T} and \tcode{u2} a distinct object of type \tcode{T} equal to

\tcode{rv}. \tcode{T} models \libconcept{move_constructible} only if

\begin{itemize}

\item After the definition \tcode{T u = rv;}, \tcode{u} is equal to \tcode{u2}.

If \tcode{T} is an object type, then let \tcode{v} be an lvalue of type

\tcode{T} or \tcode{\keyword{const} T} or an rvalue of type \tcode{\keyword{const} T}.

\tcode{T} models \libconcept{copy_constructible} only if

\begin{itemize}

\item After the definition \tcode{T u = v;},

\tcode{u} is equal to \tcode{v}\iref{concepts.equality} and

\tcode{v} is not modified.

\item \tcode{T(v)} is equal to \tcode{v} and does not modify \tcode{v}.

\end{itemize}

\end{itemdescr}

\rSec1[concepts.compare]{Comparison concepts}

Let \tcode{e} be an expression such that

\tcode{decltype((e))} is \tcode{T}.

\tcode{T} models \exposconcept{boolean-testable-impl} only if

\begin{itemize}

either \tcode{remove_cvref_t<T>} is not a class type, or

A \defnadj{disqualifying}{parameter}

is a function parameter whose declared type \tcode{P}

\begin{itemize}

is not dependent on a template parameter, and

A \defnadj{disqualifying}{declaration} is

\begin{itemize}

a (non-template) function declaration that

Given a type \tcode{T}, let \tcode{a}, \tcode{b}, and \tcode{c} be

lvalues of type \tcode{const remove_reference_t<T>}.

\tcode{T} models \libconcept{totally_ordered} only if

\begin{itemize}

\item Exactly one of \tcode{bool(a < b)}, \tcode{bool(a > b)}, or

\tcode{bool(a == b)} is \tcode{true}.

\item \tcode{bool(a <= b) == !bool(b < a)}.

\item \tcode{bool(a >= b) == !bool(a < b)}.

\end{itemize}

\end{itemdescr}

\begin{itemdecl}

and

\tcode{equiv}

both be transitive relations:

\begin{itemize}

\tcode{comp(a, b) \&\& comp(b, c)}

\ref{vector.modifiers})

all container types defined in this Clause meet

the following additional requirements:

\begin{itemize}

\item

If an exception is thrown by an

Likewise, the extent to which an implementation determines that a type cannot be

an allocator is unspecified, except that as a minimum a type \tcode{A} shall not qualify

as an allocator unless it meets both of the following conditions:

\begin{itemize}

\item The \grammarterm{qualified-id} \tcode{A::value_type}

is valid and denotes a type\iref{temp.deduct}.

the terms below are defined as if \tcode{A} were

\tcode{allocator<T>} --- no allocator object needs to be created

and user specializations of \tcode{allocator<T>} are not instantiated:

\begin{itemize}

\item

\tcode{T} is \defnx{\oldconcept{DefaultInsertable} into \tcode{X}}

to

\tcode{j}

is positive, the following condition holds:

\begin{codeblock}

value_comp(*j, *i) == false

\end{codeblock}

\pnum

For associative containers with unique keys the stronger condition holds:

\begin{codeblock}

value_comp(*i, *j) != false

\end{codeblock}

\pnum

The following exposition-only alias template may appear in deduction guides for sequence containers:

\begin{codeblock}

template<class InputIterator>

using @\placeholdernc{iter-value-type}@ = iterator_traits<InputIterator>::value_type; // \expos

appends \tcode{sz - size()} default-inserted elements to the

sequence.

If \tcode{sz <= size()}, equivalent to:

\begin{codeblock}

list<T>::iterator it = begin();

advance(it, sz);

\tcode{stack},

the library provides the following constexpr-enabled formatter specialization

where \tcode{\placeholder{adaptor-type}} is the name of the template:

\indexlibraryglobal{formatter}%

\begin{codeblock}

namespace std {

\pnum

\result

A type \tcode{OP} such that:

\begin{itemize}

\item

\tcode{OP} meets the accessor policy requirements,

\pnum

Let \tcode{SubExtents} be a specialization of \tcode{extents} such that:

\begin{itemize}

\item

\tcode{SubExtents::rank()} equals

\tcode{SubExt\-ents::static_extent(\placeholder{MAP_RANK}(slices, $k$))}

equals the following, where $\Sigma_k$

denotes the type of \tcode{slices...[$k$]}:

\begin{itemize}

\item

\tcode{Extents::static_extent($k$)}