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

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

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

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

• Uma indireta de tipo de referência (^& ou type^% detype) para uma maçaneta para uma instância do tipo delimitador.

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

• Do mesmo tipo que o tipo de valor delimitador.

• Uma indireta de tipo ponteiro detype(^) para o tipo delimitador.

• Uma indireta de tipo de referência (%typeou type&) para o tipo delimitador.

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

Você pode definir os seguintes operadores:

Operator	Formulários unários binários/?
!	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
verdadeiro	Unário
|	Binário
||	Binário
~	Unário

Exemplo

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

O exemplo a seguir demonstra a síntese do operador, que está disponível somente quando você usa /clr para compilar.A síntese do operador cria o formulário da atribuição de um operador binário, se um não é definido, onde 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);
}

Consulte também

Referência

Classes e Estruturas (Extensões de Componentes C++)