std::move_o...::operator()(3)

👑 NAME 👑

okay bestie, we're in the C++ Standard Libary manual, and this page is std::move_o...::operator()(3) — yes, that ellipsis is literally in the page title, no cap.

std::move_only_function::operator() — std::move_only_function::operator().

It's the call operator, and the NAME section just says it twice. Iconic. 💅

---

✨ Synopsis ✨

R operator()( Args... args ) /*cv*/ /*ref*/ noexcept(/*noex*/);

(since C++23)

It invokes the stored callable target with the parameters args. The /*cv*/, /*ref*/, and /*noex*/ parts of operator() are identical to those of the template parameter of std::move_only_function.

Equivalent to:

return std::invoke_r<R>(/*cv-ref-cast*/(f), std::forward<Args>(args)...);

where f is a cv-unqualified lvalue that denotes the target object of *this, and /*cv-ref-cast*/(f) is equivalent to:

• * f if cv ref is either empty or &, or
• std::as_const(f) if cv ref is either const or const &, or
• std::move(f) if cv ref is &&, or
• std::move(std::as_const(f)) if cv ref is const &&.

The behavior is undefined if *this is empty. Bestie, do not call an empty one — that's UB and it's giving "we don't do that here" 😭💀

---

🌸 Parameters 🌸

• args — parameters to pass to the stored callable target.

---

🎀 Return value 🎀

std::invoke_r<R>(/*cv-ref-cast*/(f), std::forward<Args>(args)...).

---

💅 Exceptions 💅

Propagates the exception thrown by the underlying function call.

---

🦋 Example 🦋

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

The page literally says // Run this code right before the snippet:

#include <iostream>
#include <functional>

void call(std::move_only_function<int() const> f)  // can be passed by value
{
    std::cout << f() << '\n';
}

int normal_function()
{
    return 42;
}

int main()
{
    int n = 1;
    auto lambda = [&n](){ return n; };
    std::move_only_function<int() const> f = lambda;
    call(std::move(f));

    n = 2;
    call(lambda);

    f = normal_function;
    call(std::move(f));
}

🍓 Output 🍓

1
2
42

---

💖 See also 💖

• operator() invokes the target (public member function of std::function<R(Args...)>)
• operator() calls the stored function (public member function of std::reference_wrapper<T>)
• invoke — invokes any Callable object with given arguments
• invoke_r — and possibility to specify return type
• The page also has these version/type tags: (C++17), (since C++23), (C++23), (function template)

---

Source/version: http://cppreference.com, date 2024.06.10, page std::move_o...::operator()(3). Mwah 💋✨🎀