Derived class with extra private attributes

Question

I want to implement some hierarchy of classes with polymorphism and I can't make it to work. I have two problems:

1. The Derived class has extra private variables
2. The methods of the derived class take as argument an object of the derived class and return an object of the derived class.

I can make this code work, but in a non-polymorphic way. This is the simplified version:

class Base
{
protected:
    int mInt;
public: 
    Base(int iValue) : mInt(iValue) {}
    virtual Base operator+(const Base otherBase)
    {
        Base result( otherBase.mInt + mInt);
        return result;
    }

};

class Derived : public Base
{
private:
    double mDouble;
public:
    Derived(int iValue, double dValue) : Base(iValue) 
   {
        mDouble = dValue;
   }
   Derived operator+(const Derived otherDerived)
   {
        Derived result(otherDerived.mInt + mInt,
                       otherDerived.mDouble + mDouble);
        return result;
   }

};

int main()
{

    Derived DobjectA(2,6.3);
    Derived DobjectB(5,3.1);
    Base* pBaseA = &DobjectA;
    Base* pBaseB = &DobjectB;
    // This does not work
    Derived DobjectC = (*pBaseA)+(*pBaseB);

}

How can I design the classes to make this work?

Answer 1

The key here is to hide the type of actual object behind the scenes, such that it can be operated on in a meaningful way without knowin the actual type.

We need some way to identify what type of "thing" we actually have:

enum ThingType { TypeA, TypeB } ;

We need a class that is an interface:

class ThingInterface
{
public:
   /* Type of the object */
   virtual ThingType Type() = 0;
   /* Make a copy of ourselves */
   virtual ThingInterface* Clone() = 0;
   /* Add rhs to this */
   virtual void Add(ThingInterface *rhs) = 0;
   virtual ~ThingInterface();
};

Then we need a class that supports our actual operations:

class Thing
{
public:
   /* Create empty object */
   Thing(ThingType type) { ... }
   /* Create copy of existing object */
   Thing(ThingInterface* rhs)
   {
       pImpl = rhs->Clone();
   }

   Thing operator+(const Thing& rhs)
   {
       Thing result(pImpl);
       result.pImpl->Add(rhs.pImpl);
       return result;
   }
private:
   ThingInterface *pImpl;
};

And now we can implement some class to do the different types of thing:

class ThingTypeA: public ThingInterface
{
public:
    ThingTypeA() { ... };
    ThingType Type() { return TypeA; }
    void Clone(ThingInterface *rhs) { ... }
    void Add(ThingInterface *rhs) { ... }
};


class ThingTypeB: public ThingInterface
{
public:
    ThingTypeA() { ... };
    ThingType Type() { return TypeB; }
    void Clone(ThingInterface *rhs) { ... }
    void Add(ThingInterface *rhs) { ... }
};

Obviously, for a matrix implementation, you would need to have some general purpose "get me content of cell X, Y" that is implemented in both ThingTypeA and ThingTypeB - and maybe also something more clever when it comes to figuring out what type the result matrix should be for TypeA + TypeB, etc.

Answer 2

To make the problem line work, you may use a dynamic cast:

Derived DobjectC = *(dynamic_cast<Derived*>(pBaseA)) + *(dynamic_cast<Derived*>(pBaseB));