This header is part of the general utility library.
Includes | |
<initializer_list>(C++11) | |
Namespaces | |
rel_ops | Provide automatic comparison operators |
| Defined in namespace std::rel_ops | |
|---|---|
automatically generates comparison operators based on user-defined operator== and operator< (function template) | |
Functions | |
| swaps the values of two objects (function template) | |
| (C++14) | replaces the argument with a new value and returns its previous value (function template) |
| (C++11) | forwards a function argument (function template) |
| (C++11) | obtains an rvalue reference (function template) |
| (C++11) | obtains an rvalue reference if the move constructor does not throw (function template) |
| (C++11) | obtains a reference to its argument for use in unevaluated context (function template) |
creates a pair object of type, defined by the argument types (function template) | |
| lexicographically compares the values in the pair (function template) | |
| (C++11) | specializes the std::swap algorithm (function template) |
| (C++11) | accesses an element of a pair (function template) |
Classes | |
| implements binary tuple, i.e. a pair of values (class template) | |
| (C++11) | tag type used to select correct function overload for piecewise construction (class) |
| (C++14) | implements compile-time sequence of integers (class template) |
Forward declarations | |
| (C++11) | implements fixed size container, which holds elements of possibly different types (class template) |
Objects | |
| (C++11) | an object of type piecewise_construct_t used to disambiguate functions for piecewise construction (constant) |
Synopsis
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 | #include <initializer_list> namespace std { // operators: namespace rel_ops { template<class T> bool operator!=(const T&, const T&); template<class T> bool operator> (const T&, const T&); template<class T> bool operator<=(const T&, const T&); template<class T> bool operator>=(const T&, const T&); } // swap: template<class T> void swap(T& a, T& b) noexcept(noexcept(a.swap(b)); template <class T, size_t N> void swap(T (&a)[N], T (&b)[N]) noexcept(noexcept(swap(*a, *b))); // exchange: template<class T, class U=T> T exchange(T& obj, U&& new_value); // forward/move: template <class T> T&& forward(typename remove_reference<T>::type& t) noexcept; template <class T> T&& forward(typename remove_reference<T>::type&& t) noexcept; template <class T> typename remove_reference<T>::type&& move(T&&) noexcept; template <class T> typename conditional< !is_nothrow_move_constructible<T>::value && is_copy_constructible<T>::value, const T&, T&&>::type move_if_noexcept(T& x) noexcept; // declval, as unevaluated operand: template <class T> typename add_rvalue_reference<T>::type declval() noexcept; // pairs: template <class T1, class T2> struct pair; // pair specialized algorithms: template <class T1, class T2> bool operator==(const pair<T1,T2>&, const template <class T1, class T2> bool operator< (const pair<T1,T2>&, const pair<T1,T2>&); template <class T1, class T2> bool operator!=(const pair<T1,T2>&, const pair<T1,T2>&); template <class T1, class T2> bool operator> (const pair<T1,T2>&, const pair<T1,T2>&); template <class T1, class T2> bool operator>=(const pair<T1,T2>&, const pair<T1,T2>&); template <class T1, class T2> bool operator<=(const pair<T1,T2>&, const pair<T1,T2>&); template <class T1, class T2> void swap(pair<T1,T2>& x, pair<T1,T2>& y) noexcept(noexcept(x.swap(y))); template <class T1, class T2> pair<V1,V2> make_pair(T1&&, T2&&); //tuple-like access to pair: template <class T> class tuple_size; template <size_t I, class T> class tuple_element; template <class T1, class T2> struct tuple_size<std::pair<T1, T2> >; template <class T1, class T2> struct tuple_element<0, std::pair<T1, T2> >; template <class T1, class T2> struct tuple_element<1, std::pair<T1, T2> >; template<size_t I, class T1, class T2> typename tuple_element<I, std::pair<T1, T2> >::type& get(std::pair<T1, T2>&) noexcept; template<size_t I, class T1, class T2> typename tuple_element<I, std::pair<T1, T2> >::type&& get(std::pair<T1, T2>&&) noexcept; template<size_t I, class T1, class T2> const typename tuple_element<I, std::pair<T1, T2> >::type& get(const std::pair<T1, T2>&) noexcept; // pair piecewise construction struct piecewise_construct_t { }; constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t(); template <class... Types> class tuple; // defined in <tuple>} |
Class std::pair
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | template <class T1, class T2>struct pair { typedef T1 first_type; typedef T2 second_type; T1 first; T2 second; pair(const pair&) = default; pair(pair&&) = default; constexpr pair(); pair(const T1& x, const T2& y); template<class U, class V> pair(U&& x, V&& y); template<class U, class V> pair(const pair<U, V>& p); template<class U, class V> pair(pair<U, V>&& p); template <class... Args1, class... Args2> pair(piecewise_construct_t, tuple<Args1...> first_args, tuple<Args2...> second_args); pair& operator=(const pair& p); template<class U, class V> pair& operator=(const pair<U, V>& p); pair& operator=(pair&& p) noexcept(see below); template<class U, class V> pair& operator=(pair<U, V>&& p); void swap(pair& p) noexcept( noexcept(swap(first, p.first)) && noexcept(swap(second, p.second)) );}; |
See also
<tuple> | Defines std::tuple |
| Utility library | |
Please login to continue.