std::function in C++

The std::function() in C++ is a function wrapper class which can store and call any function or a callable object. In this article, we will learn about std::function in C++ and how to use it in different cases.

What is std::function in C++?

std::function is a template class in C++ that is used to wrap a particular function or any other callable object such as a lambda, or function object. It is generally used to write generic code where we need to pass functions as arguments in another function (callbacks). It avoids the creation of extra overloads of the function that may take similar callback functions as arguments.

std::function is defined in the <functional> header file.

Declaration

To create a wrapper object, we first declare it using the following syntax:

std::function< rtype (atype...)> name();

where,

• name: Name of the wrapper.
• atype: Types of the arguments that function takes.
• rtype: Return type of the function you want to store.

Initialization

The above syntax only creates an empty instance of std::function. To wrap a particular function inside this wrapper object, we use assignment operator as shown:

std::function< ret_t (args_t)> name = f;

where f is the function to be wrapped.

We can also initialize it at the time of declaration:

std::function< ret_t (args_t)> name(f);

Example of std::function

// C++ Program to illustrate the working
// std::function
#include <bits/stdc++.h>
using namespace std;

int f(int a, int b) {
  return a + b;
}

int main() {
  
  	// std::function wrapping traditional
  	// function
	function<int(int, int)> calc = f;
  	cout << "Sum: " << calc(8, 2) << endl;
    
  	// std::function wrapping a lambda
    // expression
    calc = [](int a, int b) { return a * b; };
  	cout << "Product: " << calc(8, 2);
    return 0;
}

Sum: 10
Product: 16

Member Functions of std::function

std::function contains some member functions to provide some basic functionality. The following table lists some useful member functions of std::function class template:

Applications of std::functions in C++

Apart from the applications shown in the above examples, std::function can also be used for:

• Callbacks: Used for event-driven systems where functions are passed and called later when an event occurs.
• Function Wrapping and Higher-Order Functions: Allows passing functions as parameters and returning them.
• Stateful Callbacks: Enables callbacks with preserved states, making it easier to manage state without global variables.
• Replacing Function Pointers: Provides a safer and more flexible alternative to traditional function pointers, supporting multiple callable types.

More Examples of std::function

The following examples demonstrates the usage of std::function in C++ for different applications such as callbacks, state preserved callbacks, function composition.

Example 1: Passing std::function as Argument (Callback)

// C++ program to pass the std::function
// as arguments
#include <bits/stdc++.h>
using namespace std;

// Functions for simple math operations
int add(int a, int b) {
    return a + b;
}
int sub(int a, int b) {
    return a - b;
}
int mul(int a, int b) {
    return a * b;
}
int divs(int a, int b) {
    return a / b;
}

// Using std::function as parameter
void func(int a, int b, 
         function<int(int, int)> calc) {
  
    int res = calc(a, b);
    cout << "Result: " << res << endl;
}

int main() {
    
  	// Calling all the arithmetic functions
    func(8, 2, add);
    func(8, 2, sub);
    func(8, 2, mul);
    func(8, 2, divs);
    return 0;
}

Result: 10
Result: 6
Result: 16
Result: 4

Example 2: Wrapping Member Functions of a Class

We can also wrap a member function of a class using std::function object but we have to add one extra argument as shown in the below program.

// C++ program to demonstrate usage of
// unction with member functions
#include <bits/stdc++.h>
using namespace std;

class C {
public:
    int f(int a, int b) {
        return a * b;
    }
};

int main() {
    C c;
    
    // Wrapping member function of C
    function<int(C&, int, int)> calc = &C::f;
    
    // Call the member function using function
  	if (calc)
    	cout << "Product: " << calc(c, 4, 5);
  	else
      	cout << "No Callable Assigned";
    return 0;
}

Product: 20

Example 3: Composing Two Functions into One

// C++ program to demonstrate usage of
// std::function for function composition
#include <bits/stdc++.h>
using namespace std;

// Composed function
function<int(int)> cf(function<int(int)> f1,
                        function<int(int)> f2) {
  
  	// Returning a lambda expression that
  	// in turn returns a function
    return [f1, f2](int x) {
      
      	// Apply f1 first, then f2
        return f2(f1(x)); 
    };
}

int main() {
    auto add = [](int x) { return x + 2; };
    auto mul = [](int x) { return x * 3; };

    function<int(int)> calc = cf(add, mul);
    cout << calc(4);
    return 0;
}

18

Explanation: In this example, we composted two lambda functions add() and mul() into one function cf() which takes two function wrappers and returns another function wrapper. Then we created a wrapper for this using this composed function and use it to perform the addition and multiplication operator at one call.