static bool eq_int_type( int_type c1, int_type c2 ); (until C++11) static constexpr bool eq_int_type( int_type c1, int_type c2 ); (since C++11) Checks whether two values of type int_type are equal. Parameters c1, c2 - values to compare Return value true if c1 is equal to c2, false otherwise. Exceptions (none) (until C++11) noexcept specification: noexcept (since C++11) Complexity Constant.

void reset(); (since C++11) Resets the internal state of the distribution object. After a call to this function, the next call to operator() on the distribution object will not be dependent on previous calls to operator(). Parameters (none). Return value (none). Complexity Constant.

void register_callback( event_callback function, int index ); Registers a user-defined function which will be called by imbue(), std::basic_ios::copyfmt() and ~ios_base(). Every registered callback is called every time: the event type (a value of type event) is passed as its first argument, and may be used to distinguish between the callers. The callbacks are called in the reverse order of registration (in other words, register_callback() pushes a callback pair on the callback stack). I

Defined in header <memory> template< class T > struct default_delete (1) (since C++11) template< class T > struct default_delete<T[]> (2) (since C++11) std::default_delete is the default destruction policy used by std::unique_ptr when no deleter is specified. 1) The non-specialized default_delete uses delete to deallocate memory for a single object. 2) A partial specialization for array types that uses delete[] is also provided. Member functions

Usage long type modifier

Defined in header <atomic> (1) (since C++11) template< class T > bool atomic_compare_exchange_weak( std::atomic<T>* obj, T* expected, T desired ); template< class T > bool atomic_compare_exchange_weak( volatile std::atomic<T>* obj, T* expected, T desired ); (2) (since C++11) template< class T > bool atomic_compare_exchange_strong( std::atomic<T>* obj,

Defined in header <scoped_allocator> template < class T, class... Args > void construct( T* p, Args&&... args ); (1) template< class T1, class T2, class... Args1, class... Args2 > void construct( std::pair<T1, T2>* p, std::piecewise_construct_t, std::tuple<Args1...> x, std::tuple<Args2...> y ); (2) template< class T1, class T2 > void construct( std::pair<T1, T2>* p ); (3

Defined in header <sstream> template< class CharT, class Traits = std::char_traits<CharT>, class Allocator = std::allocator<CharT> > class basic_stringbuf : public std::basic_streambuf<CharT, Traits> std::basic_stringbuf is a std::basic_streambuf whose associated character sequence is a memory-resident sequence of arbitrary characters, which can be initialized from or made available as an instance of std::basic_string. Typical impleme

Defined in header <algorithm> template< class BidirIt, class UnaryPredicate > BidirIt stable_partition( BidirIt first, BidirIt last, UnaryPredicate p ); Reorders the elements in the range [first, last) in such a way that all elements for which the predicate p returns true precede the elements for which predicate p returns false. Relative order of the elements is preserved. Parameters first, last - the range of elements to reorder p - unary predicate whic

Defined in header <cwchar> wint_t putwchar( wchar_t ch ); Writes a wide character ch to stdout. Parameters ch - wide character to be written Return value ch on success, WEOF on failure. See also putchar writes a character to stdout (function) fputwcputwc writes a wide character to a file stream (function) C documentation for putwchar