void discard( unsigned long long z ); (since C++11) Advances the internal state by z times. Equivalent to calling operator() z times and discarding the result. Parameters z - integer value specifying the number of times to advance the state by Return value (none). Complexity See also operator() advances the engine's state and returns the generated value (public member function)

Defined in header <random> template< class UIntType, UIntType a, UIntType c, UIntType m > class linear_congruential_engine; (since C++11) linear_congruential_engine is a random number engine based on Linear congruential generator (LCG). A LCG has a state that consists of single integer. The transition algorithm of the LCG function is xi+1 ← (axi+c) mod m. The following typedefs define the random number engine with two commonly used parameter sets:

explicit linear_congruential_engine( result_type value = default_seed ); (1) (since C++11) template< class Sseq > explicit linear_congruential_engine( Sseq& s ); (2) (since C++11) linear_congruential_engine( const linear_congruential_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 <stdexcept> class length_error; Defines a type of object to be thrown as exception. It reports errors that are consequence of attempt to exceed implementation defined length limits for some object. This exception is thrown by member functions of std::basic_string and std::vector::reserve. Inheritance diagram. Member functions (constructor) constructs the exception object (public member function) std::length_error::length_error explici

Defined in header <functional> template< class T > struct less_equal; (until C++14) template< class T = void > struct less_equal; (since C++14) Function object for performing comparisons. Unless specialized, invokes operator<= on type T. Specializations The partial specialization of std::less_equal for any pointer type yields a total order, even if the built-in operator<= does not. The standard library provides a specialization of std::less_equa

Defined in header <ios> std::ios_base& left( std::ios_base& str ); (1) std::ios_base& right( std::ios_base& str ); (2) std::ios_base& internal( std::ios_base& str ); (3) Modifies the default positioning of the fill characters. left and right apply to any output, internal applies to integer, floating-point, and monetary output. Has no effect on input. 1) sets the adjustfield of the stream str to left as if by calling str.setf(std::ios_base

Defined in header <functional> template<> class less<void>; (since C++14) std::less<> is a specialization of std::less with parameter and return type deduced. Member types Member type Definition is_transparent /* unspecified */ Member functions operator() tests if the lhs compares less than rhs (public member function) std::less<>::operator() template< class T, class U> constexpr auto operator()( T&& lhs, U&

Defined in header <functional> template< class T > struct less; (until C++14) template< class T = void > struct less; (since C++14) Function object for performing comparisons. Unless specialized, invokes operator< on type T. Specializations The partial specialization of std::less for any pointer type yields a total order, even if the built-in operator< does not. The standard library provides a specialization of std::less when T is not specified,

Defined in header <functional> template<> class less_equal<void>; (since C++14) std::less_equal<> is a specialization of std::less_equal with parameter and return type deduced. Member types Member type Definition is_transparent /* unspecified */ Member functions operator() tests if the lhs compares less or equal than rhs (public member function) std::less_equal<>::operator() template< class T, class U> constexpr aut

Defined in header <future> enum class launch : /* unspecified */ { async = /* unspecified */, deferred = /* unspecified */, /* implementation-defined */ }; (since C++11) Specifies the launch policy for a task executed by the std::async function. std::launch is an enumeration used as BitmaskType. The following constants denoting individual bits are defined by the standard library: Constant Explanation std::launch::async a new thread is launched to execu