C/C++: sobrecarga de operadores en C++

En el lenguaje de programación C++ existe un conjunto de símbolos especiales destinados a indicar operaciones con los tipos de datos fundamentales (enteros, reales y caracteres), estos símbolos son llamados operadores, un ejemplo es el operador de suma “+” que se usa con operandos numéricos y efectúa la suma de estos, o el mismísimo operador de asignación “=” que sirve para asignar los valores que tendrán las variables;  gracias a estos operadores  es posible usar expresiones como esta:

int a = 1 + 3; //asignación de la suma de 1+3 a la variable a

Todo lo anterior aplica para los tipos de datos primitivos o fundamentales de C++, es decir, dichos operadores solamente funcionan con estos operandos, pero ¿qué hay si queremos hacer suma de números complejos o de racionales? Definitivamente estos no son tipos de datos primitivos, más bien tendríamos que definirlos a partir de los existentes, tendrían que ser tipos de datos estructurados o clases definidos por nosotros. El problema es que en los compiladores de C++ no está definido como operar con números racionales o complejos porque no son tipos primitivos, por lo tanto el compilador no sabría que hacer si se encontrara con algo así:

Fraccion a(1,2); // objeto Fraccion que representa 1/2
Fraccion b(2,3);
Fraccion c;
c = a + b; // ¡Error! El operador "+" no puede operar sobre fracciones.

c = suma(a,b);

Para ello hay que definir la función suma que reciba como argumentos dos fracciones (los sumandos) y retorne otra fracción (el resultado) y con esto queda resuelto el problema, pero diremos adiós a la bonita presentación que implica el uso de los operadores.

Si observamos bien el ejemplo anterior, notaremos que sustituimos el operador + por suma(), pero para la asignación no hicimos algo similar, ese operador sí funciona aunque opere con objetos de la clase Fraccion, esto indica que efectivamente se pueden usar los operadores con otros tipos de datos, pero ¿por qué solo funciona con el de asignación y no con el de suma? la respuesta es muy simple: funciona con el operador de asignación porque el compilador sobrecarga el operador si el programador no lo hace explícitamente, básicamente hace una definición adicional del operador, para que pueda usar operandos del tipo Fraccion además de los tipos primitivos, de esta manera copia directamente cada atributo de un objeto a otro; esto se logra a través de un tipo especial de sobrecarga llamado sobrecarga de operadores. Este tipo de sobrecarga trabaja de manera muy similar a la convencional, también se sobrecargan funciones pero con nombres (identificadores) especiales, a estas funciones se les llama funciones-operador. La sintaxis de una función-operador es la siguiente:

// A manera de función independiente o externa
tipo_retorno operator simbolo_de_operador (tipo_arg arg1,...); //prototipo

tipo_retorno operator simbolo_de_operador (tipo_arg arg1,...){
  //Implementación de la operación
}

// Como función miembro de una clase
// Al interior de la definición de la clase
tipo_retorno operator simbolo_de_operador (tipo_arg arg1,...); //prototipo

// Implementación fuera de la definición de la clase
tipo_retorno nombre_clase::operator simbolo_de_operador (tipo_arg arg1,...){
  //Implementación de la operación
}

Lo importante aquí y diferente a la sobrecarga convencional es el uso de la palabra reservada operator seguida por el símbolo del operador que queremos sobrecargar.

Como primer ejemplo veamos la sobrecarga a manera de función independiente o externa:

// Supongamos que ya tenemos definida la clase Fraccion
#include "Fraccion.h"
// Sobrecarga del operador "+" para sumar fracciones
Fraccion operator+(const& Fraccion f1, const& Fraccion f2){
  Fraccion fr;
  fr.denominador = f1.dameDenominador() * f2.dameDenominador();
  fr.numerador = f1.dameNumerador() * f2.dameDenominador() + 
                      f2.dameNumerador * f1.dameDenominador;
  return fr;
}

Con esto ya podremos hacer sumas de fracciones  usando el operador como si sumáramos enteros, solo basta con tener definida la clase Fraccion y esta función.

Ahora veamos como podría ser la sobrecarga del operador de suma como función miembro de la clase Fraccion:

// Definición de la clase Fraccion
class Fraccion{
private:
  int numerador;
  int denominador;
public:
  Fraccion(int num=1, int den=1);
  Fraccion operator +(const Fraccion& f2);  //prototipo de la función-operador miembro
};

// Implementación de los métodos
// Constructor
Fraccion::Fraccion(int num, int den){ 
  this -> numerador = num;
  this -> den = den;
}
// Sobrecarga del operador "+" para hacer suma de fracciones
Fraccion Fraccion::operator +(const Fraccion& f2){
  Fraccion fr;
  fr.denominador = this -> denominador * f2.denominador;
  fr.numerador = this -> numerador * f2.denominador + 
                      f2.numerador * this -> denominador;
  return fr;
}

Con esta clase podemos hacer lo siguiente sin problemas:

 Fraccion a(1,2); // fracción 1/2
 Fraccion b(1,3); // fracción 1/3
 // Las siguientes dos sentencias son equivalentes
 Fraccion c = a + b; //c tendrá la fracción 5/6
 Fraccion c = a.operator+(b); //también se puede usar la notación funcional

std::string mensaje;
std::string saludo = "hola";
std::string receptor = " mundo";
mensaje = saludo + receptor + "!!"; //mensaje = hola mundo!!