std::function<R(Args...)>:: operator()

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 .

Parameters

Return value

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

Exceptions

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

Example

#include <functional>
#include <iostream>
 
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;
    try
    {
        call(f);
    }
    catch (const std::bad_function_call& ex)
    {
        std::cout << ex.what() << '\n';
    }
 
    f = [&n](){ return n; };
    call(f);
 
    n = 2;
    call(f);
 
    f = normal_function;
    call(f);
 
    std::function<void(std::string, int)> g;
    g = [](std::string str, int i) { std::cout << str << ' ' << i << '\n'; };
    g("Hi", 052);
}

bad_function_call
1
2
42
Hi 42

See also