SOBRECARGA DE OPERADORES DE C++

La sobrecarga de operadores es uno de los mecanismos que nos permite ampliar las capacidades de los lenguajes de programación orientados a objetos. En C++, la declaración y definición de una sobrecarga de operador es muy similar a la declaración y definición de una función cualquiera. El ejemplo más sencillo de una sobrecarga de operadores nos lo da el lenguaje mismo, es decir, en una operación aritmética (por ejemplo, una suma ) el compilador determina el tipo de operación requerida de acuerdo con el tipo de datos involucrados. Vamos a suponer que se tienen las variables: int A, B; double X, Y; int R; y las siguientes instrucciones:

R = A + B - C;
R = A + X;
R = X + Y;

Ahora bien:

• en el primer caso el compilador determina que el tipo de operación requerida es una suma de enteros debido a que los dos miembros ( A y B ) de la suma son del tipo entero.
• en el segundo caso parece ser que las cosas no son tan claras, ya que en este los miembros involucrados en la suma son de tipos diferentes, sin embargo el compilador determinará el tipo de operación requerida y depositará en el resultado ( R )el valor resultante redondeado.
• en el tercero y último de los casos el compilador determina que el tipo de operación requerida es una suma de reales debido a que los dos miembros ( X e Y ) de la suma son del tipo double. También en este caso el resultado de la suma se redondea antes de ponerlo en R.

Mi primer sobrecarga

Para poner un ejemplo práctico de sobrecarga del operador de suma ( + ) vamos a considerar el caso de la clase pareja mostrada en seguida:

class Pareja {
public:
    double a, b;

    // constructor parametrizado
    Pareja(const double a,const double b)
    {
        this->a = a;
        this->b = b;
    }
};

int main()
{
    Pareja A(50, 75 );
    Pareja B(150, 175 );
    Pareja C = A + B;

    return 0;
}

Si usted trata de compilar el programa anterior descubrirá que el compilador se queja, es decir, el compilador no sabe que hacer en el caso de la instrucción Pareja C = A + B; aunque es evidente que se trata de la declaracion del objeto C y que el mismo se espera que sea igual a la suma de los objetos A y B. El error se debe al hecho de que el tipo Pareja es en realidad una clase y no un tipo primitivo y, en consecuencia, se debe de adiestrar al mismo compilador para que éste sepa de que manera hara la suma de dos objetos del tipo Pareja. Así, para solucionar el error vamos a sobrecargar el operador + para trabajar la suma de dos de dichos objetos. Vamos:

// Titulo..: programa sobrecarga01.cpp
// Objetivo: demostración de sobrecarga de operadores
// Autor...: Oscar E. Palacios
#include <iostream>
using namespace std;

class Pareja {
public:
    double a, b;

    // constructor parametrizado
    Pareja(const double a,const double b)
    {
        this->a = a;
        this->b = b;
    }
};

// Sobrecarga del operador +
Pareja& operator +(const Pareja &p1,const Pareja &p2)
{
  return *(new Pareja(p1.a + p2.a, p1.b + p2.b) );
}

int main()
{
    Pareja A(50, 75 );
    Pareja B(150, 175 );
    Pareja C = A + B;

    cout << "A = " << A.a << ',' << A.b << "\n";
    cout << "B = " << B.a << ',' << B.b << "\n";
    cout << "C = " << C.a << ',' << C.b << "\n";

    return 0;
}

Sintaxis general

Tal y como usted lo habrá notado, la declaración de sobrecarga en el programa anterior es lo más parecido a una función, es decir, la sintaxis general para sobrecargar uno operador cualquiera es:

1. tipo se refiere al tipo regresado por el operador
2. operator es una palabra reservada y debe aparecer en toda declaración de sobrecarga de operadores
3. el simbolo + está en representación de cualquier operador
4. lista de parámetros indica los argumentos sobre los que operarará la función de sobrecarga

Nota: en el caso de que el operador sobrecargado se hace para una clase específica la sintaxis se extiende de la siguiente manera:nombre_clase::operator + (lista de parámetros);

Regresando al caso de la clase Pareja, específicamente al operador + de sobrecarga para dicha clase, nos damos cuenta que dicho operador opera sobre dos objetos de dicha clase y también devuelve un resultado de la misma clase. Esto es lo más recomendable ya que si usted recuerda el compilador regresa un resultado entero si es que (por ejemplo) se le da una instrucción como: R = 100 + 23;. En todo caso, el resultado devuelto por los operadores sobrecargados es responsabilidad del que esta programando

EJEMPLO DE PROGRAMA:

#include <iostream>
using namespace std;
 
class Tiempo {
  public:
   Tiempo(int h=0, int m=0) : hora(h), minuto(m) {}
   
   void Mostrar();
   Tiempo operator+(Tiempo h);
       
  private:
   int hora;
   int minuto;
};

Tiempo Tiempo::operator+(Tiempo h) {
   Tiempo temp;
   
   temp.minuto = minuto + h.minuto;
   temp.hora   = hora   + h.hora;
   
   if(temp.minuto >= 60) {
      temp.minuto -= 60;
      temp.hora++;
   }
   return temp;
}

void Tiempo::Mostrar() {
   cout << hora << ":" << minuto << endl;
}

int main() {
   Tiempo Ahora(12,24), T1(4,45);
   
   T1 = Ahora + T1;   // (1)
   T1.Mostrar();
   
   (Ahora + Tiempo(4,45)).Mostrar(); // (2)
   
   return 0;
}

PARA VER EL FUNCIONAMIENTO DEL PROGRAMA DE EJEMPLO, DIRIGIRSE A ESTE ENLACE DONDE COPIE Y PEGUE EL EJEMPLO .

• http://cpp.sh/

FUENTE DE CONSULTA:

• https://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C%2B%2B/Sobrecarga_de_Operadores
• http://www.chuidiang.com/clinux/sobrecarga/sobrecarga.php
• http://c.conclase.net/curso/?cap=035