Namespaces
Variants

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

From cppreference.net
C++
Utilities library
std::pair
(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 < P > ( u ) ) переменной first и std :: get < 1 > ( std:: forward < P > ( u ) ) переменной second .
Эта перегрузка участвует в разрешении перегрузки только если
10) Присваивает std :: get < 0 > ( std:: forward < P > ( u ) ) переменной first и std :: get < 1 > ( std:: forward < P > ( u ) ) переменной second .
Эта перегрузка участвует в разрешении перегрузки только если

Содержание

Параметры

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

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

* this

Исключения

1-4) Может генерировать исключения, определяемые реализацией.
5)
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= был неограниченным и мог
приводить к необязательному неопределённому поведению 		ограничен

Смотрите также

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