std::pair<T1,T2>::operator=
pair& operator=( const pair& other );
|
(1) | (constexpr desde C++20) |
constexpr const pair& operator=( const pair& other ) const;
|
(2) | (desde C++23) |
template< class U1, class U2 >
pair& operator=( const pair<U1, U2>& other );
|
(3) | (constexpr desde C++20) |
template< class U1, class U2 >
constexpr const pair& operator=( const pair<U1, U2>& other ) const;
|
(4) | (desde C++23) |
pair& operator=( pair&& other ) noexcept(/* see below */);
|
(5) | (desde C++11) (constexpr desde C++20) |
constexpr const pair& operator=( pair&& other ) const;
|
(6) | (desde C++23) |
template< class U1, class U2 >
pair& operator=( pair<U1, U2>&& p );
|
(7) | (desde C++11) (constexpr desde C++20) |
template< class U1, class U2 >
constexpr const pair& operator=( pair<U1, U2>&& p ) const;
|
(8) | (desde C++23) |
template< pair-like P >
constexpr pair& operator=( P&& u );
|
(9) | (desde C++23) |
template< pair-like P >
constexpr const pair& operator=( P&& u ) const;
|
(10) | (desde C++23) |
Reemplaza el contenido del par.
other.
|
El operador de asignación se declara implícitamente. El uso de este operador de asignación hace que el programa esté mal formado si |
(hasta C++11) |
|
Esta sobrecarga se define como eliminada si |
(desde C++11) |
std::is_copy_assignable_v<const T1> y std::is_copy_assignable_v<const T2> son ambos true.other.first a first y other.second a second.
|
Esta sobrecarga participa en la resolución de sobrecarga solo si |
(desde C++11) |
other.first a first y other.second a second.std::is_assignable_v<const T1&, const U1&> y std::is_assignable_v<const T2&, const U2&> son ambos true.other usando semántica de movimiento.std::is_move_assignable<T1>::value y std::is_move_assignable<T2>::value son ambos true.std::is_assignable_v<const T1&, T1> y std::is_assignable_v<const T2&, T2> son ambos true.std::forward<U1>(p.first) a first y std::forward<U2>(p.second) a second.std::is_assignable<T1&, U1>::value y std::is_assignable<T2&, U2>::value son ambos true.std::forward<U1>(p.first) a first y std::forward<U2>(p.second) a second.std::is_assignable_v<const T1&, U1> y std::is_assignable_v<const T2&, U2> son ambos true.std::get<0>(std::forward<P>(u)) a first y std::get<1>(std::forward<P>(u)) a second.std::same_as<std::remove_cvref_t<P>, std::pair>esfalse,std::remove_cvref_t<P>no es una especialización de std::ranges::subrange,std::is_assignable_v<T1&, decltype(std::get<0>(std::forward<P>(p)))>estrue, ystd::is_assignable_v<T1&, decltype(std::get<1>(std::forward<P>(p)))>estrue.
std::get<0>(std::forward<P>(u)) a first y std::get<1>(std::forward<P>(u)) a second.std::same_as<std::remove_cvref_t<P>, std::pair>esfalse,std::remove_cvref_t<P>no es una especialización de std::ranges::subrange,std::is_assignable_v<const T1&, decltype(std::get<0>(std::forward<P>(p)))>estrue, ystd::is_assignable_v<const T1&, decltype(std::get<1>(std::forward<P>(p)))>estrue.
Parámetros
| other | - | par de valores para reemplazar el contenido de este par |
| p | - | par de valores de posiblemente diferentes tipos para reemplazar el contenido de este par |
| u | - | pair-like objeto de valores para reemplazar el contenido de este par |
| Requisitos de tipo | ||
-
T1
debe cumplir con los requisitos de
CopyAssignable
desde
U1
.
(hasta C++11)
|
||
-
T2
debe cumplir con los requisitos de
CopyAssignable
desde
U2
.
(hasta C++11)
|
||
Valor de retorno
* this
Excepciones
std::
is_nothrow_move_assignable
<
T1
>
::
value
&&
std::
is_nothrow_move_assignable
<
T2
>
::
value
Ejemplo
#include <cstddef> #include <iomanip> #include <iostream> #include <utility> #include <vector> template<class Os, class T> Os& operator<<(Os& os, const std::vector<T>& v) { os << '{'; for (std::size_t t = 0; t != v.size(); ++t) os << v[t] << (t + 1 < v.size() ? ", " : ""); return os << '}'; } template<class Os, class U1, class U2> Os& operator<<(Os& os, const std::pair<U1, U2>& pair) { return os << '{' << pair.first << ", " << pair.second << '}'; } int main() { std::pair<int, std::vector<int>> p{1, {2}}, q{2, {5, 6}}; p = q; // (1) operator=(const pair& other); std::cout << std::setw(23) << std::left << "(1) p = q;" << "p: " << p << " q: " << q << '\n'; std::pair<short, std::vector<int>> r{4, {7, 8, 9}}; p = r; // (3) operator=(const pair<U1, U2>& other); std::cout << std::setw(23) << "(3) p = r;" << "p: " << p << " r: " << r << '\n'; p = std::pair<int, std::vector<int>>{3, {4}}; p = std::move(q); // (5) operator=(pair&& other); std::cout << std::setw(23) << "(5) p = std::move(q);" << "p: " << p << " q: " << q << '\n'; p = std::pair<int, std::vector<int>>{5, {6}}; p = std::move(r); // (7) operator=(pair<U1, U2>&& other); std::cout << std::setw(23) << "(7) p = std::move(r);" << "p: " << p << " r: " << r << '\n'; }
Salida:
(1) p = q; p: {2, {5, 6}} q: {2, {5, 6}}
(3) p = r; p: {4, {7, 8, 9}} r: {4, {7, 8, 9}}
(5) p = std::move(q); p: {2, {5, 6}} q: {2, {}}
(7) p = std::move(r); p: {4, {7, 8, 9}} r: {4, {}}
Informes de defectos
Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares publicados anteriormente de C++.
| DR | Aplicado a | Comportamiento publicado | Comportamiento correcto |
|---|---|---|---|
| LWG 885 | C++98 | falta asignación de copia heterogénea | añadido (como sobrecarga (3) ) |
| LWG 2729 | C++11 |
pair::operator=
no estaba restringido y podría
resultar en comportamiento indefinido innecesario |
restringido |
Véase también
asigna el contenido de un
tuple
a otro
(función miembro pública de
std::tuple<Types...>
)
|