C++ „größer“ Funktion Objektdefinition

Question

template <class T> struct greater : binary_function <T, T, bool> { 
    bool operator() (const T& x, const T& y) const { 
     return x > y; 
    } 
}; 

ich diese Definition gefunden. Kann mir bitte jemand erklären, wie dieser Code funktioniert und kompiliert?

Answer 1

template <class T> // A template class taking any type T 
// This class inherit from std::binary_function 
struct greater : binary_function <T, T, bool> 
{ 
    // This is a struct (not a class). 
    // It means members and inheritens is public by default 

    // This method defines operator() for this class 
    // you can do: greater<int> op; op(x,y); 
    bool operator() (const T& x, const T& y) const { 
    // method is const, this means you can use it 
    // with a const greater<T> object 
    return x > y; // use T::operator> const 
        // if it does not exist, produces a compilation error 
    } 
}; 

hier ist die Definition von std::binary_function

template <class Arg1, class Arg2, class Result> 
struct binary_function { 
    typedef Arg1 first_argument_type; 
    typedef Arg2 second_argument_type; 
    typedef Result result_type; 
}; 

das Sie die Typen definieren, die binary_function

greater<int> op; 
greater<int>::result_type res = op(1,2); 

, die

std::result_of<greater<int>>::type res = op(1,2); 

Answer 2

Es ist eine Vorlagenklasse, die mit einem Typargument instanziiert werden kann. So können Sie sagen greater<int>, greater<my_class>, etc. Jede dieser Instanzen hat einen Operator(), der zwei Argumente vom Typ const T& übernimmt und das Ergebnis des Vergleichs zurückgibt.

greater<int> gi; 
if (gi(1, 2)) { 
    // won't get here 
} else { 
    // will get here 
} 

Answer 3

Ich weiß nicht, haben viel wissen Sie über Template-Programmierung und functors.

Beginnen wir mit functors starten:

struct greater { 
    bool operator()(const int& x, const int& b) const { 
    return x > y; 
} 

greater g; 
g(2,3); // returns false 
g(3,2); // returns true 

So spotten functors eine Funktion, die Sie auch bool g (int x, int y) umgesetzt haben könnte {return x> y;} und verwendet es die gleiche Weise.

Das Schöne an Funktoren ist, dass Sie auch Daten speichern können, wenn Sie an komplexeren Datenstrukturen arbeiten.

Dann gibt es die Vorlage Teil: Sie wollen den gleichen Funktor für jeden Typ schreiben, ist es egal, ob der Typ ein Int, ein Float, ein komplexes Objekt ist, wird der Code der gleiche sein. Dafür ist der Vorlagen-Teil gedacht.