Quelle est la signification de cette structure C++?

Question

J'ai obtenu un simple, struct C++ comme suit:

// Functor for peak to decreasing intensity sorting 
struct cmp_decr_int2 
{ 
    bool operator() (peak2 a, peak2 b) 
    { 
     return a.int2 > b.int2; 
    } 
}; 

est là une surcharge de l'opérateur dans cet échantillon?

Answer 1

Structures en C++ sont juste des classes avec un accesseur par défaut de public au lieu de privé. Alors oui, cela aurait une surcharge de fonction.

Answer 2

Oui. operator() est appelé l'opérateur "appel de fonction", et permet à un objet d'être utilisable comme s'il s'agissait d'une fonction. Une telle classe est appelée un "foncteur".

Un modèle commun est de faire des foncteurs qui comparent deux choses pour l'égalité ou les relations, pour une utilisation dans tout ce qui nécessite un prédicat de comparaison. (Celui-ci pourrait être utilisable dans un std::map, par exemple, il aurait un membre comme cmp_decr_int2 compare; et il pourrait alors comparer la relation entre deux choses avec:. if (compare(x, y)) /* x is less than y, by some metric */)

ORDONNE struct particulier deux peak2 de « s en comparant leur int2 membres. Il pourrait être mieux écrit:

struct cmp_decr_int2 
{ 
    //      note const! vvvvv 
    bool operator() (peak2 a, peak2 b) const 
    { 
     return a.int2 > b.int2; 
    } 
}; 

La fonction doit être const parce qu'il n'a pas besoin de changer les membres (il n'y en a pas à changer.) const-correctness est important *

Dans de nombreux cas, ces de foncteurs. sont utilisés dans des contextes où les arguments eux-mêmes sont const, donc vous devriez soit prendre les arguments par valeur comme dans l'exemple ou par référence constante.

Vous devriez préférer passer les types par const-référence plutôt que par valeur, sauf si ce type est fondamental (float, unsigned int, double, etc.) ou plus petit qu'un void*. Dans la plupart des cas, alors, vous passerez par const-référence:

struct cmp_decr_int2 
{ 
    // note const&: vvvvv  v vvvvv  v vvvvv 
    bool operator() (const peak2 & a, const peak2 & b) const 
    { 
     return a.int2 > b.int2; 
    } 
}; 

_{* Si cela était utilisé comme prédicat dans un std::map, par exemple, sans const la carte ne serait pas en mesure de comparer deux choses tout dans une const fonction.}

Answer 3

en C++ struct est dans tous les sens comme une classe, à l'exception que l'accès aux paramètres par défaut est public: plutôt que private:. C'est une pratique courante d'utiliser struct à la place de class lorsque la portée de l'utilisation du type défini est très étroite, comme dans l'exemple d'un simple foncteur.

Ce que cet exemple fait est d'émuler l'apparence d'un pointeur de fonction sans la fragilité d'être éventuellement nul.

Le membre operator() surcharge ici l'appel de fonction. lorsque vous essayez de faire quelque chose comme:

cmp_decr_int2 foo; 
foo(peek2(), peek2()); 

ce membre de surcharge est appelé.

Answer 4

#include <iostream> 
using namespace std; 

struct cmp_decr_int2 
{ 
    bool operator() (int a, int b) 
    { 
     return a > b; 
    } 

    bool operator() (int i) 
    { 
     return i > 0; 
    } 
}; 

int main() 
{ 
    cmp_decr_int2 a; 
    cout << a(1, 2) << endl; 
    cout << a(1) << endl; 
} 

Oui, cela peut surcharger la fonction! Cela a fonctionné parfaitement pour moi.

Answer 5

13,5 $.Operator() doit être une fonction membre non statique avec un nombre de paramètres arbitraire. Il peut avoir des arguments par défaut. Il implémente la syntaxe d'appel de fonction postfix-expression (expression-listopt) où l'expression postfixée évalue un objet de classe et la liste d'expressions éventuellement vide correspond à la liste de paramètres d'une fonction membre operator() de la classe. Ainsi, un appel x (arg1, ...) est interprété comme x.operator() (arg1, ...) pour un objet de classe x de type T si T :: operator() (T1, T2, T3) existe et si l'opérateur est sélectionné comme meilleure fonction de correspondance par le mécanisme de résolution de surcharge (13.3.3).

Par conséquent, la structure 'cmp_decr_int2' a définitivement surchargé operator(). Notez que c'est également le seul opérateur en C++ qui peut prendre un nombre variable d'arguments.