Increment e Decrement (C++)

Os operadores increment e decrement se encaixam em uma categoria especial porque há duas variantes de cada um:

• Preincrement e postincrement

• Predecrement e postdecrement

Quando você escrever funções de operador sobrecarregado, pode ser útil implementar versões separadas para o prefixo e sufixo versões desses operadores.Para distinguir entre os dois, a seguinte regra é observada: O formulário de prefixo do operador é declarado exatamente da mesma maneira que qualquer outro operador unário; o formulário postfix aceita um argumento adicional do tipo int.

Observação
Ao especificar um operador sobrecarregado para o formulário do sufixo do operador de incremento ou decremento, o argumento adicional deve ser do tipo int; a especificação de qualquer outro tipo gera um erro.

O exemplo a seguir mostra como definir um prefixo e sufixo incremento e decrementar operadores para o Point classe:

// 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 podem ser definidos no escopo do arquivo (globalmente) usando os cabeçotes de função a seguir:

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 sufixo do incremento ou decremento operador não é comumente usado para passar argumentos.Ele geralmente contém o valor 0.No entanto, ele pode ser usado da seguinte maneira:

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

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

Consulte também

Referência

Sobrecarga de operador