Cómo sobrecargar el operador == en C++

Una clase puede definir la igualdad implementando operator==. La función debe comparar los campos que representan el valor del objeto. El ejemplo Employee siguiente compara un nombre y un salario, y luego muestra cómo == informa de empleados coincidentes y diferentes.

Sobrecarga de operadores en C++

La sobrecarga de operadores da a un operador existente un significado para un tipo definido por el usuario, como una clase o un struct. Una sobrecarga miembro suele tener esta forma: return_type operator symbol(parameters). Por ejemplo, operator== es el nombre de la función utilizada para sobrecargar la igualdad.

Una sobrecarga debe involucrar al menos un tipo definido por el usuario; no puede redefinir una operación cuyos operandos sean todos tipos integrados como int o char. Tampoco puede cambiar la precedencia de un operador, su número de operandos o su asociatividad. La sintaxis y la expresión familiar permanecen iguales, por lo que quien llama puede escribir first == second en lugar de llamar directamente a un método de comparación.

Algunos operadores no se pueden sobrecargar, incluidos ::, ., .*, ?: y sizeof. El operador typeid tampoco se puede sobrecargar.

Sobrecargar el operador == en C++

Para una clase, decide qué campos definen la igualdad antes de escribir la función. Este valor Employee utiliza tanto name como salary; si cualquiera de los dos difiere, los objetos se comparan como desiguales. Una función miembro const y un parámetro de referencia const permiten la comparación sin copiar ni modificar ninguno de los objetos.

#include <iostream>
#include <string>

class Employee {
 public:
  Employee(std::string name, int salary)
      : name_(name), salary_(salary) {}

  bool operator==(const Employee& other) const {
    return name_ == other.name_ && salary_ == other.salary_;
  }

 private:
  std::string name_;
  int salary_;
};

int main() {
  const Employee first("David", 1000);
  const Employee same("David", 1000);
  const Employee different_salary("David", 1200);

  std::cout << (first == same ? "Equal" : "Not equal") << '\n';
  std::cout << (first == different_salary ? "Equal" : "Not equal") << '\n';
}

Equal
Not equal

La salida muestra Equal cuando ambos campos seleccionados coinciden y Not equal cuando el salario difiere. Si la clase gana posteriormente otro campo de valor, inclúyelo cuando ese campo deba afectar a la igualdad.

Sobrecargar el operador == en una jerarquía de clases

Una función de igualdad de la clase base comprueba solo el estado de la clase base incluido en su implementación. Puede ser invocable para objetos derivados a través del miembro heredado, pero no inspecciona automáticamente los miembros añadidos por una clase derivada. Un tipo derivado no tiene que definir la igualdad a menos que su propia semántica de comparación necesite incluir estado adicional.

Por ejemplo, si A almacena foo y define bool operator==(const A& other) const, entonces esa función compara foo. Si B : public A añade bar, define una comparación de B cuando la igualdad para B deba incluir bar: su resultado puede combinar A::operator==(static_cast<const A&>(other)) con bar == other.bar. Esto compara explícitamente la porción base y el campo derivado. Cuando una sobrecarga derivada tiene el mismo nombre, puede ocultar las sobrecargas de la base durante la búsqueda ordinaria; utiliza un conjunto de sobrecargas deliberado si ambas comparaciones deben estar disponibles.

Los tipos estáticos de los operandos de la expresión determinan qué sobrecargas participan. Para referencias base polimórficas, una comparación de la base sigue comparando la vista de la base; no descubre ni compara dinámicamente los miembros derivados. La igualdad a través de una jerarquía polimórfica necesita, por tanto, una política explícita sobre si tipos dinámicos diferentes pueden compararse como iguales, con un comportamiento coincidente en ambos órdenes de operandos. Mantén la regla consistente para que la igualdad siga siendo simétrica y refleje los valores que tu tipo promete representar.