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

Les opérateurs définis par l’utilisateur pour les types managés sont autorisés en tant que membres statiques ou membres d’instance, ou à l’étendue globale. Toutefois, seuls les opérateurs statiques sont accessibles via des métadonnées aux clients qui sont écrits dans un langage autre que Visual C++.

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

• Handle (type ^) vers une instance du type englobant.

• Indirection de type référence (type^& ou type^%) à un handle vers une instance du type englobant.

Dans un type valeur, l’un des paramètres d’un opérateur statique défini par l’utilisateur doit être l’un des suivants :

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

• Un type de pointeur indirection (type^) vers le type englobant.

• Indirection de type référence (type% ou type&) au type englobant.

• Indirection de type référence (type^% ou type^&) au handle.

Vous pouvez définir les opérateurs suivants :

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

Exemple : opérateurs définis par l’utilisateur

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

Exemple : synthèse d’opérateurs

L’exemple suivant illustre la synthèse des opérateurs, qui est disponible uniquement lorsque vous utilisez /clr pour compiler. La synthèse d’opérateur crée la forme d’affectation d’un opérateur binaire, si elle n’est pas définie, où le côté gauche de l’opérateur d’affectation 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);
}

30

Voir aussi

Classes et structs