C ++ / STL是否支持按属性对对象进行排序？

Question

我想知道STL是否有这方面的支持：

说我有这样的课程：

class Person
{
public:
  int getAge() const;
  double getIncome() const;
  ..
  ..
};

和矢量：

vector<Person*> people;

我想根据他们的年龄对人的矢量进行排序： 我知道我可以通过以下方式实现：

class AgeCmp
{
public:
   bool operator() ( const Person* p1, const Person* p2 ) const
   {
     return p1->getAge() < p2->getAge();
   }
};
sort( people.begin(), people.end(), AgeCmp() );

是否有一种不那么冗长的方式来做到这一点？仅仅因为我想基于'属性'进行排序而必须定义整个类似乎有点过分。这样的事可能吗？

sort( people.begin(), people.end(), cmpfn<Person,Person::getAge>() );

Answer 1

基于成员属性进行比较的通用适配器。虽然它第一次可重复使用时更加冗长。

// Generic member less than
template <typename T, typename M, typename C>
struct member_lt_type 
{
   typedef M T::* member_ptr;
   member_lt_type( member_ptr p, C c ) : ptr(p), cmp(c) {}
   bool operator()( T const & lhs, T const & rhs ) const 
   {
      return cmp( lhs.*ptr, rhs.*ptr );
   }
   member_ptr ptr;
   C cmp;
};

// dereference adaptor
template <typename T, typename C>
struct dereferrer
{
   dereferrer( C cmp ) : cmp(cmp) {}
   bool operator()( T * lhs, T * rhs ) const {
      return cmp( *lhs, *rhs );
   }
   C cmp;
};

// syntactic sugar
template <typename T, typename M>
member_lt_type<T,M, std::less<M> > member_lt( M T::*ptr ) {
   return member_lt_type<T,M, std::less<M> >(ptr, std::less<M>() );
}

template <typename T, typename M, typename C>
member_lt_type<T,M,C> member_lt( M T::*ptr, C cmp ) {
   return member_lt_type<T,M,C>( ptr, cmp );
}

template <typename T, typename C>
dereferrer<T,C> deref( C cmp ) {
   return dereferrer<T,C>( cmp );
}

// usage:    
struct test { int x; }
int main() {
   std::vector<test> v;
   std::sort( v.begin(), v.end(), member_lt( &test::x ) );
   std::sort( v.begin(), v.end(), member_lt( &test::x, std::greater<int>() ) );

   std::vector<test*> vp;
   std::sort( v.begin(), v.end(), deref<test>( member_lt( &test::x ) ) );
}

Answer 2

您不需要创建一个类 - 只需编写一个函数：

#include <vector>
#include <algorithm>
using namespace std;

struct Person {
    int age;
    int getage() const {
        return age;
    }
};

bool cmp( const Person * a, const Person * b ) {
    return a->getage() < b->getage() ;
}

int main() {
    vector <Person*> v;
    sort( v.begin(), v.end(), cmp );
}

Answer 3

这本身并不是一个答案，作为回答AraK对我的评论的回复，用函数而不是函子进行排序可能会更慢。这里有一些（不可否​​认的丑陋 - 太多的CnP）测试代码比较各种排序：qsort，std :: sort of vector与array，std :: sort使用模板类，模板函数或plain函数进行比较：

#include <vector>
#include <algorithm>
#include <stdlib.h>
#include <time.h>

int compare(void const *a, void const *b) {
    if (*(int *)a > *(int *)b)
        return -1;
    if (*(int *)a == *(int *)b)
        return 0;
    return 1;
}

const int size = 200000;

typedef unsigned long ul;

void report(char const *title, clock_t ticks) { 
    printf("%s took %f seconds\n", title, ticks/(double)CLOCKS_PER_SEC);
}

void wait() { 
    while (clock() == clock())
        ;
}

template <class T>
struct cmp1 { 
    bool operator()(T const &a, T const &b) { 
        return a < b;
    }
};

template <class T>
bool cmp2(T const &a, T const &b) { 
    return a<b;
}

bool cmp3(int a, int b) { 
    return a<b;
}

int main(void) {
    static int array1[size];
    static int array2[size];

    srand(time(NULL));

    for (int i=0; i<size; i++) 
        array1[i] = rand();

    const int iterations = 100;

    clock_t total = 0;

    for (int i=0; i<iterations; i++) { 
        memcpy(array2, array1, sizeof(array1));
        wait();
        clock_t start = clock();
        qsort(array2, size, sizeof(array2[0]), compare);
        total += clock()-start;
    }
    report("qsort", total);

    total = 0;
    for (int i=0; i<iterations; i++) {
        memcpy(array2, array1, sizeof(array1));
        wait();
        clock_t start = clock();
        std::sort(array2, array2+size);
        total += clock()- start;
    }
    report("std::sort (array)", total);

    total = 0;
    for (int i=0; i<iterations; i++) {
        memcpy(array2, array1, sizeof(array1));
        wait();
        clock_t start = clock();
        std::sort(array2, array2+size, cmp1<int>());
        total += clock()- start;
    }
    report("std::sort (template class comparator)", total);

    total = 0;
    for (int i=0; i<iterations; i++) {
        memcpy(array2, array1, sizeof(array1));
        wait();
        clock_t start = clock();
        std::sort(array2, array2+size, cmp2<int>);
        total += clock()- start;
    }
    report("std::sort (template func comparator)", total);

    total = 0;
    for (int i=0; i<iterations; i++) {
        memcpy(array2, array1, sizeof(array1));
        wait();
        clock_t start = clock();
        std::sort(array2, array2+size, cmp3);
        total += clock()- start;
    }
    report("std::sort (func comparator)", total);

    total = 0;
    for (int i=0; i<iterations; i++) {
        std::vector<int> array3(array1, array1+size);
        wait();
        clock_t start = clock();
        std::sort(array3.begin(), array3.end());
        total += clock()-start;
    }
    report("std::sort (vector)", total);

    return 0;
} 

使用cl /O2b2 /GL sortbench3.cpp使用VC ++ 9 / VS 2008进行编译，得到：

qsort took 3.393000 seconds
std::sort (array) took 1.724000 seconds
std::sort (template class comparator) took 1.725000 seconds
std::sort (template func comparator) took 2.725000 seconds
std::sort (func comparator) took 2.505000 seconds
std::sort (vector) took 1.721000 seconds

我相信它们会相当干净地分为三组：使用sort与默认比较，并使用模板类生成最快的代码。使用函数或模板函数显然较慢。使用qsort（令人惊讶的是一些）是最慢的，大约是2：1的边缘。

cmp2和cmp3之间的差异似乎完全取决于通过引用与值的传递 - 如果你改变cmp2以通过值获取其参数，它的速度与cmp3完全匹配（至少在我的测试中）。不同之处在于，如果您知道类型将是int，那么您几乎肯定会通过值传递，而对于通用T，您通常会传递const引用（以防万一）复制成本更高的东西。

Answer 4

如果只有一件事你想要按人格排序（或者如果你有大部分时间都想要使用合理的默认值），请覆盖operator< { {1}}类按此属性排序。如果没有明确的比较器，STL排序函数（以及隐式使用排序的任何内容，如集合和映射）将使用People。

当你想用operator<以外的东西排序时，你所描述的方式是当前版本的C ++的唯一方法（尽管比较器可以只是一个常规函数;它不会'必须是一个算子）。通过允许lambda functions，C ++ 0x标准将使这更简洁。

如果您不愿意等待C ++ 0x，另一种方法是使用boost::lambda。

Answer 5

我看到dribeas已经发布了这个想法，但是既然我已经写过了，那么你就是如何编写一个通用的比较器来使用getter函数。

#include <functional>

template <class Object, class ResultType>
class CompareAttributeT: public std::binary_function<const Object*, const Object*, bool>
{
    typedef ResultType (Object::*Getter)() const;
    Getter getter;
public:
    CompareAttributeT(Getter method): getter(method) {}
    bool operator()(const Object* lhv, const Object* rhv) const
    {
        return (lhv->*getter)() < (rhv->*getter)();
    }
};

template <class Object, class ResultType>
CompareAttributeT<Object, ResultType> CompareAttribute(ResultType (Object::*getter)() const)
{
    return CompareAttributeT<Object, ResultType>(getter);
}

用法：

std::sort(people.begin(), people.end(), CompareAttribute(&Person::getAge));

我认为为非指针重载operator()可能是一个好主意，但是后者无法通过继承binary_function来解析argument_types - 这可能不是一个很大的损失，因为在任何需要的地方都很难使用它，例如，无论如何都不能否定比较函子。

Answer 6

虽然我喜欢模板的想法，但这些答案都非常冗长！只需使用lambda函数，它就会变得更加简单！

你可以使用它：

sort( people.begin(), people.end(), []( Person a, Person b ){ return a.age < b.age; } );

Answer 7

您可以只拥有全局函数或静态函数。这些全局或静态函数中的每一个都与属性进行比较。无需上课。保持papeters进行比较的一种方法是使用boost bind，但bind仅用于查找所有类或将所有类与某些绑定参数进行比较。在多个元素之间存储数据是制作仿函数的唯一原因。

编辑：另请参阅boost lambda函数，但它们仅适用于简单函数。

Answer 8

我刚试过这个基于UncleBens和david-rodriguez-dribeas的想法。

这似乎与我当前的编译器一样（原样）。 g ++ 3.2.3。如果它适用于其他编译器，请告诉我。

#include <vector>
#include <algorithm>
#include <iostream>

using namespace std;

class Person
{
public:
    Person( int _age )
        :age(_age)
    {
    }
    int getAge() const { return age; }
private:
    int age;
};

template <typename T, typename ResType>
class get_lt_type
{
    ResType (T::*getter) () const;
public:
    get_lt_type(ResType (T::*method) () const ):getter(method) {}
    bool operator() ( const T* pT1, const T* pT2 ) const
    {
        return (pT1->*getter)() < (pT2->*getter)();
    }
};

template <typename T, typename ResType>
get_lt_type<T,ResType> get_lt( ResType (T::*getter) () const ) {
    return get_lt_type<T, ResType>( getter );
}

int main() {
    vector<Person*> people;
    people.push_back( new Person( 54 ) );
    people.push_back( new Person( 4 ) );
    people.push_back( new Person( 14 ) );

    sort( people.begin(), people.end(), get_lt( &Person::getAge) );

    for ( size_t i = 0; i < people.size(); ++i )
    {
        cout << people[i]->getAge() << endl;
    }
    // yes leaking Persons
    return 0;
}