Benutzerdefinierte Operatoren (C++/CLI)

Benutzerdefinierte Operatoren für verwaltete Typen sind als statische Mitglieder oder Instanzmitglieder oder auf globalem Umfang 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 Referenztyp-Indirektion (^& oder Typ^%) zu einem Handle für eine Instanz des umgebenden Typs.

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

• Derselbe Typ wie der eingeschlossene Werttyp.

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

• Ein indirekter Verweis (type% oder type&) auf den umschließenden Typ.

• Eine Referenztypindirektion (type^% oder type^&) auf das Handle.

Sie können die folgenden Operatoren definieren:

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