Benutzerdefinierte Operatoren (C++/CLI)

Benutzerdefinierte Operatoren für verwaltete Typen sind als statische Member oder Instanzmember oder auf globaler Ebene zulässig. Auf statische Operatoren kann jedoch nur über Metadaten für Clients zugegriffen werden, die in einer anderen Sprache als Visual C++ geschrieben sind.

In einem Verweistyp muss einer der Parameter eines statischen benutzerdefinierten Operators einer der folgenden sein:

• Ein Handle (type ^) zu einer Instanz des eingeschlossenen Typs.

• Eine Referenztypdereferenzierung (type^& oder Typ^%) für ein Handle für eine Instanz des eingeschlossenen Typs.

In einem Werttyp muss einer der Parameter eines statischen benutzerdefinierten Operators einer der folgenden sein:

• Derselbe Typ wie der eingeschlossene Werttyp.

• Eine Zeigertypdereferenzierung (type^) auf den eingeschlossenen Typ.

• Eine Verweistypdereferenzierung (type% oder type&) auf den eingeschlossenen Typ.

• Eine Referenztypdereferenzierung (type^% oder type^&) zum Handle.

Sie können die folgenden Operatoren definieren:

Operator	Unary/Binary Forms?
!	Unär
!=	Binary
%	Binary
&	Unär und binär
&&	Binary
*	Unär und binär
+	Unär und binär
++	Unär
,	Binary
-	Unär und binär
--	Unär
->	Unär
/	Binary
<	Binary
<<	Binary
<=	Binary
=	Binary
==	Binary
>	Binary
>=	Binary
>>	Binary
^	Binary
false	Unär
true	Unär
|	Binary
||	Binary
~	Unär

Beispiel: Benutzerdefinierte Operatoren

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

Beispiel: Operatorsynthese

Im folgenden Beispiel wird die Operatorsynthese veranschaulicht, die nur verfügbar ist, wenn Sie /clr zum Kompilieren verwenden. Die Operatorsynthese erstellt die Zuordnungsform eines binären Operators, wenn eine nicht definiert ist, wobei die linke Seite des Zuordnungsoperators einen CLR-Typ aufweist.

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

Siehe auch

Klassen und Strukturen