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

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 <mutex> class recursive_mutex; (since C++11) The recursive_mutex class is a synchronization primitive that can be used to protect shared data from being simultaneously accessed by multiple threads. recursive_mutex offers exclusive, recursive ownership semantics: A calling thread owns a recursive_mutex for a period of time that starts when it successfully calls either lock or try_lock. During this period, the thread may make additional calls to lock or try

Defined in header <cwctype> int iswalnum( std::wint_t ch ); Checks if the given wide character is an alphanumeric character, i.e. either a number (0123456789), an uppercase letter (ABCDEFGHIJKLMNOPQRSTUVWXYZ), a lowercase letter (abcdefghijklmnopqrstuvwxyz) or any alphanumeric character specific to the current locale. Parameters ch - wide character Return value Non-zero value if the wide character is a alphanumeric character, zero otherwise. Example #incl

Defined in header <functional> template< class > class function; /* undefined */ (since C++11) template< class R, class... Args > class function<R(Args...)> (since C++11) Class template std::function is a general-purpose polymorphic function wrapper. Instances of std::function can store, copy, and invoke any Callable target -- functions, lambda expressions, bind expressions, or other function objects, as well as pointers to member functions and point

explicit basic_stringbuf( std::ios_base::openmode which = std::ios_base::in | std::ios_base::out ); (1) explicit basic_stringbuf( const std::basic_string<CharT, traits, Allocator>& new_str, std::ios_base::openmode which = std::ios_base::in | std::ios_base::out ); (2) basic_stringbuf( const basic_stringbuf& rhs ) = delete; (3) (s

The C++ source file is processed by the compiler as if the following phases take place, in this exact order: Phase 1 1) The individual bytes of the source code file are mapped (in implementation defined manner) to the characters of the basic source character set. In particular, OS-dependent end-of-line indicators are replaced by newline characters. The basic source character set consists of 96 characters: a) 5 whitespace characters (space, horizontal tab, vertical tab, form feed, new-line)

explicit strstreambuf( std::streamsize alsize = 0 ); (1) strstreambuf( void* (*palloc)(std::size_t), void (*pfree)(void*) ); (2) strstreambuf( char* gnext, std::streamsize n, char* pbeg = 0 ); (3) strstreambuf( signed char* gnext, std::streamsize n, signed char* pbeg = 0 ); (4) strstreambuf( unsigned char* gnext, std::streamsize n, unsigned char* pbeg = 0 ); (5) strstreambuf( const char* gnext, std::streamsize n ); (6) strstreambuf( const signed char* gnext,

Defined in header <cfenv> #define FE_DIVBYZERO /*implementation defined power of 2*/ (since C++11) #define FE_INEXACT /*implementation defined power of 2*/ (since C++11) #define FE_INVALID /*implementation defined power of 2*/ (since C++11) #define FE_OVERFLOW /*implementation defined power of 2*/ (since C++11) #define FE_UNDERFLOW /*implementation defined power of 2*/ (since C++11) #define FE_ALL_EXCEPT FE_DIVBYZERO | FE_INEXACT