A SequenceContainer is a Container that stores objects of the same type in a linear arrangement. Requirements The type X satisfies SequenceContainer if. The type X satisfies Container, and Given. T, the element type of X A, the allocator type of X: X::allocator_type if it exists, otherwise std::allocator<T> a, rvalue expression of type of type X p, a valid const iterator into a q, a valid dereferenceable const iterator into a q1 and q2, two const iterators into a such tha

A seed sequence is an object that produces unsigned integer values i in the range 0 ≤ i < 232 based on a consumed range of integer data. Requirements S is a SeedSequence. q is an object of S and r is a potentially constant object of S. T is the result_type. ib,ie are InputIterators with a value_type of unsigned integer values of at least 32 bits. il is an std::initializer_list<T>. rb,re are mutable RandomAccessIterators with a value_type of unsigned integer values of at l

This header is part of the dynamic memory management library. Classes scoped_allocator_adaptor (C++11) implements multi-level allocator for multi-level containers (class template) Functions operator==operator!= compares two scoped_allocator_adaptor instances (public member function of std::scoped_allocator_adaptor) Synopsis namespace std { template <class OuterAlloc, class... InnerAlloc> class scoped_allocator_adaptor; template <class OuterA1,

Each name that appears in a C++ program is only valid in some possibly discontiguous portion of the source code called its scope. Within a scope, unqualified name lookup can be used to associate the name with its declaration. Block scope The potential scope of a variable introduced by a declaration in a block (compound statement) begins at the point of declaration and ends at the end of the block. Actual scope is the same as potential scope unless there is a nested block with a declaration t

A ReversibleContainer is a Container that has iterators that meet the requirements of either BidirectionalIterator or RandomAccessIterator. Such iterators allow a ReversibleContainer to be iterated over in reverse. Requirements X Container type T Element type a, b Objects of type X Types expression return type conditions complexity X::reverse_iterator iterator type whose value type is T reverse_iterator<iterator> compile time X::const_reverse_iterator constant

Terminates current function and returns specified value to the caller function. Syntax attr(optional) return expression(optional) ; (1) attr(optional) return braced-init-list ; (2) (since C++11) attr(C++11) - optional sequence of any number of attributes expression - expression, convertible to the function return type braced-init-list - brace-enclosed list of initializers and other braced-init-lists Explanation 1) Evaluates the expression, terminates the

Usage return statement: as the declaration of the statement

Usage in a function or function template declaration, specifies an associated constraint (concepts TS) specifies an constant expression on template parameters that evaluates a requirement(concepts TS)

The preprocessor supports text macro replacement. Function-like text macro replacement is also supported. Syntax #define identifier replacement-list(optional) (1) #define identifier( parameters ) replacement-list (2) #define identifier( parameters, ... ) replacement-list (3) (since C++11) #define identifier( ... ) replacement-list (4) (since C++11) #undef identifier (5) Explanation #define directives The #define directives define the identifier as macro

Converts between types by reinterpreting the underlying bit pattern. Syntax reinterpret_cast < new_type > ( expression ) Returns a value of type new_type. Explanation Unlike static_cast, but like const_cast, the reinterpret_cast expression does not compile to any CPU instructions. It is purely a compiler directive which instructs the compiler to treat the sequence of bits (object representation) of expression as if it had the type new_type. Only the following conversions can