Invoking Multiple std::function Objects

To store and invoke multiple std::function objects, you can use a container such as std::vector or std::list. Here's an example of how you can store and invoke multiple std::function objects using a std::vector:

1#include <functional>
2#include <iostream>
3#include <vector>
4
5void Function1() {
6  std::cout << "Function1 called\n";
7}
8
9void Function2(int x) {
10  std::cout << "Function2 called with: "
11    << x << "\n";
12}
13
14struct Functor {
15  void operator()(const std::string& str) {
16    std::cout << "Functor called with: "
17      << str << "\n";
18  }
19};
20
21int main() {
22  std::vector<std::function<void()>> Callables;
23
24  Callables.emplace_back(Function1);
25  Callables.emplace_back(std::bind(Function2, 42));
26  Callables.emplace_back([] {
27    std::cout << "Lambda called\n"; });
28
29  Functor functor;
30  Callables.emplace_back(
31    std::bind(functor, "Hello"));
32
33  for (const auto& Callable : Callables) {
34    Callable();  
35  }
36}

1Function1 called
2Function2 called with: 42
3Lambda called
4Functor called with: Hello

In this example, we create a std::vector named Callables that stores std::function<void()> objects, i.e., callables that take no arguments and return void.

We then use emplace_back to add various callables to the vector:

1. A plain function Function1.
2. A std::bind expression that binds Function2 with the argument 42.
3. A lambda expression that prints a message.
4. A std::bind expression that binds the operator() of a Functor object with the argument "Hello".

Finally, we use a range-based for loop to iterate over the Callables vector and invoke each std::function object using the Callable() syntax.

Note that we used std::bind to adapt callables with different signatures (Function2 and Functor) to the signature expected by the std::function<void()>. std::bind creates a new callable that binds the arguments to the original callable, allowing it to be invoked with the expected signature.

This technique allows you to store and invoke a heterogeneous collection of callables, providing a flexible way to manage and execute multiple std::function objects.