Comment travailler avec la surcharge d'opérateurs en C #

Le polymorphisme est l'un des principes de base de la programmation orientée objet (Object Oriented Programming). Le mot polymorphisme est dérivé de deux mots - «poly» signifiant plusieurs et «morph» signifiant des formes. Le polymorphisme implique donc l'existence de la même chose mais sous des formes différentes.

La surcharge d'opérateurs est un exemple de polymorphisme statique. Vous pouvez tirer parti de la surcharge des opérateurs ou ajouter des fonctionnalités aux opérateurs afin de travailler avec des types définis par l'utilisateur de la même manière que vous travaillez avec des types de données fondamentaux.

Quels sont les opérateurs et quels sont les opérateurs qui peuvent être surchargés?

Dans une expression, vous avez généralement des opérateurs et des opérandes. Les opérateurs sont ceux qui travaillent sur les opérandes et ils font tous partie d'une expression. À titre d'exemple, voici une expression qui contient deux opérandes et un opérateur. Les opérandes sont X et Y et l'opérateur est +.

X + Y

Les opérateurs sont classés comme unaire, binaire, comparaison, affectation, etc. en fonction de leur objectif et du nombre d'opérandes sur lesquels les opérateurs travailleraient. Bien que la plupart des opérateurs puissent être surchargés, certaines restrictions s'appliquent. En substance, tous les opérateurs ne peuvent pas être surchargés.

Les opérateurs unaires, c'est-à-dire les opérateurs qui travaillent avec un opérande, peuvent être surchargés. Vous pouvez également surcharger les opérateurs binaires et les opérateurs de comparaison comme, ==,! =,, =. Cependant, vous ne pouvez pas surcharger les opérateurs =,?, ->, new, is, sizeof ou typeof. Vous ne pouvez pas non plus surcharger les opérateurs conditionnels comme && et || facilement. En outre, l'opérateur d'indexation de tableau [] ne peut pas être surchargé.

Vous pouvez en savoir plus sur ce que tous les opérateurs peuvent être surchargés à partir de cet article MSDN.

Implémentation de la surcharge d'opérateurs en C #

Dans cette section, nous allons explorer comment nous pouvons implémenter la surcharge d'opérateurs en C #. Considérez la classe suivante nommée DistanceCalculator.

public class DistanceCalculator

   {

       Int32 feet = 0, inch = 0;

       public DistanceCalculator(Int32 feet = 0, Int32 inch = 0)

       {

           this.feet = feet;

           this.inch = inch;

       }

   }

Reportez-vous à la liste des codes ci-dessus. La classe DistanceCalculator contient deux membres de données de type Int32, à savoir, pieds et pouces. Nous ajouterions maintenant plus de méthodes à cette classe pour illustrer comment les opérateurs peuvent être surchargés.

Lorsque vous travaillez avec une surcharge de l'opérateur, vous devez garder certains points à l'esprit. L'opérateur à surcharger doit avoir une méthode correspondante marquée avec l'opérateur de mot-clé. Les arguments de la fonction opérateur sont des opérandes et votre fonction opérateur peut renvoyer une valeur. La fonction d'opérateur doit être statique et doit être membre du type conteneur.

L'extrait de code suivant illustre à quoi ressemblerait une fonction d'opérateur typique. Cet exemple montre comment les opérateurs == et! = Peuvent être surchargés.

public static bool operator ==(DistanceCalculator obj1, DistanceCalculator obj2)

       {

           return obj1.Value == obj2.Value;

       }

       public static bool operator !=(DistanceCalculator obj1, DistanceCalculator obj2)

       {

           return obj1.Value != obj2.Value;

       }

Notez que Value est une propriété qui renvoie la valeur en pouces.

public Int32 Value

       {

           get

           {

               return (feet * 12) + inch;

           }

       }

Voici la liste complète des codes de la classe DistanceCalculator.

public class DistanceCalculator

   {

       Int32 feet = 0, inch = 0;

       public DistanceCalculator(Int32 feet = 0, Int32 inch = 0)

       {

           this.feet = feet;

           this.inch = inch;

       }

       public static bool operator ==(DistanceCalculator obj1, DistanceCalculator obj2)

       {

           return obj1.Value == obj2.Value;

       }

       public static bool operator !=(DistanceCalculator obj1, DistanceCalculator obj2)

       {

           return obj1.Value != obj2.Value;

       }

       public override bool Equals(object obj)

       {

           DistanceCalculator distanceCalculator = obj as DistanceCalculator;

           if (distanceCalculator != null)

           {

               return (distanceCalculator == this);

           }

           return false;

       }

       public override int GetHashCode()

       {

           return Value.GetHashCode();

       }

     public Int32 Feet

       {

           get { return feet; }

       }

       public Int32 Inch

       {

           get { return inch; }

       }

       public Int32 Value

       {

           get

           {

               return (feet * 12) + inch;

           }

       }

   }

L'extrait de code suivant illustre comment vous pouvez utiliser la classe DistanceCalculator.

static void Main(string[] args)

       {

           DistanceCalculator obj1 = new DistanceCalculator(1, 2);

           DistanceCalculator obj2 = new DistanceCalculator(1, 2);

           Console.WriteLine((obj1 == obj2).ToString());

           Console.Read();

       }

L'extrait de code suivant montre comment vous pouvez surcharger l'opérateur + pour ajouter deux objets.

public static DistanceCalculator operator +(DistanceCalculator obj1, DistanceCalculator obj2)

       {

           Int32 totalInches = obj1.Value + obj2.Value;

           Int32 feet = totalInches / 12;

           Int32 inch = totalInches % 12;

           DistanceCalculator temp = new DistanceCalculator(feet, inch);

           return temp;

       }

Ajoutons les deux propriétés suivantes à la classe DistanceCalculator. L'extrait de code suivant montre comment vous pouvez ajouter deux objets de type DistanceCalculator et renvoyer l'objet résultant sous le même type, c'est-à-dire que l'objet renvoyé est de type DistanceCalculator.

public Int32 Feet

       {

           get { return feet; }

       }

       public Int32 Inch

       {

           get { return inch; }

       }

Voici comment créer deux instances de la classe DistanceCalculator et tirer parti de la fonction d'opérateur surchargée pour affecter le résultat à un autre objet du même type.

static void Main(string[] args)

       {

           DistanceCalculator obj1 = new DistanceCalculator(1, 11);

           DistanceCalculator obj2 = new DistanceCalculator(1, 2);

           DistanceCalculator obj3 = obj1 + obj2;

           Console.WriteLine("Feet: "+obj3.Feet.ToString());

           Console.WriteLine("Inch: " + obj3.Inch.ToString());

           Console.Read();

       }