Difference between revisions of "cpp/header/utility"
From cppreference.com
(Add exchange (C++14)) |
(fix {{=}} breakage) |
||
| Line 54: | Line 54: | ||
// exchange: | // exchange: | ||
| − | template<class T, class U=T> T exchange(T& obj, U&& new_value); | + | template<class T, class U{{=}}T> T exchange(T& obj, U&& new_value); |
// forward/move: | // forward/move: | ||
Revision as of 07:12, 20 May 2015
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 | ||
| (deprecated in C++20) |
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 and use the type template argument to preserve its value category (function template) | |
| (C++11) |
converts the argument to an xvalue (function template) | |
| (C++11) |
converts the argument to an xvalue if the move constructor does not throw (function template) | |
| (C++11) |
obtains a reference to an object of the template type argument for use in an unevaluated context (function template) | |
creates a pair object of type, determined by the argument types (function template) | ||
| (removed in C++20)(removed in C++20)(removed in C++20)(removed in C++20)(removed in C++20)(C++20) |
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 | ||
| piecewise construction tag (tag) | ||
Synopsis
#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
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 | |
