char* str() const; Calls freeze(), then returns a copy of start pointer of the get area, std::streambuf::eback(). The start of the get area, for all writeable std::strstreambuf objects constructed through the interface provided by std::strstream, is also the start of the put area. Parameters (none). Return value A copy of eback(), which may be a null pointer. Notes This function is typically called through the std::strstream interface. The call to freeze() guarantees that the r

Defined in header <thread> template< class Clock, class Duration > void sleep_until( const std::chrono::time_point<Clock,Duration>& sleep_time ); (since C++11) Blocks the execution of the current thread until specified sleep_time has been reached. The clock tied to sleep_time is used, which means that adjustments of the clock are taken into account. Thus, the duration of the block might, but might not, be less or more than sleep_time - Clock::now() at the ti

Defined in header <complex> template< class T > complex<T> log10( const complex<T>& z ); Computes complex common (base 10) logarithm of a complex value z with a branch cut along the negative real axis. The behavior of this function is equivalent to std::log(z)/std::log(10). Parameters z - complex value Return value Complex common logarithm of z. Example #include <iostream> #include <cmath> #include <complex> int

Defined in header <system_error> bool operator==( const error_code& lhs, const error_code& rhs ); (1) (since C++11) bool operator!=( const error_code& lhs, const error_code& rhs ); (1) (since C++11) bool operator<( const error_code& lhs, const error_code& rhs ); (1) (since C++11) Compares two error code objects. 1) Compares lhs and rhs for equality. 2) Compares lhs and rhs for equality. 3) Checks whether lhs is less than rhs. Par

Defined in header <ios> template< > struct is_error_code_enum<std::io_errc> : public std::true_type { }; (since C++11) This specialization of std::is_error_code_enum informs other library components that values of type std::io_errc are enumerations that hold error codes, which makes them implicitly convertible and assignable to objects of type std::error_code. Inherited from std::integral_constant Member constants value [static] true (public static m

(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

std::basic_stringbuf<CharT, Traits, Allocator>* rdbuf() const; Returns pointer to the underlying raw string device object. Parameters (none). Return value Pointer to the underlying raw string device. Example

(since C++11) (member only of atomic<Integral> template specialization) T fetch_sub( T arg, std::memory_order order = std::memory_order_seq_cst ); T fetch_sub( T arg, std::memory_order order = std::memory_order_seq_cst ) volatile; (since C++11) (member only of atomic<T*> template specialization) T* fetch_sub( std::ptrdiff_t arg, std::memory_order order = std::memory_order_seq_cst ); T* fetch_sub( std::ptrdiff_t ar

Defined in header <functional> template< class T > struct minus; (until C++14) template< class T = void > struct minus; (since C++14) Function object for performing subtraction. Effectively calls operator- on two instances of type T. Specializations The standard library provides a specialization of std::minus when T is not specified, which leaves the parameter types and return type to be deduced. minus<void> function object implementing x - y

Usage reinterpret_cast type conversion expression: as the declaration of the expression