Incremento y decremento (C++)

La extensión de los operadores de incremento y decremento en una categoría especial porque hay dos variantes de cada uno:

• Preincrement y postincrement

• Predecrement y postdecrement

Al escribir funciones sobrecargadas de operador, puede ser útil implementar versiones independientes para las versiones de prefijo y de sufijo de estos operadores.para distinguir entre los dos, la regla siguiente se observa: El formulario de prefijo del operador se declara exactamente de la misma forma que cualquier otro operador unario; el formulario de sufijo acepta un argumento adicional de intescrito.

[!NOTA]

Al especificar un operador sobrecargado para el formulario del sufijo del operador de incremento y decremento, el argumento adicional debe ser de intescrito; especificar cualquier otro tipo genera un error.

El ejemplo siguiente se muestra cómo definir operadores de prefijo y de incremento y decremento postfijos para la clase de 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()
{
}

Los mismos operadores pueden definirse en el ámbito de archivo (global) mediante puntas siguientes de la función:

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

El argumento de int cuyas denota el forma postfija de operador de incremento y decremento no suele utilizarse pasar argumentos.Normalmente contiene el valor 0.Sin embargo, se puede utilizar como sigue:

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

No hay ninguna sintaxis para utilizar los operadores de incremento y decremento superar estos valores distintos de la invocación explícita, como se muestra en el código anterior.Una manera más sencilla de implementar esta funcionalidad es sobrecargar la adición y el operador de asignación (+=).

Vea también

Referencia

Sobrecarga de operadores