Sobrecarga del operador C ++ (con ejemplos)

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

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

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

Dado que la sobrecarga de operadores nos permite cambiar cómo funcionan los operadores, podemos redefinir cómo funciona el +operador y usarlo 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 utilizar la sobrecarga de operadores para tipos de datos fundamentales como int, float, chary así sucesivamente.

Sintaxis para la sobrecarga del operador C ++

Para sobrecargar a un operador, usamos una operatorfunción especial .

 class className (… public returnType operator symbol (arguments) (… )… );

Aquí,

  • returnType es el tipo de retorno de la función.
  • operador es una palabra clave.
  • symboles el operador que queremos sobrecargar. Como: +, <, -, ++, 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 el operador de decremento --son ejemplos de operadores unarios.

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

 // Overload ++ when used as prefix #include 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

 Cuenta: 6

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

Nota: Cuando sobrecargamos operadores, podemos usarlo para que funcione como queramos. Por ejemplo, podríamos haber utilizado ++para aumentar el valor en 100.

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

El ejemplo anterior funciona solo cuando ++se usa como prefijo. Para que ++funcione como sufijo utilizamos esta sintaxis.

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

Observe el intinterior 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 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

 Cuenta: 6 Cuenta: 7

El Ejemplo 2 funciona cuando ++se usa como prefijo y sufijo. Sin embargo, no funciona si intentamos 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 Countcomo 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 de operador (Operador ++)

 #include 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

 Cuenta: 6 Cuenta: 7

Aquí, hemos utilizado el siguiente código para la sobrecarga del operador de prefijo:

 // 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 postfix es el mismo también. Observe que hemos creado un objeto temp y devuelto su valor a la función del operador.

También observe el código

 temp.value = ++value;

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

Sobrecarga de operadores en operadores binarios

Los operadores binarios trabajan con dos operandos. Por ejemplo,

 result = num + 9;

Aquí, +hay 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;

Se llama a la función del operador usando el objeto obj1 y obj2 se pasa como argumento a la función.

Ejemplo 4: Sobrecarga del operador binario de C ++

 // C++ program to overload the binary operator + // This program adds two complex numbers #include 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 <> 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:"; complex1.input(); cout << "Enter second complex number:"; complex2.input(); // complex1 calls the operator function // complex2 is passed as an argument to the function result = complex1 + complex2; result.output(); return 0; )

Salida

 Ingrese el primer número complejo: Ingrese partes reales e imaginarias respectivamente: 9 5 Ingrese el segundo número complejo: Ingrese partes reales e imaginarias respectivamente: 7 6 Salida Número complejo: 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,

  • el uso &hace que nuestro código sea eficiente al hacer referencia al objeto complex2 en lugar de hacer un objeto duplicado dentro de la función del operador.
  • el uso constse considera una buena práctica porque evita que la función del operador modifique complex2.
Sobrecarga de operadores binarios en C ++

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

  1. 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.
  2. La sobrecarga de operadores no puede cambiar la precedencia y la asociatividad de los operadores. Sin embargo, si queremos cambiar el orden de evaluación, conviene utilizar paréntesis.
  3. Hay 4 operadores que no se pueden sobrecargar en C ++. Son:
    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 al operador de incremento de manera correcta?
  • ¿Cómo sobrecargar el operador binario para restar números complejos?

Articulos interesantes...