Operadores definidos pelo usuário (C++/CLI)

Os operadores definidos pelo usuário para tipos gerenciados são permitidos como membros estáticos ou membros de instância ou no escopo global. No entanto, somente operadores estáticos são acessíveis por meio de metadados para clientes escritos em um idioma diferente do Visual C++.

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

• Um identificador (type ^) para uma instância do tipo delimitador.

• Um tipo de referência indirection (type^& ou type^%) para um identificador para uma instância do tipo de delimitação.

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

• Do mesmo tipo que o tipo de valor delimitador.

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

• Um tipo de referência indireção (type% ou type&) para o tipo de delimitação.

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

Você pode definir os seguintes operadores:

Operador	Formas uniá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
false	Unário
true	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 do operador cria a forma de atribuição de um operador binário, se não for definida, em que o lado esquerdo do operador de atribuição tem 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

Confira também

Classes e Structs