Operatory zdefiniowane przez użytkownika (C++/CLI)

Operatory zdefiniowane przez użytkownika dla typów zarządzanych są dozwolone jako statyczne elementy członkowskie lub elementy członkowskie wystąpienia lub w zakresie globalnym. Jednak tylko operatory statyczne są dostępne za pośrednictwem metadanych dla klientów napisanych w języku innym niż Visual C++.

W typie odwołania jeden z parametrów statycznego operatora zdefiniowanego przez użytkownika musi być jednym z następujących:

• Uchwyt (type ^) do wystąpienia otaczającego typu.

• Pośredni typ odwołania (type^& lub type^%) do dojścia do wystąpienia otaczającego typu.

W typie wartości jeden z parametrów statycznego operatora zdefiniowanego przez użytkownika musi być jednym z następujących:

• Tego samego typu co typ otaczającej wartości.

• Pośredni typ wskaźnika (type^) do otaczającego typu.

• Pośredni typ odwołania (type% lub type&) do otaczającego typu.

• Pośredni typ odwołania (type^% lub type^&) do uchwytu.

Można zdefiniować następujące operatory:

Operator	Formularze jednoargumentowe/binarne?
!	Jednoargumentowy
!=	Plik binarny
%	Plik binarny
&	Jednoargumentowe i binarne
&&	Plik binarny
*	Jednoargumentowe i binarne
+	Jednoargumentowe i binarne
++	Jednoargumentowy
,	Plik binarny
-	Jednoargumentowe i binarne
--	Jednoargumentowy
->	Jednoargumentowy
/	Plik binarny
<	Plik binarny
<<	Plik binarny
<=	Plik binarny
=	Plik binarny
==	Plik binarny
>	Plik binarny
>=	Plik binarny
>>	Plik binarny
^	Plik binarny
fałsz	Jednoargumentowy
prawda	Jednoargumentowy
|	Plik binarny
||	Plik binarny
~	Jednoargumentowy

Przykład: operatory zdefiniowane przez użytkownika

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

Przykład: synteza operatorów

W poniższym przykładzie pokazano syntezę operatora, która jest dostępna tylko w przypadku użycia /clr do skompilowania. Synteza operatora tworzy formę przypisania operatora binarnego, jeśli nie jest zdefiniowany, gdzie lewa strona operatora przypisania ma typ 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

Zobacz też

Klasy i struktury