Partager via

function, classe

  • Article

Wrapper pour un objet pouvant être appelé.

Syntaxe

template <class Fty>
class function  // Fty of type Ret(T1, T2, ..., TN)
    : public unary_function<T1, Ret>       // when Fty is Ret(T1)
    : public binary_function<T1, T2, Ret>  // when Fty is Ret(T1, T2)
{
public:
    typedef Ret result_type;

    function();
    function(nullptr_t);
    function(const function& right);
    template <class Fty2>
        function(Fty2 fn);
    template <class Fty2, class Alloc>
        function(reference_wrapper<Fty2>, const Alloc& Ax);

    template <class Fty2, class Alloc>
        void assign(Fty2, const Alloc& Ax);
    template <class Fty2, class Alloc>
        void assign(reference_wrapper<Fty2>, const Alloc& Ax);
    function& operator=(nullptr_t);
    function& operator=(const function&);
    template <class Fty2>
        function& operator=(Fty2);
    template <class Fty2>
        function& operator=(reference_wrapper<Fty2>);

    void swap(function&);
    explicit operator bool() const;

    result_type operator()(T1, T2, ....., TN) const;
    const std::type_info& target_type() const;
    template <class Fty2>
        Fty2 *target();

    template <class Fty2>
        const Fty2 *target() const;

    template <class Fty2>
        void operator==(const Fty2&) const = delete;
    template <class Fty2>
        void operator!=(const Fty2&) const = delete;
};

Paramètres

Fty
Type de fonction à encapsuler.

Hache
Fonction allocator.

Notes

Le modèle de classe est un wrapper d’appel dont la signature d’appel est Ret(T1, T2, ..., TN). Vous l’utilisez pour placer différents objets appelants dans un wrapper uniforme.

Certaines fonctions membres acceptent un opérande qui nomme l’objet cible souhaité. Vous pouvez spécifier cet opérande de plusieurs façons :

fn: objet pouvant être fnappelé ; après l’appel, l’objet function contient une copie de fn

fnref: l’objet pouvant être appelé par fnref.get(); après l’appel auquel l’objet function contient une référence fnref.get()

right: objet pouvant être appelé, le cas échéant, détenu par l’objet functionright

npc: pointeur Null ; une fois que l’appel de l’objet function est vide

Dans tous les cas, INVOKE(f, t1, t2, ..., tN)où f est l’objet pouvant être appelé et t1, t2, ..., tN sont respectivement des valeurs lvalues de types T1, T2, ..., TN , doit être bien formé et, s’il Ret n’est pas vide, convertible en Ret.

Un objet vide function ne contient pas d’objet pouvant être appelé ou d’une référence à un objet pouvant être appelé.

Membres

Constructeurs

Nom Description
function Construit un wrapper qui est vide ou stocke un objet pouvant être appelé de type arbitraire avec une signature fixe.

Typedefs

Nom Description
result_type Type de retour de l’objet pouvant être appelé stocké.

Functions

Nom Description
assign Assigne un objet pouvant être appelé à cet objet de fonction.
swap Échange deux objets pouvant être appelés.
cible Vérifie si l’objet pouvant être appelé stocké peut être appelé comme spécifié.
target_type Obtient les informations de type sur l'objet pouvant être appelé.

Opérateurs

Nom Description
opérateur non spécifié Vérifie si l’objet pouvant être appelé stocké existe.
operator() Appelle un objet pouvant être appelé.
operator= Remplace l’objet pouvant être appelé stocké.

attribuer

Assigne un objet pouvant être appelé à cet objet de fonction.

template <class Fx, class Alloc>
    void assign(
        Fx _Func,
        const Alloc& Ax);

template <class Fx, class Alloc>
    void assign(
        reference_wrapper<Fx> _Fnref,
        const Alloc& Ax);

Paramètres

_Func
Objet pouvant être appelé.

_Fnref
Wrapper de référence qui contient un objet pouvant être appelé.

Hache
Objet allocateur.

Notes

Les fonctions membres remplacent chacune le callable object contenu dans *this par l’objet pouvant être appelé passé comme operand. Les deux allouent le stockage avec l’objet ax d’allocator.

function

Construit un wrapper qui est vide ou stocke un objet pouvant être appelé de type arbitraire avec une signature fixe.

function();
function(nullptr_t npc);
function(const function& right);
template <class Fx>
    function(Fx _Func);
template <class Fx>
    function(reference_wrapper<Fx> _Fnref);
template <class Fx, class Alloc>
    function(
        Fx _Func,
        const Alloc& Ax);

template <class Fx, class Alloc>
    function(
        reference_wrapper<Fx> _Fnref,
        const Alloc& Ax);

Paramètres

right
Objet de fonction à copier.

Fx
Type de l’objet pouvant être appelé.

_Func
Objet pouvant être appelé à inclure dans un wrapper.

Alloc
Type allocateur.

Hache
Allocateur.

_Fnref
Référence de l’objet pouvant être appelé à inclure dans un wrapper.

Notes

Les deux premiers constructeurs construisent un objet function vide. Les trois constructeurs suivants construisent un objet function qui contient l’objet pouvant être appelé passé comme opérande. Les deux derniers constructeurs allouent du stockage avec l’objet allocateur Ax.

Exemple

// std__functional__function_function.cpp
// compile with: /EHsc
#include <functional>
#include <iostream>
#include <vector>

int square(int val)
{
    return val * val;
}

class multiply_by
{
public:
    explicit multiply_by(const int n) : m_n(n) { }

    int operator()(const int x) const
    {
        return m_n * x;
    }

private:
    int m_n;
};

int main()
{
    typedef std::vector< std::function<int (int)> > vf_t;

    vf_t v;
    v.push_back(square);
    v.push_back(std::negate<int>());
    v.push_back(multiply_by(3));

    for (vf_t::const_iterator i = v.begin(); i != v.end(); ++i)
    {
        std::cout << (*i)(10) << std::endl;
    }

    std::function<int (int)> f = v[0];
    std::function<int (int)> g;

    if (f) {
        std::cout << "f is non-empty (correct)." << std::endl;
    } else {
        std::cout << "f is empty (can't happen)." << std::endl;
    }

    if (g) {
        std::cout << "g is non-empty (can't happen)." << std::endl;
    } else {
        std::cout << "g is empty (correct)." << std::endl;
    }

    return 0;
}

100
-10
30
f is non-empty (correct).
g is empty (correct).

opérateur non spécifié

Vérifie si l’objet pouvant être appelé stocké existe.

operator unspecified();

Notes

L’opérateur retourne une valeur convertible en bool valeur true uniquement si l’objet n’est pas vide. Vous l’utilisez pour vérifier si l’objet est vide.

Exemple

// std__functional__function_operator_bool.cpp
// compile with: /EHsc
#include <functional>
#include <iostream>

int neg(int val)
    {
    return (-val);
    }

int main()
    {
    std::function<int (int)> fn0;
    std::cout << std::boolalpha << "not empty == " << (bool)fn0 << std::endl;

    std::function<int (int)> fn1(neg);
    std::cout << std::boolalpha << "not empty == " << (bool)fn1 << std::endl;

    return (0);
    }

not empty == false
not empty == true

operator()

Appelle un objet pouvant être appelé.

result_type operator()(
    T1 t1,
    T2 t2, ...,
    TN tN);

Paramètres

AMT
Type du N-ième argument de l’appel.

Amt
N-ième argument de l’appel.

Notes

La fonction membre retourne INVOKE(fn, t1, t2, ..., tN, Ret), où fn est l’objet cible stocké dans *this. Vous l’utiliser pour appeler l’objet pouvant être appelé inclus dans un wrapper.

Exemple

// std__functional__function_operator_call.cpp
// compile with: /EHsc
#include <functional>
#include <iostream>

int neg(int val)
    {
    return (-val);
    }

int main()
    {
    std::function<int (int)> fn1(neg);
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;
    std::cout << "val == " << fn1(3) << std::endl;

    return (0);
    }

empty == false
val == -3

opérateur =

Remplace l’objet pouvant être appelé stocké.

function& operator=(null_ptr_type npc);
function& operator=(const function& right);
template <class Fty>
    function& operator=(Fty fn);
template <class Fty>
    function& operator=(reference_wrapper<Fty> fnref);

Paramètres

Npc
Pointeur null constant.

right
Objet de fonction à copier.

Fn
Objet pouvant être appelé à inclure dans un wrapper.

fnref
Référence de l’objet pouvant être appelé à inclure dans un wrapper.

Notes

Les opérateurs remplacent chacun l’objet pouvant être appelé contenu dans *this par l’objet pouvant être appelé passé comme opérande.

Exemple

// std__functional__function_operator_as.cpp
// compile with: /EHsc
#include <functional>
#include <iostream>

int neg(int val)
    {
    return (-val);
    }

int main()
    {
    std::function<int (int)> fn0(neg);
    std::cout << std::boolalpha << "empty == " << !fn0 << std::endl;
    std::cout << "val == " << fn0(3) << std::endl;

    std::function<int (int)> fn1;
    fn1 = 0;
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;

    fn1 = neg;
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;
    std::cout << "val == " << fn1(3) << std::endl;

    fn1 = fn0;
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;
    std::cout << "val == " << fn1(3) << std::endl;

    fn1 = std::cref(fn1);
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;
    std::cout << "val == " << fn1(3) << std::endl;

    return (0);
    }

empty == false
val == -3
empty == true
empty == false
val == -3
empty == false
val == -3
empty == false
val == -3

result_type

Type de retour de l’objet pouvant être appelé stocké.

typedef Ret result_type;

Notes

Le typedef est un synonyme du type Ret dans la signature d’appel du modèle. Vous l’utilisez pour déterminer le type de retour de l’objet pouvant être appelé inclus dans un wrapper.

Exemple

// std__functional__function_result_type.cpp
// compile with: /EHsc
#include <functional>
#include <iostream>

int neg(int val)
    {
    return (-val);
    }

int main()
    {
    std::function<int (int)> fn1(neg);
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;

    std::function<int (int)>::result_type val = fn1(3);
    std::cout << "val == " << val << std::endl;

    return (0);
    }

empty == false
val == -3

swap

Échange deux objets pouvant être appelés.

void swap(function& right);

Paramètres

right
Objet de fonction à échanger.

Notes

La fonction membre échange les objets cibles entre *this et vers la droite. Elle le fait dans un cadre de temps fixe, et ne lève aucune exception.

Exemple

// std__functional__function_swap.cpp
// compile with: /EHsc
#include <functional>
#include <iostream>

int neg(int val)
    {
    return (-val);
    }

int main()
    {
    std::function<int (int)> fn0(neg);
    std::cout << std::boolalpha << "empty == " << !fn0 << std::endl;
    std::cout << "val == " << fn0(3) << std::endl;

    std::function<int (int)> fn1;
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;
    std::cout << std::endl;

    fn0.swap(fn1);
    std::cout << std::boolalpha << "empty == " << !fn0 << std::endl;
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;
    std::cout << "val == " << fn1(3) << std::endl;

    return (0);
    }

empty == false
val == -3
empty == true

empty == true
empty == false
val == -3

cible

Vérifie si l’objet pouvant être appelé stocké peut être appelé comme spécifié.

template <class Fty2>
    Fty2 *target();
template <class Fty2>
    const Fty2 *target() const;

Paramètres

Fty2
Type d’objet pouvant être appelé cible à vérifier.

Notes

Le type Fty2 doit être appelant pour les types T1, T2, ..., TN d’arguments et le type Retde retour . Si target_type() == typeid(Fty2), la fonction de modèle membre retourne l’adresse de l’objet cible ; sinon, elle retourne 0.

Un type Fty2 est appelant pour les types T1, T2, ..., TN d’arguments et le type Ret de retour si, pour les valeurs lvalues fn, t1, t2, ..., tN de types Fty2, T1, T2, ..., TN, respectivement, INVOKE(fn, t1, t2, ..., tN) est bien formé et, si Ret ce n’est pas void, convertible en Ret.

Exemple

// std__functional__function_target.cpp
// compile with: /EHsc
#include <functional>
#include <iostream>

int neg(int val)
    {
    return (-val);
    }

int main()
    {
    typedef int (*Myfun)(int);
    std::function<int (int)> fn0(neg);
    std::cout << std::boolalpha << "empty == " << !fn0 << std::endl;
    std::cout << "no target == " << (fn0.target<Myfun>() == 0) << std::endl;

    Myfun *fptr = fn0.target<Myfun>();
    std::cout << "val == " << (*fptr)(3) << std::endl;

    std::function<int (int)> fn1;
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;
    std::cout << "no target == " << (fn1.target<Myfun>() == 0) << std::endl;

    return (0);
    }

empty == false
no target == false
val == -3
empty == true
no target == true

target_type

Obtient les informations de type sur l'objet pouvant être appelé.

const std::type_info& target_type() const;

Notes

La fonction membre retourne typeid(void) si *this est vide. Sinon, elle retourne typeid(T), où T est le type de l'objet cible.

Exemple

// std__functional__function_target_type.cpp
// compile with: /EHsc
#include <functional>
#include <iostream>

int neg(int val)
    {
    return (-val);
    }

int main()
    {
    std::function<int (int)> fn0(neg);
    std::cout << std::boolalpha << "empty == " << !fn0 << std::endl;
    std::cout << "type == " << fn0.target_type().name() << std::endl;

    std::function<int (int)> fn1;
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;
    std::cout << "type == " << fn1.target_type().name() << std::endl;

    return (0);
    }

empty == false
type == int (__cdecl*)(int)
empty == true
type == void