重载运算符 == 和多态的好习惯？

Question

Here is my goal: I have an abstract base class A implementing an operator ==, then I have several derived classes (ie B and C) that each implement an operator ==. I want that when I test b1 == b2 it call the operator defined in B, but I also want to be able to call b1 == c1 and it call the operator defined in the base class A.

Indeed, my library represent geometric object and even though b1 and c1 are not the same class they may represent the same 3D object but stored/formulated in a different manner. The operator == in the base class A is slow but test exactly if the 3D objects are equal (by disctretizing) and the operators defined in the child class are faster as they know which formulation is used and can check exactly for equality.

Here was my first try :

// Base class A
class A{

public:
  A() {}

  // ... some pure virtual methods

  virtual bool operator==(const A& other) const {
    std::cout<<" operator == in A"<<std::endl;
    // slow equality test by discretization
  }

  virtual bool operator!=(const A& other) const {
    return !(*this == other);
  }

}; // end A

// Derived class B
class B: public A{

public:
  B() {}

  // ... stuff

  virtual bool operator==(const B& other) const {
    std::cout<<" operator == in B"<<std::endl;
    // fast and exact test between two B objects
  }

  virtual bool operator!=(const B& other) const {
    return !(*this == other);
  }

}; // end B

// Derived classC
class C: public A{

public:
  C() {}

  // ... stuff

  virtual bool operator==(const C& other) const {
    std::cout<<" operator == in C"<<std::endl;
    // fast and exact test between two C objects
  }

  virtual bool operator!=(const C& other) const {
    return !(*this == other);
  }

}; // end C

This implementation worked only for test between the same objects :

B b1(...),b2(...);
C c1(...),c2(...);
b1 == b2; // OK, output " operator == in B"
c1 == c2; // OK, output " operator == in C"
b1 == c1; // do not compile : unknow conversion from C to B

So, to fix this issue I added the following methods in B and C implementation (1) :

  virtual bool operator==(const A& other) const {
    return A::operator==(other);
  }

  virtual bool operator!=(const A& other) const {
    return !(*this == other);
  }

Now, my first test code work :

b1 == c1; // OK, output " operator == in A" as expected

But, I still cannot use polymorphisme (not 100% sure it's the right term in this context) with this operators :

A* a_b1 = new B(...);
A* a_c1 = new C(...);
b1 == *a_b1; // output " operator == in A" !
c1 == *a_c1; // output " operator == in A" !

So to fix this, I changed the method added in (1) to the implementation of B and C try to cast the input of type A to the current child type. Here is the final result :

// Base class A
class A{

public:
  A() {}

  // ... some pure virtual methods

  virtual bool operator==(const A& other) const {
    std::cout<<" operator == in A"<<std::endl;
    // slow equality test by discretization
  }

  virtual bool operator!=(const A& other) const {
    return !(*this == other);
  }

}; // end A

// Derived class B
class B: public A{

public:
  B() {}

  // ... stuff

  virtual bool operator==(const B& other) const {
    std::cout<<" operator == in B"<<std::endl;
    // fast and exact test between two B objects
  }

  virtual bool operator!=(const B& other) const {
    return !(*this == other);
  }

  // CHANGED METHOD :
  virtual bool operator==(const A& other) const {
   const B* other_cast = dynamic_cast<const B*>(&other);
   if(other_cast)
     return *this == *other_cast;
   else
     return A::operator()(other);
  }

  virtual bool operator!=(const A& other) const {
    return !(*this == other);
  }

}; // end B

// Derived classC
class C: public A{

public:
  C() {}

  // ... stuff

  virtual bool operator==(const C& other) const {
    std::cout<<" operator == in C"<<std::endl;
    // fast and exact test between two C objects
  }

  virtual bool operator!=(const C& other) const {
    return !(*this == other);
  }

  // CHANGED METHOD :
  virtual bool operator==(const A& other) const {
   const C* other_cast = dynamic_cast<const C*>(&other);
   if(other_cast)
     return *this == *other_cast;
   else
     return A::operator()(other);
  }

  virtual bool operator!=(const A& other) const {
    return !(*this == other);
  }

}; // end C

So, with this code I achieved what I wanted, ie :

B b1(...),b2(...);
C c1(...),c2(...);
b1 == b2; // OK, output " operator == in B"
c1 == c2; // OK, output " operator == in C"
b1 == c1; // OK, output " operator == in A"
A* a_b1 = new B(...);
A* a_c1 = new C(...);
b1 == *a_b1; //OK, output " operator == in B" !
c1 == *a_c1; //OK, output " operator == in C" !

But I am really not sure if it's a good way to achieve that, as the need for a cast usually highlight a bad design. What are your suggestions to improve this code ?

Answer 1

As a possible way to solve your problem you couldimplement the comparison as a non-member template function, with specialization for the possible and valid combinations.

Simple (and incomplete) example:

// Base case
template<typename T, typename U>
std::enable_if_t<std::is_base_of_v<A, T> && std::is_base_of_v<A, U>, bool> operator==(T const&, U const&);
// The enable_if is to make sure only A and derivatives of it could be used

// Specialization: Compare A against A
template<>
bool operator==(A const& l, A const& r) { /* Some implementation... */ }

// Specialization: Compare B against B
template<>
bool operator==(B const& l, B const& r) { /* Some implementation... */ }

// Specialization: Compare B against A
template<>
bool operator==(B const& l, A const& r) { /* Some implementation... */ }

// Specialization: Compare B against C
template<>
bool operator==(B const& l, C const& r) { /* Some implementation... */ }

// Specialization: Compare C against C
template<>
bool operator==(C const& l, C const& r) { /* Some implementation... */ }

Only those comparisons explicitly specialized will be allowed, any other will lead to build errors. And each specialization could be implemented to perform the comparisons in the most effective way.

Yes it's a lot of seemingly duplicated code, but the specializations could call some common functions for combinations that are to be compared in the same way (for example comparing a B against C is probably the same as comparing C against B , and thus can be implemented in a shared function).