Requirements A FormattedInputFunction is a stream input function that performs the following: Constructs an object of type basic_istream::sentry with automatic storage duration and with the noskipws argument set to false, which performs the following if eofbit or badbit are set on the input stream, sets the failbit as well, and if exceptions on failbit are enabled in this input stream's exception mask, throws ios_base::failure. flushes the tie()'d output stream, if applicable if ios_b

std::map::value_compare value_comp() const; Returns a function object that compares objects of type std::map::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)

(1) explicit lock_guard( mutex_type& m ); (until C++17) explicit lock_guard( MutexTypes&... m ); (since C++17) (2) lock_guard( mutex_type& m, std::adopt_lock_t t ); (until C++17) lock_guard( MutexTypes&... m, std::adopt_lock_t t ); (since C++17) lock_guard( const lock_guard& ) = delete; (3) (since C++11) Acquires ownership of the given mutex m. 1) Effectively calls m.lock(). The behavior is undefined if m is not a recursive mutex and the cur

bool owns_lock() const; (since C++11) Checks whether *this owns a locked mutex or not. Parameters (none). Return value true if *this has an associated mutex and has acquired ownership of it, false otherwise. Exceptions noexcept specification: noexcept See also operator bool tests whether the lock owns its associated mutex (public member function)

template< class Iterator > typename reverse_iterator<Iterator>::difference_type operator-( const reverse_iterator<Iterator>& lhs, const reverse_iterator<Iterator>& rhs ); (until C++11) template< class Iterator1, class Iterator2 > auto operator-( const reverse_iterator<Iterator1>& lhs, const reverse_iterator<Iterator2>& rhs ) -> decltype(rhs.base() - lhs.base()); (since C++11) Returns t

Defined in header <future> std::error_condition make_error_condition( std::future_errc e ); (since C++11) Constructs an std::error_condition object from a value of type std::future_errc as if by: std::error_condition(static_cast<int>(e), std::future_category()). Parameters e - error code number Return value A value of type std::error_condition that holds the error code number from e associated with the error category "future". Example See also e

Defined in header <cwchar> wint_t fgetwc( std::FILE* stream ); wint_t getwc( std::FILE* stream ); Reads the next wide character from the given input stream. getwc() may be implemented as a macro and may evaluate stream more than once. Parameters stream - to read the wide character from Return value The next wide character from the stream or WEOF if an error has occurred or the end of file has been reached. If an encoding error occurred, errno is set to E

static std::chrono::time_point<std::chrono::high_resolution_clock> now(); (since C++11) Returns a time point representing the current point in time. Parameters (none). Return value A time point representing the current time. Exceptions noexcept specification: noexcept Example #include <iostream> #include <vector> #include <numeric> #include <chrono> volatile int sink; int main() { for (auto size = 1ull; size < 1000000000ull; size *=

Defined in header <iostream> extern std::istream cin; (1) extern std::wistream wcin; (2) The global objects std::cin and std::wcin control input from a stream buffer of implementation-defined type (derived from std::streambuf), associated with the standard C input stream stdin. These objects are guaranteed to be constructed before the first constructor of a static object is called and they are guaranteed to outlive the last destructor of a static object, so that it is

native_handle_type native_handle(); (since C++11) (optional) Returns the underlying implementation-defined native handle object. Parameters (none). Return value Implementation-defined native handle object. Exceptions Implementation-defined. Example