function::function

Article
03/04/2013

Crée un wrapper qui est vide ou stocke un objet 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
L'objet de fonction d'impression.
Fx
Le type de l'objet appelé.
_Func
L'objet peut être appelé à l'enveloppe.
Alloc
Le type de l'allocateur.
_Ax
l'allocateur.
_Fnref
La référence d'objet peut être appelé à l'enveloppe.

Notes

Les deux premiers constructeurs construisent un objet vide d' function .Les trois constructeurs suivants construisent un objet d' function qui juge l'objet appelé passé comme opérande.Les deux derniers constructeurs allouent la mémoire avec le _Ax d'objet d'allocation.

Exemple

// std_tr1__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; 
}