User-Defined operátorok (C++/CLI)

A felügyelt típusok felhasználó által definiált operátorai statikus tagokként vagy példánytagokként vagy globális hatókörben engedélyezettek. Azonban csak a statikus operátorok érhetők el metaadatokon keresztül a Visual C++-on kívüli nyelven írt ügyfelek számára.

Referenciatípus esetén egy statikus, felhasználó által definiált operátor egyik paraméterének a következők egyikének kell lennie:

• Egy fogantyú (type ^) a körülvevő típus egy példányára.

• Hivatkozástípus indirekt (type^> vagy^%) egy leíróra a beágyazási típus egy példányára.

Egy értéktípusban egy statikus, felhasználó által definiált operátor egyik paraméterének a következők egyikének kell lennie:

• A beágyazási érték típusával megegyező típusú.

• A mutató típusa indirekt (type^) a beágyazási típushoz.

• Hivatkozástípus indirekt (type% vagy type&) a beágyazási típushoz.

• Hivatkozástípus indirekt (^% vagy ^ &) a handle-re.

A következő operátorokat határozhatja meg:

Operátor	Egyoperandusú/Kétoperandusú Formák?
!	Unáris
!=	Bináris
%	Bináris
&	Unáris és Bináris
&&	Bináris
*	Unáris és Bináris
+	Unáris és Bináris
++	Unáris
,	Bináris
-	Unáris és Bináris
--	Unáris
->	Unáris
/	Bináris
<	Bináris
<<	Bináris
<=	Bináris
=	Bináris
==	Bináris
>	Bináris
>=	Bináris
>>	Bináris
^	Bináris
hamis	Unáris
igaz	Unáris
|	Bináris
||	Bináris
~	Unáris

Példa: Felhasználó által definiált operátorok

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

Példa: Operátorszintézis

Az alábbi minta az operátorszintézist mutatja be, amely csak akkor érhető el, ha a /clr-t használja a fordításhoz. Az operátorszintézis egy bináris operátor hozzárendelési formáját hozza létre, ha nincs definiálva, ahol a hozzárendelési operátor bal oldali része CLR-típussal rendelkezik.

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

Lásd még

Osztályok és struktúrák