What is the difference between ’std::bind’ and lambda functions in C++? When would you use each?

In C++, both std::bind and lambda functions can be used to create callable objects, but they differ in their implementation and usage.

std::bind is a function template defined in the <functional> header, which allows creating a new callable object by binding one or more arguments to a given function. It takes the function pointer or function object as the first argument, followed by the arguments that need to be bound. The resulting object can be called with the remaining arguments that were not bound. Here is an example of using std::bind to bind an argument to a function:

    #include <iostream>
    #include <functional>
    
    void foo(int a, int b, int c) {
        std::cout << "a = " << a << ", b = " << b << ", c = " << c << std::endl;
    }
    
    int main() {
        auto bound_foo = std::bind(foo, 1, std::placeholders::_1, 2);
        bound_foo(3);  // prints "a = 1, b = 3, c = 2"
        return 0;
    }

In this example, we create a new callable object bound_foo by binding the first argument of the function foo to the value 1 and the third argument to the value 2. We use the placeholder _1 to represent the second argument, which will be passed when the object is called.

On the other hand, lambda functions are anonymous functions that can be defined inline within a code block. They provide a concise way of defining small functions without the need to create a separate function object. Lambda functions can capture variables from their enclosing scope, and their syntax allows specifying function parameters and return types. Here is an example of using a lambda function to add two integers:

    #include <iostream>
    
    int main() {
        auto add = [](int a, int b) -> int { return a + b; };
        std::cout << add(2, 3) << std::endl;  // prints "5"
        return 0;
    }

In this example, we define a lambda function add that takes two integer arguments and returns their sum. The function is assigned to a variable add using the auto keyword, which infers the function type from the lambda expression.

When to use std::bind versus lambda functions depends on the situation. std::bind is useful when we want to bind one or more arguments of a function and create a new callable object. It can be particularly useful when working with legacy code that takes a specific number of arguments and cannot be modified. Lambda functions, on the other hand, are useful for defining small functions inline, especially when they need to capture variables from their enclosing scope. They can also be used to create function objects with custom behavior, such as sorting algorithms that take a custom comparison function.