std::function vs Function Pointer Performance

std::function provides more flexibility than raw function pointers but comes with some overhead. Let's examine the differences and when each might be appropriate.

Raw Function Pointers

Function pointers are simple and lightweight:

• Fixed size (typically 8 bytes on 64-bit systems)
• No heap allocation
• Very fast to call (similar to regular function calls)

1class Player {
2public:
3  using FnPtr = void(*)(int NewHealth);
4
5  void SetDelegate(FnPtr Fn) {
6    OnDamage = Fn;
7  }
8
9  void TakeDamage(int Damage) {
10    Health -= Damage;
11    if (OnDamage) OnDamage(Health);
12  }
13
14private:
15  FnPtr OnDamage{nullptr};
16  int Health{100};
17};
18
19void LogHealth(int NewHealth) {
20  std::cout << "Health: " << NewHealth << '\n';
21}
22
23int main() {
24  Player P;
25  P.SetDelegate(LogHealth);
26  P.TakeDamage(30);
27}

std::function

std::function is more flexible but has overhead:

• Variable size (typically 32 bytes for the object itself)
• May require heap allocation for larger callables
• Slightly slower call time due to type erasure

1class Player {
2 public:
3  using Delegate = std::function<
4    void(int NewHealth)>;
5
6  void SetDelegate(Delegate D) {
7    OnDamage = D;  
8  }
9
10  void TakeDamage(int Damage) {
11    Health -= Damage;
12    if (OnDamage) OnDamage(Health);
13  }
14
15 private:
16  Delegate OnDamage;
17  int Health{100};
18};
19
20int main() {
21  Player P;
22
23  // Can store free functions
24  P.SetDelegate(LogHealth);
25
26  // Can store lambdas with capture
27  int LogCount{0};
28  P.SetDelegate([&LogCount](int NewHealth) {  
29    std::cout << "Health: " << NewHealth << '\n';
30    LogCount++;
31  });
32
33  P.TakeDamage(30);
34}

When to Use Each

Use raw function pointers when:

• You only need to store simple function pointers
• Performance is absolutely critical
• Memory usage must be minimized

Use std::function when:

• You need to store lambdas with captures
• You need to store member functions
• You want to store different types of callables
• The flexibility is worth the small overhead

Remember that premature optimization is the root of all evil. Start with std::function for its flexibility, and only switch to raw function pointers if profiling shows it's necessary for your specific use case.