C++ definición de objeto de función "mayor"

Question

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

Encontré esta definición de "clase de objeto de función para una comparación mayor que la desigualdad" en la biblioteca STL. ¿Puede alguien explicarme cómo funciona y compila este código?

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

aquí es la definición de 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; 
}; 

esto le permite acceder a los tipos que define el binary_function

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

lo que equivale a

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

Answer 2

Es una clase de plantilla que se puede crear instancias con un argumento de tipo. Entonces puede decir greater<int>, greater<my_class>, etc. Cada una de esas instanciaciones tiene un operador() que toma dos argumentos de tipo const T& y devuelve el resultado de compararlos.

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

Answer 3

No sé, usted sabe mucho sobre programación de plantillas y funtores.

Vamos a empezar con funtores:

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 

Así funtores se burlan de una función que podría haber tan bien implementado bool g (int x, int y) {return x> y;} y se utiliza de la misma manera.

Lo bueno de los funtores es que también puede almacenar algunos datos cuando se trabaja en una estructura de datos más compleja.

Luego está la parte de la plantilla: desea escribir el mismo funtor para cualquier tipo, no importa si el tipo es un int, un float, un objeto complexe, el código será el mismo. Para eso está la parte de la plantilla.