(1) explicit set( const Compare& comp = Compare(), const Allocator& alloc = Allocator() ); (until C++14) set() : set( Compare() ) {} explicit set( const Compare& comp, const Allocator& alloc = Allocator() ); (since C++14) explicit set( const Allocator& alloc ); (1) (since C++11) (2) template< class InputIt > set( InputIt first, InputIt last, const Compare& comp = Compare(), const Allocator& alloc = Al

Defined in header <tuple> template< class... Types > tuple<VTypes...> make_tuple( Types&&... args ); (since C++11) (until C++14) template< class... Types > constexpr tuple<VTypes...> make_tuple( Types&&... args ); (since C++14) Creates a tuple object, deducing the target type from the types of arguments. For each Ti in Types..., the corresponding type Vi in Vtypes... is std::decay<Ti>::type unless application of std::decay

Defined in header <string> int stoi( const std::string& str, std::size_t* pos = 0, int base = 10 ); int stoi( const std::wstring& str, std::size_t* pos = 0, int base = 10 ); (1) (since C++11) long stol( const std::string& str, std::size_t* pos = 0, int base = 10 ); long stol( const std::wstring& str, std::size_t* pos = 0, int base = 10 ); (2) (since C++11) long long stoll( const std::string& str, std::size_t* pos = 0, int base

Compare two shared_ptr objects template < class T, class U > bool operator==( const shared_ptr<T>& lhs, const shared_ptr<U>& rhs ); (1) (since C++11) template< class T, class U > bool operator!=( const shared_ptr<T>& lhs, const shared_ptr<U>& rhs ); (2) (since C++11) template< class T, class U > bool operator<( const shared_ptr<T>& lhs, const shared_ptr<U>& rhs ); (3) (since C++11) templat

Defined in header <iterator> template< class CharT, class Traits = std::char_traits<CharT> > class ostreambuf_iterator : public std::iterator<std::output_iterator_tag, void, void, void, void> (until C++17) template< class CharT, class Traits = std::char_traits<CharT> > class ostreambuf_iterator; (since C++17) std::ostreambuf_iterator is a single-pass OutputIterator that writes successive ch

Defined in header <regex> template < class CharT, class Traits = std::regex_traits<CharT> > class basic_regex; (since C++11) The class template basic_regex provides a general framework for holding regular expressions. Several specializations for common character types are provided: Defined in header <regex> Type Definition regex basic_regex<char> wregex basic_regex<wchar_t> Member types Member type Definition va

Defined in header <exception> template< class E > std::exception_ptr make_exception_ptr( E e ); (since C++11) Creates an std::exception_ptr that holds a reference to a copy of e. This is done as if executing the following code: try { throw e; } catch(...) { return std::current_exception(); } Parameters (none). Return value An instance of std::exception_ptr holding a reference to the copy of e, or to an instance of std::bad_alloc or to an instance of std:

(1) void erase( iterator pos ); (until C++11) iterator erase( iterator pos ); (since C++17) iterator erase( const_iterator pos ); (since C++11) (2) void erase( iterator first, iterator last ); (until C++11) iterator erase( const_iterator first, const_iterator last ); (since C++11) size_type erase( const key_type& key ); (3) Removes specified elements from the container. 1) Removes the element at pos. 2) Removes the elements in the range [first; last),

Initializes an object from explicit set of constructor arguments. Syntax T object ( arg ); T object ( arg1, arg2, ... ); (1) T object { arg }; T object { arg1, arg2, ... }; (2) (since C++11) T ( other ) T ( arg1, arg2, ... ); (3) static_cast< T >( other ) (4) new T(args, ...) (5) Class::Class() : member(args, ...) {... (6) [arg](){... (7) (since C++11) Explanation Direct initialization is performed in the following situations: 1) in

Allows values of integer type to be used in expressions directly. Syntax An integer literal is a primary expression of the form. decimal-literal integer-suffix(optional) (1) octal-literal integer-suffix(optional) (2) hex-literal integer-suffix(optional) (3) binary-literal integer-suffix(optional) (4) (since C++14) where. decimal-literal is a non-zero decimal digit (1, 2, 3, 4, 5, 6, 7, 8, 9), followed by zero or more decimal digits (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)