Namespaces
Variants

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

    从 zh.cppreference.net
     
    C++
     
    工具库
    通用工具
    关系运算符 (在 C++20 中弃用)
    整数比较函数
    (C++20)(C++20)(C++20)    
    (C++20)
    交换 和 类型操作
    (C++20)
    (C++14)
    (C++11)
    (C++23)
    (C++11)
    (C++23)
    (C++11)
    (C++11)
    (C++17)
    常用词汇类型
    (C++11)
    (C++17)
    (C++17)
    (C++17)
    (C++11)
    (C++11)
    (C++17)
    (C++17)
    (C++23)



     
    std::pair
     
    pair& operator=( const pair& other );
    		(1) (自 C++20 起为 constexpr) 
    constexpr const pair& operator=( const pair& other ) const;
    		(2) (自 C++23 起) 
    template< class U1, class U2 >
pair& operator=( const pair<U1, U2>& other );
    		(3) (自 C++20 起为 constexpr) 
    template< class U1, class U2 >
constexpr const pair& operator=( const pair<U1, U2>& other ) const;
    		(4) (自 C++23 起) 
    pair& operator=( pair&& other ) noexcept(/* see below */);
    		(5) (自 C++11 起)
    (自 C++20 起为 constexpr)    		 
    constexpr const pair& operator=( pair&& other ) const;
    		(6) (自 C++23 起) 
    template< class U1, class U2 >
pair& operator=( pair<U1, U2>&& p );
    		(7) (自 C++11 起)
    (自 C++20 起为 constexpr)    		 
    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 起)

    替换 pair 的内容。

    1) 复制赋值运算符。用 other 内容的副本替换内容。

    如果 T1 或 T2 是 const 限定类型、引用类型、具有不可访问复制赋值运算符的类类型或此类类型的数组类型，则使用此赋值运算符会使程序格式错误。

    		(直到 C++11)

    如果 std::is_copy_assignable<T1>::value 或 std::is_copy_assignable<T2>::value 是 false，则此重载被定义为弃置的。

    		(自 C++11 起)
    2) 用于 const 限定操作数的复制赋值运算符。
    仅当 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) 用于 const 限定操作数的移动赋值运算符。
    仅当 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。
    仅当
    • std::same_as<std::remove_cvref_t<P>, std::pair> 是 false，
    • std::remove_cvref_t<P> 不是 std::ranges::subrange 的特化，
    • std::is_assignable_v<T1&, decltype(std::get<0>(std::forward<P>(p)))> 是 true，且
    • std::is_assignable_v<T1&, decltype(std::get<1>(std::forward<P>(p)))> 是 true 时，此重载才参与重载决议。
    10) 将 std::get<0>(std::forward<P>(u)) 赋给 first，并将 std::get<1>(std::forward<P>(u)) 赋给 second。
    仅当
    • std::same_as<std::remove_cvref_t<P>, std::pair> 是 false，
    • std::remove_cvref_t<P> 不是 std::ranges::subrange 的特化，
    • std::is_assignable_v<const T1&, decltype(std::get<0>(std::forward<P>(p)))> 是 true，且
    • std::is_assignable_v<const T1&, decltype(std::get<1>(std::forward<P>(p)))> 是 true 时，此重载才参与重载决议。

    参数

    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...> 的公开成员函数)