C++ Capture Lists 🎯

Welcome to our deep dive into C++ Capture Lists! In this tutorial, we'll explore how to effectively use this powerful tool in your C++ projects. Let's get started!

What are C++ Capture Lists? 📝

Capture Lists are used in C++ lambda functions to bind specific variables to the function. They allow you to access the values of variables defined outside the lambda function, making them incredibly useful in a variety of scenarios.

Creating a Simple Capture List Function 💡

Let's begin with a simple example. Here's a function that accepts a lambda function as an argument and demonstrates the use of a capture list.

cpp

#include <iostream>
#include <functional>

void printValue(int value, std::function<void(int)> function) {
    function(value);
}

int main() {
    int myNumber = 42;

    auto myLambda = [myNumber](int val) {
        std::cout << "Value of myNumber is: " << myNumber << std::endl;
        std::cout << "Value passed is: " << val << std::endl;
    };

    printValue(7, myLambda);

    return 0;
}

In this example, the lambda function myLambda captures the variable myNumber from the main function and uses it inside the lambda function. The printValue function takes a lambda function and an integer, and calls the lambda function with the provided integer.

Capture Lists Types 💡

Capture lists can capture variables by reference ([&]) or by value ([=]).

[&] captures all variables by reference. This means that any changes made inside the lambda function will be reflected in the original variables.
[=] captures all variables by value. This means that any changes made inside the lambda function will not affect the original variables.

Advanced Capture Lists 💡

Capture lists can also be customized to capture specific variables. For example:

cpp

auto myLambda = [=, &myNumber](int val) {
    std::cout << "Value of myNumber is: " << myNumber << std::endl;
    std::cout << "Value passed is: " << val << std::endl;
};

In this example, myLambda captures all variables by value except myNumber, which is captured by reference.

Putting it All Together 💡

Now that you understand the basics of C++ Capture Lists, let's put them to use in a more practical scenario.

Here's an example of a simple event listener that uses a capture list to handle events:

cpp

#include <iostream>
#include <vector>
#include <functional>

class EventManager {
public:
    void subscribe(std::function<void()> function) {
        subscribers.push_back(function);
    }

    void notify() {
        for (auto& func : subscribers) {
            func();
        }
    }

private:
    std::vector<std::function<void()>> subscribers;
};

void onEvent1() {
    std::cout << "Event 1 happened!" << std::endl;
}

void onEvent2() {
    std::cout << "Event 2 happened!" << std::endl;
}

int main() {
    EventManager eventManager;
    int count = 5;

    eventManager.subscribe([count]() {
        if (count > 0) {
            --count;
            std::cout << "Count is now: " << count << std::endl;
        } else {
            std::cout << "All events have been triggered!" << std::endl;
        }
    });

    eventManager.subscribe([&count]() {
        count += 2;
        std::cout << "Count is now: " << count << std::endl;
    });

    eventManager.notify();
    eventManager.notify();
    eventManager.notify();

    return 0;
}

In this example, we've created an EventManager class that can manage events and notify subscribers. We've also created two event handlers, onEvent1 and onEvent2, which are subscribed to the event manager. The first event handler decrements a counter, while the second event handler increments the counter by 2.

Quiz 💡

Wrapping Up 💡

Now that you've learned about C++ Capture Lists, you're one step closer to becoming a C++ master! Remember to practice and experiment with these concepts to fully understand their power.

Happy coding! 🎉💻🚀