Defined in header <ios> class ios_base; The class ios_base is a multipurpose class that serves as the base class for all I/O stream classes. It maintains several kinds of data: 1) state information: stream status flags 2) control information: flags that control formatting of both input and output sequences and the imbued locale 3) private storage: indexed extensible data structure that allows both long and void* members, which may be implemented as two arbitrary-length a

T& operator[]( const Key& key ); (1) (since C++11) T& operator[]( Key&& key ); (2) (since C++11) Returns a reference to the value that is mapped to a key equivalent to key, performing an insertion if such key does not already exist. 1) Inserts a value_type object constructed in-place from std::piecewise_construct, std::forward_as_tuple(key), std::tuple<>() if the key does not exist. This function is equivalent to return this->try_emplace(key).first-&

In a member-specification of a class/struct or union, define the visibility of subsequent members. In a base-clause of a derived class declaration, define the accessibility of inherited members of the subsequent base-specifiers. Syntax public : member-declarations (1) protected : member-declarations (2) private : member-declarations (3) class_name : public base_classes (4) class_name : protected base_classes (5) class_name : private base_classes (6) 1)

"Substitution Failure Is Not An Error" This rule applies during overload resolution of function templates: When substituting the deduced type for the template parameter fails, the specialization is discarded from the overload set instead of causing a compile error. This feature is used in template metaprogramming. Explanation Function template parameters are substituted (replaced by template arguments) twice: explicitly specified template arguments are substituted before template argument

Defined in header <algorithm> template< class ForwardIt > ForwardIt unique( ForwardIt first, ForwardIt last ); (1) template< class ForwardIt, class BinaryPredicate > ForwardIt unique( ForwardIt first, ForwardIt last, BinaryPredicate p ); (2) Removes all consecutive duplicate elements from the range [first, last) and returns a past-the-end iterator for the new logical end of the range. The first version uses operator== to compare the elements, the second ve

This header is part of the function objects library and provides the standard hash function. Namespaces placeholders Defines placeholders for the unbound arguments in a std::bind expression Constants Defined in namespace std::placeholders _1, _2, _3, _4, ... (C++11) placeholders for the unbound arguments in a std::bind expression (constant) Classes function (C++11) wraps callable object of any type with specified function call signature (class template) mem

template< class Clock, class Duration > bool try_lock_until( const std::chrono::time_point<Clock,Duration>& timeout_time ); (since C++14) Tries to lock the mutex. Blocks until specified timeout_time has been reached or the lock is acquired, whichever comes first. On successful lock acquisition returns true, otherwise returns false. If timeout_time has already passed, this function behaves like try_lock(). The clock tied to timeout_time is used, which means that adjustmen

Defined in header <csetjmp> void longjmp( std::jmp_buf env, int status ); Loads the execution context env saved by a previous call to setjmp. This function does not return. Control is transferred to the call site of the macro setjmp that set up env. That setjmp then returns the value, passed as the status. If the function that called setjmp has exited, the behavior is undefined (in other words, only long jumps up the call stack are allowed). No destructors for automatic obj

A function template defines a family of functions. Syntax template < parameter-list > function-declaration (1) export template < parameter-list > function-declaration (2) (until C++11) function-declaration-with-placeholders (3) (concepts TS) Explanation function-declaration - a function declaration. The function name declared become a template name. function-declaration-with-placeholders - a function declaration where the type of at least one par

Defined in header <deque> template< class T, class Allocator = std::allocator<T> > class deque; std::deque (double-ended queue) is an indexed sequence container that allows fast insertion and deletion at both its beginning and its end. In addition, insertion and deletion at either end of a deque never invalidates pointers or references to the rest of the elements. As opposed to std::vector, the elements of a deque are not stored contiguously: typical imp