Defined in header <iomanip> template< class MoneyT > /*unspecified*/ put_money( const MoneyT& mon, bool intl = false ); (since C++11) When used in an expression out << put_money(mon, intl), converts the monetary value mon to its character representation as specified by the std::money_put facet of the locale currently imbued in out. This function behaves as a FormattedOutputFunction. Parameters mon - a monetary value, either long double or basic_strin

Defined in header <ctime> char* asctime( const std::tm* time_ptr ); Converts given calendar time std::tm to a textual representation of the following fixed 25-character form: Www Mmm dd hh:mm:ss yyyy\n. Www - three-letter English abbreviated day of the week from time_ptr->tm_wday, one of Mon, Tue, Wed, Thu, Fri, Sat, Sun. Mmm - three-letter English abbreviated month name from time_ptr->tm_mon, one of Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec. dd

std::pair<iterator,bool> insert( const value_type& value ); (1) (since C++11) template< class P > std::pair<iterator,bool> insert( P&& value ); (2) (since C++11) std::pair<iterator,bool> insert( value_type&& value ); (2) (since C++17) iterator insert( const_iterator hint, const value_type& value ); (3) (since C++11) template< class P > iterator insert( const_iterator hint, P&& value ); (4) (since C++11)

template< class Clock, class Duration > std::cv_status wait_until( std::unique_lock<std::mutex>& lock, const std::chrono::time_point<Clock, Duration>& timeout_time ); (1) (since C++11) template< class Clock, class Duration, class Predicate > bool wait_until( std::unique_lock<std::mutex>& lock, const std::chrono::time_point<Clock, Duration>& timeout_time, Predicate pred ); (2

Defined in header <regex> template< class CharT > class regex_traits; (since C++11) The type trait template regex_traits supplies std::basic_regex with the set of types and functions necessary to operate on the type CharT. Since many of regex operations are locale-sensitive (when std::regex_constants::collate flag is set), the regex_traits class typically holds an instance of a std::locale as a private member. Standard specializations Two specializations of std::re

template< class Rep, class Period > bool try_lock_for( const std::chrono::duration<Rep,Period>& timeout_duration ); (since C++11) Tries to lock the mutex. Blocks until specified timeout_duration has elapsed or the lock is acquired, whichever comes first. On successful lock acquisition returns true, otherwise returns false. If timeout_duration is less or equal timeout_duration.zero(), the function behaves like try_lock(). A steady clock is used to measure the duration. Th

Defined in header <exception> typedef /*unspecified*/ exception_ptr; (since C++11) std::exception_ptr is a nullable pointer-like type that manages an exception object which has been thrown and captured with std::current_exception. An instance of std::exception_ptr may be passed to another function, possibly on another thread, where the exception may be rethrown and handled with a catch clause. A default-constructed std::exception_ptr is a null pointer; it does not point to

Defined in header <functional> template< class Predicate > std::unary_negate<Predicate> not1(const Predicate& pred); (until C++14) template< class Predicate > constexpr std::unary_negate<Predicate> not1(const Predicate& pred); (since C++14) not1 is a helper function to create a function object that returns the complement of the unary predicate function passed. The function object created is of type std::unary_negate<Predicate>. Th

iterator erase( const_iterator pos ); (1) (since C++11) iterator erase( const_iterator first, const_iterator last ); (2) (since C++11) size_type erase( const key_type& key ); (3) (since C++11) Removes specified elements from the container. 1) Removes the element at pos. 2) Removes the elements in the range [first; last), which must be a valid range in *this. 3) Removes the element (if one exists) with the key equivalent to key. References and iterators to the erased e

C++ includes built-in support for threads, mutual exclusion, condition variables, and futures. Threads Threads enable programs to execute across several processor cores. Defined in header <thread> thread (C++11) manages a separate thread (class) Functions managing the current thread Defined in namespace this_thread yield (C++11) suggests that the implementation reschedule execution of threads (function) get_id (C++11) returns the thread id of the current