This header is part of the dynamic memory management library, in particular provides low level memory management features. Functions operator newoperator new[] allocation functions (function) operator deleteoperator delete[] deallocation functions (function) get_new_handler (C++11) obtains the current new handler (function) set_new_handler registers a new handler (function) Classes bad_alloc exception thrown when memory allocation fails (class) bad_arr

void rehash( size_type count ); (since C++11) Sets the number of buckets to count and rehashes the container, i.e. puts the elements into appropriate buckets considering that total number of buckets has changed. If the new number of buckets makes load factor more than maximum load factor (count < size() / max_load_factor()), then the new number of buckets is at least size() / max_load_factor(). Parameters count - new number of buckets Return value (none). Complexity

bitset<N> operator<<( std::size_t pos ) const; (1) bitset<N>& operator<<=( std::size_t pos ); (2) bitset<N> operator>>( std::size_t pos ) const; (3) bitset<N>& operator>>=( std::size_t pos ); (4) Performs binary shift left and binary shift right. Zeroes are shifted in. 1-2) Performs binary shift left. The (2) version is destructive, i.e. performs the shift to the current object. 3-4) Performs binary shift right.

void swap( shared_ptr& r ); (since C++11) Exchanges the contents of *this and r. Parameters r - smart pointer to exchange the contents with Return value (none). Exceptions noexcept specification: noexcept

const char* name() const; (since C++11) Returns the name of the associated std::type_info object. Equivalent to calling std::type_info::name() directly. Parameters (none). Return value The name of the associated type_info object. Exceptions (none) (until C++14) noexcept specification: noexcept (since C++14) Example

explicit subtract_with_carry_engine( result_type value = default_seed ); (1) (since C++11) template< class Sseq > explicit subtract_with_carry_engine( Sseq& s ); (2) (since C++11) subtract_with_carry_engine( const subtract_with_carry_engine& ); (3) (since C++11) (implicitly declared) Constructs the pseudo-random number engine. The overload (2) only participate in overload resolution if Sseq qualifies as a SeedSequence. In particular, it is excluded from the se

Defined in header <functional> template< class T > std::reference_wrapper<T> ref(T& t); (1) (since C++11) template< class T > std::reference_wrapper<T> ref( std::reference_wrapper<T> t ); (2) (since C++11) template <class T> void ref(const T&&) = delete; (3) (since C++11) template< class T > std::reference_wrapper<const T> cref( const T& t ); (4) (since C++11) template< class T > std::ref

(1) template< class Clock, class Dur1, class Dur2 > bool operator==( const time_point<Clock,Dur1>& lhs, const time_point<Clock,Dur2>& rhs ); (since C++11) (until C++14) template< class Clock, class Dur1, class Dur2 > constexpr bool operator==( const time_point<Clock,Dur1>& lhs, const time_point<Clock,Dur2>& rhs ); (since C++14) (2) template< class Clock, class Dur1, class Dur2 >

protected: virtual int_type pbackfail( int_type c = Traits::eof() ); This protected virtual function is called by the public functions sungetc() and sputbackc() (which, in turn, are called by basic_istream::unget and basic_istream::putback) when either: 1) There is no putback position in the get area (pbackfail() is called with no arguments). In this situation, the purpose of pbackfail() is to back up the get area by one character, if the associated character sequence allows this (e.g.

Defined in header <functional> template< class Predicate > std::binary_negate<Predicate> not2(const Predicate& pred); (until C++14) template< class Predicate > constexpr std::binary_negate<Predicate> not2(const Predicate& pred); (since C++14) not2 is a helper function to create a function object that returns the complement of the binary predicate function passed. The function object created is of type std::binary_negate<Predicate>