Why Use Delegates?

Delegates solve a fundamental problem in software design: how to allow objects to communicate without creating tight coupling between them. Let's explore why this matters with a practical example.

Consider a game where we want to update the UI when a player takes damage. The direct approach might look like this:

1class Player {
2public:
3  void TakeDamage(int Damage) {
4    Health -= Damage;
5    UserInterface->UpdateHealthBar(Health);
6  }
7private:
8  UserInterface* UserInterface;
9  int Health{100};
10};

This creates several problems:

• Our Player class now needs to know about UI implementation details
• We can't easily change which UI elements respond to damage
• Testing becomes harder because we can't separate player logic from UI logic
• If we want to add new responses to damage (like sound effects), we need to modify the Player class

Using delegates solves these problems by inverting the dependency:

1class Player {
2 public:
3  using DamageDelegate = std::function<
4    void(int NewHealth)>;
5  void SetOnDamageDelegate(DamageDelegate D) {
6    OnDamageDelegate = D;
7  }
8
9  void TakeDamage(int Damage) {
10    Health -= Damage;
11    if (OnDamageDelegate) {
12      OnDamageDelegate(Health);  
13    }
14  }
15
16 private:
17  DamageDelegate OnDamageDelegate;
18  int Health{100};
19};

Now:

• Player doesn't need to know anything about UI
• We can add or remove damage responses without touching the Player class
• Different parts of our program can respond to damage in different ways
• Testing is easier because we can provide test delegates

This pattern is particularly valuable in game development where systems often need to be loosely coupled but still communicate effectively.