Virtual Member Function Pointers

Yes, it is possible to create a pointer to a virtual member function in C++. However, there are important implications and behaviors to understand.

Basic Syntax

Creating a pointer to a virtual function uses the same syntax as for non-virtual functions:

1#include <iostream>
2
3class Base {
4 public:
5  virtual void foo() {
6    std::cout << "Base::foo()\n";
7  }
8};
9
10class Derived : public Base {
11 public:
12  void foo() override {
13    std::cout << "Derived::foo()\n";
14  }
15};
16
17int main() {
18  void (Base::*ptrToVirtual)() = &Base::foo;
19
20  Base b;
21  Derived d;
22
23  (b.*ptrToVirtual)();
24  (d.*ptrToVirtual)();
25}

1Base::foo()
2Derived::foo()

Late Binding Is Preserved

The key implication is that virtual function pointers still preserve late binding (dynamic dispatch).

When you call a virtual function through a pointer-to-member, the actual function called is determined by the runtime type of the object, not the type of the pointer.

Base Class Pointers

You can store a pointer to a derived class's virtual function in a base class function pointer:

1void (Base::*ptrToDerivedVirtual)() =
2  &Derived::foo;
3Base* bp = new Derived();
4
5// Outputs: Derived::foo()
6(bp->*ptrToDerivedVirtual)();

std::mem_fn() and std::function

These utilities work well with virtual functions and preserve their polymorphic behavior:

1auto virtualFn = std::mem_fn(&Base::foo);
2Base b;
3Derived d;
4virtualFn(b); // Outputs: Base::foo()
5virtualFn(d); // Outputs: Derived::foo()

Performance Considerations

Using virtual function pointers doesn't introduce additional runtime overhead compared to normal virtual function calls. The vtable lookup still occurs.

Multiple Inheritance

With multiple inheritance, you need to be careful about which base class's virtual function you're pointing to:

1#include <iostream>
2
3class A {
4 public:
5  virtual void foo() {
6    std::cout << "A::foo()\n";
7  }
8};
9class B {
10 public:
11  virtual void foo() {
12    std::cout << "B::foo()\n";
13  }
14};
15class C : public A, public B {
16 public:
17  void foo() override {
18    std::cout << "C::foo()\n";
19  }
20};
21
22int main() {
23  void (A::*ptrA)() = &A::foo;
24  void (B::*ptrB)() = &B::foo;
25
26  C c;
27  (c.*ptrA)();  // Outputs: C::foo()
28  (c.*ptrB)();  // Outputs: C::foo()
29}

1C::foo()
2C::foo()

Pure Virtual Functions

You can create pointers to pure virtual functions, but attempting to call them through a base class object will result in undefined behavior:

1#include <iostream>
2
3class Abstract {
4 public:
5  virtual void pureVirtual() = 0;
6};
7
8class Concrete : public Abstract {
9 public:
10  void pureVirtual() override {
11    std::cout << "Concrete::pureVirtual()\n";
12  }
13};
14
15int main() {
16  void (Abstract::*ptrToPureVirtual)() =
17    &Abstract::pureVirtual;
18
19  Concrete c;
20  (c.*ptrToPureVirtual)();
21
22  // Error: cannot instantiate abstract class
23  // Abstract a; 
24
25  // Undefined behavior if a existed
26  // (a.*ptrToPureVirtual)(); 
27}

1Concrete::pureVirtual()

Type Safety

While virtual function pointers preserve polymorphism, they don't provide additional type safety. It's the programmer's responsibility to ensure that the object used with the function pointer is of a compatible type.

Understanding these implications allows you to leverage virtual function pointers effectively in C++, particularly in scenarios involving plugin architectures, callback systems, or when implementing generic algorithms that need to work with polymorphic types.