const char* name() const; Returns an implementation defined null-terminated character string containing the name of the type. No guarantees are given, in particular, the returned string can be identical for several types and change between invocations of the same program. Parameters (none). Return value null-terminated character string containing the name of the type. Notes With compilers such as gcc and clang, the returned string can be piped through c++filt -t to be converted

Defined in header <cstring> std::size_t strlen( const char* str ); Returns the length of the given byte string, that is, the number of characters in a character array whose first element is pointed to by str up to and not including the first null character. The behavior is undefined if there is no null character in the character array pointed to by str. Parameters str - pointer to the null-terminated byte string to be examined Return value The length of the nu

bool try_lock(); (since C++14) Tries to lock the mutex. Returns immediately. On successful lock acquisition returns true, otherwise returns false. This function is allowed to fail spuriously and return false even if the mutex is not currently locked by any other thread. If try_lock is called by a thread that already owns the mutex in any mode (shared or exclusive), the behavior is undefined. Prior unlock() operation on the same mutex synchronizes-with (as defined in std::memory_order) t

static const bool has_signaling_NaN; (until C++11) static constexpr bool has_signaling_NaN; (since C++11) The value of std::numeric_limits<T>::has_signaling_NaN is true for all types T capable of representing the special value "Signaling Not-A-Number". This constant is meaningful for all floating-point types and is guaranteed to be true if std::numeric_limits<T>::is_iec559 == true. Standard specializations T value of std::numeric_limits<T>::has_signaling_Na

Defined in header <regex> regex_error(std::regex_constants::error_type ecode); (since C++11) Constructs a regex_error with a given ecode of type std::regex_constants::error_type . See Also error_type (C++11) describes different types of matching errors (typedef)

Defined in header <array> template< class T, size_t N > class tuple_size< array<T, N> > : public integral_constant<size_t, N> { }; (1) (since C++11) Provides access to the number of elements in an std::array as a compile-time constant expression. Inherited from std::integral_constant Member constants value [static] N, the number of elements in the array (public static member constant) Member functions operator std::size_t conver

Defined in header <iterator> template< class InputIt, class Distance > void advance( InputIt& it, Distance n ); Increments given iterator it by n elements. If n is negative, the iterator is decremented. In this case, InputIt must meet the requirements of BidirectionalIterator, otherwise the behavior is undefined. Parameters it - iterator to be advanced n - number of elements it should be advanced Type requirements - InputIt must meet the requirem

template< class Key, class T, class Hash, class KeyEqual, class Alloc > void swap( unordered_multimap<Key,T,Hash,KeyEqual,Alloc>& lhs, unordered_multimap<Key,T,Hash,KeyEqual,Alloc>& rhs ); (since C++11) Specializes the std::swap algorithm for std::unordered_multimap. Swaps the contents of lhs and rhs. Calls lhs.swap(rhs). Parameters lhs, rhs - containers whose contents to swap Return value (none). Complexity Constant. Exceptions

This header is part of the dynamic memory management library. Classes scoped_allocator_adaptor (C++11) implements multi-level allocator for multi-level containers (class template) Functions operator==operator!= compares two scoped_allocator_adaptor instances (public member function of std::scoped_allocator_adaptor) Synopsis namespace std { template <class OuterAlloc, class... InnerAlloc> class scoped_allocator_adaptor; template <class OuterA1,

(since C++11) T load( std::memory_order order = std::memory_order_seq_cst ) const; T load( std::memory_order order = std::memory_order_seq_cst ) const volatile; Atomically loads and returns the current value of the atomic variable. Memory is affected according to the value of order. order must be one of std::memory_order_relaxed, std::memory_order_consume, std::memory_order_acquire or std::memory_order_seq_cst. Otherwise the behavior is undefined. Parameters order - me