Question

Given the following class structure:

class Base
{
    virtual void outputMessage() { cout << "Base message!"; }
};

class Derived : public Base
{
    virtual void outputMessage() { cout << "Derived message!"; }
}

.. and this code snippet:

Base baseObj;
Derived* convertedObj = (Derived*) &baseObj;
convertedObj->outputMessage();

.. the output will be “Base message!”.

Is there any way to cast or manipulate the object to make Derived’s version of the outputMessage method to be called polymorphically?

Edit: I will attempt to show the reason why I’m after this:

I am writing migration tools that hook into our main system. For this reason, I need to get access to protected member methods, or customise existing virtual methods. The former I can do by defining a derived class and casting objects to it, to call methods statically. What I can’t do is change the behaviour for methods which I do not call statically (ie methods that are called elsewhere in the codebase).

I have also tried creating objects of the derived class directly, but this causes issues in other parts of the system due to the manipulation of the objects passed through the constructor.

Answer 1

No Standard-compliant solution

What you’re trying to do isn’t possible using behaviours guaranteed by the C++ Standard.

If you really MUST do this as a short-term measure to assist your migration, don’t depend on it in production, and can adequately verify the behaviour, you could experiment as illustrated below.

Discussion of your attempt

What I’m showing is that you’re taking the wrong approach: simply casting a pointer-to-base to a pointer-to-derived doesn’t alter the object’s vtable pointer.

Deriving a plausible hack

Addressing that, the naive approach is to reconstruct the object in place as a derived object (“placement” new), but this doesn’t work either – it will reinitialise the base class members.

What you can possibly do is create a non-derived object that has no data members but the same virtual dispatch table entries (i.e. same virtual functions, same accessibility private/protected/public, same order).

More warnings and caveats

It may work (as it does on my Linux box), but use it at your own risk (I suggest not on production systems).

Further warning: this can only intercept virtual dispatch, and virtual functions can sometimes be dispatched statically when the compiler knows the types at compile time.

~/dev cat hack_vtable.cc
// change vtable of existing object to intercept virtual dispatch...

#include <iostream>

struct B
{
    virtual void f() { std::cout << "B::f()\n"; }

    std::string s_;
};

struct D : B
{
    virtual void f() { std::cout << "D::f()\n"; }
};

struct E
{
    virtual void f() { std::cout << "E::f()\n"; }
};

int main()
{
    B* p = new B();
    p->s_ = "hello";
    new (p) D();  // WARNING: reconstructs B members

    p->f();
    std::cout << '\'' << p->s_ << "'\n"; // no longer "hello"

    p->s_ = "world";
    new (p) E();
    p->f();  // correctly calls E::f()
    std::cout << '\'' << p->s_ << "'\n"; // still "world"
}

~/dev try hack_vtable   
make: `hack_vtable' is up to date.
D::f()
''
E::f()
'world'