function Class

Article
03/04/2013

Wrapper pour un objet appelé.

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>
       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
Le type de fonction à inclure.
_Ax
La fonction de l'allocateur.

Notes

La classe de modèle est un wrapper d'appel dont la signature d'appel est Ret(T1, T2, ..., TN).Vous l'utilisez pour encadrer un grand tableau d'objets pouvant être appelées dans un wrapper uniforme.

Certaines fonctions membres utilisent un opérande qui nomme l'objet cible désirée.Vous pouvez spécifier un tel opérande de plusieurs façons :

fn -- l'objet peut être appelé fn; après l'appel à l'objet d' function maintienne une copie d' fn

fnref -- l'objet peut être appelé nommé par fnref.get(); après l'appel à l'objet d' function maintienne une référence à fnref.get()

right -- l'objet peut être appelé, le cas échéant, maintenu par l'objet rightd' function

npc -- un pointeur null ; après l'appel à l'objet d' function est vide

Dans tous les cas, INVOKE(f, t1, t2, ..., tN), où f est l'objet appelé et t1, t2, ..., tN sont l-value qu'des types T1, T2, ..., TN respectivement, doit être de forme correcte et, si Ret n'est pas void, convertible à Ret.

Un objet vide d' function ne contient pas d'objet appelé ou une référence à un objet appelé.

Constructeurs

function::function

Crée un wrapper qui est vide ou stocke un objet appelé de type arbitraire avec une signature fixe.

Typedef

function::result_type

Le type de retour de l'objet appelé stocké.

Fonctions membres

function::assign	Assigne un objet appelé à cet objet de fonction.
function::swap	Objets pouvant être appelées de l'échange deux.
function::target	Teste si l'objet appelé stocké peut être appelé comme spécifié.
function::target_type	Obtient les informations de type sur l'objet appelé.

Opérateurs

function::operator unspecified	Teste si l'objet appelé stocké existe.
function::operator()	Appelle un objet appelé.
function::operator=	Remplace l'objet appelé stocké.

Configuration requise

en-tête : <functional>

l'espace de noms : DST

Voir aussi

Référence

mem_fn Function

reference_wrapper Class

Partager via