std::basic_ios::swap

protected: void swap( basic_ios& other ); (since C++11) Exchanges the states of *this and other, except for the associated rdbuf objects. rdbuf() and other.rdbuf() returns the same values as before the call. This swap function is protected: it is called by the swap member functions of the derived stream classes such as std::basic_ofstream or std::basic_istringstream, which know how to correctly swap the associated streambuffers. Parameters other - the basic_ios object to exc

std::allocator::allocate

pointer allocate( size_type n, std::allocator<void>::const_pointer hint = 0 ); Allocates n * sizeof(T) bytes of uninitialized storage by calling ::operator new(std::size_t), but it is unspecified when and how this function is called. The pointer hint may be used to provide locality of reference: the allocator, if supported by the implementation, will attempt to allocate the new memory block as close as possible to hint. Parameters n - the number of objects to allocate stor

std::allocator_traits::allocate

Defined in header <memory> static pointer allocate( Alloc& a, size_type n ); (1) (since C++11) static pointer allocate( Alloc& a, size_type n, const_void_pointer hint ); (2) (since C++11) Uses the allocator a to allocate n*sizeof(Alloc::value_type) bytes of uninitialized storage. 1) Calls a.allocate(n) 2) Additionally passes memory locality hint hint. Calls a.allocate(n, hint) if possible. If not possible (e.g. a has no two-argument member function allocate

std::recursive_mutex::unlock

void unlock(); (since C++11) Unlocks the mutex if its level of ownership is 1 (there was exactly one more call to lock() than there were calls to unlock() made by this thread), reduces the level of ownership by 1 otherwise. The mutex must be locked by the current thread of execution, otherwise, the behavior is undefined. This operation synchronizes-with (as defined in std::memory_order) any subsequent lock operation that obtains ownership of the same mutex. Parameters (none). Retur

std::unordered_map::clear

void clear(); (since C++11) Removes all elements from the container. Invalidates any references, pointers, or iterators referring to contained elements. May invalidate any past-the-end iterators. Parameters (none). Return value (none). Exceptions noexcept specification: noexcept Complexity Linear in the size of the container. See also erase erases elements (public member function)

std::deque::push_back

void push_back( const T& value ); (1) void push_back( T&& value ); (2) (since C++11) Appends the given element value to the end of the container. 1) The new element is initialized as a copy of value. 2) value is moved into the new element. All iterators, including the past-the-end iterator, are invalidated. No references are invalidated. Parameters value - the value of the element to append Type requirements - T must meet the requirements of CopyInsertabl

wchar_t

Usage wchar_t type: as the declaration of the type

std::boolalpha

Defined in header <ios> std::ios_base& boolalpha( std::ios_base& str ); (1) std::ios_base& noboolalpha( std::ios_base& str ); (2) 1) Enables the boolalpha flag in the stream str as if by calling str.setf(std::ios_base::boolalpha) 2) Disables the boolalpha flag in the stream str as if by calling str.unsetf(std::ios_base::boolalpha) std::boolalpha is an I/O manipulator, so it may be called with an expression such as out << std::boolalpha for an

std::match_results::suffix

const_reference suffix() const; (since C++11) Obtains a reference to the std::sub_match object representing the target sequence between the end of the entire match of the regular expression and the end of the target sequence. The behavior is undefined unless ready() == true. Parameters (none). Return value Reference to the unmatched suffix. Example #include <iostream> #include <regex> #include <string> int main() { std::regex re("a(a)*b"); std::str

std::for_each

Defined in header <algorithm> template< class InputIt, class UnaryFunction > UnaryFunction for_each( InputIt first, InputIt last, UnaryFunction f ); Applies the given function object f to the result of dereferencing every iterator in the range [first, last), in order. If InputIt is a mutable iterator, f may modify the elements of the range through the dereferenced iterator. If f returns a result, the result is ignored. Parameters first, last - the range to app