pointer address( reference x ) const; const_pointer address( const_reference x ) const; Returns the actual address of x even in presence of overloaded operator&. Parameters x - the object to acquire address of Return value The actual address of x. Exceptions (none) (until C++11) noexcept specification: noexcept (since C++11)

Defined in header <memory> template< class T, class Alloc, class... Args > shared_ptr<T> allocate_shared( const Alloc& alloc, Args... args ); (since C++11) Constructs an object of type T and wraps it in a std::shared_ptr using args as the parameter list for the constructor of T. All memory allocation is done using a copy of alloc, which satisfies the Allocator requirements. The copy constructor and the destructor of Alloc must not throw exceptions. Paramet

Defined in header <memory> template< class T > struct allocator; (1) template<> struct allocator<void>; (2) The std::allocator class template is the default Allocator used by all standard library containers if no user-specified allocator is provided. The default allocator is stateless, that is, all instances of the given allocator are interchangeable, compare equal and can deallocate memory allocated by any other instance of the same allocator type.

Defined in header <type_traits> template< class T > struct alignment_of; (since C++11) Provides the member constant value equal to the alignment requirement of the type T, as if obtained by an alignof expression. If T is an array type, returns the alignment requirements of the element type. If T is a reference type, returns the alignment requirements of the type referred to. If alignof(T) is not a valid expression, the behavior is undefined. Helper variable templat

Defined in header <type_traits> template< std::size_t Len, std::size_t Align = /*default-alignment*/ > struct aligned_storage; (since C++11) Provides the member typedef type, which is a PODType suitable for use as uninitialized storage for any object whose size is at most Len and whose alignment requirement is a divisor of Align. The default value of Align is the most stringent (the largest) alignment requirement for any object whose size is at most Len. If the defaul

Defined in header <algorithm> template< class ForwardIt > ForwardIt adjacent_find( ForwardIt first, ForwardIt last ); (1) template< class ForwardIt, class BinaryPredicate> ForwardIt adjacent_find( ForwardIt first, ForwardIt last, BinaryPredicate p ); (2) Searches the range [first, last) for two consecutive identical elements. The first version uses operator== to compare the elements, the second version uses the given binary predicate p. Parameters firs

Defined in header <memory> void* align( std::size_t alignment, std::size_t size, void*& ptr, std::size_t& space ); (since C++11) Given a pointer ptr to a buffer of size space, returns a pointer aligned by the specified alignment for size number of bytes and decreases space argument by the number of bytes used for alignment. The first aligned address is returned. The function modifies the pointer only if it would be possible to

Defined in header <type_traits> template< std::size_t Len, class... Types > struct aligned_union; (since C++11) Provides the member typedef type, which is a POD type of a size and alignment suitable for use as uninitialized storage for an object of any of the types listed in Types. The size of the storage is at least Len. std::aligned_union also determines the strictest (largest) alignment requirement among all Types and makes it available as the constant alignment_va

Defined in header <iterator> template< class InputIt, class Distance > void advance( InputIt& it, Distance n ); Increments given iterator it by n elements. If n is negative, the iterator is decremented. In this case, InputIt must meet the requirements of BidirectionalIterator, otherwise the behavior is undefined. Parameters it - iterator to be advanced n - number of elements it should be advanced Type requirements - InputIt must meet the requirem

Defined in header <memory> template< class T > T* addressof(T& arg); (since C++11) Obtains the actual address of the object or function arg, even in presence of overloaded operator& Parameters arg - lvalue object or function Return value Pointer to arg. Exceptions noexcept specification: noexcept Possible implementation template< class T > T* addressof(T& arg) { return reinterpret_cast<T*>( &const_