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)

Defined in header <functional> template< class Res, class T > std::mem_fun_ref_t<Res,T> mem_fun_ref( Res (T::*f)() ); (1) (until C++17)(deprecated since C++11) template< class Res, class T > std::const_mem_fun_ref_t<Res,T> mem_fun_ref( Res (T::*f)() ); (1) (until C++17)(deprecated since C++11) template< class Res, class T, class Arg > std::mem_fun1_ref_t<Res,T,Arg> mem_fun_ref( Res (T::*f)(Arg) ); (2) (until C++17)(deprecated

size_type max_size() const; (since C++11) Returns the maximum number of elements the container is able to hold due to system or library implementation limitations, i.e. std::distance(begin(), end()) for the largest container. Parameters (none). Return value Maximum number of elements. Exceptions noexcept specification: noexcept Complexity Constant. Notes This value is typically equal to std::numeric_limits<size_type>::max(), and reflects the theoretical limit on t

void swap( packaged_task& other ); (since C++11) Exchanges the shared states and stored tasks of *this and other. Parameters other - packaged task whose state to swap with Return value (none). Exceptions noexcept specification: noexcept See also std::swap(std::packaged_task) (C++11) specializes the std::swap algorithm (function template)

Defined in header <future> template<> struct is_error_condition_enum<std::future_errc> : std::true_type; (since C++11) Specifies that std::future_errc is an error condition enum. This enables std::error_code and std::error_condition automatic conversions. See also is_error_condition_enum (C++11) identifies an enumeration as an std::error_condition (class template)

template< class Key, class Compare, class Alloc > bool operator==( const set<Key,Compare,Alloc>& lhs, const set<Key,Compare,Alloc>& rhs ); (1) template< class Key, class Compare, class Alloc > bool operator!=( const set<Key,Compare,Alloc>& lhs, const set<Key,Compare,Alloc>& rhs ); (2) template< class Key, class Compare, class Alloc > bool operator<( const set<Key,Compare,Alloc>&

explicit operator bool() const; (since C++14) Checks whether *this owns a locked mutex or not. Effectively calls owns_lock(). Parameters (none). Return value true if *this has an associated mutex and has acquired shared ownership of it, false otherwise. Exceptions noexcept specification: noexcept See also owns_lock tests whether the lock owns its associated mutex (public member function)

iterator end(); const_iterator end() const; const_iterator cend() const; (since C++11) Returns an iterator to the element following the last element of the container. This element acts as a placeholder; attempting to access it results in undefined behavior. Parameters (none). Return value Iterator to the element following the last element. Exceptions (none) (until C++11) noexcept specification: noexcept (since C++11) Complexity Constant. See also begin

This header is part of the containers library. Includes <initializer_list>(C++11) Classes array (since C++11) static contiguous array (class template) std::tuple_size<std::array> obtains the size of an array (class template specialization) std::tuple_element<std::array> obtains the type of the elements of array (class template specialization) Functions operator==operator!=operator<operator<=operator>operator>= lexicographically c

Defined in header <type_traits> template< class T > struct remove_pointer; (since C++11) Provides the member typedef type which is the type pointed to by T, or, if T is not a pointer, then type is the same as T. Member types Name Definition type the type pointed to by T or T if it's not a pointer Helper types template< class T > using remove_pointer_t = typename remove_pointer<T>::type; (since C++14) Possible implementation temp