Overload degli operatori di incremento e decremento (C++)

Gli operatori di incremento e decremento rientrano in una categoria speciale poiché esistono due varianti di ciascuno:

• Incremento prefisso e incremento suffisso

• Decremento prefisso e decremento suffisso

Quando si creano le funzioni dell'operatore di overload, può essere utile implementare versioni separate della forma prefissa e suffissa di questi operatori. Per distinguere tra i due, viene osservata la regola seguente: la forma prefisso dell'operatore viene dichiarata esattamente come qualsiasi altro operatore unario; Il modulo di prefisso accetta un argomento aggiuntivo di tipo int.

Nota

Quando si specifica un operatore di overload per la forma suffisso dell'operatore di incremento o decremento, l'argomento aggiuntivo deve essere di tipo ; specificando qualsiasi altro tipo intgenera un errore.

Di seguito viene illustrato come definire gli operatori di incremento e di decremento in forma prefissa e suffissa per la classe Point:

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

Gli stessi operatori possono essere definiti nell'ambito del file (a livello globale) usando i prototipi di funzione seguenti:

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

L'argomento di tipo int che indica la forma del prefisso dell'operatore di incremento o decremento non viene comunemente usato per passare argomenti. Di solito contiene il valore 0. Tuttavia, può essere utilizzato nel modo seguente:

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

Non esiste alcuna sintassi per l'uso degli operatori di incremento o decremento per passare questi valori diversi dalla chiamata esplicita, come illustrato nel codice precedente. Un modo più semplice per implementare questa funzionalità consiste nell'eseguire l'overload dell'operatore di addizione/assegnazione (+=).

Vedi anche

Overload degli operatori