为什么 STL 的 std::sort 不适用于不可变类？

Question

Std::sort 在类属性可变时起作用。例如，以下代码有效，并且向量按预期按升序排序。

class PersonMutable
{
public:

    PersonMutable(int age, std::string name):
        Age(age),Name(name)
    {
    }



    int Age;
    std::string Name;
};



void TestSort()
{
    std::vector<PersonMutable> people;
    people.push_back(PersonMutable(24,"Kerry"));
    people.push_back(PersonMutable(30,"Brian"));
    people.push_back(PersonMutable(3,"James"));
    people.push_back(PersonMutable(28,"Paul"));

    std::sort(people.begin(),people.end(),
        [](const PersonMutable& a, PersonMutable & b) -> bool
    {
        return a.Age < b.Age;
    });
}

但是当同一个类不可变时，它与 std::sort 不兼容。

class PersonImmutable
{
public:

    PersonImmutable(int age, std::string name):
        Age(age),Name(name)
    {
    }

    PersonImmutable& operator=(const PersonImmutable& a)
    {
        PersonImmutable b(a.Age,a.Name);
        return b;
    }

    const int Age;
    const std::string Name;
};


void TestSort()
{
    std::vector<PersonImmutable> people;
    people.push_back(PersonImmutable(24,"Kerry"));
    people.push_back(PersonImmutable(30,"Brian"));
    people.push_back(PersonImmutable(3,"James"));
    people.push_back(PersonImmutable(28,"Paul"));

    std::sort(people.begin(),people.end(),
        [](const PersonImmutable& a, PersonImmutable & b) -> bool
    {
        return a.Age < b.Age;
    });
}

谁能告诉我为什么？

非常感谢。

Answer 1

C++ 的std::sort 要求被排序的迭代器实现ValueSwappable。

类型 T 是 ValueSwappable 如果

1. T 型满足迭代器要求
2. 对于任何 T 类型的可解引用对象 x（即除结束迭代器之外的任何值），*x 满足 Swappable 要求。

并且要可交换，您基本上需要这样才能工作：

using std::swap;
swap(*x, *y);

此外，std::sort 要求以下表达式有效（MoveConstructible 和 MoveAssignable：

定义：

• t 是 T 类型的可修改左值。
• rv 是 T 类型的右值表达式。

要求：

1. t = rv;
2. T u = rv;
3. T(rv);

您的编译器似乎已损坏...

您提供的代码确实满足这些要求。所以我不确定你的编译器为什么拒绝这段代码。由于operator= 过载，您的PersonImmutable 确实实现了std::swap 的要求。

你的不可变对象不应该满足这个要求（因为它是不可变的）......

话虽如此，您的operator= 重载将导致编译器崩溃，因为您通过引用返回了一个堆栈变量。

operator= 重载几乎总是通过引用返回 *this。这需要改变对象。所以它在不可变对象中没有多大意义。

您真的需要对这些对象进行排序吗？

如果您必须对它们进行排序，有一些选项。

1. 您可以对指针向量进行排序。
2. 您可以对不可变对象的 std::list 进行排序。
3. 还有其他选择..

此代码的最小（ish）测试用例...

一个有效的编译器应该接受以下代码为有效的。听起来你的没有。

#include <string>

class PersonImmutable {
    public:
        PersonImmutable(int age): Age(age) {}

        PersonImmutable operator=(const PersonImmutable& a) {
            return *this;
        }

    private:
        const int Age;
};

int main() {
    PersonImmutable a(1, "a");
    PersonImmutable b(2, "b");

    using std::swap;
    swap(a,b);
}