Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::invoke: invocazione uniforme dei callable

std::invoke chiama funzioni, oggetti funzione e puntatori a membro con un’unica interfaccia perfect-forwarding.

Versione: C++23

Sintassi

template<class F, class... Args>
constexpr std::invoke_result_t<F, Args...>
std::invoke(F&& callable, Args&&... args)
    noexcept(std::is_nothrow_invocable_v<F, Args...>);

std::invoke(f,args...) applica INVOKE: un callable ordinario riceve argomenti inoltrati; un puntatore a funzione membro richiede oggetto, puntatore o std::reference_wrapper; un puntatore a dato membro produce il membro. Partecipa solo se std::is_invocable_v<F,Args...> è true.

L’esempio chiama Counter::add, legge Counter::base ed esegue una lambda, quindi stampa 12 7 12. Categorie di valore e const sono inoltrate con std::forward, perciò l’accesso al dato può restituire riferimento.

Il risultato è std::invoke_result_t<F,Args...> e il noexcept condizionale segue std::is_nothrow_invocable_v; le eccezioni si propagano. Un ricevitore di membro incompatibile rende std::is_invocable_v falso e l’overload std::invoke non disponibile. Il comportamento indefinito deriva invece dall’accesso tramite puntatore o riferimento altrimenti compatibile ma null o dangling. Oggetto e riferimenti devono vivere durante la chiamata; std::invoke non differisce lavoro né ne gestisce il lifetime.

Esempi

#include <functional>
#include <iostream>

struct Counter {
    int base;
    int add(int value) const { return base + value; }
};

int main() {
    const Counter counter{7};
    std::cout << std::invoke(&Counter::add, counter, 5) << ' '
              << std::invoke(&Counter::base, counter) << ' '
              << std::invoke([](int a, int b) { return a * b; }, 3, 4) << '\n';
}

Risultato

12 7 12

std::invoke → 12 7 12

Fonti