Quelle est la bonne façon de référencer une fonction membre d'une classe?

Question

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

class C 
{ 
public: 
    vector<int> CSort(); 
    bool Func(int x, int y); 
private: 
    vector<int> data; 
}; 

vector<int> C::CSort() 
{ 
    vector<int> result(data.size(), 0); 
    iota(result.begin(), result.end(), 0); 
    sort(result.begin(), result.end(), Func); 
    return result; 
} 

bool C::Func(int x, int y) 
{ 
    return (data[x] > data[y]); 
} 

Dans ma classe C défini comme ci-dessus, je voudrais obtenir un vecteur d'ordre de data avec std::sort en utilisant la fonction de membre Func. Le résultat était une erreur

'C :: Func': syntaxe non standard; utilisation & 'pour créer un pointeur vers un membre

Je crois que cela a quelque chose à voir avec Why doesn't reference-to-member exist in C++.

Cependant, je ne peux pas trouver un moyen correct de faire référence à cette fonction dans std::sort. Comment puis-je l'implémenter correctement?

Answer 1

Façon rapide et sale: déplacez Func en dehors de la classe.

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

class C 
{ 
public: 
    vector<int> CSort(); 
private: 
    vector<int> data; 
}; 

bool Func(int x, int y) { 
    return x > y; 
} 

vector<int> C::CSort() 
{ 
    vector<int> result(data.size(), 0); 
    // iota(data.begin(), data.end(), 0); 
    sort(data.begin(), data.end(), Func); 
    return result; 
} 

Answer 2

lambda fonctionne:

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

class C 
{ 
public: 
    vector<int> CSort(); 
    bool Func(int x, int y); 
private: 
    vector<int> data; 
}; 

vector<int> C::CSort() 
{ 
    vector<int> result(data.size(), 0); 
    iota(data.begin(), data.end(), 0); 
    sort(data.begin(), data.end(), [this](auto& l, auto& r) {return Func(l, r); }); 
    return result; 
} 

bool C::Func(int x, int y) 
{ 
    return (data[x] > data[y]); 
} 

int main() 
{ 
    C c; 
} 

ou bind:

#include <iostream> 
#include <algorithm> 
#include <numeric> 
#include <vector> 
#include <functional> 

using namespace std; 

class C 
{ 
public: 
    vector<int> CSort(); 
    bool Func(int x, int y); 
private: 
    vector<int> data; 
}; 

vector<int> C::CSort() 
{ 
    vector<int> result(data.size(), 0); 
    iota(data.begin(), data.end(), 0); 
    sort(data.begin(), data.end(), std::bind(&C::Func,this,std::placeholders::_1,std::placeholders::_2)); 
    return result; 
} 

bool C::Func(int x, int y) 
{ 
    return (data[x] > data[y]); 
} 

int main() 
{ 
    C c; 
} 

Answer 3

Vous avez deux options:

Si vous n'avez pas accès à C++ 11 vous pouvez aller à l'ancienne école et mettre en œuvre votre propre comparateur qui préserve l'état:

class C 
{ 
    friend struct MyComp; 
public: 
    vector<int> CSort(); 
private: 
    vector<int> data; 
}; 

struct MyComp 
{ 
    C* data; 
    MyComp(C* data) : data(data) {} 
    bool operator()(int x, int y) 
    { 
     return data->data[x] > data->data[y]; 
    } 
}; 

vector<int> C::CSort() 
{ 
    vector<int> result(data.size(), 0); 
    iota(data.begin(), data.end(), 0); 
    sort(data.begin(), data.end(), MyComp(this)); 
    return result; 
} 

Cependant, si vous le faites, vous pouvez simplement utiliser un lambda:

vector<int> C::CSort() 
{ 
    vector<int> result(data.size(), 0); 
    iota(data.begin(), data.end(), 0); 
    sort(data.begin(), data.end(), [this] (int x, int y) { 
     return (data[x] > data[y]); 
    }); 
    return result; 
}