Comment surcharger l’opérateur ++ de deux manières différentes pour postfix a ++ et prefix ++ a?

Comment surcharger l’opérateur ++ de deux manières différentes pour postfix a++ et prefix ++a ?

Devrait ressembler à ceci:

 class Number { public: Number& operator++ () // prefix ++ { // Do work on this. (increment your object here) return *this; } // You want to make the ++ operator work like the standard operators // The simple way to do this is to implement postfix in terms of prefix. // Number operator++ (int) // postfix ++ { Number result(*this); // make a copy for result ++(*this); // Now use the prefix version to do the work return result; // return the copy (the old) value. } }; 

La différence réside dans la signature que vous choisissez pour votre ou vos surcharges d’ operator ++ .

Cité de l’ article pertinent sur ce sujet dans la FAQ C ++ (allez-y pour plus de détails):

 class Number { public: Number& operator++ (); // prefix ++: no parameter, returns a reference Number operator++ (int); // postfix ++: dummy parameter, returns a value }; 

PS: Lorsque j’ai découvert cela, tout ce que je voyais au départ était le paramètre factice, mais les différents types de retour sont en fait plus intéressants; ils pourraient expliquer pourquoi ++x est considéré comme plus efficace que x++ en général .

Vous avez deux façons de surcharger les deux opérateurs ++ (préfixe / postfix) ++ pour un type T:

Méthode object:

C’est le moyen le plus simple, en utilisant le langage “commun” de la POO.

 class T { public : T & operator++() // ++A { // Do increment of "this" value return *this ; } T operator++(int) // A++ { T temp = *this ; // Do increment of "this" value return temp ; } } ; 

Fonction d’object non membre:

Ceci est une autre façon de faire: tant que les fonctions sont dans le même espace de nommage que l’object auquel elles se réfèrent, elles seront sockets en compte lorsque le compilateur recherchera une fonction pour gérer ++t ; ou t++ ; code:

 class T { // etc. } ; T & operator++(T & p_oRight) // ++A { // Do increment of p_oRight value return p_oRight ; } T operator++(T & p_oRight, int) // A++ { T oCopy ; // Copy p_oRight into oCopy // Do increment of p_oRight value return oCopy ; } 

Il est important de se rappeler que, du sharepoint vue C ++ (y compris un sharepoint vue du compilateur C ++), ces fonctions non membres font toujours partie de l’interface de T (tant qu’elles se trouvent dans le même espace de noms).

Il y a deux avantages potentiels de la notation de fonction non-membre:

  • Si vous parvenez à les coder sans les rendre amis de T, alors vous avez augmenté l’encapsulation de T
  • vous pouvez l’appliquer même aux classes ou aux structures dont vous ne possédez pas le code. C’est un moyen non intrusif d’améliorer l’interface d’un object sans modifier sa déclaration.

Je sais que c’est tard, mais j’ai eu le même problème et j’ai trouvé une solution plus simple. Ne vous méprenez pas, c’est la même solution que la première (publiée par Martin York). C’est juste un peu plus simple. Juste un peu. C’est ici:

 class Number { public: /*prefix*/ Number& operator++ () { /*Do stuff */ return *this; } /*postfix*/ Number& operator++ (int) { ++(*this); //using the prefix operator from before return *this; } }; 

La solution ci-dessus est un peu plus simple car elle n’utilise pas d’object temporaire dans la méthode postfix.

Déclarez comme ça:

 class A { public: A& operator++(); //Prefix (++a) A operator++(int); //Postfix (a++) }; 

Mettre en œuvre correctement – ne plaisante pas avec ce que tout le monde sait qu’ils font (incrémenter puis utiliser, utiliser puis augmenter).