Operadores binarios que pueden sobrecargarse:  

Además del operador + pueden sobrecargarse prácticamente todos los operadores:

+, -, *, /, %, ^, &, |, (,), <, >, <=, >=, <<, >>, ==, !=, &&, ||, =, +=. -=, *=, /=, %=, ^=, &=, |=, <<=,>>=, [], (),->, new y delete.

Los operadores =, [], () y -> sólo pueden sobrecargarse en el interior de clases.

Por ejemplo, el operador > podría declararse y definirse así:

class Tiempo {
...
bool operator>(Tiempo h);
...
};

bool Tiempo::operator>(Tiempo h) {
   return (hora > h.hora || 
           (hora == h.hora && minuto > h.minuto));
}
...
if(Tiempo(1,32) > Tiempo(1,12)) 
   cout << "1:32 es mayor que 1:12" << endl;
else 
   cout << "1:32 es menor o igual que 1:12" << endl;
...

Para los operadores de igualdad el valor de retorno es bool, lógicamente, ya que estamos haciendo una comparación.

Y el operador +=, de esta otra:

class Tiempo {
...
void operator+=(Tiempo h);
...
};
 
void Tiempo::operator+=(Tiempo h) {
   minuto += h.minuto;
   hora   += h.hora;
   
   while(minuto >= 60) {
      minuto -= 60;
      hora++;
   }
}
...
Ahora += Tiempo(1,32);
Ahora.Mostrar();
...

Los operadores de asignación mixtos no necesitan valor de retorno, ya que es el propio objeto al que se aplican el que recibe el resultado de la operación y además, no pueden asociarse.

Con el resto de lo operadores binarios se trabaja del mismo modo.

No es imprescindible mantener el significado de los operadores. Por ejemplo, para la clase Tiempo no tiene sentido sobrecargar el operadores >>, <<, * ó /, pero podemos hacerlo de todos modos, y olvidar el significado que tengan habitualmente. De igual modo podríamos haber sobrecargado el operador + y hacer que no sumara los tiempos sino que, por ejemplo, los restara. En última instancia, es el programador el que decide el significado de los operadores.

Por ejemplo, sobrecargaremos el operador >> para que devuelva el mayor de los operandos.

class Tiempo {
...
Tiempo operator>>(Tiempo h);
...
};

Tiempo Tiempo::operator>>(Tiempo h) {
   if(*this > h) return *this; else return h;
}
...

T1 = Ahora >> Tiempo(13,43) >> T1 >> Tiempo(12,32);
T1.Mostrar();
... 

En este ejemplo hemos recurrido al puntero this, para usar el objeto actual en una comparación y para devolverlo como resultado en el caso adecuado.

Esta es otra de las aplicaciones del puntero this, si no dispusiéramos de él, sería imposible hacer referencia al propio objeto al que se aplica el operador.

También vemos que los operadores binarios deben seguir admitiendo la asociación aún estando sobrecargados.

Forma funcional de los operadores:  

Por supuesto también es posible usar la forma funcional de los operadores sobrecargados, aunque no es muy habitual ni aconsejable.

En el caso del operador + las siguientes expresiones son equivalentes:

T1 = T1.operator+(Ahora);
 
T1 = Ahora + T1;

Sobrecarga de operadores para clases con punteros:  

Si intentamos sobrecargar el operador suma con la clase Cadena usando el mismo sistema que con Tiempo, veremos que no funciona.

Cuando nuestras clases tienen punteros con memoria dinámica asociada, la sobrecarga de funciones y operadores puede complicarse un poco.

Por ejemplo, sobrecarguemos el operador + para la clase Cadena:

class Cadena {
...
   Cadena operator+(const Cadena &);
...
};
 
Cadena Cadena::operator+(const Cadena &c) {
   Cadena temp;
   
   temp.cadena = new char[strlen(c.cadena)+strlen(cadena)+1];
   strcpy(temp.cadena, cadena);
   strcat(temp.cadena, c.cadena);
   return temp;
}
...
Cadena C1, C2("Primera parte");

C1 = C2 + " Segunda parte";

Ahora analicemos cómo funciona el código de este operador.

El equivalente de ésta última línea es:

C1.operator=(Cadena(C2.operator+(Cadena(" Segunda parte"))));

1) Se crea automáticamente un objeto temporal sin nombre para la cadena " Segunda parte". Y se llama al operador + del objeto C2.

2) Dentro del operador + se crea un objeto temporal: temp, reservamos memoria para la cadena que almacenará la concatenación de this->cadena y c.cadena, y le asignamos el valor de ambas cadenas, temp contiene la cadena: "Primera parte Segunda parte".

3) Retornamos el objeto temporal.

4) Ahora el objeto temporal temp se copia a otro objeto temporal sin nombre, y temp es destruido. Y el objeto temporal sin nombre se pasa como parámetro al operador de asignación. Si esto es difícil de entender, piensa lo que pasa cuando usamos el operador de asignación con una cadena, por ejemplo:

C1 = "hola";

En este caso se crea un objeto temporal sin nombre para "hola", igual que pasó con la cadena " Segunda parte".

5) Se asigna el objeto temporal sin nombre a C1, y se destruye.

Parece que todo ha ido bien, pero en el paso 4 hay un problema. Para copiar temp en el objeto temporal sin nombre se usa el constructor copia de Cadena. Pero como nosotros no hemos creado un constructor copia, se usará el constructor copia por defecto. Recuerda que ese constructor copia los punteros, no los contenidos de estos.

Recapitulemos: el objeto temp se copia en un temporal sin nombre, y después se destruye, ¿qué pasa con el dato temp.cadena?, evidentemente también se destruye, pero el constructor copia por defecto ha copiado ese puntero, por lo tanto, también su cadena es destruida. El resultado es que C1 no recibe la suma de las cadenas.

Para evitar eso tenemos que sobrecargar el constructor copia, afortunadamente es sencillo ya que disponemos del operador de asignación, sin olvidar que tenemos que inicializar los datos miembros, el constructor copia no deja de ser un constructor:

class Cadena {
...
   Cadena(const Cadena &c) : cadena(NULL) { *this = c; }
...
};

Si no tenemos cuidado de iniciar el valor de cadena, cuando se invoque al operador "=" el puntero cadena tendrá algún valor inválido, y al ejecutar el código del operador de asignación se producirá un error al intentar liberarlo.

Cadena &Cadena::operator=(const Cadena &c) {
   if(this != &c) {
      delete[] cadena; // (1)
      if(c.cadena) {
         cadena = new char[strlen(c.cadena)+1];
         strcpy(cadena, c.cadena);
      }
      else cadena = NULL;
   }
   return *this;
}

En (1), si cadena no es NULL, pero tampoco es un puntero válido, se producirá un error de ejecución. En general, si se usa el operador de asignación con objetos que existan no habrá problema, pero si se usa desde el constructor copia debemos asegurarnos de que el puntero es NULL.

La moraleja es que cuando nuestras clases tengan datos miembro que sean punteros a memoria dinámica debemos sobrecargar siempre el constructor copia, ya que nunca sabemos cuándo puede ser invocado sin que nos demos cuenta.

(Gracias a Steven por la idea de crear una clase Tiempo como ejemplo para la sobrecarga de operadores)