Operadores User-Defined (C++/CLI)

Os operadores definidos pelo usuário para tipos gerenciados são permitidos como membros estáticos ou membros da instância, ou no escopo global. No entanto, apenas operadores estáticos são acessíveis através de metadados para clientes que são escritos em uma linguagem diferente do Visual C++.

Em um tipo de referência, um dos parâmetros de um operador estático definido pelo usuário deve ser um destes:

• Um identificador (type ^) para uma instância do tipo de inclusão.

• Um tipo de referência de indireção (type^& ou type^%) para uma referência para uma instância do tipo envolvente.

Em um tipo de valor, um dos parâmetros de um operador estático definido pelo usuário deve ser um destes:

• Do mesmo tipo que o tipo de valor de delimitação.

• Um tipo de ponteiro de indireção (type^) para o tipo envolvente.

• Um tipo de referência indirection (type% ou type&) para o tipo de inclusão.

• Um tipo de referência indireta (type^% ou type^&) para o manipulador.

Você pode definir os seguintes operadores:

Operador	Formas unárias/binárias?
!	Unário
!=	Binário
%	Binário
&	Unário e binário
&&	Binário
*	Unário e binário
+	Unário e binário
++	Unário
,	Binário
-	Unário e binário
--	Unário
->	Unário
/	Binário
<	Binário
<<	Binário
<=	Binário
=	Binário
==	Binário
>	Binário
>=	Binário
>>	Binário
^	Binário
falso	Unário
verdadeiro	Unário
|	Binário
||	Binário
~	Unário

Exemplo: operadores definidos pelo usuário

// mcppv2_user-defined_operators.cpp
// compile with: /clr
using namespace System;
public ref struct X {
   X(int i) : m_i(i) {}
   X() {}

   int m_i;

   // static, binary, user-defined operator
   static X ^ operator + (X^ me, int i) {
      return (gcnew X(me -> m_i + i));
   }

   // instance, binary, user-defined operator
   X^ operator -( int i ) {
      return gcnew X(this->m_i - i);
   }

   // instance, unary, user-defined pre-increment operator
   X^ operator ++() {
      return gcnew X(this->m_i++);
   }

   // instance, unary, user-defined post-increment operator
   X^ operator ++(int i) {
      return gcnew X(this->m_i++);
   }

   // static, unary user-defined pre- and post-increment operator
   static X^ operator-- (X^ me) {
      return (gcnew X(me -> m_i - 1));
   }
};

int main() {
   X ^hX = gcnew X(-5);
   System::Console::WriteLine(hX -> m_i);

   hX = hX + 1;
   System::Console::WriteLine(hX -> m_i);

   hX = hX - (-1);
   System::Console::WriteLine(hX -> m_i);

   ++hX;
   System::Console::WriteLine(hX -> m_i);

   hX++;
   System::Console::WriteLine(hX -> m_i);

   hX--;
   System::Console::WriteLine(hX -> m_i);

   --hX;
   System::Console::WriteLine(hX -> m_i);
}

-5
-4
-3
-2
-1
-2
-3

Exemplo: Síntese do operador

O exemplo a seguir demonstra a síntese do operador, que só está disponível quando você usa /clr para compilar. A síntese de operadores cria a forma de atribuição de um operador binário, se este não estiver já definido, onde o lado esquerdo do operador de atribuição é de um tipo CLR.

// mcppv2_user-defined_operators_2.cpp
// compile with: /clr
ref struct A {
   A(int n) : m_n(n) {};
   static A^ operator + (A^ r1, A^ r2) {
      return gcnew A( r1->m_n + r2->m_n);
   };
   int m_n;
};

int main() {
   A^ a1 = gcnew A(10);
   A^ a2 = gcnew A(20);

   a1 += a2;   // a1 = a1 + a2   += not defined in source
   System::Console::WriteLine(a1->m_n);
}

30

Ver também

Classes e Estruturas