Sorting vectors of objects by data members

Question

Yes, I know this is a repeat question and I already know that the anwser im looking for is here:

Sorting a vector of objects by a property of the object

However I have problems converting this to my own code. I'm looking at this code snippet from the above question:

struct SortByX
{
    bool operator() const(MyClass const& L, MyClass const& R) {
        return L.x < R.x;
    }
};

std::sort(vec.begin(), vec.end(), SortByX();

What I do not understand is what is being represented by MyClass const & L, and MyClass const & R. And I am not grasping how I can apply this to my code.

To give a bit more detail I am putting 3 sort methods into a wrapper class of a vector of objects that have parameters of (string, double, double, double, bool). And the over all goal is to sort the vector by the string, the bool and any one out of the 3 doubles.

This is the lastest version I have:

void StationVector::sortByGrade(int kindOfGas) {
struct SortByGrade {
    int kindOfGas;

    SortByGrade(int kindOfGas) :
            kindOfGas(kindOfGas) {
    }

    bool operator()(GasStation const &L, GasStation const & R) const {
        return L.getPrice(kindOfGas) < R.getPrice(kindOfGas);
    }
};

std::sort(localStations.begin(), localStations.end(),
        SortByGrade(kindOfGas));
}

the line SortByGrade(kindOfGas)) gives me the following error:

no matching function for call to `sort(__gnu_cxx::__normal_iterator > >, __gnu_cxx::__normal_iterator > >, model::StationVector::sortByGrade(int)::SortByGrade)'

Answer 1

SortByX is a binary predicate functor. Binary predicate means it takes two arguments and returns a boolean. Functor means it's instances are callable. For example:

MyClass a = ....;
MyClass b = ....;
SortByX comp;
bool flag = comp(a,b); // call this SortByX instance with two MyClass instances

Now, std::sort will internally use a copy of the instance of SortByX that you pass it in order to perform the comparisons between the elements of a std::vector<MyClass> needed to sort that vector.

std::vector<MyClass> v;
// fill the vector with MyClass objects
std::sort(v.begin(), v.end(), SortByX()); // sort the vector using a SortByX instance for comparisons

Note: for this to work, the binary predicate must implement strict weak ordering.

Answer 2

What I do not understand is what is being represented by MyClass const & L, and MyClass const & R.

L and R, in this case are two items (instances of your class MyClass) from the container that are being compared, with L on the left of the less-than operator and R on the right. They are passed in by const-reference.

And I am not grasping how I can apply this to my code.

In your own bool operator() const(MyClass const& L, MyClass const& R), you need to compare the three data members you mention in your question, vitally remembering to apply strict weak ordering. Return true if L is "less than" R and false otherwise.

---

Following updates to the question...

It looks like you wish to pass a variable into your functor. You do this by creating a constructor, like this SSCCE (which compiles here):

#include <algorithm>
#include <vector>

namespace model {

struct GasStation
{
    double getprice(int kindOfGas) const
    {
        return kindOfGas;
    }
};

struct StationVector
{
    std::vector<GasStation> localStations;

    struct SortByGrade
    {
        int kindOfGas_;
        SortByGrade(int kindOfGas)
            :kindOfGas_(kindOfGas)
        {
        }

        bool operator() (GasStation const &L, GasStation const & R) const
        { 
            // You'll need other comparisons here, but this is a good start...
            return L.getprice(kindOfGas_) < R.getprice(kindOfGas_); 
        }
    };

    void sortByGrade(int kindOfGas) 
    {
        std::sort(localStations.begin(), localStations.end(), SortByGrade(kindOfGas));
    }
};

}

int main()
{
    model::StationVector sv;
    sv.sortByGrade(0);
}

Note: The const qualifier comes after the argument list and not after the method name.

Also, please don't put the entire method on one line, it makes it very difficult to read.