傳遞類方法而不是std :: sort中的函數

Question

在類中，我試圖通過傳遞相同類的方法來排序向量。但它在編譯時會出錯。任何人都可以告訴問題是什麼？謝謝！

它提供了以下錯誤： 參數bool (Sorter::)(D&, D&)' does not match bool類型（分揀機:: *）（d &，d &）」

我一直在使用sortBynumber(D const& d1, D const& d2)

#include<vector> 
#include<stdio.h> 
#include<iostream> 
#include<algorithm> 

class D { 
     public:     
      int getNumber();    
      D(int val); 
      ~D(){}; 
     private: 
       int num; 
}; 

D::D(int val){ 
     num = val; 
     }; 

int D::getNumber(){ 
    return num; 
}; 


class Sorter { 
     public:     
      void doSorting(); 
      bool sortByNumber(D& d1, D& d2); 
      std::vector<D> vec_D;   
      Sorter(); 
      ~Sorter(){}; 
     private: 
       int num; 
}; 

Sorter::Sorter(){     
     int i; 
     for (i = 0; i < 10; i++){ 
      vec_D.push_back(D(i)); 
      } 
     }; 

bool Sorter::sortByNumber(D& d1, D& d2){ 
    return d1.getNumber() < d2.getNumber(); 
    }; 

void Sorter::doSorting(){ 
    std::sort(vec_D.begin(), vec_D.end(), this->sortByNumber); 
    }; 




int main(){  
    Sorter s; 
    s.doSorting(); 

    std::cout << "\nPress RETURN to continue..."; 
    std::cin.get(); 

    return 0; 
} 

Answer 1

讓Sorter::sortByNumber靜也嘗試。由於它不引用任何對象成員，因此不需要改變其他任何東西。

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) 
{ 
    ... 
} 

您還應該使用const的引用作爲sortByNumber不應該被修改的對象。

Answer 2

我認爲沒有任何理由使sortByNumber成爲類Sorter的成員函數。如果你使它成爲一個自由函數，你可以更容易地進行排序，以避免所有難看的綁定代碼。此外，您應該在代碼中適用的任何地方使用const。下面是使用免費的功能，這樣做的例子：

首先更改int getNumber()爲const功能int getNumber() const;

然後寫你的免費功能sortByNumber通過const引用再次服用參數。 bool sortByNumber(const D& d1, const D& d2);

你可以叫sort爲： std::sort(vec_D.begin(), vec_D.end(), sortByNumber);

Answer 3

我認爲沒有理由對sortByNumber()是一個成員函數。當它是一個成員函數時，它可以訪問它不需要的東西（因此不應該有權訪問）。提取方法並將其重構爲函數對象：

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()); 

這就是說，你可以編譯代碼是像這樣，與boost::bind()：

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

您需要Boost庫爲工作，你將需要#include <boost/bind.hpp>。

Answer 4

除非你有一個很好的理由不這樣做，只是定義爲operator<你整理項目的類型，並用它做：

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()); } 
}; 

的方式你寫你的sorter類取決於知道關於D類的內部的批，以至於它們實際上是單個類（例如，如果沒有其他類，它們看起來都不能做很多事情）。

根據猜測，您的sorter可能是您的真實代碼的一些簡化版本。該SortByNumber使得它聽起來像原來的代碼可能會支持許多不同類型的按鍵，類似的：

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

，你會希望能夠D對象的名字，身高或體重排序。在這樣的情況下，比較是真的還涉及到D類，所以我可能會把它們放在一個公共的命名空間：

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()); 

請注意，這是而不是使用免費功能。爲了這種目的，通常優選仿函子。我還使用了一個名稱空間來顯示被排序的對象與排序對象的不同方式之間的關聯。你可能而不是他們的嵌套類，但我通常更喜歡公共命名空間（保持耦合儘可能寬鬆）。如果可以避免（在這種情況下，它可以），通過對象的公共接口，我會而不是訪問原始數據（甚至是隻讀訪問）。