Member Function Pointers vs Virtual Functions

Member function pointers and virtual functions serve different purposes when it comes to runtime behavior modification. Here's why you might choose one over the other:

Virtual functions are best when you have a fixed set of behaviors that vary based on the type of object:

1class Character {
2public:
3  virtual void Attack() {
4    std::cout << "Basic attack\n";
5  }
6};
7
8class Warrior : public Character {
9public:
10  void Attack() override {
11    std::cout << "Sword attack\n";
12  }
13};

Member function pointers are more flexible when you need to:

• Change behavior without inheritance
• Swap behaviors at runtime
• Store multiple behaviors per object
• Configure behavior through data rather than code

Here's an example:

1#include <iostream>
2
3class Character {
4public:
5  using AttackFunc = void (Character::*)();
6
7  void SetAttack(AttackFunc NewAttack) {
8    CurrentAttack = NewAttack;
9  }
10
11  void ExecuteAttack() {
12    (this->*CurrentAttack)();
13  }
14
15  void SlashAttack() {
16    std::cout << "Slash attack!\n";
17  }
18
19  void FireballAttack() {
20    std::cout << "Fireball attack!\n";
21  }
22
23private:
24  AttackFunc CurrentAttack{
25    &Character::SlashAttack};
26};
27
28int main() {
29  Character player;
30
31  player.ExecuteAttack();
32  player.SetAttack(&Character::FireballAttack);
33  player.ExecuteAttack();
34}

1Slash attack!
2Fireball attack!

The key differences are:

• Virtual functions are resolved through the vtable at runtime based on the actual type
• Member function pointers can be changed dynamically for any instance
• Virtual functions require inheritance hierarchy
• Member function pointers work with any compatible function signature

Choose virtual functions when behavior is tied to type hierarchy, and member function pointers when you need more dynamic behavior switching or configuration-based behavior selection.