Могу ли я передать параметр функции сортировки std::vector?

Рассмотрим класс:

MyClass {
    int varA;
    int varB;
};

У меня есть вектор указателей на объекты MyClass:

std::vector<MyClass*> Vec;

Я хочу отсортировать вектор в соответствии с varA или varB с помощью той же функции сортировки, то есть:

bool SortFunction(const MyClass* obj1, const MyClass* obj2, const short type) {
     if( type == VARA_ID )
         return obj1->varA < obj2->varA;
     else if( type == VARB_ID )
         return obj1->varB < obj2->varB;
}

AFAICT это невозможно. Какой был бы самый элегантный способ для этого без использования внешних библиотек?

Ответ 1

class sorter {
      short type_;
public:
      sorter(short type) : type_(type) {}
      bool operator()(MyClass const* o1, MyClass const* o2) const {
            return SortFunction(o1, o2, type_ );
      }
};

std::sort(Vec.begin(), Vec.end(), sorter(MY_TYPE) );

Ответ 2

Вы почти там, сделайте type параметр шаблона и подпись в порядке:

template<int type>
bool SortFunction(const MyClass* obj1, const MyClass* obj2) {
     if( type == VARA_ID )
         return obj1->varA < obj2->varA;
     else // if( type == VARB_ID ) -- A sort function must have a default.
         return obj1->varB < obj2->varB;
}

std::sort(Vec.begin(), Vec.end(), &SortFunction<VARA_ID> );

Оптимизатор обнаружит, что ( type == VARA_ID ) является константой времени компиляции.

Ответ 3

Используя Boost.Lambda и без специальной функции сортировки, прямо в коде, где вам нужна сортировка:

Коротко

// sort with VARA_ID
sort(Vec.begin(), Vec.end(), bind(&MyClass::varA, _1)<bind(&MyClass::varA, _2));

// sort with VARB_ID
sort(Vec.begin(), Vec.end(), bind(&MyClass::varB, _1)<bind(&MyClass::varB, _2));

Полный пример

#include <iostream>
#include <vector>
#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>
#include <algorithm>

using namespace boost::lambda;

class MyClass {
public:
    int varA;
    int varB;
};

enum SorterType {
    VARA_ID,
    VARB_ID 
};

int main()
{

    std::vector<MyClass*> Vec;

    Vec.push_back(new MyClass());
    Vec.push_back(new MyClass());
    Vec.push_back(new MyClass());

    Vec[0]->varA = 1; Vec[0]->varB = 8;
    Vec[1]->varA = 2; Vec[1]->varB = 7;
    Vec[2]->varA = 3; Vec[2]->varB = 6;

    // sort with VARA_ID
    std::sort(Vec.begin(), Vec.end(), 
              bind(&MyClass::varA, _1)  < bind(&MyClass::varA, _2) );

    // VARB_ID
    std::sort(Vec.begin(), Vec.end(), 
              bind(&MyClass::varB, _1)  < bind(&MyClass::varB, _2) );

    return 0;
}

Ответ 4

Изменяется ли значение type при каждом сравнении? Он не может, как кажется. В этом случае используйте валютную функцию - см. boost::bind.

std::sort(v.begin(), v.end(), boost::bind(SortFunction, _1, _2, type));

Ответ 5

Более общее решение может также заключаться в использовании указателей-к-членам:

#include <vector>
#include <algorithm>
#include <functional>

struct MyClass {
    int varA;
    int varB;
};

template <class Object, class VarType>
class CompareMemberT: public std::binary_function<bool, const Object*, const Object*>
{
    VarType Object::*p;
public:
    CompareMemberT(VarType Object::*p): p(p) {}
    bool operator()(const Object* a, const Object* b) const
    {
        return a->*p < b->*p;
    }
};

//helper to deduce template arguments
template <class Object, class VarType>
CompareMemberT<Object, VarType> CompareMember(VarType Object::*p)
{
    return CompareMemberT<Object, VarType>(p);
}

int main()
{
    std::vector<MyClass*> vec;
    std::sort(vec.begin(), vec.end(), CompareMember(&MyClass::varA));
    std::sort(vec.begin(), vec.end(), CompareMember(&MyClass::varB));
}