Tipos de sobrecarga de operadores en C++

Sobrecarga del operador: 
 

C++ proporciona una función especial para cambiar la funcionalidad actual de algunos operadores dentro de su clase, que a menudo se denomina sobrecarga de operadores. La sobrecarga de operadores es el método por el cual podemos cambiar la función de algunos operadores específicos para realizar una tarea diferente. 

Esto se puede hacer declarando la función, su sintaxis es, 
 

Return_Type classname :: operator op(Argument list)
{
    Function Body
}

En la sintaxis anterior, Return_Type es el tipo de valor que se devolverá a otro objeto, el operador op es la función donde el operador es una palabra clave y op es el operador que se sobrecargará.
La función de operador debe ser no estática (función miembro) o función amiga.
La sobrecarga del operador se puede realizar mediante el uso de tres enfoques , son 
 

1. Sobrecarga del operador unario.
2. Sobrecarga del operador binario.
3. Sobrecarga del operador binario usando una función de amigo.

A continuación se presentan algunos criterios/reglas para definir la función del operador: 
 

• En el caso de una función no estática, el operador binario debe tener solo un argumento y el unario no debe tener ningún argumento.
• En el caso de una función amiga, el operador binario debe tener solo dos argumentos y el unario debe tener solo un argumento.
• Todo el objeto miembro de la clase debe ser público si se implementa la sobrecarga del operador.
• Los operadores que no se pueden sobrecargar son . .* :: ?:
• El operador no se puede usar para sobrecargar al declarar esa función como función amiga = () [] -> .

Consulte esto, para obtener más reglas de sobrecarga del operador
 

1. Sobrecarga del operador unario : Consideremos sobrecargar (-) el operador unario. En la función de operador unario, no se deben pasar argumentos. Funciona solo con objetos de una clase. Es una sobrecarga de un operador que opera en un solo operando.
   Ejemplo: 
   suponga que la clase Distancia toma dos objetos miembro, es decir, pies y pulgadas, cree una función mediante la cual el objeto Distancia debería disminuir el valor de pies y pulgadas en 1 (con un solo operando de Tipo de distancia).
    

// C++ program to show unary operator overloading
#include <iostream>
 
using namespace std;
 
class Distance {
public:
 
    // Member Object
    int feet, inch;
 
    // Constructor to initialize the object's value
    Distance(int f, int i)
    {
        this->feet = f;
        this->inch = i;
    }
 
    // Overloading(-) operator to perform decrement
    // operation of Distance object
    void operator-()
    {
        feet--;
        inch--;
        cout << "\nFeet & Inches(Decrement): " << feet << "'" << inch;
    }
};
 
// Driver Code
int main()
{
    // Declare and Initialize the constructor
    Distance d1(8, 9);
 
    // Use (-) unary operator by single operand
    -d1;
    return 0;
}

Feet & Inches(Decrement): 7'8

1. En el programa anterior, muestra que no se pasa ningún argumento y no se devuelve ningún valor de return_type, porque el operador unario funciona en un solo operando. El operador (-) cambia la funcionalidad a su función miembro.
   Nota: d2 = -d1 no funcionará, porque operator-() no devuelve ningún valor.
2. Sobrecarga del operador binario : en la función de sobrecarga del operador binario, debe pasar un argumento. Es la sobrecarga de un operador que opera con dos operandos.
   Tomemos el mismo ejemplo de la clase Distancia, pero esta vez agreguemos dos objetos de distancia. 
    

// C++ program to show binary operator overloading
#include <iostream>
 
using namespace std;
 
class Distance {
public:
    // Member Object
    int feet, inch;
    // No Parameter Constructor
    Distance()
    {
        this->feet = 0;
        this->inch = 0;
    }
 
    // Constructor to initialize the object's value
    // Parameterized Constructor
    Distance(int f, int i)
    {
        this->feet = f;
        this->inch = i;
    }
 
    // Overloading (+) operator to perform addition of
    // two distance object
    Distance operator+(Distance& d2) // Call by reference
    {
        // Create an object to return
        Distance d3;
 
        // Perform addition of feet and inches
        d3.feet = this->feet + d2.feet;
        d3.inch = this->inch + d2.inch;
 
        // Return the resulting object
        return d3;
    }
};
 
// Driver Code
int main()
{
    // Declaring and Initializing first object
    Distance d1(8, 9);
 
    // Declaring and Initializing second object
    Distance d2(10, 2);
 
    // Declaring third object
    Distance d3;
 
    // Use overloaded operator
    d3 = d1 + d2;
 
    // Display the result
    cout << "\nTotal Feet & Inches: " << d3.feet << "'" << d3.inch;
    return 0;
}

Total Feet & Inches: 18'11

1. Aquí en el programa anterior, 
   Ver Línea no. 26 , Operador de distancia+(Distancia &d2), aquí el tipo de función de retorno es distancia y usa llamadas por referencias para pasar un argumento. 
   Ver Línea no. 49 , d3 = d1 + d2; aquí, d1 llama a la función de operador de su objeto de clase y toma d2 como parámetro, por lo que la función de operador devuelve el objeto y el resultado se reflejará en el objeto d3.
   Vista pictórica del funcionamiento del operador binario: 
    

1. Sobrecarga del operador binario usando una función Friend : en este enfoque, la función de sobrecarga del operador debe preceder a la palabra clave friend y declarar un alcance de clase de función. Teniendo en cuenta que la función de operador amigo toma dos parámetros en un operador binario, varía un parámetro en un operador unario. Todo el trabajo y la implementación serían los mismos que la función del operador binario, excepto que esta función se implementará fuera del alcance de la clase.
   Tomemos el mismo ejemplo usando la función amigo. 
    

// C++ program to show binary operator overloading
#include <iostream>
 
using namespace std;
 
class Distance {
public:
 
    // Member Object
    int feet, inch;
 
    // No Parameter Constructor
    Distance()
    {
        this->feet = 0;
        this->inch = 0;
    }
 
    // Constructor to initialize the object's value
    // Parameterized Constructor
    Distance(int f, int i)
    {
        this->feet = f;
        this->inch = i;
    }
 
    // Declaring friend function using friend keyword
    friend Distance operator+(Distance&, Distance&);
};
 
// Implementing friend function with two parameters
Distance operator+(Distance& d1, Distance& d2) // Call by reference
{
    // Create an object to return
    Distance d3;
 
    // Perform addition of feet and inches
    d3.feet = d1.feet + d2.feet;
    d3.inch = d1.inch + d2.inch;
 
    // Return the resulting object
    return d3;
}
 
// Driver Code
int main()
{
    // Declaring and Initializing first object
    Distance d1(8, 9);
 
    // Declaring and Initializing second object
    Distance d2(10, 2);
 
    // Declaring third object
    Distance d3;
 
    // Use overloaded operator
    d3 = d1 + d2;
 
    // Display the result
    cout << "\nTotal Feet & Inches: " << d3.feet << "'" << d3.inch;
    return 0;
}

Total Feet & Inches: 18'11

1. Aquí, en el programa anterior, la función del operador se implementa fuera del alcance de la clase al declarar esa función como la función amiga.

De esta manera, se puede sobrecargar a un operador para realizar ciertas tareas al cambiar la funcionalidad de los operadores.