C++ Trouble with operator code inheritage: am I require to copy same code for all derived classes?

Question

I'd like to write a group of class D_I (aka I=1,2,... just I mean '_I' to be class proper name, not integer) which handle some (boolean, for example) operations F with same meaning for all classes. But also I want to operate with "sums" of object of such classes, different classes of the group might be "added" together. Mentioned operation of sum of such object depends on corresponding operation of added objects.

That's why I'm going to create common Base class B to handle operation of "summing":

class B
  {public:
      B (): LEFT(NULL), RIGHT(NULL) {};
      B (const SpBrd& S);
      B (const B& A, const B B); 
      ~B ();
           {if (LEFT != NULL) delete LEFT; // NULL if it is default B or D_I
            if (RIGHT != NULL) delete RIGHT; // NULL if it is default B or D_I
           }
      B operator + (const B& S) const;
      bool F(const Point& P) const;
           {bool b = aF(P);
            if (LEFT != NULL) b = b && LEFT->F(P);  // this is how F depends 
            if (RIGHT != NULL) b = b && RIGHT->F(P);  // of added classes
           }
   protected:
      virtual bool aF(const Point& P) const {return true;}; // Default!
      B* LEFT; // Pointer to left operand of "sum" 
      B* RIGHT; // Pointer to right operand of "sum" 
         // (since it might point to D_i class too as well)
  };

so this way derived class D is easy to write since it should only handle it's constructor and aF:

class D_I: public B
   {public:
       D() {...};
    protected:
       virtual bool aF (const Point& P) const
           {// return something here
           }
   };

The problem is: HOW TO WRITE operator + and copy constructor of class B:

   B:B (const B& S)
       {if (S.LEFT != NULL) LEFT = new B (S.LEFT)
        if (S.RIGHT != NULL) RIGHT = new B (S.RIGHT)             
       };
   B B:operator + (const B& S) const
       {SpBrd S;
        S.LEFT = new B (*this);
        S.RIGHT = new B (S);
       };

would not produce proper result because 'new B ... ' should be substituted to corresponding 'new D_I ... ' if either 'this', 'S' in in 'operator +' or 'S.LEFT' or 'S.RIGHT' in copy constructor are refers not to object of class B exactly but object of one of class D_I.

So, I can't find a way to make B::operator+ know what type sources of sum has since there might be large amount of D_I and they will be added from time to time. What should I do to write this all properly?

I can't write pars of D_I operator+ (D_J) and D_I::D_I(const D_J) for all pairs of (D_I,D_J), it is not fair!

(This would represent something like borders (surface) in space. Function F represent to be inside the border -- i.e. to check if the point is inside a space body. But bodies inside border I want to operate might be intersection (operator+) of space bodies inside other two borders. Examples: intersection of two sphere borders -- inner and outer zones -- produces spherical shell aka 3D ring; might also want to review intersection spherical border with radius R and solid angle of 10*10 degrees around pole and so on.)

Answer 1

It's a little hard to follow exactly what you are trying to do (what is SpBrd?) but you might consider making a new virtual function like this:

class B
{
    ...
    virtual B *Clone() const { return new B(*this); }
    ...
};
class D: public B
{
    ...
    virtual D *Clone() const { return new D(*this); }
    ...
};

which can then be used like this:

S.LEFT = this->Clone();
S.RIGHT = S.Clone();

Answer 2

Your question is confusing, and I'm feeling rushed here, but I will say this.

Typically operators are declared outside a class as non-member functions and use member functions to accomplish their goal. This is so that both arguments to the operator can participate equally in overload resolution.

In this case it looks like you're trying to create some sort of parse tree based on C++ operators. In this case, code like this might be what you're looking for:

const B operator +(const B &a, const B &b)
{
    return B(a, b);
}

Note that this will work even if something derived from B is either operand. And if I'm right about what you're doing, you will likely have a special node type for two things added to eachother, and operator + can return that.

---

Now that I see your clarified version, here is a different answer.

First, I question your use of operator + in this way. operator overloading often leads to surprises for people using your class, and unless your use of operator + behaves a lot like people expect operator + to behave in general it will cause more problems that it solves.

But your actual question seems to revolve around creating copies of objects of unknown type without lots of repetitive code. When I see repetitive code, I tend to think templates. Here is some sample code that's probably a little more complex than you need that uses templates and I think solves your problem.

#include <memory>
#include <iostream>

template <class BaseType, class DerivedType>
class Cloneable {
 public:
   virtual ~Cloneable() {}

   ::std::auto_ptr<DerivedType> clone() const {
      return ::std::auto_ptr<DerivedType>(static_cast<DerivedType *>(i_clone()));
   }

 protected:
   virtual BaseType *i_clone() const {
      return new DerivedType(dynamic_cast<const DerivedType &>(*this));
   }
};

class A : public Cloneable<A, A> {
 public:
   A() {}
   A(const A &b) {
      const void * const voidb = &b;
      const void * const voidme = this;
      ::std::cerr << "Creating a copy of the A at " << voidb << " and this new copy will reside at " << voidme << "\n";
   };
   virtual ~A() {
      const void * const voidme = this;
      ::std::cerr << "Destroying the A at " << voidme << "\n";
   }
};

template <class Derived>
class B : public A, public Cloneable<A, Derived> {
 public:
   B() {}
   B(const B &b) {
      const void * const voidb = &b;
      const void * const voidme = this;
      ::std::cerr << "Creating a copy of the B at " << voidb << " and this new copy will reside at " << voidme << "\n";
   };
   virtual ~B() {
      const void * const voidme = this;
      ::std::cerr << "Destroying the B at " << voidme << "\n";
   }
   // Make sure clone can be mentioned in derived classes with no ambiguity
   using Cloneable<A, Derived>::clone;

 protected:
   // Force dominance rules to choose the correct i_clone virtual function.
   virtual A *i_clone() const {
      return Cloneable<A, Derived>::i_clone();
   }
};

class C : public B<C> {
 public:
   C() {}
   C(const C &b) {
      const void * const voidb = &b;
      const void * const voidme = this;
      ::std::cerr << "Creating a copy of the C at " << voidb << " and this new copy will reside at " << voidme << "\n";
   };
   virtual ~C() {
      const void * const voidme = this;
      ::std::cerr << "Destroying the C at " << voidme << "\n";
   }
};

class D : public B<D> {
 public:
   D() {}
   D(const D &b) {
      const void * const voidb = &b;
      const void * const voidme = this;
      ::std::cerr << "Creating a copy of the D at " << voidb << " and this new copy will reside at " << voidme << "\n";
   };
   virtual ~D() {
      const void * const voidme = this;
      ::std::cerr << "Destroying the D at " << voidme << "\n";
   }
};

int main(int argc, const char *argv[])
{
   C c;
   D d;
   ::std::auto_ptr<A> cptr(c.clone());
   ::std::auto_ptr<A> dptr(d.clone());
   cptr = dptr->clone();
   return 0;
}

I made the i_clone and clone methods so that each class would end up with a version of clone that returned a pointer to the class' own type. I also have to have the using declaration in template class B to make sure there is no ambiguity in which clone is going to be called in derived classes.

Notice how classes C and D contain no repetitive code relating to creating clones of themselves.

While a didn't know it at the time, this appears to be yet another re-invention of The Curiously Recurring Template idiom as applied to polymorphic copy construction.