Std::function (3) Linux Manual Page

std::function – std::function

Synopsis

Defined in header <functional>

template< class >                   (since C++11)

class function; /* undefined */

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

class function<R(Args...)>;

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, as well as pointers to member functions and pointers to data members.
The stored callable object is called the target of std::function. If a std::function contains no target, it is called empty. Invoking the target of an empty std::function results in std::bad_function_call exception being thrown.
std::function satisfies the requirements of CopyConstructible and CopyAssignable.

Member types

Type Definition
result_type R
argument_type(deprecated in C++17)(removed in C++20) T if sizeof…(Args)==1 and T is the first and only type in Args…
first_argument_type(deprecated in C++17)(removed in C++20) T1 if sizeof…(Args)==2 and T1 is the first of the two types in Args…
second_argument_type(deprecated in C++17)(removed in C++20) T2 if sizeof…(Args)==2 and T2 is the second of the two types in Args…

Member functions

              constructs a new std::function instance
constructor (public member function)
              destroys a std::function instance
destructor (public member function)
              assigns a new target
operator= (public member function)
              swaps the contents
swap (public member function)

assign assigns a new target
              (public member function)
(until C++17)
              checks if a valid target is contained
operator_bool (public member function)
              invokes the target
operator() (public member function)

Target access

obtains the typeid of the stored target
target_type (public member function)
obtains a pointer to the stored target
target (public member function)

Non-member functions

std::swap(std::function) specializes the std::swap algorithm
(function template)
(C++11)
compares a std::function with nullptr
operator== (function template)
operator!=

Helper classes

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

Deduction_guides(since C++17)

Example

// Run this code

#include <functional>

#include <iostream>
struct Foo {
    Foo(int num)
        : num_(num)
    {
    }
    void print_add(int i) const
    {
        std::cout << num_ + i << '\n';
    }
    int num_;
};
void print_num(int i)

{
    std::cout << i << '\n';
}
struct PrintNum {
    void operator()(int i) const
    {
        std::cout << i << '\n';
    }
};
int main()

{
    // store a free function
    std::function<void(int)> f_display = print_num;
    f_display(-9);
    // store a lambda
    std::function<void()> f_display_42 = []() { print_num(42); };
    f_display_42();
    // store the result of a call to std::bind
    std::function<void()> f_display_31337 = std::bind(print_num, 31337);
    f_display_31337();
    // store a call to a member function
    std::function<void(const Foo &, int)> f_add_display = &Foo::print_add;
    const Foo foo(314159);
    f_add_display(foo, 1);
    f_add_display(314159, 1);
    // store a call to a data member accessor
    std::function<int(Foo const &)> f_num = &Foo::num_;
    std::cout << "num_: " << f_num(foo) << '\n';
    // store a call to a member function and object
    using std::placeholders::_1;
    std::function<void(int)> f_add_display2 = std::bind(&Foo::print_add, foo, _1);
    f_add_display2(2);
    // store a call to a member function and object ptr
    std::function<void(int)> f_add_display3 = std::bind(&Foo::print_add, &foo, _1);
    f_add_display3(3);
    // store a call to a function object
    std::function<void(int)> f_display_obj = PrintNum();
    f_display_obj(18);
}

Output:

  -9
  42
  31337
  314160
  314160
  num_: 314159
  314161
  314162
  18

std::function (3) Linux Manual Page