如何在c＆＃x2b;＆＃x2b;中使用sort（）使用自定义排序成员功能？

Question

我有一个问题，要将比较函数传递到sort（）。

我想做的是定义sort（）函数，该函数考虑到其计算我想进行排序的类的成员变量。

基本上，我的代码看起来像这样（简化了仅显示相关部分）：

mappingtechnique.h

struct MappingTechnique {
    vector<int> usedIndexCount; 
};

struct SimpleGreedyMappingTechnique : MappingTechnique {
    bool sortByWeights(int index1, int index2);
};

mappingtechnique.m

bool SimpleGreedyMappingTechnique::sortByWeights(int index1, int index2) {
    return usedIndexCount[index1] > usedIndexCount[index2];
}

void SimpleGreedyMappingTechnique::processFrame(Frame frame) {
    vector<int> payloadIndices = <generate the vector>

    // sort the payload indices according to their current usedIndexCount
    sort(payloadIndices.begin(), payloadIndices.end(), sortByWeights);
}

此代码不编译，它给出以下错误：

 error: reference to non-static member function must be called

并指向指向sortbyWeaights。

是否可以使用类的成员函数进行排序？如果是这样，我如何实现？

Answer 1

是的，但是通常我会鼓励只使用适当的函子或lambda：

使用lambda：

std::sort(payloadIndices.begin(), payloadIndices.end(), [this](int a, int b){
    return this->sortByWeights(a, b);
});

或者使用std :: mem_fn：

auto sorter = std::bind(std::mem_fn(SimpleGreedyMappingTechnique::sortByWeights), this);
std::sort(payloadIndices.begin(), payloadIndices.end(), sorter);

或者使用functor：

namespace{
struct indicies_less_than
{
    const SimpleGreedyMappingTechnique & mapping_tech;
    indicies_less_than(const SimpleGreedyMappingTechnique & mapping_tech)
       :mapping_tech(mapping_tech){}

    bool operator()(int a, int b)
    {
       return mapping_tech.sortByWeights(a, b);
    }
};
}

std::sort(payloadIndices.begin(), payloadIndices.end(), indicies_less_than(*this));

注意：

如果被排序的类型比int更复杂，您肯定想通过const＆amp;通过它们来防止复制

Answer 2

如Mgetz所述，可以使用函子。函子的示例：

#include <algorithm>
#include <cstdlib>
#include <iostream>
#include <iomanip>
#include <vector>

#define asize 16

class example{
public:
    unsigned int a[asize];      // array
    std::vector<size_t> v;      // indices to array

example(void)
{
    v.resize(asize);
    for(size_t i = 0; i < asize; i++){
        a[i] = rand()%10;
        v[i] = i;
    }
}

void displayarray(void)
{
    for(size_t i = 0; i < asize; i++)
        std::cout << std::setw(3) << a[v[i]];
    std::cout << std::endl;
}

class lessthan                  // lessthan functor for std::sort
{
public:
const example &x;
    lessthan(const example &e ) : x(e) { }
    bool operator()(const size_t & i0, const size_t & i1)
    {
        return x.a[i0] < x.a[i1];
    }
};

void sortarray(void)
{
    std::sort(v.begin(), v.end(), lessthan(*this));
}
};

int main()
{
example x;

    x.displayarray();
    x.sortarray();
    x.displayarray();
    return 0;
}