A RandomNumberDistribution is a function object returning random numbers according to a

Encapsulates strategies for access/addressing, allocation/deallocation and construction/destruction of objects.

An AllocatorAwareContainer is a Container that holds an instance of an *Allocator*

An AssociativeContainer is an ordered Container that provides fast lookup of objects based on keys.

BasicFormatter is a type that abstracts formatting operations for a given formatting argument type and character type.

The BasicLockable requirements describe the minimal characteristics of types that provide exclusive blocking semantics for execution agents (i.e. threads).

The Lockable requirements extends the BasicLockable requirements to include attempted locking.

BinaryPredicate is a set of requirements expected by some of the standard library facilities from the user-provided arguments.

A BinaryTypeTrait is a class template that describes a relationship between its two template type parameters with a intergral_constant

Defines a type that can be used to represent a set of constant values or any combination of those values.

A Callable type is a type for which the INVOKE and INVOKE<R> operations

CharTraits is a traits class that abstracts basic character and string operations for a given character type.

The Clock requirements describe a bundle consisting of a std::timepoint,

Compare is a set of requirements expected by some of the standard library facilities from the user-provided function object types.

A ConstexprIterator is a LegacyIterator

A Container is an object used to store other objects and taking care of the management of the memory used by the objects it contains.

A ContiguousContainer is a Container that stores objects in contiguous memory locations.

Specifies that an instance of the type can be copy-assigned from an lvalue expression.

Specifies that an instance of the type can be copy-constructed from an lvalue expression.

Specifies that an instance of the type can be copy-constructed in-place by a given allocator.

Specifies that an instance of the type can be default constructed.

Specifies that an instance of the type can be default-constructed in-place by a given allocator.

Specifies that an instance of the type can be destructed.

Specifies that an object of the type can be constructed from a given set of arguments in uninitialized storage by a given allocator.

The type must work with == operator and the result should have standard semantics.

Specifies that an object of the type can be destroyed by a given Allocator.

Requirements

Requirements

Formatter is a type that abstracts formatting operations for a given formatting argument type and character type.

A FunctionObject type is the type of an object that can be used on the left of the function call operator.

A Hash is a function object for which the output depends only on the input and has a very low probability of

Note: the standard doesn't define a named requirement with this name. This is a type category defined by the core language.

A LegacyBidirectionalIterator is a LegacyForwardIterator

A LegacyContiguousIterator is a LegacyIterator

A LegacyForwardIterator is a LegacyIterator that can read data from the pointed-to element.

A LegacyInputIterator is a LegacyIterator that can read from the pointed-to element.

The LegacyIterator requirements describe types that can be used to identify and traverse the elements of a container.

A LegacyOutputIterator is a LegacyIterator that can write to the pointed-to element.

A LegacyRandomAccessIterator is a LegacyBidirectionalIterator

The type must work with < operator and the result should have standard semantics.

Specifies that a type is a literal type. Literal types are the types of constexpr variables and they can be constructed,

Specifies that an instance of the type can be assigned from an rvalue argument.

Specifies that an instance of the type can be constructed from an rvalue argument.

Specifies that an object of the type can be constructed into uninitialized storage from an rvalue of that type by a given allocator.

The Mutex requirements extends the Lockable requirements to include inter-thread synchronization.

Specifies that the type is a pointer-like object which can be compared to std::nullptrt objects.

Specifies that the type can be used as the template argument of std::valarray

Specifies that the type is POD (Plain Old Data) type. This means the type is compatible with the types used in the C programming language,

The Predicate requirements describe a callable that returns a value testable as a bool.

A random number engine is a function object returning unsigned integer values such that each value in the range of possible results has (ideally) equal probability.

A RandomNumberEngineAdaptor is a RandomNumberEngine that transforms the output of

Range adaptor closure objects are FunctionObjects that are callable via the pipe operator:

Range adaptor objects are customization point objects that accept viewablerange as their first arguments and return a view.

RegexTraits is a traits class that abstracts operations needed for a given character type when as template type parameters

A ReversibleContainer is a Container that has iterators that meet the requirements of either

Note: the standard doesn't define a named requirement with this name. This is a type category defined by the core language.

A SeedSequence is an object that produces unsigned integer values i in the range 0 ≤ i 32 based on a consumed range of integer data.

A SequenceContainer is a Container that stores objects of the same type in a linear arrangement.

The SharedMutex requirements extend the Mutex requirements to include shared lock ownership mode.

The SharedTimedLockable requirements describe the characteristics of types that provide timed shared blocking semantics for execution agents (threads, processes, tasks).

The SharedTimedMutex requirements extend the TimedMutex requirements to include shared lock ownership mode.

Specifies that a type is a standard layout type. Standard layout types are useful for communicating with code written in other programming languages.

Any lvalue or rvalue of this type can be swapped with any lvalue or rvalue of some other type, using unqualified function call swap()

The SharedLockable requirements describe the minimal characteristics of types that provide shared blocking semantics for execution agents (i.e. threads).

The TimedLockable requirements describe the characteristics of types that provide timed exclusive blocking semantics for execution agents

The TimedMutex requirements extend the TimedLockable requirements to include inter-thread synchronization.

A TransformationTrait is a class template that provides a transformation of its template type parameter.

The TrivialClock requirements describe the requirements satisfied by several clocks in the chrono library.

Note: the standard doesn't define a named requirement with this name. This is a type category defined by the core language.

Specifies that a type is a trivial type.

A UnaryTypeTrait is a class template that describes a property of its template type parameter with an integralconstant (typically boolconstant) specialization.

Requirements

Requirements

A uniform random bit generator is a function object returning unsigned integer values such that each value in the range of

Unordered associative containers are Containers that provide fast lookup of objects based on keys.

Two objects of this type can be dereferenced and the resulting values can be swapped using unqualified function call swap()

Smart Pointer