How do member function pointers impact performance compared to virtual functions or `std::function`? Are there memory overhead considerations?

Question

Ryan McCombe · Accepted Answer

Let's examine the performance characteristics of member function pointers compared to alternatives:

Memory Overhead

Here's a comparison of memory sizes:

1#include <functional>
2#include <iostream>
3
4class Character {
5public:
6  virtual void Attack() {}
7  void RegularAttack() {}
8};
9
10int main() {
11  // Size comparisons
12  std::cout << "Regular function ptr: " <<
13    sizeof(&Character::RegularAttack)
14    << " bytes\n";
15
16  std::cout << "Virtual class size: " << sizeof(
17    Character) << " bytes\n";
18
19  std::cout << "std::function size: " << sizeof(
20      std::function<void()>)
21    << " bytes\n";
22}

1Regular function ptr: 8 bytes
2Virtual class size: 8 bytes
3std::function size: 32 bytes

Performance Comparison

Here's a benchmark comparing different calling mechanisms:

1#include <chrono>
2#include <functional>
3#include <iostream>
4
5class Character {
6public:
7  virtual void VirtualAttack() { count++; }
8  void DirectAttack() { count++; }
9  int count{0};
10};
11
12void BenchmarkCalls(const char* Name, auto Func,
13                    int Iterations) {
14  auto start =
15    std::chrono::high_resolution_clock::now();
16
17  for (int i = 0; i < Iterations; i++) {
18    Func();
19  }
20
21  auto end =
22    std::chrono::high_resolution_clock::now();
23  auto duration =
24    std::chrono::duration_cast<
25      std::chrono::microseconds>(end - start);
26
27  std::cout << Name << ": " << duration.count()
28    << "us\n";
29}
30
31int main() {
32  Character c;
33  void (Character::*memPtr)() = &
34    Character::DirectAttack;
35  std::function<void()> func = [&](){
36    c.DirectAttack();
37  };
38
39  const int iterations = 1000000;
40
41  // Direct call
42  BenchmarkCalls(
43    "Direct", [&](){ c.DirectAttack(); },
44    iterations);
45
46  // Member function pointer
47  BenchmarkCalls(
48    "Member Ptr", [&](){ (c.*memPtr)(); },
49    iterations);
50
51  // Virtual function
52  BenchmarkCalls(
53    "Virtual", [&](){ c.VirtualAttack(); },
54    iterations);
55
56  // std::function
57  BenchmarkCalls(
58    "std::function", [&](){ func(); },
59    iterations);
60}

1Direct: 3298us
2Member Ptr: 3605us
3Virtual: 3808us
4std::function: 11404us

Key performance considerations:

Direct function calls are fastest but least flexible
Member function pointers have minimal overhead
Virtual functions have vtable lookup overhead
std::function has the most overhead but maximum flexibility

Memory considerations:

Regular member function pointers: typically 8-16 bytes
Virtual functions: add vtable pointer (usually 8 bytes) per object
std::function: larger size for type erasure (typically 32+ bytes)

When to use each:

Use direct calls when flexibility isn't needed
Use member function pointers for runtime flexibility with good performance
Use virtual functions for type-based polymorphism
Use std::function when maximum flexibility is needed

The performance impact is usually negligible for most applications, but can matter in performance-critical code paths or when dealing with millions of calls per frame.

Pointers to Members

Member Function Pointer Performance

Memory Overhead

Performance Comparison

Pointers to Members

Professional C++

Questions & Answers