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

> C++ Atlas: `cppatlas.com/w/cpp/utility/functional/function/operator()` | Source: https://en.cppreference.com/w/cpp/utility/functional/function/operator() | Domain: Utility | Standards: C++11, C++17, C++23

Invokes the stored callable function target with the parameters args.

## Official Specification Summary (cppreference)

```cpp
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`.

### 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

Throws `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.

```cpp
#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);
}
```

Possible output:

```text
bad_function_call
1
2
42
Hi 42
```

### See also

- [`operator()`](https://en.cppreference.com/w/cpp/utility/functional/move_only_function/operator()): invokes the target (public member function of `std::move_only_function`)
- [`operator()`](https://en.cppreference.com/w/cpp/utility/functional/reference_wrapper/operator()): calls the stored function (public member function of `std::reference_wrapper<T>`)
- [`bad_function_call`](https://en.cppreference.com/w/cpp/utility/functional/bad_function_call) (C++11): the exception thrown when invoking an empty `std::function` (class)
- [`invoke`](https://en.cppreference.com/w/cpp/utility/functional/invoke) (C++17), [`invoke_r`](https://en.cppreference.com/w/cpp/utility/functional/invoke) (C++23): invokes any *Callable* object with given arguments and possibility to specify return type (since C++23) (function template)

---
Attribution: content from https://en.cppreference.com/w/cpp/utility/functional/function/operator() (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.