std::pair<T1,T2>::operator=

	(1)
pair& operator=( const pair& other );		(до C++20)
constexpr pair& operator=( const pair& other );		(с C++20)
constexpr const pair& operator=( const pair& other ) const;	(2)	(с C++23)
	(3)
template< class U1, class U2 > pair& operator=( const pair<U1, U2>& other );		(до C++20)
template< class U1, class U2 > constexpr pair& operator=( const pair<U1, U2>& other );		(с C++20)
template< class U1, class U2 > constexpr const pair& operator=( const pair<U1, U2>& other ) const;	(4)	(с C++23)
	(5)
pair& operator=( pair&& other ) noexcept(/* see below */);		(с C++11) (до C++20)
constexpr pair& operator=( pair&& other ) noexcept(/* see below */);		(с C++20)
constexpr const pair& operator=( pair&& other ) const;	(6)	(с C++23)
	(7)
template< class U1, class U2 > pair& operator=( pair<U1, U2>&& p );		(с C++11) (до C++20)
template< class U1, class U2 > constexpr pair& operator=( pair<U1, U2>&& p );		(с C++20)
template< class U1, class U2 > constexpr const pair& operator=( pair<U1, U2>&& p ) const;	(8)	(с C++23)
template< pair-like P > constexpr pair& operator=( P&& u );	(9)	(с C++23)
template< pair-like P > constexpr const pair& operator=( P&& u ) const;	(10)	(с C++23)

Заменяет содержимое пары.

1) Оператор присваивания копирования. Заменяет содержимое копией содержимого other.

Оператор присваивания неявно объявлен. Использование этого оператора присваивания делает программу некорректной, если либо T1 или T2 является константным типом, ссылкой, или классом с недоступным оператором копирования присваивания, или массивом такого класса.

(до C++11)

Этот перегруз определяется как удаленный, если либо std::is_copy_assignable<T1>::value или std::is_copy_assignable<T2>::value является false.

(с C++11)

2) Оператор присваивания копирования для константного операнда.

Этот перегруз участвует в разрешении перегрузки только если std::is_copy_assignable_v<const T1> и std::is_copy_assignable_v<const T2> оба являются true.

3) Присваивает other.first к first и other.second к second.

Этот перегруз участвует в разрешении перегрузки только если std::is_assignable<T1&, const U1&>::value и std::is_assignable<T2&, const U2&>::value оба являются true.

(с C++11)

4) Присваивает other.first к first и other.second к second.

Этот перегруз участвует в разрешении перегрузки только если std::is_assignable_v<const T1&, const U1&> и std::is_assignable_v<const T2&, const U2&> оба являются true.

5) Оператор присваивания перемещения. Заменяет содержимое содержимым other с использованием семантики перемещения.

Этот перегруз участвует в разрешении перегрузки только если std::is_move_assignable<T1>::value и std::is_move_assignable<T2>::value оба являются true.

6) Оператор присваивания перемещения для константного операнда.

Этот перегруз участвует в разрешении перегрузки только если std::is_assignable_v<const T1&, T1> и std::is_assignable_v<const T2&, T2> оба являются true.

7) Присваивает std::forward<U1>(p.first) к first и std::forward<U2>(p.second) к second.

Этот перегруз участвует в разрешении перегрузки только если std::is_assignable<T1&, U1>::value и std::is_assignable<T2&, U2>::value оба являются true.

8) Присваивает std::forward<U1>(p.first) к first и std::forward<U2>(p.second) к second.

Этот перегруз участвует в разрешении перегрузки только если std::is_assignable_v<const T1&, U1> и std::is_assignable_v<const T2&, U2> оба являются true.

9) Присваивает std::get<0>(std::forward(u)) к first и std::get<1>(std::forward(u)) к second.

Этот перегруз участвует в разрешении перегрузки только если

std::same_as<std::remove_cvref_t, std::pair> является false,
std::remove_cvref_t не является специализацией std::ranges::subrange,
std::is_assignable_v<T1&, decltype(std::get<0>(std::forward(p)))> является true, и
std::is_assignable_v<T1&, decltype(std::get<1>(std::forward(p)))> является true.

10) Присваивает std::get<0>(std::forward(u)) к first и std::get<1>(std::forward(u)) к second.

Этот перегруз участвует в разрешении перегрузки только если

std::same_as<std::remove_cvref_t, std::pair> является false,
std::remove_cvref_t не является специализацией std::ranges::subrange,
std::is_assignable_v<const T1&, decltype(std::get<0>(std::forward(p)))> является true, и
std::is_assignable_v<const T1&, decltype(std::get<1>(std::forward(p)))> является true.

Параметры

other	-	пара значений для замены содержимого этой пары
p	-	пара значений, возможно разных типов, для замены содержимого этой пары
u	-	объект `pair-like` значений для замены содержимого этой пары
Требования к типу
-`T1` должно удовлетворять требованиям CopyAssignable из `U1`. (до C++11)
-`T2` должно удовлетворять требованиям CopyAssignable из `U2`. (до C++11)

Возвращаемое значение

*this

Исключение

1-4) Может выбросить исключение, определенное реализацией.

noexcept спецификация:

noexcept(
 std::is_nothrow_move_assignable<T1>::value &&
 std::is_nothrow_move_assignable<T2>::value

)

6-10) Может выбросить исключение, определенное реализацией.

Пример

#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';
}

Вывод:

(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, {}}

Отчеты об ошибках

Следующие отчеты об ошибках, изменяющие поведение, были применены ретроактивно к ранее опубликованным стандартам C++.

DR	Применён к	Поведение, как опубликовано	Корректное поведение
LWG 885	C++98	отсутствует гетерогенное присваивание по копированию	добавлен (как перегрузка (3))
LWG 2729	C++11	`pair::operator=` не было ограничено и могло привести к ненужному неопределённому поведению	ограничено

См. также

operator=

присваивает содержимое одной tuple другой
(публичный член-функция std::tuple<Types...>)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/utility/pair/operator%3D