std::invoke / std::apply

std::invoke(f, args...) вызывает f с аргументами args... независимо от того, что такое f: обычная функция или функциональный объект — вызов эквивалентен f(args...); указатель на функцию-член класса (&Class::method) — первым аргументом ожидается объект или указатель на объект этого класса, дальше обычные аргументы метода; указатель на данные-член (&Class::field) — с единственным аргументом-объектом возвращает значение этого поля. std::apply(f, tuple) вызывает f с аргументами, распакованными из tuple по порядку: apply(f, std::make_tuple(1, 2)) эквивалентно f(1, 2).std::invoke(f, args...) calls f with arguments args... regardless of what f is: an ordinary function or a function object — the call is equivalent to f(args...); a pointer to a class member function (&Class::method) — the first argument is expected to be an object or a pointer to an object of that class, followed by the method's ordinary arguments; a pointer to a data member (&Class::field) — with a single object argument it returns that field's value. std::apply(f, tuple) calls f with arguments unpacked from tuple in order: apply(f, std::make_tuple(1, 2)) is equivalent to f(1, 2).

struct Widget { void draw() const; };

void callDraw(void(Widget::*m)() const, const Widget& w) {
    (w.*m)();  // синтаксис .* — несовместим с обычным m(w)// .* syntax — incompatible with an ordinary m(w)
}
// generic-код, принимающий "что угодно вызываемое",// generic code accepting "anything callable"
// не мог единообразно обработать этот случай без ручных проверок// couldn't handle this case uniformly without manual checks

struct Widget { void draw() const; };

template <class F, class... Args>
void callAnything(F&& f, Args&&... args) {
    std::invoke(std::forward<F>(f), std::forward<Args>(args)...);
}
callAnything(&Widget::draw, w);  // работает: invoke сам понимает, что это member pointer// works: invoke figures out it's a member pointer itself
callAnything([]{ std::cout << "hi"; });  // тоже работает — обычная лямбда// also works — an ordinary lambda

#include <functional>
#include <tuple>

struct Point {
    int x, y;
    int sum() const { return x + y; }
};

Point p{3, 4};

// invoke с обычной функцией — как обычный вызов:// invoke with an ordinary function — like an ordinary call:
std::invoke(printf, "%d\n", 42);

// invoke с указателем на метод — объект вторым аргументом:// invoke with a member-function pointer — the object is the second argument:
int s = std::invoke(&Point::sum, p);          // эквивалент p.sum()// equivalent to p.sum()

// invoke с указателем на поле — тоже объект вторым аргументом:// invoke with a data-member pointer — also the object as the second argument:
int xv = std::invoke(&Point::x, p);            // эквивалент p.x// equivalent to p.x

// apply — вызов с аргументами, распакованными из tuple:// apply — a call with arguments unpacked from a tuple:
auto args = std::make_tuple(1, 2, 3);
int total = std::apply([](int a, int b, int c) { return a + b + c; }, args);

std::invoke редко пишут напрямую в прикладном коде — это низкоуровневая утилита, на которой строятся другие generic-компоненты. Если в коде встречается прямой вызов std::invoke, скорее всего это реализация чего-то вроде обёртки над Callable, кастомного std::function-подобного типа или generic-адаптера, а не типичный бизнес-код.std::invoke is rarely written directly in application code — it's a low-level utility other generic components are built on. If direct use of std::invoke shows up in code, it's most likely the implementation of something like a wrapper over a Callable, a custom std::function-like type, or a generic adapter, not typical business code.

• cppreference — std::invoke
• cppreference — std::apply
• WG21 P0146 — Regarding INVOKE