Surcharge d'opérateur en C#

La surcharge peut être définie comme un processus de définition et de mise en œuvre de la technique du polymorphisme, qui permet aux variables ou aux objets du programme de prendre diverses autres formes lors de l'exécution du code. Cette technique peut être utilisée lorsque les propriétés de la méthode ne sont pas similaires au type d'arguments, à un ordre d'exécution différent, lorsqu'il existe plusieurs méthodes avec le même nom et des propriétés différentes, etc. Ceci peut être réalisé dans un programme avec différentes méthodes, tels que le nombre différent de paramètres, les différents types de paramètres, l'ordre différent des paramètres, les paramètres facultatifs et les arguments nommés.

Diverses surcharges d'opérateurs en C#

Il existe plusieurs opérateurs en C#.

1. Nous pouvons surcharger tous les opérateurs binaires, c'est-à-dire +, -, *, /, %, &, |, <<, >>.
2. Nous pouvons surcharger tous les opérateurs unaires, c'est-à-dire ++, –, true, false, + , -, ~.
3. Certains opérateurs comme &&, ||,[] ,() ne peuvent pas être surchargés.
4. On peut surcharger les opérateurs relationnels par paires. Ce sont ==, =, <, >, <= , >= etc.
5. Nous pouvons surcharger les opérateurs composés car ils sont déjà surchargés par rapport à l'opérateur binaire.

Voici donc quelques opérateurs prédéfinis que nous pouvons surcharger.

Syntaxe :

Vous trouverez ci-dessous la syntaxe d'implémentation de la surcharge d'opérateur :

public static classname  operator op (parameters)
{
// Code
}

Pour l'opérateur unaire

public static classname operator op (t)
{
// Code
}

Pour l'opérateur binaire

public static classname operator op (t1, t2)
{
// Code
}

Operator est le mot-clé utilisé pour implémenter la surcharge d'opérateur. Le type de retour de surcharge d'opérateur ne peut jamais être nul. Dans la surcharge des opérateurs, la préférence est toujours donnée aux implémentations définies par l'utilisateur plutôt qu'aux implémentations prédéfinies. En cas de surcharge, les méthodes surchargées doivent avoir un type d'arguments différent, un nombre d'arguments différent et l'ordre des arguments doivent être différents. Les méthodes surchargées d’opérateurs sont donc les mêmes que toutes les autres méthodes. Dans les implémentations définies par l'utilisateur, la syntaxe et la priorité ne peuvent pas être modifiées. Dans l'opérateur binaire, celui de gauche de .operator est un membre et sur le côté droit, l'objet est appelé un paramètre.

Exemples de surcharge d'opérateurs en C#

Vous trouverez ci-dessous les exemples qui montrent comment implémenter le concept de surcharge d'opérateur en C# :

Exemple n°1

Surcharge d'opérateur avec opérateur unaire. Dans cet exemple, l'opérateur unaire est utilisé pour la surcharge. – L’opérateur est utilisé dans la classe nommée Exemple qui appelle la méthode de surcharge.  Comme mentionné ci-dessous, le compilateur de code le prend comme opérateur-(obj);.

Code :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OperatorOverloading
{
class Example
{
public int val1, val2;
public Example(int no1, int no2)
{
val1 = no1;
val2 = no2;
}
public Example()
{
}
public static Example operator -(Example eg1)
{
eg1.val1 = -eg1.val1;
eg1.val1 = -eg1.val1;
return eg1;
}
public void Print()
{
Console.WriteLine("value1 =" + val1);
Console.WriteLine("value2 =" + val2);
Console.Read();
}
class Program
{
static void Main(string[] args)
{
Example eg = new Example(30, -60);
eg.Print();
Example eg1 = new Example();
eg1 = -eg;
eg1.Print();
Console.Read();
}
}
}
}

Sortie :

Exemple n°2

Surcharge d'opérateur avec opérateur binaire. Dans cet exemple, l'opérateur binaire est utilisé pour montrer comment nous pouvons implémenter la surcharge d'opérateur. L'opérateur + est utilisé pour ajouter les objets. L'opérateur reçoit un paramètre. Dans le code, num est un objet de la classe nommée Exemple à laquelle l'objet est passé. En surcharge, celui de gauche de l'opérateur est un membre et du côté droit, l'objet est appelé paramètre.

Code :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OperatorOverloading
{
class Example
{
public int num;
public Example()
{
num = 0;
}
public Example(int n)
{
num = n;
}
public static Example operator +(Example e1, Example e2)
{
Example e3 = new Example();
e3.num = e1.num + e2.num;
return e3;
}
public void display()
{
Console.WriteLine("{0}", num);
}
}
class Program
{
static void Main(string[] args)
{
Example num = new Example(200);
Example num1 = new Example(300);
Example num2 = new Example();
num2 = num + num1;
num.display();
num1.display();
num2.display();
Console.Read();
}
}
}

Sortie :

Exemple #3

Surcharge des opérateurs et héritage.

Code :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OperatorOverloading
{
class Example
{
public int num;
public Example()
{
num = 0;
}
public Example(int n)
{
num = n;
}
public static Example operator +(Example e1, Example e2)
{
Example e3 = new Example();
e3.num = e1.num + e2.num;
return e3;
}
public void display()
{
Console.WriteLine("{0}", num);
}
}
class Example1 : Example
{
private double a;
private double b;
public Example1(double x, double y)
{
a = x;
b = y;
}
public Example1()
{
}
public void Show()
{
Console.WriteLine("{0} {1}", a, b);
}
}
class Program
{
static void Main(string[] args)
{
Example1 num = new Example1(20.0,2.3);
num.Show();
Example1 num1 = new Example1(3.0,3.1);
num1.Show();
Example1 num2 = new Example1();
//num2 = num + num1;
//num2.Show();
Console.Read();
}
}
}

Sortie :

Les opérateurs surchargés peuvent également être hérités de la classe dérivée. Comme il n'est pas possible d'opérateur déclaré dans la classe dérivée pour masquer l'opérateur déclaré de la classe de base.

Exemple n°4

Surcharge d'opérateurs avec des opérateurs d'égalité. Dans cet exemple, la surcharge d'opérateur est illustrée à l'aide de l'opérateur d'égalité. L'opérateur d'égalité est utilisé lorsque nous voulons faire une comparaison. Nous pouvons surcharger la méthode dans la classe pour faire une comparaison. Dans ce code, les valeurs des objets e1 et e2 sont les mêmes. Mais leurs références sont différentes. La comparaison des valeurs des objets est basée sur des références. Dans le cas de e2 et e3, il fait référence au même objet.

Code :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OperatorOverloading
{
class Example
{
private int a;
private int b;
public Example()
{
}
public Example(int x, int y)
{
a = x;
b = y;
}
public void Display()
{
Console.WriteLine("{0} {1}", a, b);
}
}
class Program
{
public static void Main()
{
Example e1 = new Example(30, 20);
e1.Display();
Example e2 = new Example(30, 20);
e2.Display();
Example e3 = e2;
e3.Display();
if (e1.Equals(e2))
Console.WriteLine("equal");
else
Console.WriteLine("not equal");
if (e2.Equals(e3))
Console.WriteLine("equal");
Console.ReadLine();
}
}
}

Sortie :

Conclusion

La surcharge des opérateurs est un concept important. Il permet la réutilisation des opérateurs dans plusieurs opérations. En C#, nous ne pouvons surcharger qu’un ensemble défini de paramètres. Tous les langages de .Net ne prennent pas en charge la surcharge des opérateurs. Ainsi, en C#, il offre des fonctionnalités supplémentaires en termes d'implémentations définies par l'utilisateur.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!