Capturing this in Lambdas

In C++, lambdas can capture the this pointer, allowing them to call member functions of the enclosing class. This can be useful when you need to create a function pointer that wraps a member function. Here's an example:

1#include <iostream>
2
3class Player {
4 public:
5  bool isAlive() const { return mAlive; }
6  void setAlive(bool Alive) { mAlive = Alive; }
7
8  template <typename Func>
9  void useHealthPotion(Func&& onHealthRestored) {
10    mAlive = true;
11    onHealthRestored();
12  }
13
14 private:
15  bool mAlive{true};
16};
17
18int main() {
19  Player MyPlayer;
20  MyPlayer.setAlive(false);
21
22  MyPlayer.useHealthPotion([&MyPlayer]() {
23    if (MyPlayer.isAlive()) {
24      std::cout << "Health restored!\n";  
25    }
26  });
27}

1Health restored!

In this example, the Player class has a useHealthPotion member function that takes a function pointer (or any callable object) as an argument. We use a lambda to create this function pointer inline.

The lambda captures MyPlayer by reference using [&MyPlayer]. This allows the lambda to access MyPlayer and call its member functions, such as isAlive().

When useHealthPotion is called, it sets the player's mAlive state to true and then invokes the provided function pointer (onHealthRestored). The lambda, which captures MyPlayer, is able to call MyPlayer.isAlive() to check the player's state and print a message.

By capturing this (explicitly or implicitly), lambdas can create function pointers that have access to the enclosing class's member functions and state. This can be a convenient way to create callback functions or hook into class functionality without having to define separate free functions.