surcharge de l'opérateur ++ ()

Question

Comment surcharger operator++ de deux manières différentes (pour a++ et ++a )?

Answer 1

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

Answer 2

La différence réside dans ce que la signature que vous choisissez pour votre surcharge(s) de l' operator ++.

Cité de l' article sur ce sujet dans le C++ FAQ (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
};

P. S.: Quand j'ai découvert à ce sujet, tout ce que je voyais à l'origine était le paramètre fictif, mais les différents types de retour sont en fait plus intéressant; ils pourraient peut-être expliquer pourquoi ++x est considéré comme plus efficace que l' x++ en général.

Answer 3

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

Méthode de l'objet:

C'est le moyen le plus facile, à l'aide de "commun" de la programmation orientée objet idiome.

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

Objet non-membre de la fonction:

C'est une autre manière de faire ceci: tant Que les fonctions sont dans le même espace de noms que l'objet qu'elles sont en se référant aussi, ils seront pris en considération lorsque le compilateur recherche d'une fonction à manipuler ++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 rappeler que, d'un C++ point de vue (y compris un compilateur C++ le point de vue), les fonctions de membre font encore partie de la T de l'interface (tant qu'ils sont dans le même espace de noms).

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

• Si vous parvenez à code sans faire de leur ami de T, alors vous avez augmenté l'encapsulation de T
• vous pouvez appliquer ce même pour des classes ou des structures dont le code ne vous appartient pas. C'est un non-intrusive de façon à améliorer l'interface d'un objet sans en modifier sa déclaration.

Answer 4

Lisez ceci: http://www.parashift.com/c++-faq-lite/operator-overloading.html#faq-13.14

Answer 5

Déclare comme ça:

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

};
 

Implémentez correctement - ne jouez pas avec ce que tout le monde sait qu'ils font (incrémenter puis utiliser, utiliser puis incrémenter).