Question

I read that early C++ “compilers” actually translated the C++ code to C and used a C compiler on the backend, and that made me wonder. I’ve got enough technical knowledge to wrap my head around most of how that would work, but I can’t figure out how to do class inheritance without having language support for it.

Specifically, how do you define a class with a few fields, then a bunch of subclasses that inherit from it and each add their own new fields, and be able to pass them around interchangeably as function arguments? And especially how can you do it when C++ allows you to allocate objects on the stack, so you might not even have pointers to hide behind?

NOTE: The first couple answers I got were about polymorphism. I know all about polymorphism and virtual methods. I’ve even given a conference presentation once about the low-level details of how the virtual method table in Delphi works. What I’m wondering about is class inheritance and fields, not polymorphism.

Answer 1

In C anyway you an do it the way cfront used to do it in the early days of C++ when the C++ code was translated into C. But you need to be quite disciplined and do all the grunt work manually.

Your ‘classes’ have to be initialized using a function that performs the constructor’s work. this will include initializing a pointer to a table of polymorphic function pointers for the virtual functions. Virtual function calls have to be made through the vtbl function pointer (which will point to a structure of function pointers – one for each virtual function).

The virtual function structure for each derived calss needs to be a super-set of the one for the base class.

Some of the mechanics of this might be hidden/aided using macros.

Miro Samek’s first edition of “Practical Statecharts in C/C++” has an Appendix A – “C+ – Object Oriented Programming in C” that has such macros. It looks like this was dropped from the second edition. Probably because it’s more trouble than it’s worth. Just use C++ if you want to do this…

You should also read Lippman’s “Inside the C++ Object Model” which goes into gory details about how C++ works behind the scenes, often with snippets of how things might work in C.

---

I think I see what you’re after. Maybe.

How can something like this work:

typedef 
struct foo {
    int a;
} foo;

void doSomething( foo f);   // note: f is passed by value

typedef
struct bar {
    foo base;
    int b;
} bar;


int main() {
    bar b = { { 1 }, 2};

    doSomething( b);    // how can the compiler know to 'slice' b
                        //  down to a foo?

    return 0;
}

Well you can’t do that as simply as that without language support – you’d need to do some things manually (that’s what it means to not have language support):

    doSomething( b.base);       // this works