Question

I have a C++ header declaring a class composed of pure virtual methods only. I have two DLLs using that header, (with one implementing that interface) but not linked at compile time. One DLL is loading the other one dynamically, passing a pointer of the implemented interface to the other. Are these DLL’s sharing the same virtual table structure?

Answer 1

You’re safe.

The order in which the methods appear in the vftable is determined by the base class structure, and that’s all you should care about. But this is compiler specific, so use the same compiler for generating the dll’s. Don’t rely on them being backward-compatible (or at least check the documentation).

Assume you have the following header:

//header.h

class A
{
public:
    virtual void foo() = 0;
    virtual void goo() = 0;
};

And you have B.dll with the following class:

class B : public A
{
public:
    virtual void foo() {}
    virtual void goo() {}
}

Now, in X.dll, you receive a pointer to an A that is a B object created in B.dll.

The call

void test( A* a )
{ 
   a->foo();
}

will invoke B::foo().

One neat experiment you can try is to compile B.dll with header.h and when you compile X.dll, invert the order of the methods in header.h:

//header.h

class A
{
public:
    virtual void goo() = 0;
    virtual void foo() = 0;
};

In this case, although you should never do this, the same call to test() in X.dll will probably call the method B::goo(). That is because X.dll assumes the vftable present in the header. It’s undefined behavior though; I just wrote this example to make a point.