Überladen von Inkrementierungs- und Dekrementierungsoperatoren (C++)

Die Inkrement- und Dekrementoperatoren gehören einer speziellen Kategorie an, da es jeweils zwei Varianten gibt:

• Präinkrement und Postinkrement

• Prädekrement und Postdekrement

Wenn Sie überladene Operator-Funktionen schreiben, kann es hilfreich sein, separate Versionen für die Präfix- und Postfix-Versionen dieser Operatoren zu implementieren. Um zwischen den beiden zu unterscheiden, wird die folgende Regel beobachtet: Die Präfixform des Operators wird genauso deklariert wie jeder andere unäre Operator; das Postfix-Formular akzeptiert ein zusätzliches Argument vom Typ int.

Hinweis

Wenn Sie einen überladenen Operator für die Postfixform des Inkrement- oder Dekrementoperators angeben, muss das zusätzliche Argument vom Typ intsein; durch Angabe eines anderen Typs wird ein Fehler generiert.

Das folgende Beispiel zeigt, wie Präfix- und Postfix-Inkrement- und Dekrementoperatoren für die Klasse Point definiert werden:

// increment_and_decrement1.cpp
class Point
{
public:
   // Declare prefix and postfix increment operators.
   Point& operator++();       // Prefix increment operator.
   Point operator++(int);     // Postfix increment operator.

   // Declare prefix and postfix decrement operators.
   Point& operator--();       // Prefix decrement operator.
   Point operator--(int);     // Postfix decrement operator.

   // Define default constructor.
   Point() { _x = _y = 0; }

   // Define accessor functions.
   int x() { return _x; }
   int y() { return _y; }
private:
   int _x, _y;
};

// Define prefix increment operator.
Point& Point::operator++()
{
   _x++;
   _y++;
   return *this;
}

// Define postfix increment operator.
Point Point::operator++(int)
{
   Point temp = *this;
   ++*this;
   return temp;
}

// Define prefix decrement operator.
Point& Point::operator--()
{
   _x--;
   _y--;
   return *this;
}

// Define postfix decrement operator.
Point Point::operator--(int)
{
   Point temp = *this;
   --*this;
   return temp;
}

int main()
{
}

Dieselben Operatoren können im Dateibereich (global) mithilfe der folgenden Funktionsprototypen definiert werden:

friend Point& operator++( Point& );      // Prefix increment
friend Point operator++( Point&, int );  // Postfix increment
friend Point& operator--( Point& );      // Prefix decrement
friend Point operator--( Point&, int );  // Postfix decrement

Das Argument des Typs int , das die Postfixform des Inkrement- oder Dekrementoperators angibt, wird häufig nicht zum Übergeben von Argumenten verwendet. Es enthält in der Regel den Wert 0. Es kann jedoch wie folgt verwendet werden:

// increment_and_decrement2.cpp
class Int
{
public:
    Int operator++( int n ); // Postfix increment operator
private:
    int _i;
};

Int Int::operator++( int n )
{
    Int result = *this;
    if( n != 0 )    // Handle case where an argument is passed.
        _i += n;
    else
        _i++;       // Handle case where no argument is passed.
    return result;
}

int main()
{
   Int i;
   i.operator++( 25 ); // Increment by 25.
}

Es gibt keine Syntax für die Verwendung der Inkrementierungs- oder Dekrementoperatoren, um diese Werte zu übergeben, die nicht explizite Aufrufe sind, wie im vorherigen Code gezeigt. Eine einfachere Möglichkeit zum Implementieren dieser Funktionalität besteht darin, den Additions-/Zuordnungsoperator (+=) zu überladen.

Siehe auch

Operatorüberladung