Opérateurs définis par l'utilisateur (C++/CLI)

Il permet des opérateurs définis par l'utilisateur pour les types managés comme membres statiques ou membres d'instance, ou au niveau de la portée globale.Toutefois, seules les opérateurs statiques sont accessibles via des métadonnées aux clients qui sont écrits dans un langage différent de Visual C++.

Dans un type référence, l'un des paramètres d'un opérateur défini par l'utilisateur statique doit être l'un de ces éléments :

• Un handle (^ d'type ) à une instance du type englobant.

• Une indirection de type référence (^& ou type^% d'type) à un handle à une instance du type englobant.

Dans un type valeur, l'un des paramètres d'un opérateur défini par l'utilisateur statique doit être l'un de ces éléments :

• Du même type que le type englobant valeur.

• Une indirection de type pointeur d'type(^) au type englobant.

• Une indirection de type référence (type% ou typeet) au type englobant.

• Une indirection de type référence (type^% ou ^& d' type) pour gérer.

Vous pouvez définir des opérateurs suivants :

Opérateur	Unaire/formes binaires ?
!	Unaire
!=	Binaire
%	Binaire
&	Unaire et binaire
&&	Binaire
*	Unaire et binaire
+	Unaire et binaire
++	Unaire
,	Binaire
-	Unaire et binaire
--	Unaire
->	Unaire
/	Binaire
<	Binaire
<<	Binaire
<=	Binaire
=	Binaire
==	Binaire
>	Binaire
>=	Binaire
>>	Binaire
^	Binaire
false	Unaire
true	Unaire
|	Binaire
||	Binaire
~	Unaire

Exemple

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

L'exemple suivant montre le résumé d'opérateur, qui est uniquement disponible lorsque vous utilisez /clr pour compiler.Le résumé d'opérateur crée la forme d'assignation d'un opérateur binaire, s'il n'est pas défini, où la partie gauche de l'opérateur d'assignation a un type 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);
}

Voir aussi

Référence

Classes et structs (extensions du composant C++)