class Impl_base;

class PImpl {
 public:
  bool operator == (const PImpl &impl) const;

 private:
  Impl_base *m_pImpl;
};

class Impl_base {
 public:
  virtual bool IsEqual(const Impl_base* pImpl) const=0;
};

bool PImpl::operator == (const PImpl &impl) const
{
  return m_pImpl->IsEqual(impl);
}

class Impl_A: public Impl_base {
 public:
  virtual bool IsEqual(const Impl_base* pImpl) const;
  {
    const Impl_A *pImplA=dynamic_cast<const Impl_A*>(pImpl);
    if (!pImplA) return false;
    return m_a==pImplA->m_a;
  }

 private:
  int m_a;
};

class Impl_A: public Impl_base {
 public:
  virtual bool IsEqual(const Impl_base* pImpl) const;
  {
    return m_a==pImplA->GetA();
  }
  protected:
  virtual int GetA() const
  {
     return m_a;
  }
 private:
  int m_a;
};

А>class Impl_base;

А>class PImpl {
А> public:
А>  bool operator == (const PImpl &impl) const;

А> private:
А>  Impl_base *m_pImpl;
А>};

bool PImpl::operator == (const PImpl &impl) const
{
  return *m_pImpl == *(impl.m_pImpl);
}

class Impl_A: public Impl_base {
public:
  virtual bool IsEqual(const Impl_base* pImpl) const;
  {
    return GetClassId() == pImplA->GetClassId();
  }
 
  virtual void* GetClassId() const
  {
     static int uniqAddressVar = 0;
     return &uniqAddressVar;
  }
};

class Impl_A;
class Impl_base {
public:
    virtual bool IsEqual(const Impl_base& other) const=0;
    virtual bool IsEqual(const Impl_A& other) const=0;
};

class Impl_A: public Impl_base {
public:
    virtual bool IsEqual(const Impl_base& other ) const;
    {
        return other.IsEqual(*this);
    }
     virtual bool IsEqual(const Impl_A& other) const=0
     {
        // compare somehow 2 Impl_A
     }
};

class Impl_base 
{
public:
    virtual std::string hash() const = 0;
};

bool PImpl::operator == (const PImpl &other) const
{
  return m_pImpl.hash() == other.m_pImpl.hash();
}

class Impl_Animal {
 public:
  virtual void Run()=0;
};

class Impl_Cat: public Impl_Animal  {
 public:
  virtual void Run() { /*something to do*/ }
};

class Impl_Dog: public Impl_Animal  {
 public:
  virtual void Run() { /*something to do*/ }
};

class Impl_Mouse: public Impl_Animal  { /*......*/ };
class Impl_Snake: public Impl_Animal  { /*......*/ };

class Animal {
 public:
  void Run() { m_pImpl->Run(); }

 private:
  Impl_Animal *m_pImpl;  
};

Segmented memory model:
* .............
* Pages can overlap / poor resource protection and isolation
* Many to one address translation correspondence: Many segment:offset combinations resolve to the same physical address

3.9.2.4
A void* shall be able to hold any object pointer.

5.9.2
— If two pointers p and q of the same type point to the same object or function, or both point one past the end of the same array, or are both null, then p<=q and p>=q both yield true and p<q and p>q both yield false.

5.10.1.
Pointers to objects or functions of the same type (after pointer conversions) can be compared for equality. Two pointers of the same type compare equal if and only if they are both null, both point to the same function, or both represent the same address (3.9.2).

class IImpl
{
public:
    virtual bool IsEqual(IImpl const& other) const = 0; // typeid(*this) == typeid(other)
};

class SomeImpl : public IImpl
{
    bool IsEqual(SomeImpl const& other) const { ..... }
    virtual bool IsEqual(IImpl const& other) const
    {
        return IsEqual(static_cast<SomeImpl const&>(other)); // или dynamic_cast для уверенности
    }
};

class Facade
{
    IImpl* m_impl;
public:
    bool operator == (Facade const& other) const
    {
        return typeid(*m_impl) == typeid(*other.m_impl) && m_impl->IsEqual(*other.m_impl);
    }
};

template<class X> bool is(IImpl const& x) { return typeid(X) == typeid(x); }

template<class X, class Y> bool eq(IImpl const& x, IImpl const& y) { return AreEqual(static_cast<X>(x), static_cast<Y>(y)); }
// где AreEqual - перегруженная функция, реализующая то самое сравнение

bool operator == (IImpl const& a, IImpl const& b)
{
    if( is<Rectangle>(a) && is<Rectangle>(b) ) return eq<Rectangle,Rectangle>(a,b);
    
    if( is<Square>(a)    && is<Square>(b)    ) return eq<Square,Square>(a,b);
    
    if( is<Rectangle>(a) && is<Square>(b)    ) return eq<Rectangle,Square>(a,b);
    if( is<Rectangle>(b) && is<Square>(a)    ) return eq<Rectangle,Square>(b,a); // воспользовались симметрией
    
    return false;
}