Eu tenho alguns ponteiros para um tipo base de Shape. Eu quero comparar esses objetos usando o operador ==. O operador == deve obviamente retornar false se os objetos forem de tipos derivados diferentes. Se eles são do mesmo tipo derivado, no entanto, os membros do tipo derivado devem ser comparados.

Eu li que usando o C ++ RTTI é uma má prática e só deve ser usado em circunstâncias raras e essenciais. Tanto quanto eu posso ver este problema não pode ser geralmente resolvido sem usar o RTTI. Cada operador sobrecarregado == teria que verificar o typeid e, se forem os mesmos, executar um dynamic_cast e comparar os membros. Isso parece uma necessidade comum. Existe algum tipo de idioma para esse 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 ==
}