C++ named requirements: FunctionObject

Un FunctionObject est un type d'objet qui peut être utilisé à gauche de l'opérateur d'appel de fonction.

Exigences

Le type T satisfait FunctionObject si

• Le type T satisfait std::is_object , et

Étant donné

• f , une valeur de type T ou const T ,
• args , liste d'arguments appropriée, qui peut être vide.

Les expressions suivantes doivent être valides :

Notes

Les fonctions et les références aux fonctions ne sont pas des types d'objets fonction, mais peuvent être utilisées là où des types d'objets fonction sont attendus en raison de la conversion implicite fonction-vers-pointeur.

Bibliothèque standard

• Tous les pointeurs vers des fonctions satisfont cette exigence.
• Tous les objets fonction définis dans <functional> .
• Certains types de retour des fonctions de <functional> .

Exemple

#include <functional>
#include <iostream>
void foo(int x) { std::cout << "foo(" << x << ")\n"; }
void bar(int x) { std::cout << "bar(" << x << ")\n"; }
int main()
{
    void(*fp)(int) = foo;
    fp(1); // calls foo using the pointer to function
    std::invoke(fp, 2); // all FunctionObject types are Callable
    auto fn = std::function(foo); // see also the rest of <functional>
    fn(3);
    fn.operator()(3); // the same effect as fn(3)
    struct S
    {
        void operator()(int x) const { std::cout << "S::operator(" << x << ")\n"; }
    } s;
    s(4); // calls s.operator()
    s.operator()(4); // the same as s(4)
    auto lam = [](int x) { std::cout << "lambda(" << x << ")\n"; };
    lam(5); // calls the lambda
    lam.operator()(5); // the same as lam(5)
    struct T
    {
        using FP = void (*)(int);
        operator FP() const { return bar; }
    } t;
    t(6); // t is converted to a function pointer
    static_cast<void (*)(int)>(t)(6); // the same as t(6)
    t.operator T::FP()(6); // the same as t(6) 
}

foo(1)
foo(2)
foo(3)
foo(3)
S::operator(4)
S::operator(4)
lambda(5)
lambda(5)
bar(6)
bar(6)
bar(6)

Voir aussi