function::function
Construit un wrapper soit vide ou qui enregistre un objet appelable 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 function à copier.Fx
Type de l'objet appelable._Func
L'objet appelable à inclure dans un wrapper.Alloc
Le type de l'allocateur._Ax
L'allocateur._Fnref
La référence d'objet appelable à inclure dans un wrapper.
Notes
Les deux premiers constructeurs construisent un objet vide de function. Les trois constructeurs suivantes créent un objet d'function qui contient l'objet appelable passé en tant qu'opérande. Les deux derniers constructeurs alloue de la mémoire avec l'allocateur object _Ax.
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;
}
Configuration requise
En-tête : <functional>
Espace de noms : std