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 是 const 限定类型、引用类型、具有不可访问复制赋值运算符的类类型，或此类类型的数组类型，使用此赋值运算符将使程序格式错误。

(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 必须满足从 U1 的 CopyAssignable 要求。 (C++11 前)
-
T2 必须满足从 U2 的 CopyAssignable 要求。 (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++ 标准。

缺陷报告 适用标准 发布时行为 正确行为
LWG 885 C++98 缺少异构拷贝赋值操作 已添加（作为重载 (3) ）
LWG 2729 C++11 pair::operator= 未受约束且可能
导致不必要的未定义行为 		已添加约束

参见

将一个 tuple 的内容赋值给另一个
( std::tuple<Types...> 的公开成员函数)