If classes with virtual functions are implemented with vtables, how is a class with no virtual functions implemented?

Question

In particular, wouldn't there have to be some kind of function pointer in place anyway?

Answer 1

I think that the phrase "classes with virtual functions are implemented with vtables" is misleading you.

The phrase makes it sound like classes with virtual functions are implemented "in way A" and classes without virtual functions are implemented "in way B".

In reality, classes with virtual functions, in addition to being implemented as classes are, they also have a vtable. Another way to see it is that "'vtables' implement the 'virtual function' part of a class".

More details on how they both work:

All classes (with virtual or non-virtual methods) are structs. The only difference between a struct and a class in C++ is that, by default, members are public in structs and private in classes. Because of that, I'll use the term class here to refer to both structs and classes. Remember, they are almost synonyms!

Data Members

Classes are (as are structs) just blocks of contiguous memory where each member is stored in sequence. Note that some times there will be gaps between members for CPU architectural reasons, so the block can be larger than the sum of its parts.

Methods

Methods or "member functions" are an illusion. In reality, there is no such thing as a "member function". A function is always just a sequence of machine code instructions stored somewhere in memory. To make a call, the processor jumps to that position of memory and starts executing. You could say that all methods and functions are 'global', and any indication of the contrary is a convenient illusion enforced by the compiler.

Obviously, a method acts like it belongs to a specific object, so clearly there is more going on. To tie a particular call of a method (a function) to a specific object, every member method has a hidden argument that is a pointer to the object in question. The member is hidden in that you don't add it to your C++ code yourself, but there is nothing magical about it -- it's very real. When you say this:

void CMyThingy::DoSomething(int arg);
{
    // do something
}

The compiler really does this:

void CMyThingy_DoSomething(CMyThingy* this, int arg)
{
    /do something
}

Finally, when you write this:

myObj.doSomething(aValue);

the compiler says:

CMyThingy_DoSomething(&myObj, aValue);

No need for function pointers anywhere! The compiler knows already which method you are calling so it calls it directly.

Static methods are even simpler. They don't have a this pointer, so they are implemented exactly as you write them.

That's is! The rest is just convenient syntax sugaring: The compiler knows which class a method belongs to, so it makes sure it doesn't let you call the function without specifying which one. It also uses that knowledge to translates myItem to this->myItem when it's unambiguous to do so.

(yeah, that's right: member access in a method is always done indirectly via a pointer, even if you don't see one)

(Edit: Removed last sentence and posted separately so it can be criticized separately)