Tengo algunos punteros a un tipo base de forma. Quiero comparar estos objetos usando el operador ==. El operador == obviamente debe devolver falso si los objetos son de un tipo derivado diferente. Si son del mismo tipo derivado, sin embargo, los miembros del tipo derivado deben compararse.

He leído que usar el C ++ RTTI es una mala práctica y solo se debe usar en circunstancias excepcionales y esenciales. Por lo que puedo ver, este problema no se puede resolver en general sin usar el RTTI. Cada operador == sobrecargado tendría que verificar el ID de tipo y, si son iguales, realizar un Dynamic_cast y comparar los miembros. Esto parece una necesidad común. ¿Hay algún tipo de expresión para este problema?

#include <iostream>
using namespace std;

class Shape {
  public:
    Shape() {}
    virtual ~Shape() {}
    virtual void draw() = 0;

    virtual bool operator == (const Shape &Other) const = 0;
};

class Circle : public Shape {
  public:
    Circle() {}
    virtual ~Circle() {}
    virtual void draw() { cout << "Circle"; }

    virtual bool operator == (const Shape &Other) const {
      // If Shape is a Circle then compare radii
    }

  private:
    int radius;
};

class Rectangle : public Shape {
  public:
    Rectangle() {}
    virtual ~Rectangle() {}
    virtual void draw() { cout << "Rectangle"; }

    virtual bool operator == (const Shape &Other) const {
      // If Shape is a Rectangle then compare width and height
    }

  private:
    int width;
    int height;
};

int main() {
  Circle circle;
  Rectangle rectangle;

  Shape *Shape1 = &circle;
  Shape *Shape2 = &rectangle;

  (*Shape1) == (*Shape2); // Calls Circle ==
  (*Shape2) == (*Shape1); // Calls Rectangle ==
}