# std::function::operator()

From cppreference.com
< cpp‎ | utility‎ | functional‎ | function

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 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() | calls the stored function (public member function of `std::reference_wrapper`)
bad_function_call (C++11) | the exception thrown when invoking an empty std::function (class)
invoke (C++17) | invokes any `Callable` object with given arguments (function template)

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/utility/functional/function/operator()&oldid=90843"