NAME¶

std::function::operator() - std::function::operator()

Synopsis¶

R operator()( Args... args ) const; (since C++11)

Invokes the stored callable function target with the parameters args.

Effectively does INVOKE<R>(f, std::forward<Args>(args)...), where f is the target
object of *this and INVOKE is the operation described in Callable.

Parameters¶

args - parameters to pass to the stored callable function target

Return value¶

None if R is void. Otherwise the return value of the invocation of the stored
callable object.

Exceptions¶

* std::bad_function_call if *this does not store a callable function target, i.e.
!*this == true.

Example¶

The following example shows how std::function can be passed to other functions by
value. Also, it shows how std::function can store lambdas.

// Run this code

#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; };
call(f);

n = 2;
call(f);

f = normal_function;
call(f);
}

Output:¶

1
2
42

See also¶

operator() invokes the target
(C++23) (public member function of std::move_only_function)
operator() calls the stored function
(public member function of std::reference_wrapper<T>)
bad_function_call the exception thrown when invoking an empty std::function
(C++11) (class)
invoke invokes any Callable object with given arguments
invoke_r and possibility to specify return type
(C++17) (since C++23)
(C++23) (function template)