C++ 在std:：sort中传递类方法而不是函数

在类中，我试图通过传递同一类的方法对向量进行排序。但它在编译时给出了错误。谁能说出问题出在哪里？谢谢大家!

它给出了以下错误： 类型为

bool（分拣机：：）（D&，D&）'的参数不匹配

bool（分拣机：：*）（D&，D&）'

我也尝试过使用

sortBynumber（D const&d1，D const&d2）

#包括
#包括
#包括
#包括
D类{
公众：
int getNumber（）；
D（int-val）；
~D（）{}；
私人：
int-num；
};
D：：D（int-val）{
num=val；
};
intd:：getNumber（）{
返回num；
};
分类机{
公众：
无效剂量（）；
布尔索特比编号（D&d1、D&d2）；
std：：向量向量向量D；
分拣机（）；
~Sorter（）{}；
私人：
int-num；
};
分类器：：分类器（）{
int i；
对于（i=0；i<10；i++）{
向量推回（D（i））；
}
};
布尔分拣机：：分拣编号（D&d1、D&d2）{
返回d1.getNumber（）sortByNumber）；
};
int main（）{
分拣机；
s、 剂量（）；
std:：coutMake
Sorter:：sortByNumber
static。由于它不引用任何对象成员，因此不需要更改任何其他内容

class Sorter {
public:                   
    static bool sortByNumber(const D& d1, const D& d2);
    ...
};

// Note out-of-class definition does not repeat static
bool Sorter::sortByNumber(const D& d1, const D& d2)
{
    ...
}

您还应该使用常量引用，因为
sortByNumber
不应该修改对象。
我看不出有任何理由将
sortByNumber
作为类分类器的成员函数。如果将其设置为自由函数，您可以更轻松地进行排序，避免所有难看的绑定代码。此外，您应该使用
const
>在代码中适用的任何地方。以下是使用自由函数执行此操作的示例：

首先将
int getNumber（）
更改为const函数作为
int getNumber（）const；

然后再次编写自由函数
sortByNumber
，通过常量引用获取参数。
bool sortByNumber（常数D&d1，常数D&d2）；

您可以调用
sort
作为：
std:：sort（vec_D.begin（）、vec_D.end（）、sortByNumber）；
我认为没有理由将
sortByNumber（）
作为成员函数。当它是一个成员函数时，它可以访问它不需要的东西（因此不应该访问）。要么提取该方法，然后将其重构为函数对象：

struct sortByNumber {
    bool operator()(const D& d1, const D& d2) const {
        return d1.getNumber() < d2.getNumber();
    }
};

也就是说，您可以使用
boost:：bind（）
，按原样编译代码：

你需要boost库才能工作，你需要
#包含
除非你有很好的理由这样做，只需定义
操作符为什么你想
sortByNumber
作为一个成员函数？它也可以是一个自由函数。你不必明确说明
D
的析构函数。你可以通过编译器免费获得完全相同的代码。代码越少，错误就越少。；（另外，我知道，
Sorter:：vector
是公开的。只是一个观察；这可能不是你想要的。另一件事：如果你知道向量的大小，那么你最好在
Sorter
的初始化列表中指定它，以避免出现realloca其他人已经谈到了常量正确性的重要性，所以你应该注意这一点。最后一件事：在for循环中，你应该有
i
一个循环的局部变量。嗯，我尝试了这个，但现在它给出了以下错误：
无法声明成员函数
静态bool Sorter:：sortByNumber（D&，D&）'要有静态链接`@memC-不要在定义本身之前使用
static
。只在
类中的声明之前使用
static
。@Samuel:谢谢更新！我之前已经声明类外定义为static。所以做了更改。但是，将
D&
更改为
const D&
是非常困难的避免以下错误：
将
const D'作为
传递
int D:：getNumber（）”的此参数丢弃限定符`@memc-您有两个选择。您可以选择
D:：getNumber（）
const（即
int D:：getNumber（）const
），也可以选择
sortByNumber
按值获取对象（即
静态布尔排序编号（dD1，dD2）
）嗨，Naveen，这种排序只在这个类中进行。所以我认为最好把它放在类中，而不是放在一个自由函数中。但是把它变成一个类函数似乎有相当大的开销。@memC这不是你决定函数是否应该成为成员的方式。当你把一个函数变成一个成员时，你本质上提升了它的rights：您授予它访问类的所有受保护和私有成员的权限。因此，类成员不是“与类相关的东西”，而是“需要访问类内部的东西”。如果该类需要某些特殊服务，则可以创建一个静态链接的自由函数。也就是说，该函数将本地链接到该类的编译单元。您可以通过将该自由函数放置在未命名的命名空间中来实现此目的。Re:
bind1st
-您应该尝试编译这些内容。首先，没有
mem\u乐趣std:：tr1:：bind
来编译东西）@UncleBens:s哦，太匆忙了！谢谢你指出这一点。是的，我应该经常咨询我的编译器，让我的过度自信偶尔得到休息。
struct sortByNumber {
    bool operator()(const D& d1, const D& d2) const {
        return d1.getNumber() < d2.getNumber();
    }
};

std::sort(vec_D.begin(), vec_D.end(), sortByNumber());

std::sort(vec_D.begin(), vec_D.end(),
          boost::bind(&Sorter::sortByNumber, this, _1, _2));

class D { 
    int val;
public:
    D(int init) : val(init) {}
    bool operator<(D const &other) { return val < other.val; }
};

class sorter { 
    std::vector<D> vec_D;
public:
    void doSorting() { std::sort(vec_d.begin(), vec_D.end()); }
};

class D { 
    std::string name;
    int height;
    int weight;
// ...
};

namespace D { 
class D { 
    std::string name;
    int height;
    int weight;
public:
    friend class byWeight;
    friend class byHeight;
    friend class byName;
    // ...
};

struct byWeight { 
   bool operator()(D const &a, D const &b) { 
       return a.weight < b.weight;
   }
};

struct byHeight {
    bool operator()(D const &a, D const &b) { 
        return a.height < b.height;
    }
};

struct byName { 
    bool operator()(D const &a, D const &b) { 
        return a.name < b.name;
    }
};
}

std::vector<D::D> vec_D;

// sort by height:
std::sort(vec_D.begin(), vec_D.end(), D::byHeight());

// sort by weight:
std::sort(vec_D.begin(), vec_D.end(), D::byWeight());

// sort by name:
std::sort(vec_D.begin(), vec_D.end(), D::byName());