Sobrecarga dos operadores de incremento e decremento (C++)

Os operadores de incremento e decremento formam uma categoria especial porque há duas variantes de cada um:

• Pré-incremento e pós-incremento

• Pré-decremento e pós-decremento

Ao escrever funções de operador sobrecarregado, pode ser útil implementar versões separadas para as versões pré-fixada e pós-fixada desses operadores. Para distinguir entre os dois, a seguinte regra é observada: a forma de prefixo do operador é declarada exatamente da mesma forma que qualquer outro operador unário, e a forma postfix aceita um argumento adicional do tipo int.

Observação

Ao especificar um operador sobrecarregado para a forma de pós-fixo do operador de incremento ou decremento, o argumento adicional deverá ser do tipo int, especificar qualquer outro tipo gerará um erro.

O exemplo a seguir mostra como definir operadores de incremento e decremento pré-fixados e pós-fixados para a 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()
{
}

Os mesmos operadores poderão ser definidos no escopo do arquivo (globalmente) usando os seguintes protótipos de função:

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

O argumento do tipo int que denota a forma de pós-fixo do operador de incremento ou decremento não é muito usado para passar argumentos. Em geral, ele contém o valor 0. No entanto, pode ser usado como se segue:

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

Não há sintaxe para usar os operadores de incremento ou decremento para passar esses valores além da invocação explícita, conforme mostrado no código anterior. Uma maneira mais direta de implementar essa funcionalidade é sobrecarregar o operador atribuição/adição (+=).

Confira também

Sobrecarga de operador