Warum ist stl vergleichen Funktion ein Mitglied?

Question

Einfach nur neugierig, warum die Vergleichsfunktion für stl :: sort kein statisches Member sein kann?

Ich habe eine kleine Hilfsklasse foo, die in einer Kopfzeile deklariert und definiert ist, aber jetzt muss ich eine foo.cpp-Datei für die Implementierung von cmp() erstellen, damit sie nicht mehrfach definiert wird.

Ich muss auch an einen passend dekorierten Namen denken, so dass fooCmp() nicht mit anderen cmp() kollidiert.

Da es keinen Zugriff auf Membervariablen hat, benötigt eine Vergleichsoperation, die Zugriff auf einen anderen Wert benötigt (z. B. nach Entfernung von foo.bar), den komplexen Bind2nd-Aufruf.

Answer 1

Ich bin nicht sicher, was Sie sich beschweren: sein Auftrag kann

std::sort(begin,end)  // use operator< 
std::sort(begin,end,order) // Where order is a functor 

So:

• Eine Funktion
• Eine statische Elementfunktion
• Oder ein Objekt, das sich wie eine Funktion verhält.

Die folgenden Werke für mich:

class X 
{ 
    public: static bool diff(X const& lhs,X const& rhs) { return true;} 
}; 

int main() 
{ 
    std::vector<X> a; 

    std::sort(a.begin(),a.end(),&X::diff); 
} 

Aber wenn die Klasse eine natürliche Ordnung hat, warum dann nicht nur die Betreiber < für die Klasse definieren. Dies ermöglicht Ihnen den Zugriff auf die Mitglieder und wird sich für die meisten Standardcontainer/-algorithmen, die eine Reihenfolge definieren müssen, gut verhalten.

class X 
{ 
    public: bool operator<(X const& rhs) const { return true;} 
}; 
int main() 
{ 
    std::vector<X> a; 

    std::sort(a.begin(),a.end()); 
} 

Answer 2

Wenn Sie mit einer mehrfach definierten Vergleichsfunktion zu tun haben, versuchen Sie, die Funktion mit static Verknüpfung zu deklarieren. Dann reicht der Umfang der Funktion nicht über die Kompilierungseinheit hinaus, wo sie gefunden wird.

Das gesagt, Ihr Vergleich "Funktion" muss überhaupt keine Funktion sein, sondern kann stattdessen eine Funktion sein Objekt. Ein Funktionsobjekt ähnelt sehr stark einer Funktion, ist aber als operator() implementiert, das die entsprechenden Parameter innerhalb einer regulären Klasse verwendet. Da es sich um eine reguläre Klasse handelt, können Sie Konstruktorparameter an die Klasse übergeben.

Hier ist ein einfaches Beispiel:

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

using namespace std; 

class comparator { 
public: 
    bool operator()(int a, int b) { 
     return a < b; 
    } 
}; 

int main(int, char *[]) 
{ 
    vector<int> a; 
    a.push_back(1); 
    a.push_back(3); 
    a.push_back(2); 
    sort(a.begin(), a.end(), comparator()); 
    cout << a << endl; 
} 

Answer 3

klingt tatsächlich wie die Funktion in der Klasse deklariert wurde, im Header definiert ist, aber außerhalb der Klasse ohne Inline-Verknüpfung

also so etwas wie:

class foo{ 
public: 
    static bool compare(const foo& lhs,const foo& rhs); 
    ... 
}; 
bool foo::compare(const foo& lhs,const foo& rhs){ 
    ... 
} 

statt

class foo{ 
public: 
    static bool compare(const foo& lhs,const foo& rhs); 
    ... 
}; 
inline bool foo::compare(const foo& lhs,const foo& rhs){ 
    ... 
} 

die erste von denen wird bewirkt, dass die Funktion in jeder Kompilationseinheit definiert wird

#includes "foo.h"