Function Pointers and Virtual Functions

In C++, you can take a pointer to a virtual function, but it works a bit differently than taking a pointer to a non-virtual function.

When you take a pointer to a non-virtual member function, you get a normal function pointer that you can call directly:

1class Base {
2 public:
3  void f() {}
4};
5
6int main() {
7  void (Base::*fp)() = &Base::f;
8  Base b;
9  (b.*fp)();  
10}

However, when you take a pointer to a virtual function, you get a pointer to the virtual function table (vtable) entry for that function, not a direct function pointer. To call it, you need an object instance:

1class Base {
2 public:
3  virtual void f() {}
4};
5
6int main() {
7  void (Base::*fp)() = &Base::f;
8  Base b;
9  (b.*fp)();
10}

If you try to call the function pointer without an object instance, you'll get a compilation error.

The reason for this difference is that virtual functions are resolved dynamically based on the actual type of the object, which is not known at compile time. The vtable mechanism is used to achieve this dynamic dispatch.

When you call a virtual function through a pointer or reference to the base class, the compiler generates code to look up the function address in the vtable of the actual object at runtime. This allows the correct derived class function to be called even if the caller only knows about the base class.

So while you can take a pointer to a virtual function, it's not a regular function pointer and requires an object instance to be called. In most cases, it's simpler and safer to call virtual functions directly on objects or through pointers/references to base classes and let the language handle the dynamic dispatch.