protected: void set_rdbuf( std::basic_streambuf<CharT,Traits>* sb ); Sets the associated stream buffer to sb without clearing the error state. This member function is protected: it is called by the move constructors of the derived streams such as std::basic_ofstream or std::basic_istringstream, as the final step after constructing the base class and after moving the stream buffer: only the most derived stream class knows how to correctly move the stream buffer, but std::basic_ios

template<class T, class Deleter> struct hash<unique_ptr<T, Deleter>>; (since C++11) The template specialization of std::hash for std::unique_ptr<T, Deleter> allows users to obtain hashes of objects of type std::unique_ptr<T, Deleter>. For a given std::unique_ptr<T, Deleter> p, this specialization ensures that std::hash<std::unique_ptr<T, Deleter>>()(p) == std::hash<T*>()(p.get()). Example #include <iostream> #include <m

template< class Mutex > void swap( shared_lock<Mutex>& lhs, shared_lock<Mutex>& rhs ); (since C++14) Specializes the std::swap algorithm for std::shared_lock. Exchanges the state of lhs with that of rhs. Effectively calls lhs.swap(rhs). Parameters lhs, rhs - lock wrappers whose states to swap Return value (none). Exceptions noexcept specification: noexcept Example See also swap swaps the data members with another shared_

Classes and structs are user-defined types, defined by class-specifier, which appears in decl-specifier-seq of the declaration syntax. The class specifier has the following syntax: class-key attr class-head-name base-clause { member-specification } class-key - one of class or struct. The keywords are identical except for the default member access and the default base class access. attr(C++11) - optional sequence of any number of attributes, may include alignas specifier c

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

static constexpr Rep max(); Returns the largest possible representation. Parameters (none). Return value returns std::numeric_limits<Rep>::max(). See also max [static] returns the special duration value max (public static member function of std::chrono::duration) zero [static] returns a zero-length representation (public static member function) min [static] returns the smallest possible representation (public static member function)

size_type find_first_of( const basic_string& str, size_type pos = 0 ) const; (1) size_type find_first_of( const CharT* s, size_type pos, size_type count ) const; (2) size_type find_first_of( const CharT* s, size_type pos = 0 ) const; (3) size_type find_first_of( CharT ch, size_type pos = 0 ) const; (4) Finds the first character equal to one of the characters in the given character sequence. The search considers only the interval [pos, size()). If the character is n

local_iterator end( size_type n ); (since C++11) const_local_iterator end( size_type n ) const; (since C++11) const_local_iterator cend( size_type n ) const; (since C++11) Returns an iterator to the element following the last element of the bucket with index n. . This element acts as a placeholder, attempting to access it results in undefined behavior. Parameters n - the index of the bucket to access Return value iterator to the element following the last eleme

Constructor is a special non-static member function of a class that is used to initialize objects of its class type. In the definition of a constructor of a class, member initializer list specifies the initializers for direct and virtual base subobjects and non-static data members. ( Not to be confused with std::initializer_list ). Syntax Constructors are declared using member function declarators of the following form: class-name ( parameter-list(optional) ) except-spec(optional) attr(opti

Defined in header <utility> (1) template< size_t N, class T1, class T2 > typename std::tuple_element<I, std::pair<T1,T2> >::type& get( pair<T1, T2>& p ); (since C++11) (until C++14) template< size_t N, class T1, class T2 > constexpr std::tuple_element_t<I, std::pair<T1,T2> >& get( pair<T1, T2>& p ); (since C++14) (2) template< size_t N, class T1, class T2 > const typename std::tuple_element