Defined in header <cstdlib> #define RAND_MAX /*implementation defined*/ Expands to an integer constant expression equal to the maximum value returned by the function std::rand. This value is implementation dependent. It's guaranteed that this value is at least 32767. See also rand generates a pseudo-random number (function) srand seeds pseudo-random number generator (function) C documentation for RAND_MAX

This header was originally in the C standard library as <iso646.h>. Compatibility header, in C defines alternative operator representations which are keywords in C++. This means that in a conforming implementation this header is empty. It may still be required in order to have the alternative operator representations in old or non-conformant compilers.

Defined in header <cstdlib> std::div_t div( int x, int y ); (1) std::ldiv_t div( long x, long y ); (2) std::lldiv_t div( long long x, long long y ); (3) (since C++11) std::ldiv_t ldiv( long x, long y ); (4) std::lldiv_t lldiv( long long x, long long y ); (5) (since C++11) Defined in header <cinttypes> std::imaxdiv_t div( std::intmax_t x, std::intmax_t y ); (6) (since C++11) std::imaxdiv_t imaxdiv( std::intmax_t x, std::in

Defined in header <exception> void terminate(); (until C++11) [[noreturn]] void terminate(); (since C++11) std::terminate() is called by the C++ runtime when exception handling fails for any of the following reasons: 1) an exception is thrown and not caught (it is implementation-defined whether any stack unwinding is done in this case) 2) an exception is thrown during exception handling (e.g. from a destructor of some local object, or from a function that had to be

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

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.

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