Condividi tramite


function Class

Wrapper per un oggetto essere chiamato.

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

Parametri

  • Fty
    Il tipo di funzione da eseguire il wrapping.

  • _Ax
    La funzione di allocatore.

Note

La classe modello è un wrapper di chiamata della cui firma di chiamata è Ret(T1, T2, ..., TN).La utilizzate per racchiudere vari oggetti in un runtime callable wrapper uniforme.

Alcune funzioni membro accettano un operando che indica l'oggetto di destinazione desiderato.È possibile specificare tale operando in diversi modi:

fn -- l'oggetto essere chiamato fn; dopo la chiamata l'oggetto function utilizza una copia fn

fnref -- l'oggetto denominato essere chiamato da fnref.get(); dopo la chiamata l'oggetto function utilizza un riferimento a fnref.get()

right -- l'oggetto richiamabile, se presente, utilizzato dall'oggetto rightdi function

npc -- un puntatore null; dopo la chiamata l'oggetto function è vuoto

In tutti i casi, INVOKE(f, t1, t2, ..., tN), dove f è l'oggetto chiamabile e t1, t2, ..., tN è lvalue dei tipi T1, T2, ..., TN rispettivamente, deve essere corretto e, se Ret non è void, convertibile in Ret.

Un oggetto vuoto function non utilizza un oggetto chiamabile o un riferimento a un oggetto essere chiamato.

Bb982519.collapse_all(it-it,VS.110).gifCostruttori

function::function

Crea un wrapper che è vuoto o archiviato un oggetto chiamabile di tipo arbitrario con una firma fissa.

Bb982519.collapse_all(it-it,VS.110).gifDefinizioni typedef

function::result_type

Il tipo restituito dell'oggetto chiamabile archiviato.

Bb982519.collapse_all(it-it,VS.110).gifFunzioni membro

function::assign

Assegna un oggetto chiamabile a questo oggetto funzione.

function::swap

Questi due oggetti carattere.

function::target

Test se l'oggetto chiamabile archiviato può essere chiamato come specificato.

function::target_type

Ottiene le informazioni sul tipo dell'oggetto essere chiamato.

Bb982519.collapse_all(it-it,VS.110).gifOperatori

function::operator unspecified

Test se l'oggetto chiamabile archiviato esistente.

function::operator()

Chiama un oggetto essere chiamato.

function::operator=

Sostituisce l'oggetto chiamabile archiviato.

Requisiti

intestazione: <functional>

Spazio dei nomi: deviazione standard

Vedere anche

Riferimenti

mem_fn Function

reference_wrapper Class