Inkrementieren und Dekrementieren (C++)

Das Inkrement und Dekrementoperatoren werden in einer speziellen Kategorie, da es zwei Varianten der einzelnen gibt:

• Preincrement und postincrement

• Predecrement und postdecrement

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 unterscheiden, wird die folgende Regel beachtet werden: Das Präfix Form des Operators wird genau die gleiche Art wie jeden anderen unären Operator deklariert. Postfix das Formular nimmt ein zusätzliches Argument des Typs int.

Hinweis
Wenn es sich um einen überladenen Operator Postfix für das Formular des Inkrements oder des Dekrementoperators angibt, muss das zusätzliche Argument vom Typ intsein. Angeben eines anderen Typs generiert einen Fehler.

Im folgenden Beispiel wird gezeigt, wie Präfix und Postfixinkrement und Dekrementoperatoren für die Point-Klasse definiert:

// 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()
{
}

Die gleichen Operatoren können im Dateigültigkeitsbereich (global) mit den folgenden Funktionen köpfe definiert sind:

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, der das int Postfix Form des Inkrements oder des Dekrementoperators kennzeichnet, ist nicht häufig verwendet, um Argumente übergeben.Sie enthält in der Regel den Wert 0.Er kann jedoch verwendet werden, wie folgt:

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

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

Es gibt keine Syntax für die Verwendung des Inkrements oder Dekrementoperatoren, um diese Werte anders expliziten Aufruf, wie im vorangehenden Code dargestellt zu übergeben.Eine einfachere Möglichkeit, diese Funktionalität zu implementieren, besteht darin, das Hinzufügen/Zuweisungsoperator (+=) überladen.

Siehe auch

Referenz

Überladen von Operatoren