VTable questions

Hey,

I was recently having a discussion with a guy who is heavily into game development, anyway we were discussing C++ in general and the subject of Vtables cropped up.

Now i didnt have a clue what a Vtable was, the name rings a bell but ive never needed to use them so havent looked into them. Anyway i went online to have a look and the information on them seemed fairly sparse or a bit too in depth.

They just look like a fancy array of function pointers, but i dont get why you would use them, the syntax looks horrible for using them, so is the performance benefit worthwhile? can anyone sum up why you would use them and a quick example of how they would acctually be used. I know this may be a pain for you so i dont mind taking a decent article instead, just something to get a grasp on them and give them a little whirl myself...

Im just unsure as to how you acctually declare them properly as the syntax just looked like normal classes with virtual functions declared, which is fine if you dont need to change your class definitions, but then i dont get how you know what function will be at what memory location...

Quote:

---

Now i didnt have a clue what a Vtable was, the name rings a bell but ive never needed to use them so havent looked into them. Anyway i went online to have a look and the information on them seemed fairly sparse or a bit too in depth.

---

Please post the reference here.

As you already known, vTable is just a array of function pointer.
For instance, base class 1, derived class 2, derived class 3 and function is display().

[1], [2], [3]
If object content not type is base class 1 then call else proceed to derived class 2 and so on.


Please correct me if i wrong.

Quote:

---

Originally Posted by Peter_APIIT

Please post the reference here.

---

google.com then type in Vtable

There were a few things that were useful, such as the wikipedia pages and general C++ pages, but they all felt a little incomplete on the subject, like they only gave you a snippit of the information.

Quote:

---

Originally Posted by Peter_APIIT

As you already known, vTable is just a array of function pointer.
For instance, base class 1, derived class 2, derived class 3 and function is display().

[1], [2], [3]
If object content not type is base class 1 then call else proceed to derived class 2 and so on.

---

Well from my limited understanding they are arrays of virtual function pointers, but i still dont get how you know what functions are at what indexes as well as how to call them correctly, wikipedia gave a decent example but then it confused me when it said you could call something another way, which looked like a normal calling convention, so if you are calling it normally why use vtables...

Quote:

---

Originally Posted by Peter_APIIT

Please correct me if i wrong.

---

I wouldnt know if you are, im the one who isnt experienced with vtables...

Basically to try and narrow things down the areas i could do with knowing a bit more on are:

- Is a Vtable created automatically from your functions? It seems like the uses are just telling the pointer to move to certain memory locations than just calling the function directly.

- How are you meant to call the functions via the Vtable, as it just looks like hacking up the pointer from my current research and would like something a bit more *solid* to look at.

- How do you know what function is where, as surely the pointers contain all available functions, not just virtual ones, so in that case how do you know which index is the correct function?

Quick Bump incase anyone has their Boffin hat on!

Grofit, the information you saw about VTable is talking about how C++ compilers IMPLEMENT virtual functions.

Writing and calling virtual functions is very easy:

Code:

---

#include <iostream>

using namespace std;

class Base
{
public:
virtual ~Base() {}

virtual void f() { cout << "I'm the base class" << endl; }
virtual void g() { cout << "Me too! I'm the base class as well" << endl; }
};

class Derived : public Base
{
public:
virtual void f() { cout << "I'm the derived class" << endl; }
virtual void g() { cout << "Me too! I'm the derived class as well" << endl; }
};

int main()
{
Derived d;
Base* b = &d;

b->f();
b->g();
}

---

:)

vtables are one way that C++ can use to implement virtual functions (and most compilers use them). Normally they are completely invisible when programming in C++, so I imagine that your friend was either talking about accessing the vtables directly or using a similar technique for quick selection of functions from an array of function pointers. This is quicker than the familiar if/else chain as the address of the function is stored in an array and is retrieved by indexing into this array. Be aware though that you may find that a switch/case construct may be just as quick, as the compiler can usually optimise it down to a array of function pointers anyway.

Thanks John,

I know how to call virtual functions, i just wanted to know how to call functions directly from the vtable rather than doing it via the normal object method.

I was just unsure if you had to do anything special to generate them, and when they were generated how you knew what function was at what index... As if you had 5 functions but only 1 is virtual surely you would have to know which 1 index out of 5 you needed. If its generated top down order in a class then i can live with that, but the more info i could get the better...

Then i was a bit unsure of how you are meant to call the functions directly through the vtable, as there was a range of examples but they were skimmed over without much depth on why you call them that way and how you are *meant* to call them using this method...

The logic i believe is that its faster for you to tell your object that it will be doing X function in the list at runtime rather than letting the compiler work out which function you should be pointing to in the derived list...

Quote:

---

Originally Posted by Grofit

I know how to call virtual functions, i just wanted to know how to call functions directly from the vtable rather than doing it via the normal object method.

---

Why would you ever want to do that? :confused:

Quote:

---

Originally Posted by Zaccheus

Why would you ever want to do that? :confused:

---

Thats what im trying to find out, he said that its well worth looking up if you are going to be doing any sort of game/console development within C/C++. If it was some normal programming grunt who told me to look at vtables i may not be so eager to find out about them, but the guy i was talking to is currently a lead developer for a prominent game developer, so if he says its worth looking into im definatly gonna try to find out as much as i can about it!

Maybe you should ask your friend why he accesses vtables directly. Maybe he is dynamically modifying them. It's a serious decision to start doing things like that as you are at the mercy of the compiler implementation.

Yeah may ask him next time i see him, i just thought i would ask incase the internet can help me find the answer myself...

I guess for consoles you will know how things will be implemented, so there may be a benefit to using it there...

Sorry to ressurect this thread, after looking over what everyone has said...

Can you acctually call the Vtable directly opposed to doing the:

myInstance->myVirtualFunction();

Wikipedia isnt that clear on how you can invoke virtual functions DIRECTLY from the vtable:

http://en.wikipedia.org/wiki/Vtable#Invocation

Im sure alot of you will still be telling me that i should never need to worry about this and that its all handled behind the scenes, but i would still like to know more about it. If anyone has the patience to give me a quick invokation example... i will even do the leg work for you:

Code:

---

#include <iostream>
using namespace std;

class A
{
        public:
                void doNothingA(){cout<<"Doing A Nothing"<<endl;}
                virtual void doStuff(){cout<<"Doing A Stuff"<<endl;}
                int intAVar;
};

class B : public A
{
        public:
                void doNothingB(){cout<<"Doing B Nothing"<<endl;}
                void doStuff(){cout<<"Doing B Stuff"<<endl;}
                int intBVar;
};

void main(void)
{
        A *a1 = new B();
        // using a1 call A::doStuff() via the Vtable
        // using a1 call B::doStuff() via the Vtable
}

---

If anyone can fill in those 2 lines i will do a little dance!

Code:

---

        a1->A::doStuff();
        a1->doStuff();

---

I feel a bit unclean posting that. It's subverting the mechanism and suggests that the design is wrong.

What is wikipedia on about when it has:

Code:

---

*((d->/*pointer to virtual method table of D (for B1)*/)[0])(d)
*((d->/*pointer to virtual method table of D (for B1)*/)[12])(d)
*((d->/*pointer to virtual method table of D (for B2)*/)[0])(d+8)

---

The 2nd example is just a direct call, although your first example works spot on!

What is the approach for direct call to VTable ?

As you might know V-table is a mechanism which is used to achieve polymorphism...and its implementation details shouldnt matter to someone using C++...but yeah its always good to know...its interesting....

So its just a array(V-table) of function pointer, one v-table for each class.
so compilers knows what all fucntions are virtual for a class, so it fills v-table with all the virtual functions.
Now lets say you derive from a class with virtual functions, it will have its own v-table (array).... so first compiler will fill v-table of derive class with fucntion ptrs of base class and change it with virtual function implemented in derive class.....
Every object of a class with atlest 1 virtual function will have vPtr member pointing to vtable for its class.
If you want to see contents on v-table, you can see it in watch window (in visual studio IDE. watch for vPtr variable)

some one asked
"Can you acctually call the Vtable directly opposed to doing the:"
note that its a array of function pointers...so i dont think you can use function pointer if you dont know the signature of tht function....Moreover i dont see any reason why anyone would need to call function using v-table...doesnt make sense...

Quote:

---

Originally Posted by Peter_APIIT

What is the approach for direct call to VTable ?

---

There is no vtable in the C++ language. The vtable is a programmer's model to help explain how virtual functions work. This is very much the same way stack and heap are used.

If you want to use a vtable, implement one in C++.

But, of course, if you really want to write helplessly compiler dependent code, you could study the compiler documentation and code output and then access the internal data structures.

Quote:

---

Originally Posted by Grofit

Sorry to ressurect this thread, after looking over what everyone has said...

Can you acctually call the Vtable directly

---

Here is a question:

If you want to do this, why did you use virtual functions to begin with? Why not just code your own calling mechanism, instead of corrupting or finagling with the proper use of virtual functions? Maybe that is the most important question to ask your friend. The mechanism of v-tables can be simulated with proper, portable, "low-level" C++ coding, instead of fooling around with true C++ virtual functions.

It's like buying a dishwashing machine, and asking "how do I wash dishes by hand in the dishwasher?". If you want to wash dishes by hand, don't use the dishwashing machine. If you want to call functions but not use the proper virtual mechanism, don't use virtual functions.

Simple.

Regards,

Paul McKenzie