To master C's std::function and std::bind, the key is to understand its core uses and use them reasonably. 1. std::function is used to uniformly store various callable objects, such as ordinary functions, lambda expressions or functions that bind parameters, and can be loaded as long as the signature is consistent; 2. std::bind is used to fix parameters or adjust the call order, and reserve subsequent parameter positions through placeholders \_1 and \_2; 3. The combination of the two can be used in event callbacks, task queues and other scenarios to improve interface flexibility; 4. When using it, you need to pay attention to the clear object life cycle and parameter order and avoid excessive complexity, and give priority to lambda to keep the code concise.

If you want to use C's std::function and std::bind clearly, it is actually not that mysterious. Their core function is to help you "wrap" functions, member functions, and calls with parameters, and unify them into an object that can be flexibly passed and called. Let’s start with a few actual situations and see how to use them.

How to store various callable objects with std::function ?

std::function is like a general "function box". It can be installed no matter whether you are a normal function, a lambda expression, or a function with parameters bound. for example:

 #include <functional>
#include <iostream>

void hello() {
    std::cout << "Hello, world!" << std::endl;
}

int main() {
    std::function<void()> f = hello;
    f(); // Output Hello, world!
}

You can also assign a lambda to it:

 std::function<int(int, int)> add = [](int a, int b) {
    return ab;
};
std::cout << add(3, 4) << std::endl; // Output 7

The key point is: as long as the signature matches (the return type and parameter list are the same), std::function can be installed.

How to use std::bind to fix parameters or adjust the order?

Sometimes you want to call a function, but its parameter order is not very appropriate, or you want to fix some parameters in advance. At this time, you can use std::bind to "preset" some content.

For example:

 #include <functional>
#include <iostream>

void print_sum(int a, int b) {
    std::cout << ab << std::endl;
}

int main() {
    auto f = std::bind(print_sum, 2, 3);
    f(); // Output 5
}

In the example above, we fixed both parameters. If you want to fix one of them and leave a subsequent pass, you can use the placeholder _1 (defined in std::placeholders ):

 auto f = std::bind(print_sum, 10, std::placeholders::_1);
f(5); // Output 15

A few points to note:

• _1 is the position of the first parameter, _2 is the second, and so on.
• If you are bound to a member function, remember to pass this or object pointer as the first parameter.

Use std::bind and std::function more flexible

These two are particularly suitable for event callbacks and task queues, where delayed execution or unified interface is required. for example:

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

void call_later(std::function<void()> cb) {
    cb();
}

struct Foo {
    void bar(int x) {
        std::cout << "bar called with " << x << std::endl;
    }
};

int main() {
    Foo foo;
    auto cb = std::bind(&Foo::bar, &foo, 42);
    call_later(cb); // Output bar called with 42
}

The key here is: std::bind binds the member function into a normal callable object, and then receives it uniformly through std::function<void></void> . This pattern is common in GUI programming or asynchronous programming.

Pay attention to a few places that are easy to get stuck

• Be careful about the object life cycle when binding : If you bind an object's reference or pointer, the object cannot be destructed in advance, otherwise an error will occur during the call.
• If there are too many binding parameters, it is easy to confuse the order : especially when nesting binds, it is recommended to write clearly the source of each parameter.
• Avoid overuse : While bind is powerful, lambdas are usually clearer and concise, and unless you need to reuse the binding logic, lambdas are preferred.

Basically that's it. Once you have used it well, you will find that the combination of std::function and std::bind can indeed solve many problems of inconsistent interfaces, but don't use it too complicatedly, otherwise it will be a headache for debugging.

The above is the detailed content of C std::bind and std::function tutorial. For more information, please follow other related articles on the PHP Chinese website!