Sobrecarga de operadores binarios (Programación)

Sobrecarga de operadores binarios (Programación) Concepto: Se llama sobrecarga de operadores cuando reutilizando el mismo operador con un número de usos diferentes, y el compilador decide como usar ese operador dependiendo sobre qué opera.

Sobrecarga de operadores binarios (Programación). Pueden ser sobrecargados de dos formas:

1. Declarando una función miembro no estática que acepte un argumento
2. Declarando una función no miembro (generalmente friend) que acepte dos argumentos.

Dependiendo de la declaración, si @ representa el operador binario, la expresión x @ y entre miembros de una clase C puede ser interpretada como cualquiera de las dos formas:

1. x.operator@(y)
2. operator@(x, y)

Si han sido declaradas ambas formas, se aplica la congruencia estándar de argumentos para resolver cualquier posible ambigüedad.

Sobrecarga del operador suma ( + )

En el ejemplo que sigue se utiliza la clase Vector, y sobrecargamos el operador suma binaria (+), de forma que pueda ser utilizada con tipos de dicha clase.

#include <iostream>
using namespace std;
class Vector {
 public:
 float x, y;
 Vector operator+ (Vector v) {  // función-operador operator+
   x = x + v.x;
   y = y + v.y;
   return *this;
 }
};

int main () {     // =========
  float x = 5, y = 6;
  cout << "R = " << x + y << endl;  // M.2: versión global
  Vector v1 = {1, 2}, v2 = {3, 4};
  Vector v3 = v1 + v2;              // M.4: versión sobrecargada
  cout << "Rx = " << v3.x << endl;
  cout << "Ry = " << v3.y << endl;
}
Salida:
R = 11
Rx = 4
Ry = 6

Comentario

El ejemplo compila sin dificultad, confirmando que el operador + puede ser utilizado en M.4 con los objetos v1 y v2 de la clase Vector. El resultado obtenido para v3 es el esperado. Sin embargo, a pesar de su aparente idoneidad, tampoco en este caso el operador ha sido sobrecargado correctamente. Si sustituimos las referencias explícitas a v3 (en las sentencias M.4 y siguientes) por dos resultados auxiliares en la sentencia de salida:

  cout << "Rx = " << (v1 + v2).x << endl;    // M.4:
  cout << "Ry = " << (v1 + v2).y << endl;    // M.5:

El programa suministra la desconcertante salida siguiente:

R = 11
Rx = 4
Ry = 10

La razón de que el valor obtenido para Ry no sea el esperado, estriba en que con el diseño actual, la función operator+ modifica el primer operando, exactamente como lo hacía la función operator=. Esta asignación oculta también podría ser manifestada añadiendo una línea a la versión inicial del programa:

cout << "v1.x = " << v1.x << " v1.y = " << v1.y << endl;    // M.7:

En este caso las salidas habrían sido:

R = 11
Rx = 4
Ry = 6
v1.x = 4 v1.y = 6

Puede Consultar

• Operadores
• Sobrecarga de operadores
• Sobrecarga de operadores unarios

Fuente

• Sobrecarga de operadores binarios
• Sobrecarga de operadores en c
• Sobrecarga de operadores en C++