C++：如何使用其参数之一对从类派生的对象向量进行排序

Question

I'm trying to sort a vector of objects, created from a class in the project.

I have two classes - Playlist and ListIndex, that inherits from a List_base class. In the List_base class, I want to sort a vector of objects (either Playlist or ListIndex) by their name. the name property is defined in the List_base class. I tried using struct or function that compares the name field and pass it to the sort function. I'm getting all kinds of errors. I'm new to C++ and stuck in this error for a very long time

The List_base sort method with the compare function

//the function should be able to get either Playlist vector
// or ListIndex vector (both inherits from List_base)
void List_base::sortList(vector<List_base> data) {
    sort(data.begin(), data.end(), compFunc());
}

bool List_base::compFunc(List_base *a, List_base *b) {
    return a->getName().compare(b->getName()) > 0;
}

The name field is declared in the List_base class:

class List_base
{
    public:
        List_base(string name);
        string getName();
        void sortList(vector<List_base> data);
        virtual ~List_base();

    protected:

    private:
        string name;
        bool compFunc(List_base *a, List_base *b);
};

What am I doing wrong? I can't even focus on a specific error. I've also tried casting but failed there too

pls, help!

Answer 1

std::sort expects the comparator you pass to be some callable type, whether that's a function pointer, functor, lambda, etc. It just needs something that can be called with a signature like bool compare(const T& left, const T& right) .

The first problem is that passing compFunc() is calling the function compFunc . This should fail because compFunc expects two arguments. You should pass the function itself, not its return value:

sort(data.begin(), data.end(), compFunc);

The second problem is that in your compare function you should accept the arguments by reference-to-const, not by pointer:

bool compFunc(const List_base& a, const List_base& b);

where List_base is exactly the element type you're sorting.

The third problem is that compFunc is a non-static member function . This means that this function depends on a List_base instance to be used, and you need a secret this parameter to call it, as in this->compFunc(...) . You should instead make it static or non-member, so that it can be treated as a normal function.

class List_base {
    /* ... */
    static bool compFunc(const List_base& a, const List_base& b);
};

bool List_base::compFunc(const List_base& a, const List_base& b){
    return a.name < b.name;
}

Your sorting should work at this point. If you want to use the sorted result outside of List_base::sortList , you should accept data by reference , so that the changes you make can be seen by the caller. Currently, sortList accepts the list by value, meaning that it always receives a copy of what you pass it.

---

Perhaps the cleanest fix to all this would be to the "less-than" operator ( < ), which the standard library uses by default in many cases to compare user-defined types. This could like something like the following:

class List_base {
    /* ... */
    friend bool operator<(const List_base& a, const List_base& b){
        return a.name < b.name;
    }
};

with this, you don't need to explicitly specify your own comparator, and sorting is now as simple as

sort(data.begin(), data.end());