Operadores definidos por el usuario (C++/CLI)

Los operadores definidos por el usuario para los tipos administrados se permiten como miembros estáticos o miembros de instancia, o en el ámbito global. Sin embargo, solo los operadores estáticos son accesibles a través de metadatos para los clientes que se escriben en un lenguaje distinto de Visual C++.

En un tipo de referencia, uno de los parámetros de un operador estático definido por el usuario debe ser uno de estos:

• Identificador (type ^) en una instancia del tipo envolvente.

• Un tipo de referencia indirecto (type^& o type^%) a un identificador de una instancia del tipo envolvente.

En un tipo de valor, uno de los parámetros de un operador estático definido por el usuario debe ser uno de estos:

• Del mismo tipo que el tipo de valor envolvente.

• Un tipo de puntero indirecto (type^) al tipo envolvente.

• Un tipo de referencia indirecto (type% o type&) al tipo envolvente.

• Un tipo de referencia indirecto (type^% o type^&) al identificador.

Puede definir los operadores siguientes:

Operador	¿Formularios unarios/binarios?
!	Unario
!=	Binary
%	Binary
&	Unario y binario
&&	Binario
*	Unario y binario
+	Unario y binario
++	Unario
,	Binario
-	Unario y binario
--	Unario
->	Unario
/	Binary
<	Binary
<<	Binary
<=	Binary
=	Binary
==	Binary
>	Binary
>=	Binary
>>	Binary
^	Binary
false	Unario
true	Unario
|	Binary
||	Binary
~	Unario

Ejemplo: Operadores definidos por el usuario

// 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

Ejemplo: Síntesis de operadores

En el ejemplo siguiente se muestra la síntesis de operadores, que solo está disponible cuando se usa /clr para compilar. La síntesis de operador crea la forma de asignación de un operador binario, si no se define una, donde el lado izquierdo del operador de asignación tiene un 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

Consulte también

Clases y structs