将代码作为参数传递（C ++）

Question

How would I go about passing a code block to a function in C++. In C# I can do something like this:

void Example(Action action)
{
    action();
}

Example(() => {
    //do something
});

All help and tips are greatly appreciated.

Answer 1

Here is a simple example to get started with...

void Example(void (*x)(void))
{
    x();
}

and the call would be...

Example([] { cout << "do something\n"; });

This is very similar to your C# example. And there are better, more versatile ways of doing this as the comments suggest. If you had wanted to return a value and take a parameter you could do something like this...

int Example2(int (*y)(int i), int p)
{
    return y(p);
}
// ...
auto ret = Example2([](int p) -> int { cout << p << "\n"; return p; }, 2);

This would be similar to the C# version as follows

int Example2(Func<int,int> y, int p)
{
    return y(p);
}
// ...
var ret = Example2((p) => { /*etc*/ return p; }, 2);

Answer 2

C++11 equivalent would be:

void Example(const std::function<void()>& action)
{
    // always good to make sure that action has a valid target
    if(action != nullptr)
        action();
}

Example([] {
    //do something
});

Answer 3

std::function<Result(Param1, Param2, ...)> is a decent default, but you have a few options:

1. Declare an auxiliary function and pass a pointer to it. This was the only way to go about things in C, and a conventional way to do it in C++98.

    void example(void (*action)()) { action(); } void example_action() { std::cout << "action\\n"; } example(example_action); 

2. Accept a function pointer, and pass a lambda that captures no variables. Lambdas are available in C++11 and later.

    void example(void (*action)()) { action(); } example([]() { std::cout << "action\\n"; }); 

3. Accept a callable template type parameter (one with operator() defined), and pass a lambda that may capture variables, or any other callable object (“functor”).

    template<class F> void example(F action) { action(); } int x = 4; example([x]() { std::cout << "action (" << x << ")\\n"; }); struct example_action { void operator()() { std::cout << "action\\n"; } }; example(example_action()); 

4. Accept a std::function object, and pass a lambda that may capture variables.

    void example(std::function<void()> action) { action(); } int x = 4; example([x]() { std::cout << "action (" << x << ")\\n"; }); 

5. Declare an auxiliary function and take pointer to it at compile time.

    template<void (*action)()> void example() { action(); } example<example_action>(); 

Like any template, #3 will generate a specialisation of example for every action type with which you call it, so it may increase your binary size, but it has no runtime overhead. #4 will allocate space for the closure at runtime, but will only generate one definition of example in the binary. #5 is rarer, but it allows the passed-in function to benefit from optimisations such as inlining.

Answer 4

Use std::function<void()> instead of Action and the C++ syntax for lambda functions:

void Example(std::function<void()> action)
{
    action();
}

Example([]() {
    //do something
});

std::function , in comparison to @Les's solution with function pointers, allows you to pass lambdas which capture context and in general any other kind of callable objects.