std::function

From Cppreference

Jump to: navigation, search

Defined in header `<functional>`

template< class > class function; /* undefined */		(since C++11)

template< class R, class... Args > class function<R(Args...)>		(since C++11)

Class template std::function is a general-purpose polymorphic function wrapper. Instances of std::function can store, copy, and invoke any callable target -- functions, lambda expressions, bind expressions, or other function objects.


type	definition

`result_type`	`R`

`argument_type`	`T` if sizeof...(Args)==1 and `T` is the first and only type in `Args...`

`first_argument_type`	`T1` if sizeof...(Args)==2 and `T1` is the first of the two types in `Args...`

`second_argument_type`	`T2` if sizeof...(Args)==2 and `T2` is the first of the two types in `Args...`

[edit] Member functions


(constructor)	constructs a new std::function instance (public member function)

(destructor)	destroys a std::function instance (public member function)

operator=	replaces a std::function (public member function)

swap	exchanges the targets of two std::functions (public member function)

assign	assigns a new target to an std::function (public member function)

operator bool	checks if std::function has a target (public member function)

operator()	invokes the target of an std::function (public member function)

target_type	obtains the typeid of the stored target of an std::function (public member function)

target	obtains a pointer to the stored target of an std::function (public member function)

[edit] Non-member functions


std::swap(std::function) (C++11)	specializes the std::swap algorithm (function template)

operator== operator!=	compares an std::function with std::nullptr (function template)

[edit] Helper classes


std::uses_allocator<std::function> (C++11)	specializes the std::uses_allocator type trait (class template specialization)

[edit] Example

#include <iostream>
#include <functional>
 
void call(std::function<int()> f) { // can be passed by value
    std::cout << f() << '\n';
}
 
int normal_function() {
    return 42;
}
 
int main()
{
    int n = 1;
    std::function<int()> f = [&n](){return n;}; // target a lambda
    std::cout << f() << '\n'; // call directly
    n = 2;
    call(f); // pass to another function
    f = normal_function; // now target a plain function
    call(f);
}

Output:

1
2
42

[edit] See also


bad_function_call (C++11)	the exception thrown when invoking an empty std::function (class)

mem_fn (C++11)	binds an object to a pointer to its member function to form independent function object (function template)