delegado (Extensões de Componentes C++)

Declara um tipo que representa um ponteiro de função.

Todos os Tempos de Execução

O Tempo de Execução do Windows e o common language runtime dão suporte a delegados.

Comentários

delegate é uma palavra-chave contextual. Para obter mais informações, consulte Palavras-chave Contextuais (Extensões de Componentes C++).

Para detectar um tempo de compilação se um tipo for um delegado, use a característica do tipo __is_delegate(). Para obter mais informações, consulte Suporte para Compilador de Traços de Tipo (Extensões de Componentes C++).

Tempo de execução do windows

C++/CX dá suporte a delegados com a sintaxe a seguir.

Sintaxe

access delegate return-type delegate-type-identifier ([ parameters ])

Parâmetros

• access
  (opcional) A acessibilidade do delegado, que pode ser public (o padrão) ou private. O protótipo de função também pode ser qualificada com as palavras-chave const ou de volatile.

• return-type
  O tipo de retorno de protótipo de função.

• delegate-type-identifier
  O nome do tipo delegado declarado.

• parameters
  (Opcional) Os tipos e identificadores do protótipo de função.

Comentários

Use delegate-type-identifier para declarar um evento com o mesmo protótipo que o representante. Para obter mais informações, consulte Delegates (C++/CX).

Requisitos

Opção do compilador: /ZW

Common Language Runtime

O common language runtime dá suporte a delegados com a sintaxe a seguir.

Sintaxe

access delegate function_declaration

Parâmetros

• access
  (opcional) A acessibilidade de delegado fora do assembly pode ser pública ou particular. O padrão é privado. Dentro de uma classe, um delegado pode ter qualquer acessibilidade.

• function_declaration
  A assinatura de função que pode ser associada ao delegado. O tipo de retorno de um delegado pode ser qualquer tipo gerenciado. Por motivos de interoperabilidade, é recomendável que o tipo de retorno de um delegado seja um tipo CLS.

  Para definir um representante não associadas, o primeiro parâmetro em function_declaration deve ser o tipo de ponteiro de this para o objeto. Para obter mais informações, consulte Delegados não acoplados.

Comentários

Delegados são multicast: o "ponteiro de função" pode ser associado a um ou mais métodos em uma classe gerenciada. A palavra-chave delegate define um tipo de destino multicast com uma assinatura específica do método.

Um delegado também pode ser associado a um método de uma classe de valor, como um método estático.

Um delegado tem as seguintes características:

• Herda de System::MulticastDelegate.

• Tem um construtor que utiliza dois argumentos: um ponteiro para uma classe gerenciada ou a NULO (no caso de associação a um método estático) e um método totalmente qualificado do tipo especificado.

• Tem um método chamado Invoke, cuja assinatura corresponde à assinatura do delegado declarado.

Quando um delegado é chamado, suas funções são chamadas na ordem em que foram anexadas.

O valor de retorno de um delegado é o valor de retorno da função do membro anexado por último.

Delegados não podem ser sobrecarregados.

Delegados podem ser associados ou não associados.

Quando você cria uma instância de um delegado associado, o primeiro argumento será uma referência de objeto. O segundo argumento de uma instanciação de delegado deve ser o endereço de um método de um objeto de classe gerenciada ou um ponteiro para um método de um tipo de valor. O segundo argumento de uma instanciação de delegado deve nomear o método com a sintaxe de escopo de classe completa e aplicar o operador address-of.

Quando você cria uma instância de um delegado não associado, o primeiro argumento será o endereço de um método de um objeto de classe gerenciada ou um ponteiro para um método de um tipo de valor. O argumento deve nomear o método com a sintaxe de escopo de classe completa e aplicar o operador address-of.

Ao criar um delegado para uma função estática ou global, somente um parâmetro é necessário: a função (opcionalmente, o endereço da função).

Para obter mais informações sobre delegados, consulte

• Delegados não acoplados

• Como: definir e usar delegados

• Delegar a um membro de uma classe de valor

• Delegar a uma função não gerenciada

• Delegados compostos

• Como: passar um delegado ^ para uma função nativa esperando um ponteiro de função

• Delegados genéricos (Visual C++)

Requisitos

Opção do compilador: /clr

Exemplos

Exemplo

O exemplo a seguir mostra como declarar, inicializar e invocar delegados.

// mcppv2_delegate.cpp
// compile with: /clr
using namespace System;

// declare a delegate
public delegate void MyDel(int i);

ref class A {
public:
   void func1(int i) {
      Console::WriteLine("in func1 {0}", i);
   }

   void func2(int i) {
      Console::WriteLine("in func2 {0}", i);
   }

   static void func3(int i) {
      Console::WriteLine("in static func3 {0}", i);
   }
};

int main () {
   A ^ a = gcnew A;

   // declare a delegate instance
   MyDel^ DelInst;

   // test if delegate is initialized
   if (DelInst)
      DelInst(7);
   
   // assigning to delegate
   DelInst = gcnew MyDel(a, &A::func1);

   // invoke delegate
   if (DelInst)
      DelInst(8);

   // add a function
   DelInst += gcnew MyDel(a, &A::func2);

   DelInst(9);

   // remove a function
   DelInst -= gcnew MyDel(a, &A::func1);

   // invoke delegate with Invoke
   DelInst->Invoke(10);

   // make delegate to static function
   MyDel ^ StaticDelInst = gcnew MyDel(&A::func3);
   StaticDelInst(11);
}

Saída

Consulte também

Conceitos

Extensões de componente para plataformas de tempo de execução