objet fonction « plus » C de la définition

Question

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

J'ai trouvé cette définition de « classe d'objets de fonction de comparaison supérieur à l'inégalité » dans la bibliothèque STL. Quelqu'un peut-il m'expliquer comment ce code fonctionne et se compile?

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

ici est la définition 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; 
}; 

ce qui vous permet d'accéder aux types définissant la binary_function

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

qui équivaut à

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

Answer 2

Il s'agit d'une classe de modèle qui peut être instanciée avec un argument de type. Donc, vous pouvez dire greater<int>, greater<my_class>, etc. Chacune de ces instanciations a un opérateur() qui prend deux arguments de type const T& et renvoie le résultat de leur comparaison.

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

Answer 3

Je ne sais pas ce que vous savez de la programmation de modèles et des foncteurs.

Commençons par foncteurs:

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 

Alors foncteurs raillent une fonction que vous auriez pu ainsi mis en œuvre bool g (int x, int y) {return x> y;} et utilisé de la même manière. La bonne chose à propos des foncteurs, c'est que vous pouvez également stocker des données lorsque vous travaillez sur une structure de données plus complexe.

Ensuite, il y a la partie template: vous voulez écrire le même foncteur pour n'importe quel type, peu importe si le type est un int, un float, un objet complexe, le code sera le même. Voilà à quoi sert la partie modèle.