Question

I have a class cl1:

class c1
{
long double * coords;
...
}

I also have a second class cl2:

class cl2
{
vector<cl1*> cl1_vec;
unsigned int d;
...
}

I would like to sort cl1_vec, from cl2, based on coords[d], using the sort function for vectors.
So i could have something like

sort(cl2_inst->cl1_vec.begin(),cl2_inst->cl1_vec.end(), ??? );

I tried approches like

sort the 'std::vector' containing classes

C++ std::sort with predicate function in Class

but i couldn’t make my way to solving this.

Thanks for any help that comes this way.

The code i’ve tried:

class cl1 {
    public:
        long double* coords;

        cl1(long double *, unsigned int);
        cl1();
        cl1(const cl1& orig);
        virtual ~cl1();        
};

class cl2 {

    public:

    unsigned int d;

    vector<cl1*> cl1_vec;

    //the srting functions
    static bool compareMyDataPredicate(cl1* lhs, cl1* rhs)
    {
        return (lhs->coords[d] < rhs->coords[d]);
    };
    // declare the functor nested within MyData.
    struct compareMyDataFunctor : public binary_function<my_point*, my_point*, bool>
    {
        bool operator()( cl1* lhs, cl1* rhs)
        {
            return (lhs->coords[d] < rhs->coords[d]);
        }
    };
    ...
    ...
}

then in main

    std::sort(cl2_inst->cl1_vec.begin(),cl2_inst->cl1_vec.end(),cl2::compareMyDataPredicate() );

Answer 1

I am not sure about the problems, because you were not precise enough about what exactly “does not work” means in your case (does not compile, does compile but does not sort etc). In case it does not compile (most likely guess) you did not post the error messages, which also makes finding and explaining the problem very hard.

Here are some guesses based on the code you posted:

Both static function as well as the functor use the member d to decide which column to sort on. However d is an instance variable, so it is not available for anything which is static. Neither the functor nor the static member function would know which of the possible ds to use, as there is one d per instance.

The best way to do this without resorting to C++11 features (lamdas) is to provide a constructor to the functor which takes the d you are planning to use. Something like this:

struct compareMyDataFunctor : public binary_function<cl1*, cl1*, bool>
{
    compareMyDataFunctor( unsigned int d ) : d( d ) {}
    bool operator()( cl1* lhs, cl1* rhs)
    {
        return (lhs->coords[d] < rhs->coords[d]);
    }

    unsigned int d;
};

This should do the trick.

There are some more things wrong with the code you posted though:

• Arrays should be indexed using type size_t not a unsigned int. Same goes for std::vectors
• The types in the std::binary_function instantiation do not match the actual types in the method (may be a problem of reducing the code).
• Do not use using namespace std (I assume you do from the declarations in your code).
• Functors such as these should take parameters as const-reference, not by value.

That’s all I can think of. Next time try to present short, self contained, complete examples, then people will not have to resort to guessing.