Sobrecarga de operadores de C++

En este tutorial, aprenderemos sobre la sobrecarga de operadores con la ayuda de ejemplos.

En C++, podemos cambiar la forma en que funcionan los operadores para tipos definidos por el usuario, como objetos y estructuras. Esto se conoce como sobrecarga de operadores. . Por ejemplo,

Supongamos que hemos creado tres objetos c1 , c2 y resultado de una clase llamada Complex que representa números complejos.

Dado que la sobrecarga de operadores nos permite cambiar la forma en que funcionan los operadores, podemos redefinir cómo + funciona el operador y utilícelo para sumar los números complejos de c1 y c2 escribiendo el siguiente código:

result = c1 + c2;

en lugar de algo como

result = c1.addNumbers(c2);

Esto hace que nuestro código sea intuitivo y fácil de entender.

Nota: No podemos usar la sobrecarga de operadores para tipos de datos fundamentales como int , float , char y así sucesivamente.

Sintaxis para la sobrecarga de operadores de C++

Para sobrecargar un operador, usamos un operator especial función. Definimos la función dentro de la clase o estructura con cuyos objetos/variables queremos que trabaje el operador sobrecargado.

class className {
    ... .. ...
    public
       returnType operator symbol (arguments) {
           ... .. ...
       } 
    ... .. ...
};

Aquí,

returnType es el tipo de retorno de la función.
operator es una palabra clave.
symbol es el operador que queremos sobrecargar. Me gusta:+ , < , - , ++ , etc.
arguments son los argumentos pasados a la función.

Sobrecarga de operadores en operadores unarios

Los operadores unarios operan en un solo operando. El operador de incremento ++ y operador decremento -- son ejemplos de operadores unarios.

Ejemplo1:Sobrecarga del operador ++ (operador unario)

// Overload ++ when used as prefix

#include <iostream>
using namespace std;

class Count {
   private:
    int value;

   public:

    // Constructor to initialize count to 5
    Count() : value(5) {}

    // Overload ++ when used as prefix
    void operator ++ () {
        ++value;
    }

    void display() {
        cout << "Count: " << value << endl;
    }
};

int main() {
    Count count1;

    // Call the "void operator ++ ()" function
    ++count1;

    count1.display();
    return 0;
}

Salida

Count: 6

Aquí, cuando usamos ++count1; , el void operator ++ () se llama. Esto aumenta el valor atributo para el objeto count1 por 1.

Nota: Cuando sobrecargamos a los operadores, podemos usarlo para trabajar de la forma que queramos. Por ejemplo, podríamos haber usado ++ para aumentar valor por 100.

Sin embargo, esto hace que nuestro código sea confuso y difícil de entender. Nuestro trabajo como programadores es utilizar la sobrecarga de operadores de forma adecuada y de forma coherente e intuitiva.

El ejemplo anterior funciona solo cuando ++ se usa como prefijo. Para hacer ++ funciona como sufijo, usamos esta sintaxis.

void operator ++ (int) {
    // code
}

Observe el int dentro de los paréntesis. Es la sintaxis usada para usar operadores unarios como sufijo; no es un parámetro de función.

Ejemplo 2:Sobrecarga del operador ++ (operador unario)

// Overload ++ when used as prefix and postfix

#include <iostream>
using namespace std;

class Count {
   private:
    int value;

   public:

    // Constructor to initialize count to 5
    Count() : value(5) {}


    // Overload ++ when used as prefix
    void operator ++ () {
        ++value;
    }


    // Overload ++ when used as postfix
    void operator ++ (int) {
        value++;
    }

    void display() {
        cout << "Count: " << value << endl;
    }
};

int main() {
    Count count1;

    // Call the "void operator ++ (int)" function
    count1++;
    count1.display();

    // Call the "void operator ++ ()" function
    ++count1;

    count1.display();
    return 0;
}

Salida

Count: 6
Count: 7

El Ejemplo 2 funciona cuando ++ se usa como prefijo y posfijo. Sin embargo, no funciona si tratamos de hacer algo como esto:

Count count1, result;

// Error
result = ++count1;

Esto se debe a que el tipo de retorno de nuestra función de operador es void . Podemos resolver este problema haciendo Count como el tipo de retorno de la función del operador.

// return Count when ++ used as prefix

Count operator ++ () {
    // code
}

// return Count when ++ used as postfix

Count operator ++ (int) {
   // code
}

Ejemplo 3:valor de retorno de la función del operador (operador ++)

#include <iostream>
using namespace std;

class Count {
   private:
    int value;

   public
       :
    // Constructor to initialize count to 5
    Count() : value(5) {}

    // Overload ++ when used as prefix
    Count operator ++ () {
        Count temp;

        // Here, value is the value attribute of the calling object
        temp.value = ++value;

        return temp;
    }

    // Overload ++ when used as postfix
    Count operator ++ (int) {
        Count temp;

        // Here, value is the value attribute of the calling object
        temp.value = value++;

        return temp;
    }

    void display() {
        cout << "Count: " << value << endl;
    }
};

int main() {
    Count count1, result;

    // Call the "Count operator ++ ()" function
    result = ++count1;
    result.display();

    // Call the "Count operator ++ (int)" function
    result = count1++;
    result.display();

    return 0;
}

Salida

Count: 6
Count: 6

Aquí, hemos usado el siguiente código para la sobrecarga de operadores de prefijos:

// Overload ++ when used as prefix
Count operator ++ () {
    Count temp;

    // Here, value is the value attribute of the calling object
    temp.value = ++value;

    return temp;
}

El código para la sobrecarga del operador sufijo también es similar. Note que hemos creado un objeto temp y devolvió su valor a la función del operador.

Además, observe el código

temp.value = ++value;

La variable valor pertenece al count1 objeto en main() porque cuenta1 está llamando a la función, mientras que temp.value pertenece a la temp objeto.

Sobrecarga de operadores en operadores binarios

Los operadores binarios trabajan en dos operandos. Por ejemplo,

result = num + 9;

Aquí, + es un operador binario que trabaja con los operandos num y 9 .

Cuando sobrecargamos el operador binario para tipos definidos por el usuario usando el código:

obj3 = obj1 + obj2;

La función de operador se llama usando obj1 objeto y obj2 se pasa como argumento a la función.

Ejemplo 4:Sobrecarga de operadores binarios de C++

// C++ program to overload the binary operator +
// This program adds two complex numbers

#include <iostream>
using namespace std;

class Complex {
   private:
    float real;
    float imag;

   public:
    // Constructor to initialize real and imag to 0
    Complex() : real(0), imag(0) {}

    void input() {
        cout << "Enter real and imaginary parts respectively: ";
        cin >> real;
        cin >> imag;
    }

    // Overload the + operator
    Complex operator + (const Complex& obj) {
        Complex temp;
        temp.real = real + obj.real;
        temp.imag = imag + obj.imag;
        return temp;
    }

    void output() {
        if (imag < 0)
            cout << "Output Complex number: " << real << imag << "i";
        else
            cout << "Output Complex number: " << real << "+" << imag << "i";
    }
};

int main() {
    Complex complex1, complex2, result;

    cout << "Enter first complex number:\n";
    complex1.input();

    cout << "Enter second complex number:\n";
    complex2.input();

   // complex1 calls the operator function
   // complex2 is passed as an argument to the function
    result = complex1 + complex2;
    result.output();

    return 0;
}

Salida

Enter first complex number:
Enter real and imaginary parts respectively: 9 5
Enter second complex number:
Enter real and imaginary parts respectively: 7 6
Output Complex number: 16+11i

En este programa, la función del operador es:

Complex operator + (const Complex& obj) {
    // code
}

En lugar de esto, también podríamos haber escrito esta función como:

Complex operator + (Complex obj) {
    // code
}

Sin embargo,

usando & hace que nuestro código sea eficiente al hacer referencia a complex2 objeto en lugar de crear un objeto duplicado dentro de la función del operador.
usando const se considera una buena práctica porque evita que la función del operador modifique complex2 .

Cosas para recordar en la sobrecarga de operadores de C++

Dos operadores = y & ya están sobrecargados por defecto en C++. Por ejemplo, para copiar objetos de la misma clase, podemos usar directamente el = operador. No necesitamos crear una función de operador.
La sobrecarga de operadores no puede cambiar la precedencia ni la asociatividad de los operadores. Sin embargo, si queremos cambiar el orden de evaluación, se deben usar paréntesis.
Hay 4 operadores que no se pueden sobrecargar en C++. Están:
1. :: (resolución de alcance)
2. . (selección de miembros)
3. .* (selección de miembros a través del puntero a la función)
4. ?: (operador ternario)

Visite estas páginas para obtener más información sobre:

¿Cómo sobrecargar el operador de incremento de la manera correcta?
¿Cómo sobrecargar el operador binario - para restar números complejos?

¿Cómo pasar y devolver un objeto desde las funciones de C++? Punteros de C++

Lenguaje C