Question

If I have this situation in C++ project:

• 1 base class ‘Base’ containing only pure virtual functions
• 1 class ‘Derived’, which is the only class which inherits (public) from ‘Base’

Will the compiler generate a VTABLE?

It seems there would be no need because the project only contains 1 class to which a Base* pointer could possibly point (Derived), so this could be resolved compile time for all cases.

This is interesting if you want to do dependency injection for unit testing but don’t want to incur the VTABLE lookup costs in production code.

Answer 1

I don’t have hard data, but I have good reasons to say no, it won’t turn virtual calls into static ones.

• Usually, the compiler only sees a single compilation unit. It cannot know there’s only a single subclass, because five months later you may write another subclass, compile it, get some ancient object files from the backup and link them all together.
• While link-time optimizations do see the whole picture, they usually work on a far lower-level representation of the program. Such representation allow e.g. inlining of static calls, but don’t represent inheritance information (except perhaps as optional metadata) and already have the virtual calls and vtables spelt out explicitly. I know this is the case for Clang and IIRC gcc’s whole-program optimizations also work on some low-level IR (GIMPLE?).
• Also note that with dynamic loading, you can still add more subclasses long after compilation and LTO. You may not need it, but if I was a compiler writer, I’d be weary of adding an optimization that allows people royally breaking virtual calls in very specific, hard-to-track-down circumstances.
• It’s rarely worth the trouble – if you don’t need virtual calls (e.g. because you know you won’t need any more subclasses), don’t make stuff virtual. Review your design. If you need some polymorphism but not the full power of virtual, the curiously recurring template pattern may help.