param_type param() const; (1) (since C++11) void param( const param_type& params ); (2) (since C++11) Manages the associated distribution parameter set. 1) Returns the associated parameter set. 2) Sets the associated parameter set to params. Parameters params - new contents of the associated parameter set Return value 1) The associated parameter set. 2) (none). Complexity Constant.

template< class... Args > std::pair<iterator,bool> emplace( Args&&... args ); (since C++11) Inserts a new element into the container by constructing it in-place with the given args if there is no element with the key in the container. Careful use of emplace allows the new element to be constructed while avoiding unnecessary copy or move operations. The constructor of the new element (i.e. std::pair<const Key, T>) is called with exactly the same arguments as sup

Defined in header <cstdio> int setvbuf( std::FILE* stream, char* buffer, int mode, std::size_t size ); Changes the the buffering mode of the given file stream stream as indicated by the argument mode. In addition, If if buffer is a null pointer, resizes of the internal buffer to size. If buffer is not a null pointer, instructs the stream to use the user-provided buffer of size size beginning at buffer. The stream must be closed (with fclose) before the lifetime of the ar

Defined in header <sstream> template< class CharT, class Traits = std::char_traits<CharT> > class basic_ostringstream; (until C++11) template< class CharT, class Traits = std::char_traits<CharT>, class Allocator = std::allocator<CharT> > class basic_ostringstream; (since C++11) The class template std::basic_ostringstream implements output operations on memory (std::basic_string) based streams. It essentially wraps

void operator+=( const std::valarray<T>& other ); void operator-=( const std::valarray<T>& other ); void operator*=( const std::valarray<T>& other ); void operator/=( const std::valarray<T>& other ); void operator%=( const std::valarray<T>& other ); void operator&=( const std::valarray<T>& other ); void operator|=( const std::valarray<T>& other ); void operator^=( const std::vala

Implementation defined behavior is controlled by #pragma directive. Syntax #pragma pragma_params (1) _Pragma ( string-literal ) (2) (since C++11) 1) Behaves in implementation-defined manner 2) Removes the L prefix (if any), the outer quotes, and leading/trailing whitespace from string-literal, replaces each \" with " and each \\ with \, then tokenizes the result (as in translation stage 3), and then uses the result as if the input to #pragma in (1) Explanation Pragma dire

Defined in header <tuple> template< class... Types > tuple<Types&...> tie( Types&... args ); (since C++11) (until C++14) template< class... Types > constexpr tuple<Types&...> tie( Types&... args ); (since C++14) Creates a tuple of lvalue references to its arguments or instances of std::ignore. Parameters args - zero or more lvalue arguments to construct the tuple from Return value A std::tuple object containing lva

(1) explicit map( const Compare& comp = Compare(), const Allocator& alloc = Allocator() ); (until C++14) map() : map( Compare() ) {} explicit map( const Compare& comp, const Allocator& alloc = Allocator() ); (since C++14) explicit map( const Allocator& alloc ); (1) (since C++11) (2) template< class InputIterator > map( InputIterator first, InputIterator last, const Compare& comp = Compare(), const Allocat

static const std::float_round_style round_style (until C++11) static constexpr std::float_round_style round_style (since C++11) The value of std::numeric_limits<T>::round_style identifies the rounding style used by the floating-point type T whenever a value that is not one of the exactly repesentable values of T is stored in an object of that type. Standard specializations T value of std::numeric_limits<T>::round_style /* non-specialized */ std::round_toward_

static constexpr T lowest() (since C++11) Returns the lowest finite value representable by the numeric type T, that is, a finite value x such that there is no other finite value y where y < x. This is different from std::numeric_limits<T>::min() for floating-point types. Only meaningful for bounded types. Return value T std::numeric_limits<T>::lowest() /* non-specialized */ T(); bool false char CHAR_MIN signed char SCHAR_MIN unsigned char ​0​ w