std::function::operator()(3)

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)