CKTIS / C++
std::invoke : invocation uniforme des callables
std::invoke appelle fonctions, objets fonction et pointeurs de membre via une interface à perfect forwarding.
Version : C++23
Syntaxe
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...) applique INVOKE : un callable ordinaire reçoit les arguments transférés ; un pointeur de fonction membre demande objet, pointeur ou std::reference_wrapper ; un pointeur de donnée membre livre le membre. La fonction ne participe que si std::is_invocable_v<F,Args...> vaut true.
L’exemple appelle Counter::add, lit Counter::base et appelle une lambda ; il affiche 12 7 12. Catégories de valeur et constance passent par std::forward, donc l’accès membre peut renvoyer une référence.
Le type résultat est std::invoke_result_t<F,Args...> et le noexcept conditionnel suit std::is_nothrow_invocable_v ; toute exception du callable se propage. Un récepteur de membre incompatible rend std::is_invocable_v faux et la surcharge std::invoke indisponible. Le comportement indéfini vient plutôt d’un accès via un pointeur ou une référence par ailleurs compatible mais nul ou pendant. Objet et références doivent vivre pendant l’appel ; std::invoke ne diffère rien et ne gère pas leur durée de vie.
Exemples
#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';
}
Résultat
12 7 12
std::invoke → 12 7 12