命名空间
变体
操作

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

来自 cppreference.com
< cpp‎ | utility‎ | pair
 
 
实用程序库
语言支持
类型支持 (基本类型、RTTI)
库功能测试宏 (C++20)
动态内存管理
程序实用程序
协程支持 (C++20)
可变参数函数
调试支持
(C++26)
三路比较
(C++20)
(C++20)(C++20)(C++20)
(C++20)(C++20)(C++20)
通用实用程序
日期和时间
函数对象
格式化库 (C++20)
(C++11)
关系运算符 (C++20 中已弃用)
整数比较函数
(C++20)(C++20)(C++20)   
(C++20)
交换类型操作
(C++14)
(C++11)
(C++11)
(C++11)
(C++17)
通用词汇类型
(C++11)
(C++17)
(C++17)
(C++17)
(C++11)
(C++17)
(C++23)
基本字符串转换
(C++17)
(C++17)

 
 
(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(/* 见下文 */);
(自 C++11 起)
(直到 C++20)
constexpr pair& operator=( pair&& other ) noexcept(/* 见下文 */);
(自 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的内容的副本替换内容。

赋值运算符是隐式声明的。如果T1T2是 const 限定类型、引用类型或具有不可访问的复制赋值运算符的类类型,或者这类类型的数组类型,则使用此赋值运算符会导致程序格式错误。

(直到 C++11)

如果std::is_copy_assignable<T1>::valuestd::is_copy_assignable<T2>::valuefalse,则此重载被定义为已删除。

(自 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&>::valuestd::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>::valuestd::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>::valuestd::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
此重载仅在以下条件满足时参与重载解析:

内容

[edit] 参数

other - 用于替换此对内容的值对
p - 可能具有不同类型的值的替换此对内容的值对
u - pair-like 用于替换此对内容的值对象
类型要求
-
T1 必须满足来自 U1CopyAssignable 的要求。 (直到 C++11)
-
T2 必须满足来自 U2CopyAssignable 的要求。 (直到 C++11)

[edit] 返回值

*this

[edit] 异常

1-4) 可能会抛出实现定义的异常。
5)
noexcept 规范:  
noexcept(

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

)
6-10) 可能会抛出实现定义的异常。

[edit] 示例

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

[edit] 缺陷报告

以下更改行为的缺陷报告已追溯应用于先前发布的 C++ 标准。

DR 应用于 发布的行为 正确的行为
LWG 885 C++98 缺少异构复制赋值 添加(作为重载 (3)
LWG 2729 C++11 pair::operator= 未受约束,可能
导致不必要的未定义行为
受约束

[编辑] 另请参阅

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