Sobrecarga de operadores de incremento (++) y decremento (–) en C++

La sobrecarga de operadores es una característica de la programación orientada a objetos que permite a un programador redefinir un operador incorporado para trabajar con tipos de datos definidos por el usuario.

¿Por qué sobrecargar al operador? 
 

Digamos que hemos definido una clase Integer para manejar operaciones con números enteros. Podemos tener funciones sumar(), restar(), multiplicar() y dividir() para manejar las operaciones respectivas. Sin embargo, para hacer el código más intuitivo y mejorar la legibilidad, se prefiere utilizar operadores que correspondan a las operaciones dadas (+, -, *, / respectivamente), es decir, podemos reemplazar el siguiente código.
Ejemplo: 

Replace
i5 = divide(add(i1, i2), subtract(i3, i4))

by a simpler code:
i5 = (i1 + i2) / (i3 - i4) 

Sobrecarga del operador de incremento

El símbolo del operador tanto para el prefijo (++i) como para el sufijo (i++) es el mismo. Por lo tanto, necesitamos dos definiciones de función diferentes para distinguirlas. Esto se logra pasando un parámetro int ficticio en la versión postfix.
Aquí está el código para demostrar lo mismo.

Ejemplo: sobrecarga de preincremento 

// C++ program to demonstrate
// prefix increment operator overloading
 
#include <bits/stdc++.h>
using namespace std;
 
class Integer {
private:
    int i;
 
public:
    // Parameterised constructor
    Integer(int i = 0)
    {
        this->i = i;
    }
 
    // Overloading the prefix operator
    Integer operator++()
    {
        Integer temp;
        temp.i = ++i;
        return temp;
    }
 
    // Function to display the value of i
    void display()
    {
        cout << "i = " << i << endl;
    }
};
 
// Driver function
int main()
{
    Integer i1(3);
 
    cout << "Before increment: ";
    i1.display();
 
    // Using the pre-increment operator
    Integer i2 = ++i1;
 
    cout << "After pre increment: ";
    i2.display();
}

Producción:

Before increment: i = 3
After pre increment: i = 4

Ejemplo: sobrecarga posterior al incremento

// C++ program to demonstrate
// postfix increment operator
// overloading
#include <bits/stdc++.h>
using namespace std;
 
class Integer {
private:
    int i;
 
public:
    // Parameterised constructor
    Integer(int i = 0)
    {
        this->i = i;
    }
 
    // Overloading the postfix operator
    Integer operator++(int)
    {
        Integer temp;
        temp.i = i++;
        return temp;
    }
 
    // Function to display the value of i
    void display()
    {
        cout << "i = " << i << endl;
    }
};
 
// Driver function
int main()
{
    Integer i1(3);
 
    cout << "Before increment: ";
    i1.display();
 
    // Using the post-increment operator
    Integer i2 = i1++;
 
    cout << "After post increment: ";
    i2.display();
}

Producción:

Before increment: i = 3
After post increment: i = 3

Sobrecarga del operador de decremento

Del mismo modo, también podemos sobrecargar el operador de decremento de la siguiente manera:

Ejemplo: sobrecarga previa al decremento

// C++ program to demonstrate
// prefix decrement operator
// overloading
 
#include <bits/stdc++.h>
using namespace std;
 
class Integer {
private:
    int i;
 
public:
    // Parameterised constructor
    Integer(int i = 0)
    {
        this->i = i;
    }
 
    // Overloading the prefix operator
    Integer operator--()
    {
        Integer temp;
        temp.i = --i;
        return temp;
    }
 
    // Function to display the value of i
    void display()
    {
        cout << "i = " << i << endl;
    }
};
 
// Driver function
int main()
{
    Integer i1(3);
 
    cout << "Before decrement: ";
    i1.display();
 
    // Using the pre-decrement operator
    Integer i2 = --i1;
 
    cout << "After pre decrement: ";
    i2.display();
}

Producción:

Before decrement: i = 3
After pre decrement: i = 2

Ejemplo: sobrecarga posterior a la disminución

// C++ program to demonstrate
// postfix decrement operator
// overloading
#include <bits/stdc++.h>
using namespace std;
 
class Integer {
private:
    int i;
 
public:
    // Parameterised constructor
    Integer(int i = 0)
    {
        this->i = i;
    }
 
    // Overloading the postfix operator
    Integer operator--(int)
    {
        Integer temp;
        temp.i = i--;
        return temp;
    }
 
    // Function to display the value of i
    void display()
    {
        cout << "i = " << i << endl;
    }
};
 
// Driver function
int main()
{
    Integer i1(3);
 
    cout << "Before decrement: ";
    i1.display();
 
    // Using the post-decrement operator
    Integer i2 = i1--;
 
    cout << "After post decrement: ";
    i2.display();
}

Producción:

Before decrement: i = 3
After post decrement: i = 3