Benutzerdefinierte Operatoren (C++/CLI)

Benutzerdefinierte Operatoren für verwaltete Typen werden als statische Member können oder Member oder im globalen Gültigkeitsbereich einer Instanz.jedoch nur statische Operatoren sind von Metadaten zu den Clients zugreifen, die in eine andere Sprache als Visual C++ geschrieben werden.

In einem Referenztyp muss einer der Parameter eines statischen benutzerdefinierten Operators einer dieser sein:

• Ein Handle type (^) an eine Instanz des einschließenden Typs.

• Eine Verweistypdereferenzierung (type^& oder type^%) zu einem Handle einer Instanz des einschließenden Typs.

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

• Wählen Sie denselben Typ wie der einschließende Werttyp.

• Eine Zeigertypdereferenzierung type(^) dem einschließenden Typ.

• Eine Verweistypdereferenzierung (type% oder type&.) dem einschließenden Typ.

• Eine Verweistypdereferenzierung (type^% oder type^&) in Anspruch.

Sie können die folgenden Operatoren definieren:

Beispiel

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

Im folgenden Beispiel wird Operatorsynthese, die nur verfügbar ist, wenn Sie /clr verwenden, um zu kompilieren.Operatorsynthese erstellt das Abtretungsformular eines binären Operators, wenn nicht definiert ist, wobei die linke Seite des Zuweisungsoperators einen CLR-Typ verfügt.

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

Siehe auch

Referenz

Classes and Structs (Managed)