Defined in header <type_traits> template< class T > struct is_integral; (since C++11) Checks whether T is an integral type. Provides the member constant value which is equal to true, if T is the type bool, char, char16_t, char32_t, wchar_t, short, int, long, long long, or any implementation-defined extended integer types, including any signed, unsigned, and cv-qualified variants. Otherwise, value is equal to false. Template parameters T - a type to check

Defined in header <algorithm> template< class BidirIt > bool prev_permutation( BidirIt first, BidirIt last); (1) template< class BidirIt, class Compare > bool prev_permutation( BidirIt first, BidirIt last, Compare comp); (2) Transforms the range [first, last) into the previous permutation from the set of all permutations that are lexicographically ordered with respect to operator< or comp. Returns true if such permutation exists, otherwise transforms th

Defined in header <type_traits> template< class T > struct is_final; (since C++14) If T is a final class (that is, a class declared with the final specifier), provides the member constant value equal true. For any other type, value is false. If T is a class type, T shall be a complete type; otherwise, the behavior is undefined. Template parameters T - a type to check Helper variable template template< class T > constexpr bool is_final_v = is_fin

This header was originally in the C standard library as <ctype.h>. This header is part of the null-terminated byte strings library. Functions isalnum checks if a character is alphanumeric (function) isalpha checks if a character is alphabetic (function) islower checks if a character is lowercase (function) isupper checks if a character is an uppercase character (function) isdigit checks if a character is a digit (function) isxdigit checks if a character i

static const bool traps (until C++11) static constexpr bool traps (since C++11) The value of std::numeric_limits<T>::traps is true for all arithmetic types T that have at least one value that, if used as an argument to an arithmetic operation, will generate a trap. Standard specializations T value of std::numeric_limits<T>::traps /* non-specialized */ false bool false char usually true signed char usually true unsigned char usually true wcha

template< class R, class Alloc > struct uses_allocator<std::packaged_task<R>, Alloc> : true_type { }; (since C++11) Provides a specialization of the std::uses_allocator type trait for std::packaged_task. Inherited from std::integral_constant Member constants value [static] true (public static member constant) Member functions operator bool converts the object to bool, returns value (public member function) operator() (C++14) returns value (publi

Defined in header <unordered_set> template< class Key, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<Key> > class unordered_set; (since C++11) Unordered set is an associative container that contains a set of unique objects of type Key. Search, insertion, and removal have average constant-time complexity. Internally, the elements are not sorted in any particular order, but organized

Usage double type: as the declaration of the type

An AssociativeContainer is an ordered Container that provides fast lookup of objects based on keys. Requirements Legend X Container type a Object of type X a_uniq Object in X when X supports unique keys a_eq Object in X when X supports multiple keys a_trans Object in X when type X::key_compare::is_transparent exists i, j InputIterators denoting a valid range p const_iterator to a q dereferenceable const_iterator to a q1, q2 const_iterators denoting a va

A move assignment operator of class T is a non-template non-static member function with the name operator= that takes exactly one parameter of type T&&, const T&&, volatile T&&, or const volatile T&&. Syntax class_name & class_name :: operator= ( class_name && ) (1) (since C++11) class_name & class_name :: operator= ( class_name && ) = default; (2) (since C++11) class_name & class_name :: operator= ( class_name &&am