为什么STL的std :: sort无法与不可变的类一起使用？

Question

Std::sort works when class properties are mutable. For example the following code works and the vector is sorted in ascending order as expected.

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;
    });
}

But the same class when made immutable isn't compatible with 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;
    });
}

Can anyone tell me why?

Many thanks.

Answer 1

C++'s std::sort requires that the iterators being sorted implement ValueSwappable .

Type T is ValueSwappable if

1. Type T satisfies the Iterator requirements
2. For any dereferencable object x of type T (that is, any value other than the end iterator), *x satisfies the Swappable requirements.

And to be swappable, you basically need this to work:

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

Additionally, std::sort requires the following expressions to be valid ( MoveConstructible and MoveAssignable :

Definitions:

• t is a modifiable lvalue of type T .
• rv is an rvalue expression of type T .

Requirements:

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

Your compiler appears to be broken...

The code you have presented does meet these requirements. So I'm not sure why your compiler is refusing this code. Your PersonImmutable does implement the requirements of std::swap because of the operator= overload.

Your immutable object shouldn't meet this requirements though (because it's immutable)...

That being said, your operator= overload will cause the compiler to crash, because you're returning a stack variable by reference.

An operator= overload should almost always return *this by reference. Which requires mutating the object. So it doesn't make much sense in an immutable object.

Do you really need to sort these objects?

If you have to sort them, there are some options.

1. You can sort a vector of pointers.
2. You can sort a std::list of immutable objects.
3. There's other options too..

The minimal(ish) testcase for this code...

A valid compiler should accept the following code as valid. It sounds like yours does not.

#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);
}