Polymorphic implementation for == with CRTP

First and foremost, I believe that your fundamental concept is flawed. Equality has a well defined meaning between objects of the same type, or between types themselves, but not in this hybrid scenario. For instance, let's say I have a class C, which inherits from A as well as from Base<C>, how shall I compare an instance of A and an instance of C? You would normally expect them to be comparable in a polymorphic context, at least if A implements operator==, wouldn't you? But their type_info is different. You could try and work around that problem by using dynamic_cast, but then I suspect that, given A a; C c;, a == c and c == a wouldn't return the same result, which is unexpected.

I suspect it's a kind of work-around you devised because you had a lot of vaguely related objects bunched together and realized afterwards you had to discriminate between them according to their concrete type.

But it would be best to improve on your overall design (that you can submit here, by the way), rather than persisting in the original one. Because what's the limit? Why not ordering objects of different types when you're at it? A common task when you have equality-comparable objects is to remove duplicates: you'll need to sort the objects to do it efficiently, meaning you have to implement operator< as well.

If you stick to your concept, though:

• Your base class lacks a virtual destructor. Any base class that will be used as a polymorphic handle needs a virtual destructor, or it might lead to resources leak (see this).

• The virtual print function clearly isn't in the right place (there's no conceptual link between equality and printability), but I suspect it's there only for the purpose of debugging.

• The code seems to be over-engineered. The only thing your CRTP base class does is a static down-cast, which could be a nice (static polymorphism) if the base_equals method wasn't called after already having performed run-time type identification. It's simpler to directly dynamic_cast your pointers.

For instance:

class Base {
    public:
    virtual bool operator==(const Base&) =0;
    virtual ~Base() = default;
};

template <typename T>
class CRTP : public Base{
    virtual bool operator==(const Base& o) const override final {
        auto same_type = dynamic_cast<const T*>(&o);
        return same_type && static_cast<const T&>(*this) == *same_type;
    }
};

• there's a balance issue in your code, because it will accept to compare objects of different derived types not implementing the equality operator, but will refuse to compare objects of the same type if it doesn't implement it. To remedy that issue you can check through SFINAE or concepts (C++20) if equality comparison is implemented. Or you can make a different trade-off and skip the CRTP step:

For instance:

class Base {
    public:
    virtual bool operator==(const Base& o) const { return this == &o; }
    virtual ~Base() = default;
};

class A : public Base {
    public:
    int i = 4;
    virtual bool operator==(const Base& o) const override final {
        auto same_type = dynamic_cast<const A*>(&o);
        return same_type && i == same_type->i;
    }
};

class B : public Base {}; 

The downside is that you have to implement the down-casting in each derived base class, and the upside that you have a more consistent fall-back scenario for derived classes not implementing an equality operator.

I apologize if I'm misunderstanding the problem your solving. If you're merely trying to first determine if two types are subclasses of a third, would it be possible to use avoid mixing an abstract base class and CRTP in favor of an operator overload like this? If so, you can get rid of the CRTP and the AbstractBase::base_equals method.

template< typename T, typename U >
bool operator==(T&& lhs, U&& rhs) { 
  return std::addressof(std::forward< T >(lhs)) == std::addressof(std::forward< U >(rhs)) ||
         std::is_base_of< AbstractBase, T >::value && std::is_base_of< AbstractBase, U >::value;
}

In Response to Original Poster's Reply

My earlier suggestion was simply (but not clearly stated) that you might pick either dynamic polymorphism or parametric polymorphism (not both). Also, I'm checking the memory addresses of objects to as a simple check of equality (to answer part of your reply).

Below is a solution I would use (using CRTP due to the different return types of getValue(); you could use dynamic polymorphism and achieve the same using operator<<). The hiccup is that you can no longer use std::vector, since you have pointers to both BaseTemplate<A>* and BaseTemplate<B>*, so you would need a heterogenous container in your driver code (ie std::tuple or the like).

Per the requirements in your reply, type/memory/value equality are checked with the free overloaded equality operators (you may need to decay the types if const/volatile cause types that fit your definition of equality don't bind to the correct operator== overload).

#include <iostream>
#include <type_traits>

template <typename Derived> class BaseTemplate {
  std::ostream &print(std::ostream &out) const {
    return static_cast<const Derived *>(this)->print(out);
  }

public:
  const auto &getValue() const {
    return static_cast<const Derived *>(this)->getValue();
  }
  friend std::ostream &operator<<(std::ostream &out,
                                  const BaseTemplate<Derived> &rhs) {
    return out << "[" << (void *)&rhs << "] " << rhs.getValue();
  }
  auto operator*() const { return *static_cast<const Derived *>(this); }
};

class A : public BaseTemplate<A> {
  int num;

public:
  A(int i = 42) : num(i) {}
  const int &getValue() const { return num; }
  bool operator==(const A &a) const { return num == a.num; }
};

class B : public BaseTemplate<B> {
  std::string str;

public:
  B(const std::string &s = "hello") : str(s) {}
  const std::string &getValue() const { return str; }
  bool operator==(const B &b) const { return str == b.str; }
};

template <typename T, typename U> bool operator==(const T &lhs, const U &rhs) {
  return false;
}

template <typename T> bool operator==(const T &lhs, const T &rhs) {
  return std::addressof(lhs) == std::addressof(rhs) || lhs == rhs;
}