含引用的std::pair排序出现异常行为，求原因解析

问题背景 #

自C++20起，结构体中的引用可通过自定义成员函数实现重绑定。测试std::pair<string, string&>在排序时出现异常输出，但自定义MyPair类表现正常，相关代码如下：

异常的std::pair测试代码 #

#include <tuple>
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>

using std::pair, std::vector, std::string, std::cout;

int main()
{
    string s1{ " MyFirst" };
    string s2{ " MySecond" };
    vector < pair<string, string&>> v; v.reserve(2);    // prevent reallocation
    v.push_back({ "string_b", s2 });
    v.push_back({ "string_a", s1 });
    cout << v[0].first << v[0].second << '\n';
    cout << v[1].first << v[1].second << '\n';

    // sort so string_a comes first
    std::sort(v.begin(), v.end(), [](pair<string, string&> a, pair<string, string&> b) {
        return a.second < b.second; });

    cout << '\n';
    cout << v[0].first << v[0].second << '\n';
    cout << v[1].first << v[1].second << '\n';

    // outputs
/*
    string_b MySecond
    string_a MyFirst

    string_a MySecond
    string_b MySecond
*/
}

正常的自定义MyPair测试代码 #

#include <iostream>
#include <algorithm>
#include <string>
#include <vector>

using std::pair, std::vector, std::string, std::cout;

struct MyPair {
    string first;
    string& second;
    MyPair(const string& s1, string &s2) : first(s1), second(s2) {}
    MyPair& operator=(const MyPair& arg) {
        if (this == &arg)
            return *this;
        std::destroy_at(this);
        return *std::construct_at(this, arg);
    }
};


int main()
{
    string s1{ " MyFirst" };
    string s2{ " MySecond" };
    vector<MyPair> v;
    v.push_back({ "string_b", s2 });
    v.push_back({ "string_a", s1 });
    cout << v[0].first << v[0].second << '\n';
    cout << v[1].first << v[1].second << '\n';

    // sort so string_a comes first
    std::sort(v.begin(), v.end(), [](MyPair &a, MyPair &b) {
        return a.second < b.second; });

    cout << '\n';
    cout << v[0].first << v[0].second << '\n';
    cout << v[1].first << v[1].second << '\n';
}
    // outputs
/*
    string_b MySecond
    string_a MyFirst

    string_a MyFirst
    string_b MySecond
*/

核心原因：赋值逻辑的差异 #

两者的行为差异完全来自赋值运算符的实现逻辑：

1. 自定义MyPair的赋值逻辑 #

你在MyPair::operator=中通过std::destroy_at销毁当前对象，再用std::construct_at基于传入的参数重新构造对象。这种方式相当于直接创建新的MyPair实例：

• 引用成员会被重新绑定到参数对象的引用指向的变量；
• 不会修改原引用指向的变量的值。

2. std::pair的赋值逻辑 #

标准库的std::pair采用逐成员赋值的默认逻辑，对于含引用成员的pair<T, U&>：

• 非引用成员（如string first）直接赋值内容；
• 引用成员的赋值操作本质是给引用指向的对象赋值（即this->second = rhs.second），而非重新绑定引用本身。

异常输出的具体过程 #

回到std::pair的测试代码：

1. 排序前：v[0].second引用s2（值为MySecond），v[1].second引用s1（值为MyFirst）。
2. 排序时，由于"MyFirst" < "MySecond"为真，sort会将v[1]移到v[0]的位置，过程中需要执行元素赋值：
   • 临时保存v[1]（临时对象的second仍引用s1）；
   • 执行v[1] = v[0]：v[1].second = v[0].second等价于s1 = s2，此时s1的值被修改为MySecond；
   • 执行v[0] = 临时对象：v[0].second = 临时对象.second等价于s2 = s1，但s1已经是MySecond，所以s2的值不变。
3. 最终s1和s2的值均为MySecond，因此两个pair的second输出都是MySecond。

而自定义MyPair在赋值时，引用成员会被重新绑定到对应变量，不会修改变量的值，因此排序后输出正常。

补充说明 #

C++20允许类通过自定义成员函数实现引用重绑定，但这属于用户自定义行为。标准库的std::pair为了保持通用性和兼容性，并未为含引用成员的场景实现这种逻辑，依然遵循传统的逐成员赋值规则。

内容的提问来源于stack exchange，提问作者doug