std::independent_bits_engine

Defined in header <random> template< class Engine, std::size_t W, class UIntType > class independent_bits_engine; (since C++11) independent_bits_engine is a random number engine adaptor that produces random numbers with different number of bits than that of the wrapped engine. Template parameters Engine - the type of the wrapped engine W - the number of bits the generated numbers should have UIntType - the type of the generated random

std::dynarray::fill

void fill( const T& value ); (since {std}) Assigns the given value value to all elements in the container. Parameters value - the value to assign to the elements Return value (none). Complexity Linear in the size of the container.

unordered_map

This header is part of the containers library. Includes <initializer_list> (C++11) Classes unordered_map (since C++11) collection of key-value pairs, hashed by keys, keys are unique (class template) unordered_multimap (since C++11) collection of key-value pairs, hashed by keys (class template) Functions operator==operator!= compares the values in the unordered_map (function template) std::swap(std::unordered_map) (C++11) specializes the std::swap al

std::shared_future::wait_until

template< class Clock, class Duration > std::future_status wait_until( const std::chrono::time_point<Clock,Duration>& timeout_time ) const; (since C++11) wait_until waits for a result to become available. It blocks until specified timeout_time has been reached or the result becomes available, whichever comes first. The return value indicates why wait_until returned. The behavior is undefined if valid()== false before the call to this function. Parameters timeout_time

std::basic_istringstream::basic_istringstream

explicit basic_istringstream( ios_base::openmode mode = ios_base::in ); (1) explicit basic_istringstream( const std::basic_string<CharT,Traits,Allocator>& str, ios_base::openmode mode = ios_base::in ); (2) basic_istringstream( basic_istringstream&& other ); (3) (since C++11) Constructs new string stream. 1) Constructs new underlying string device. The underlying basic_stringbuf object is constructed as basic_stringbuf<Char,Traits,All

std::uninitialized_copy

Defined in header <memory> template< class InputIt, class ForwardIt > ForwardIt uninitialized_copy( InputIt first, InputIt last, ForwardIt d_first ); Copies elements from the range [first, last) to an uninitialized memory area beginning at d_first as if by. for (; first != last; ++d_first, (void) ++first) ::new (static_cast<void*>(std::addressof(*d_first))) typename iterator_traits<ForwardIterator>::value_type(*first); If an exception is thrown du

operators (std::shuffle_order_engine)

template< class CharT, class Traits, class Engine, size_t k > std::basic_ostream<CharT,Traits>& operator<<( std::basic_ostream<CharT,Traits>& ost, const std::shuffle_order_engine<Engine,k>& e ); (1) (since C++11) template< class CharT, class Traits, class Engine, size_t k > std::basic_istream<CharT,Traits>& operator>>( std::basic_istream<CharT,Traits>& ist,

std::list::rend

reverse_iterator rend(); const_reverse_iterator rend() const; const_reverse_iterator crend() const; (since C++11) Returns a reverse iterator to the element following the last element of the reversed container. It corresponds to the element preceding the first element of the non-reversed container. This element acts as a placeholder, attempting to access it results in undefined behavior. Parameters (none). Return value Reverse iterator to the element following the last

std::time_get

Defined in header <locale> template< class CharT, class InputIt = std::istreambuf_iterator<CharT> > class time_get; Class template std::time_get encapsulates date and time parsing rules. The I/O manipulator std::get_time uses the std::time_get facet of the I/O stream's locale to convert text input to a std::tm object. Inheritance diagram. Type requirements - InputIt must meet the requirements of InputIterator. Specializations Two stand

std::numpunct

Defined in header <locale> template< class CharT > class numpunct; The facet std::numpunct encapsulates numeric punctuation preferences. Stream I/O operations use std::numpunct through std::num_get and std::num_put for parsing numeric input and formatting numeric output. The numbers that are supported by std::numpunct have the format described below. Here digit represents the radix set specified by the fmtflags argument value, thousands-sep and decimal-point are the r