CODEWITHSUNDEEP
c++
user649558
user649558

Reputation: 57

How to implement virtual table in c++

Virtual table is arrary of function pointers. How can i implement it as every function has different signature ?

Upvotes: 0

Views: 1067

Answers (3)

JoeG
JoeG

Reputation: 13182

If you know every function at compile time, then you could use a struct of differently typed function pointers (however, if you know every function at compile time, why wouldn't you just use a class with virtual methods?).

If you want to do this at runtime, then an array of void* would probably suffice. You'd need to cast the pointers in when you store them and out (to the correct type) again before you call them. Of course, you'll need to keep track of the function types (including calling convention) somewhere else.

Without knowing what you're planning to do with this it's very difficult to give a more useful answer.

There are valid reasons for implementing vtables in code. They're an implementation detail though, so you'll need to be targeting a known ABI rather than just 'C++'. The only time I've done this was an experiment to dynamically create new COM classes at runtime (the ABI expected of a COM object is a pointer to a vtable that contains functions following the __stdcall calling convention where the first 3 functions implement the IUnknown interface).

Upvotes: 0

Mike Seymour
Mike Seymour

Reputation: 254431

You don't implement it.

The compiler generates it (or something with equivalent functionality), and it's not constrained by the type system so it can simply store the function addresses and generate whatever code is needed to call them correctly.

You can implement something vaguely similar using a struct containing different types of function pointer, rather than an array. That's quite a common way of implementing dynamic polymorphism in C; for example, the Linux kernel provides polymorphic behaviour for file-like objects by defining an interface along the lines of:

struct fileops {
    int (*fo_read)  (struct file *fp, ...);
    int (*fo_write) (struct file *fp, ...);
    // and so on
};

Upvotes: 4

ecatmur
ecatmur

Reputation: 157334

If functions in a virtual table have different signatures, you'll have to implement it as a structure type containing members with heterogeneous types.

Alternately, if you have other information telling you what the signatures are, you can cast a function pointer to another function pointer type, as long as you cast it back to the correct type before calling it.

Upvotes: 0

Related Questions