função de classe

Artigo
08/25/2010

Wrapper para um objeto que pode ser chamado.

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(const function& right);
      template<class F>
            function(F fn);
      template<class F, class A>
            function(F fn, A ator);
      function(unspecified-null-pointer-type);

   function& operator=(null_ptr_type);
   function& operator=(const function&);
   template<class Fty2>
      function& operator=(Fty2);
   template<class Fty2>
      function& operator=(reference_wrapper<Fty2>);
   void swap(function&);

   operator unspecified() 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;

private:
   template<class Fty2>
       bool operator==(const Fty2&) const;  // undefined
   template<class Fty2>
      bool operator!=(const Fty2&) const;  // undefined
   };

Parâmetros

Fty
O tipo de função para encapsular.

Comentários

A classe de modelo é um wrapper telefonar cuja assinatura de telefonar é Ret(T1, T2, ..., TN). Você pode usá-lo para colocar uma variedade de objetos que pode ser chamados dentro de um wrapper uniforme.

Algumas funções de membro levar um operando que nomeia o objeto de destino desejado.Você pode especificar como um operando de várias maneiras:

fn --o objeto que pode ser chamado fn; Após a telefonar a function objeto mantém uma cópia do fn

fnref --o que pode ser chamado pelo objeto nomeado por fnref.get(); Após a telefonar a function objeto mantém uma referência fnref.get()

right --o objeto que pode ser chamado, se houver, mantidos pela function objeto right

npc --um ponteiro nulo; após a telefonar a function objeto estiver vazio

Em todos os casos, INVOKE(f, t1, t2, ..., tN), onde f é o objeto que pode ser chamado e t1, t2, ..., tN são lvalues de tipos T1, T2, ..., TN respectivamente, deve ser bem formado e, se Ret não é void, que podem ser convertidos para Ret.

Um vazio function objeto não possui um objeto que pode ser chamado ou uma referência a um objeto que pode ser chamado.