Sobrecargue el operador == en C++

1. Sobrecarga de operadores en C++
2. Sobrecargue el operador == en C++
3. Sobrecargar el operador == en la jerarquía de clases

Este artículo discutirá los conceptos básicos de la sobrecarga de operadores y proporciona una implementación sencilla del operador == en una clase.

Sobrecarga de operadores en C++

La sobrecarga de operadores se refiere a cambiar la forma en que debe actuar un operador cuando se usa junto con los tipos de datos definidos por el usuario, como estructuras y objetos de clase. Estas son como funciones miembro en una clase llamada a usar ese operador.

Por ejemplo, si tenemos una clase Student y queremos comprobar qué notas de los alumnos son mejores que las del otro, entonces podemos sobrecargar el operador > que puede comparar el miembro de datos marcas de los dos objetos y devolver el resultado.

La sintaxis para la sobrecarga de operadores es la siguiente:

class className {
 public:
  returnType operator operatorSymbol([list of arguments]) {
    // definition
  }
};

Tenga en cuenta que operator es una palabra clave utilizada para la sobrecarga de operadores y, después de eso, especificamos el símbolo del operador que debe sobrecargarse. Recuerde que no podemos sobrecargar operadores para tipos de datos fundamentales como int, char, float, etc.

Casi todos los operadores se pueden sobrecargar excepto algunos que no se pueden sobrecargar. Estos operadores incluyen:

• el operador sizeof
• el operador typeid
• la resolución de alcance (::)
• los operadores de acceso a los miembros de la clase (.(punto), .* (puntero al operador miembro)
• el Operador condicional (?:)

Sobrecargue el operador == en C++

== es también el operador igual a que se incluye en la clasificación de operadores de comparación y devuelve un resultado booleano de true o false. Determina si los dos operandos en los lados izquierdo y derecho del operador son iguales entre sí.

Para tipos de datos definidos por el usuario como clase, este operador se puede sobrecargar para comparar dos objetos de una clase para verificar si todos los miembros de datos de los dos objetos son iguales o no.

Considere una clase Employee que tiene los siguientes miembros de datos:

class Employee {
 private:
  string name;
  int salary;
};

En esta clase, podemos sobrecargar el operador == para verificar si los objetos de los dos empleados son iguales entre sí o no. Esta función se puede implementar como:

bool operator==(const Employee &emp) {
  if (name == emp.name && salary == emp.salary) return true;
  return false;
}

Ahora, podemos ponerlos todos juntos para tener una clase completa.

#include <iostream>
#include <string>
using namespace std;

class Employee {
 private:
  string name;
  int salary;

 public:
  Employee(string n, int s) {
    name = n;
    salary = s;
  }
  bool operator==(const Employee &emp) {
    if (name == emp.name && salary == emp.salary) return true;
    return false;
  }
};
int main() {
  Employee e1("David", 1000);
  Employee e2("David", 1000);
  if (e1 == e2)
    cout << "Equal" << endl;
  else
    cout << "Not Equal" << endl;
}

Producción :

Equal

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

Si tiene varias clases, de modo que algunas clases son padres y otras son clases secundarias, entonces necesita implementar la función de operador en todas las subclases y superclases. Por ejemplo, si hay una clase A e implementas el operador ==, este operador sobrecargado estará disponible para todas sus subclases.

class A {
 public:
  int foo;
  bool operator==(const A &a) { return foo == a.foo; }
};

Ahora, tenemos otra clase, B, una subclase de A.

class B : public A {
 public:
  int bar;
};

Si no implementamos el operador == en esta clase, llamará a la función de operador de la clase base, pero el problema es que la clase base solo compara los miembros de datos propios pero no los de la clase B. Por lo tanto, también necesitamos implementar el operador en la clase secundaria.

Después de esa implementación, la implementación de la clase base no se llamará hasta que la llamemos explícitamente. Por lo tanto, llamamos a esa función explícitamente para comparar los miembros de datos de la clase base.

Esto se demuestra en el fragmento de código a continuación:

class B : public A {
 public:
  int bar;
  bool operator==(const B &b) {
    if (!A::operator==(static_cast<const A &>(b))) {
      return false;
    }
    return bar == b.bar;
  }
};

La función del controlador será:

int main() {
  B b;
  b.bar = 2;
  b.foo = 1;
  B b2;
  b2.bar = 2;
  b2.foo = 1;
  if (b == b2) {
    cout << "Equal" << endl;
  }
}

Producción :

Equal