bool valid() const; (since C++11) Checks if the future refers to a shared state. This is the case only for futures that were not default-constructed or moved from. Unlike std::future, std::shared_future's shared state is not invalidated when get() is called. The behavior is undefined if any member function other than the destructor, the move-assignment operator, or valid is called on a shared_future that does not refer to shared state (although implementations are encouraged to throw s

Defined in header <iomanip> template< class CharT > /*unspecified*/ quoted(const CharT* s, CharT delim=CharT('"'), CharT escape=CharT('\\')); (1) (since C++14) template< class CharT, class Traits, class Allocator > /*unspecified*/ quoted(const std::basic_string<CharT, Traits, Allocator>& s, CharT delim=CharT('"'), CharT escape=CharT('\\')); (2) (since C++14) template< class CharT, class Traits, clas

void swap( priority_queue& other ); (since C++11) Exchanges the contents of the container adaptor with those of other. Effectively calls using std::swap; swap(c, other.c); swap(comp, other.comp); Parameters other - container adaptor to exchange the contents with Return value (none). Exceptions noexcept specification: noexcept(noexcept(std::swap(c, other.c)) && noexcept(std::swap(comp, other.comp))) Complexity Same as underlying container (typically cons

void clear(); (since C++11) Removes all elements from the container. Invalidates any references, pointers, or iterators referring to contained elements. May invalidate any past-the-end iterators. Parameters (none). Return value (none). Exceptions noexcept specification: noexcept Complexity Linear in the size of the container. See also erase erases elements (public member function)

std::multimap::value_compare value_comp() const; Returns a function object that compares objects of type std::multimap::value_type (key-value pairs) by using key_comp to compare the first components of the pairs. Parameters (none). Return value The value comparison function object. Complexity Constant. See also key_comp returns the function that compares keys (public member function)

Defined in header <locale> template< class charT > bool isupper( charT ch, const locale& loc ); Checks if the given character is classified as an uppercase alphabetic character by the given locale's std::ctype facet. Parameters ch - character loc - locale Return value Returns true if the character is classified as uppercase, false otherwise. Possible implementation template< class charT > bool isupper( charT ch, const std::locale&

basic_filebuf(); (1) basic_filebuf( const std::basic_filebuf& rhs ) = delete; (2) (since C++11) basic_filebuf( std::basic_filebuf&& rhs ); (3) (since C++11) Contructs new std::basic_filebuf object. 1) Constructs a std::basic_filebuf object, initializing the base class by calling the default constructor of std::basic_streambuf. The created basic_filebuf is not associated with a file, and is_open() returns false. 2) The copy constructor is deleted; std::basic_fil

Defined in header <chrono> class system_clock; (since C++11) Class std::chrono::system_clock represents the system-wide real time wall clock. It may not be monotonic: on most systems, the system time can be adjusted at any moment. It is the only C++ clock that has the ability to map its time points to C-style time, and, therefore, to be displayed. std::chrono::system_clock meets the requirements of TrivialClock. Member types Member type Definition rep signed arith

T* release(); (deprecated) Releases the held pointer. After the call *this holds the null pointer. Parameters (none). Return value get(). Exceptions (none). See also reset destroys the managed object (public member function)

void swap( promise& other ); (since C++11) Exchanges the shared states of two promise objects. Parameters other - the promise to swap with Return value (none). Exceptions noexcept specification: noexcept Example See also std::swap(std::promise) (C++11) specializes the std::swap algorithm (function template)