User-Defined Operators (C++/CLI)

Door de gebruiker gedefinieerde operators voor beheerde typen zijn toegestaan als statische leden of exemplaarleden, of in globale bereik. Alleen statische operators zijn echter toegankelijk via metagegevens voor clients die zijn geschreven in een andere taal dan Visual C++.

In een verwijzingstype moet een van de parameters van een statische door de gebruiker gedefinieerde operator een van de volgende zijn:

• Een verwijzing (type ^) naar een exemplaar van het omsluitende type.

• Een indirectie van een verwijzingstype (type^& of type^%) naar een verwijzing naar een instantie van het omsluittype.

In een waardetype moet een van de parameters van een statische door de gebruiker gedefinieerde operator een van de volgende zijn:

• Van hetzelfde type als het omhullende waardetype.

• Een aanwijzertype indirectie (type^) naar het omsluittype.

• Een verwijzingstype indirectie (type% of type&) naar het omsluittype.

• Een indirectie van het verwijzingstype (type^% of type^&) naar de handle.

U kunt de volgende operators definiëren:

Operateur	Unaire/binaire vormen?
!	Unaire
!=	Binaire
%	Binaire
&	Unary en Binary
&&	Binaire
*	Unary en Binary
+	Unary en Binary
++	Unaire
,	Binaire
-	Unary en Binary
--	Unaire
->	Unaire
/	Binaire
<	Binaire
<<	Binaire
<=	Binaire
=	Binaire
==	Binaire
>	Binaire
>=	Binaire
>>	Binaire
^	Binaire
onwaar	Unaire
waar	Unaire
|	Binaire
||	Binaire
~	Unaire

Voorbeeld: Door de gebruiker gedefinieerde operators

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

Voorbeeld: Operator synthese

In het volgende voorbeeld ziet u operatorsynthese, die alleen beschikbaar is wanneer u /clr gebruikt om te compileren. De operatorsynthese maakt de toewijzingsvorm van een binaire operator, als deze niet is gedefinieerd, waarbij de linkerkant van de toewijzingsoperator een CLR-type heeft.

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

Zie ook

Klassen en Structs