Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

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

Sources