Wie kann man den Operator++ auf zwei verschiedene Arten für Postfix a++ und Präfix ++a überladen?

Question

Wie man den Operator++ auf zwei verschiedene Arten für Postfix überlädt a++ und Vorsilbe ++a ?

Answer 1

Das sollte so aussehen:

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

Der Unterschied liegt darin, welche Signatur Sie für Ihre Überladung(en) wählen. operator ++ .

Zitiert aus den einschlägigen Artikel zu diesem Thema in den C++ FAQ (weitere Einzelheiten finden Sie dort):

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

P.S.: Als ich davon erfuhr, sah ich zunächst nur den Dummy-Parameter, aber die verschiedenen Rückgabearten sind eigentlich interessanter; sie könnten erklären, warum ++x wird als effizienter angesehen als x++ im Allgemeinen .

Answer 3

Es gibt zwei Möglichkeiten, die beiden (Präfix/Postfix) ++ Operatoren für einen Typ T zu überladen:

Objekt-Methode:

Dies ist der einfachste Weg, unter Verwendung der "üblichen" OOP-Idiomatik.

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

Objekt nicht Mitglied Funktion:

Dies ist eine weitere Möglichkeit, dies zu tun: Solange die Funktionen im selben Namespace liegen wie das Objekt, auf das sie sich beziehen, werden sie berücksichtigt, wenn der Compiler nach einer Funktion sucht, die mit ++t ; o 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 ;
}

Es ist wichtig, sich daran zu erinnern, dass aus der Sicht von C++ (einschließlich der Sicht des C++-Compilers) diese Nicht-Mitglieder-Funktionen immer noch Teil der Schnittstelle von T sind (solange sie sich im gleichen Namensraum befinden).

Es gibt zwei potenzielle Vorteile der Notation von Nichtmitgliedsfunktionen:

• Wenn es Ihnen gelingt, sie zu kodieren, ohne sie zu Freunden von T zu machen, dann haben Sie die Kapselung von T
• können Sie dies auch auf Klassen oder Strukturen anwenden, deren Code Sie nicht besitzen. Dies ist ein nicht-intrusiver Weg, die Schnittstelle eines Objekts zu verbessern, ohne seine Deklaration zu ändern.

Answer 4

Erklären Sie wie folgt:

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

};

Richtig implementieren - nicht mit dem herumspielen, was jeder weiß (erst inkrementieren, dann verwenden, dann verwenden, dann inkrementieren).

Answer 5

Ich weiß, es ist spät, aber ich hatte das gleiche Problem und habe eine einfachere Lösung gefunden. Verstehen Sie mich nicht falsch, das ist die dieselbe Lösung wie die obere (gepostet von Martin York). Es ist nur eine bit Einfacher. Nur ein bisschen. Hier ist es:

class Number
{
        public:

              /*prefix*/  
        Number& operator++ ()
        {
            /*Do stuff */
            return *this;
        }

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

Die obige Lösung ist etwas einfacher, weil sie kein temporäres Objekt in der Postfix-Methode verwendet.