Is it possible to change a C++ object's class after instantiation?

Question

I have a bunch of classes which all inherit the same attributes from a common base class. The base class implements some virtual functions that work in general cases, whilst each subclass re-implements those virtual functions for a variety of special cases.

Here's the situation: I want the special-ness of these sub-classed objects to be expendable. Essentially, I would like to implement an expend() function which causes an object to lose its sub-class identity and revert to being a base-class instance with the general-case behaviours implemented in the base class.

I should note that the derived classes don't introduce any additional variables, so both the base and derived classes should be the same size in memory.

I'm open to destroying the old object and creating a new one, as long as I can create the new object at the same memory address, so existing pointers aren't broken.

The following attempt doesn't work, and produces some seemingly unexpected behaviour. What am I missing here?

#include <iostream>  class Base { public:     virtual void whoami() {          std::cout << "I am Base\n";      } };  class Derived : public Base { public:     void whoami() {         std::cout << "I am Derived\n";     } };  Base* object;  int main() {     object = new Derived; //assign a new Derived class instance     object->whoami(); //this prints "I am Derived"      Base baseObject;     *object = baseObject; //reassign existing object to a different type     object->whoami(); //but it *STILL* prints "I am Derived" (!)      return 0; } 

Answer 1

You can at the cost of breaking good practices and maintaining unsafe code. Other answers will provide you with nasty tricks to achieve this.

I dont like answers that just says "you should not do that", but I would like to suggest there probably is a better way to achieve the result you seek for.

The strategy pattern as suggested in a comment by @manni66 is a good one.

You should also think about data oriented design, since a class hierarchy does not look like a wise choice in your case.

Answer 2

Yes and no. A C++ class defines the type of a memory region that is an object. Once the memory region has been instantiated, its type is set. You can try to work around the type system sure, but the compiler won't let you get away with it. Sooner or later it will shoot you in the foot, because the compiler made an assumption about types that you violated, and there is no way to stop the compiler from making such assumption in a portable fashion.

However there is a design pattern for this: It's "State". You extract what changes into it's own class hierarchy, with its own base class, and you have your objects store a pointer to the abstract state base of this new hierarchy. You can then swap those to your hearts content.