12.2. Sintaxis

Definir un operador sobrecargado es como definir una función, pero el nombre de esa función es operator@ en la que @ representa el operador que está siendo sobrecargado. El número de argumentos en la lista de argumentos del operador sobrecargado depende de dos factores:

Si es un operador unario (un argumento) o un operador binario (dos argumentos)
Si el operador está definido como una función global (un argumento para los unarios, dos para los binarios) o un método (cero argumentos para los unarios y uno para los binarios. En este último caso el objeto (this) se convierte en el argumento del lado izquierdo al operador).

He aquí una pequeña clase que muestra la sintaxis de la sobrecarga de operadores:

//: C12:OperatorOverloadingSyntax.cpp
#include <iostream>
using namespace std;

class Integer {
  int i;
public:
  Integer(int ii) : i(ii) {}
  const Integer
  operator+(const Integer& rv) const {
    cout << "operator+" << endl;
    return Integer(i + rv.i);
  }
  Integer&
  operator+=(const Integer& rv) {
    cout << "operator+=" << endl;
    i += rv.i;
    return *this;
  }
};

int main() {
  cout << "built-in types:" << endl;
  int i = 1, j = 2, k = 3;
  k += i + j;
  cout << "user-defined types:" << endl;
  Integer ii(1), jj(2), kk(3);
  kk += ii + jj;
} ///:~

Listado 12.1. C12/OperatorOverloadingSyntax.cpp

Los dos operadores sobrecargados están definidos como métodos en línea que imprimen un mensaje al ser llamados. El único argumento de estas funciones miembro será el que aparezca del lado derecho del operador binario. Los operadores unarios no tienen argumentos cuando se definen como métodos. El método es invocado por el objeto de la parte izquierda del operador.

Para los operadores incondicionales (los condicionales generalmente devuelven un valor booleano), generalmente se deseará devolver un objeto o una referencia del mismo tipo que está operando, si los dos argumentos son del mismo tipo. (Si no son del mismo tipo, la interpretación de lo que debería pasar es responsabilidad suya). De esta manera, se pueden construir expresiones tan complicadas como la siguiente:

kk += ii + jj;

La expresión operator+ crea un nuevo objeto Integer (un temporario) que se usa como argumento rv para el operador operator+=. Este objeto temporal se destruye tan pronto como deja de necesitarse.