Base class pointer to Derived class pointer using the already allocated memory

Question

Take two classes that both can only be created by new. One class is the base and the other is a derivative. The derived class only adds methods.

class Base
{};

class Derived : public Base
{};

Base * b = new Base{}
Derived * d = covert( b );

// - or -

Base * b = new Base{};
convert( b ); // converts Base to Derived
Derived * d = dynamic_cast<Derived *>(b);

What I want to do is take the Base class data that has been allocated and extend/wrap with the derivative via some method or function, convert.

Update: Building for embedded systems memory is scarce, so I am doing everything I can to reduce that amount of memory allocation. I was just wondering if there was a way to just sort of extend the base class already allocated memory and wrap it with the derivative.

More Updates: Although the embedded system is ARM and I am currently using LLVM compiler this might not be true in the future. So a standard compliant way is preferred.

Answer 1

Promoting classes is not possible in C++. What you might want to do is - like you said - wrap Base in Derived:

class BaseInterface { ... };

class DerivedInterface: public BaseInterface { ... };

class Base: public BaseInterface { ... };

class Derived: public DerivedInterface {
private:
  Base* base;
public:
  Derived(Base* useBase): base(useBase) {}
  ~Derived() { delete base; }
  // implement using base
};

And use it like that:

Base* object = new Base(...);
// use object with base functionality
object = new Derived(object);
// use object with derived functionality
delete object; // free both base and derived memory

Answer 2

If I understand correctly your question one possible solution is to use aggregation instead of inheritance.

class Base
{/*has only the data*/}

class Derived 
{
    Base &base;
    Derived(Base &b) : base(b) {}
    //now methods from derived will use the data members from instance passed in constructor
    //if is possible the Derived needs to be a friend class of Base in case there are no getter for all members
}

Instead of reference we can use a smart pointer if necessary. This way you avoid the cast by constructing a new Derived object which uses the data from the a Base object.

Answer 3

The derived class only adds methods.

Then there is no point to that class. At all.

You can use deriving to:

• override virtual methods (and thus customize behaviors) => Good
• extend the data of the base class => Bad, code reuse should use composition, still it works

In your particular case ? It's just useless. It does not bring anything to the table. If you wish to add new functionalities to your base class, then implement free functions. And as a bonus, getting rid of the derived class, you'll also get rid of the need to cast.

Answer 4

A potential option comes about thanks to C++11

class Base
{
  pubilc:
    Data data;

    Base( Base && base ) : data( std::move( base.data ) ) {} 
};

class Derived : public Base
{
  pubilc:
    static Derived * convert( Base *& base )
    {
        Derived * d = new Derived{ std::move( *base ) };
        delete base;

        base = d;
        return d;
    }
 };

Although it is not what I hoped for memory-wise it is only a small hit, as far as I am aware. By using the move construct, the only overhead is the creation of a new Derived object before deleting the old Base object.

There should be a check before anything is done, but this will do for now.

Answer 5

You could add a helper class which is a friend of the base class, and add extra functions to that, e.g.

class Base 
{
   friend class BaseHelper;
   // ....
};
class BaseHelper
{
    public:
    // all functions can access data into Base objects:
    void f(const Base& b) const; // can only read data in b, not change it
    void g(Base& b); // can change data in b
}

Answer 6

Derived *d =static_cast<Derived *>(b); //? :-/

Here is one explanation

Another explanation

Much more detailed explanation of what's happening under the hood

UPDATE:

Stack Overflow - Downcasting using the static_cast in c++

Downcasting in C++ using static_cast

SPECIFICATION:

An rvalue of type “pointer to cv1 B”, where B is a class type, can be converted to an rvalue of type “pointer to cv2 D”, where D is a class derived (clause 10) from B, if a valid standard conversion from “pointer to D” to “pointer to B” exists (4.10), cv2 is the same cvqualification as, or greater cvqualification than, cv1, and B is not a virtual base class of D. The null pointer value (4.10) is converted to the null pointer value of the destination type. If the rvalue of type “pointer to cv1 B” points to a B that is actually a subobject of an object of type D, the resulting pointer points to the enclosing object of type D. Otherwise, the result of the cast is undefined.

FOR LLVM ONLY:

http://llvm.org/docs/HowToSetUpLLVMStyleRTTI.html - ALLOWS DOWNCASTING(is not undefined behavior, since it doesn't use C++ RTTI).

There is no standard-compliant way of downcasting:

class Parent{
    public: void gotoWork(){ cout << doWork(); }
};

class Child: public Parent{
     public: void gotoSchool(){ cout << attendClasses();}
};

Parent *p = new Parent();
Child *ch = static_cast<Child*> p;
//now child has to go work? :-(

EDIT

Apart from all other ways, why not put two objects? one of type "Base" and another of type "Derived" into a UNION?

PS: Its language-specification conformant.

Answer 7

Looking through the many answers that I have, the common consensus is that I should do what I said and actually wrap my Base class within the Derived class. The reason I was not doing this is I would lose a particular behaviour you get with inheritance. This behaviour is setting a pointer of the Derived class to a pointer of type Base, which will happen after I did some sort of conversion that will make the Base class transform into the Derived class.

A did stumble on a solution of my own - although apparently it may not compile - and have had many other good ideas as well. In the end, I was a bit slow to realise that because, for my case, my Derived class does not override any virtual methods there was no benefit of using inheritance. The best way is indeed to to use composition.

class Base
{
    // some nice implementation
};

class Derived
{
  public:
    Derived( Base && base )
    {
        this->_base = base;
    }

    Base & base()
    {
        return _base;
    }

  private:
    Base _base;
};