Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/std-function-in-cpp/ below:

std::function in C++ - GeeksforGeeks

Last Updated : 23 Jul, 2025

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.

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.

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.

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);

// 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

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

Function

Description

swap()

Swaps the wrapped callable of two std::function objects.

operator bool

Checks if the std::function contains a callable.

operator ()

Invoke the callable with the given arguments.

target()

Returns a pointer to the stored callable. If there is no callable stored, returns nullptr.

target_type()

Returns the typeid of the callable. If no callable is stored, it returns typeid(void).

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.

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

// 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

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;
}

// 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;
}

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.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4