English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Tutoriel de base C#

Tutoriel avancé C#

C# OOP (Programmation Orientée Objet)

Surcharge des opérateurs en C#

Vous pouvez redéfinir ou surcharger les opérateurs intégrés de C#. Par conséquent, les programmeurs peuvent également utiliser les opérateurs de types personnalisés. La surcharge de l'opérateur est une fonction à nom spécial, définie par le mot-clé operator Défini après le symbole de l'opérateur. Comme d'autres fonctions, la surcharge de l'opérateur a un type de retour et une liste de paramètres.

Par exemple, regardez la fonction suivante :

public static Box operator+　(Box b, Box c)
{
　　　Box box = new Box();
　　　box.length = b.length　+　c.length;
　　　box.breadth = b.breadth　+　c.breadth;
　　　box.height = b.height　+　c.height;
　　　return box;
}

La fonction suivante réalise l'opérateur d'addition pour la classe Box personnalisée :+）。Il additionne les propriétés de deux objets Box et retourne l'objet Box ajouté.

Implémentation de l'opérateur surcharge

Le programme suivant montre une implémentation complète :

using System;
namespace OperatorOvlApplication
{
　　　class Box
　　　{
　　　　　　private double length;　　　　　　//　longueur
　　　　　　private double breadth;　　　　　//　largeur
　　　　　　private double height;　　　　　　//　hauteur
　　　　　　public double getVolume()
　　　　　　{
　　　　　　　　　return length　*　breadth　*　height;
　　　　　　}
　　　　　　public void setLength(double len)
　　　　　　{
　　　　　　　　　length = len;
　　　　　　}
　　　　　　public void setBreadth(double bre)
　　　　　　{
　　　　　　　　　breadth = bre;
　　　　　　}
　　　　　　public void setHeight(double hei)
　　　　　　{
　　　　　　　　　height = hei;
　　　　　　}
　　　　　　//　surcharge　+　l'opérateur pour additionner deux objets Box
　　　　　　public static Box operator+　(Box b, Box c)
　　　　　　{
　　　　　　　　　Box box = new Box();
　　　　　　　　　box.length = b.length　+　c.length;
　　　　　　　　　box.breadth = b.breadth　+　c.breadth;
　　　　　　　　　box.height = b.height　+　c.height;
　　　　　　　　　return box;
　　　　　　}
　　　}
　　　class Tester
　　　{
　　　　　　static void Main(string[] args)
　　　　　　{
　　　　　　　　　Box Box1　= new Box();　　　　　　　　　//　déclaration de Box1de type Box
　　　　　　　　　Box Box2　= new Box();　　　　　　　　　//　déclaration de Box2de type Box
　　　　　　　　　Box Box3　= new Box();　　　　　　　　　//　déclaration de Box3de type Box
　　　　　　　　　double volume = 0.0;　　　　　　　　　　//　volume
　　　　　　　　　//　Box1　détails
　　　　　　　　　Box1.setLength(6.0);
　　　　　　　　　Box1.setBreadth(7.0);
　　　　　　　　　Box1.setHeight(5.0);
　　　　　　　　　//　Box2　détails
　　　　　　　　　Box2.setLength(12.0);
　　　　　　　　　Box2.setBreadth(13.0);
　　　　　　　　　Box2.setHeight(10.0);
　　　　　　　　　//　Box1　le volume
　　　　　　　　　volume = Box1.getVolume();
　　　　　　　　　Console.WriteLine("Box1　le volume : {0}", volume);
　　　　　　　　　//　Box2　le volume
　　　　　　　　　volume = Box2.getVolume();
　　　　　　　　　Console.WriteLine("Box2　le volume : {0}", volume);
　　　　　　　　　//　ajouter deux objets
　　　　　　　　　Box3　Égal à Box1　+　Box2;
　　　　　　　　　//　Box3　le volume
　　　　　　　　　volume = Box3.getVolume();
　　　　　　　　　Console.WriteLine("Box3　le volume : {0}", volume);
　　　　　　　　　Console.ReadKey();
　　　　　　}
　　　}
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

Box1　Le volume :　210
Box2　Le volume :　1560
Box3　Le volume :　5400

Opérateurs redéfinissables et non redéfinissables

Le tableau suivant décrit les capacités de surcharge des opérateurs en C# :

OpérateurDescription
+, -, !, ~, ++, --Ces opérateurs unaires ont un seul opérande et peuvent être redéfinis.
+, -, *, /, %Ces opérateurs binaires ont deux opérandes et peuvent être redéfinis.
==, !=, <, >, <=, >=Ces opérateurs de comparaison peuvent être redéfinis.
&&, ||Ces opérateurs logiques conditionnels ne peuvent pas être redéfinis directement.
+=, -=, *=, /=, %=Ces opérateurs d'affectation ne peuvent pas être redéfinis.
>, new, is, sizeof, typeof -=, ., ?:,Ces opérateurs ne peuvent pas être surchargés.

exemple en ligne

Afin de développer l'exemple ci-dessus, surchargeons plus d'opérateurs :

using System;
namespace OperatorOvlApplication
{
　　　　class Box
　　　　{
　　　　　　　private double length;　　　　　　//　longueur
　　　　　　　private double breadth;　　　　　//　largeur
　　　　　　　private double height;　　　　　　//　hauteur
　　　　　　
　　　　　　　public double getVolume()
　　　　　　　{
　　　　　　　　　return length　*　breadth　*　height;
　　　　　　　}
　　　　　　public void setLength(double len)
　　　　　　{
　　　　　　　　　　length = len;
　　　　　　}
　　　　　　public void setBreadth(double bre)
　　　　　　{
　　　　　　　　　　breadth = bre;
　　　　　　}
　　　　　　public void setHeight(double hei)
　　　　　　{
　　　　　　　　　　height = hei;
　　　　　　}
　　　　　　//　surcharge　+　l'opérateur pour additionner deux objets Box
　　　　　　public static Box operator+　(Box b, Box c)
　　　　　　{
　　　　　　　　　　Box box = new Box();
　　　　　　　　　　box.length = b.length　+　c.length;
　　　　　　　　　　box.breadth = b.breadth　+　c.breadth;
　　　　　　　　　　box.height = b.height　+　c.height;
　　　　　　　　　　return box;
　　　　　　}
　　　　　　
　　　　　　public static bool operator ==(Box lhs, Box rhs)
　　　　　　{
　　　　　　　　　　bool status = false;
　　　　　　　　　　if (lhs.length == rhs.length && lhs.height == rhs.height　
　　　　　　　　　　　　　&& lhs.breadth == rhs.breadth)
　　　　　　　　　　{
　　　　　　　　　　　　　　status = true;
　　　　　　　　　　}
　　　　　　　　　　return status;
　　　　　　}
　　　　　　public static bool operator !=(Box lhs, Box rhs)
　　　　　　{
　　　　　　　　　　bool status = false;
　　　　　　　　　　if (lhs.length != rhs.length || lhs.height != rhs.height　
　　　　　　　　　　　　　　|| lhs.breadth != rhs.breadth)
　　　　　　　　　　{
　　　　　　　　　　　　　　status = true;
　　　　　　　　　　}
　　　　　　　　　　return status;
　　　　　　}
　　　　　　public static bool operator <(Box lhs, Box rhs)
　　　　　　{
　　　　　　　　　　bool status = false;
　　　　　　　　　　if (lhs.length < rhs.length && lhs.height　
　　　　　　　　　　　　　　< rhs.height && lhs.breadth < rhs.breadth)
　　　　　　　　　　{
　　　　　　　　　　　　　　status = true;
　　　　　　　　　　}
　　　　　　　　　　return status;
　　　　　　}
　　　　　　public static bool operator >(Box lhs, Box rhs)
　　　　　　{
　　　　　　　　　　bool status = false;
　　　　　　　　　　if (lhs.length > rhs.length && lhs.height　
　　　　　　　　　　　　　　> rhs.height && lhs.breadth > rhs.breadth)
　　　　　　　　　　{
　　　　　　　　　　　　　　status = true;
　　　　　　　　　　}
　　　　　　　　　　return status;
　　　　　　}
　　　　　　public static bool operator <=(Box lhs, Box rhs)
　　　　　　{
　　　　　　　　　　bool status = false;
　　　　　　　　　　if (lhs.length <= rhs.length && lhs.height　
　　　　　　　　　　　　　　<= rhs.height && lhs.breadth <= rhs.breadth)
　　　　　　　　　　{
　　　　　　　　　　　　　　status = true;
　　　　　　　　　　}
　　　　　　　　　　return status;
　　　　　　}
　　　　　　public static bool operator >=(Box lhs, Box rhs)
　　　　　　{
　　　　　　　　　　bool status = false;
　　　　　　　　　　if (lhs.length >= rhs.length && lhs.height　
　　　　　　　　　　　　　>= rhs.height && lhs.breadth >= rhs.breadth)
　　　　　　　　　　{
　　　　　　　　　　　　　　status = true;
　　　　　　　　　　}
　　　　　　　　　　return status;
　　　　　　}
　　　　　　public override string ToString()
　　　　　　{
　　　　　　　　　　return String.Format("({0}, ",1}, {2})", length, breadth, height);
　　　　　　}
　　　
　　　}
　　　　
　　　class Tester
　　　{
　　　　　　static void Main(string[] args)
　　　　　　{
　　　　　　　　Box Box1　= new Box();　　　　　　　　　　//　déclaration de Box1de type Box
　　　　　　　　Box Box2　= new Box();　　　　　　　　　　//　déclaration de Box2de type Box
　　　　　　　　Box Box3　= new Box();　　　　　　　　　　//　déclaration de Box3de type Box
　　　　　　　　Box Box4　= new Box();
　　　　　　　　double volume = 0.0;　　　//　volume
　　　　　　　　//　Box1　détails
　　　　　　　　Box1.setLength(6.0);
　　　　　　　　Box1.setBreadth(7.0);
　　　　　　　　Box1.setHeight(5.0);
　　　　　　　　//　Box2　détails
　　　　　　　　Box2.setLength(12.0);
　　　　　　　　Box2.setBreadth(13.0);
　　　　　　　　Box2.setHeight(10.0);
　　　　　　　//　afficher deux boîtes en utilisant l'opérateur overloadé ToString()
　　　　　　　　Console.WriteLine("Box1: {0}", Box1.ToString());
　　　　　　　　Console.WriteLine("Box2: {0}", Box2.ToString());
　　　　　　　　
　　　　　　　　//　Box1　le volume
　　　　　　　　volume = Box1.getVolume();
　　　　　　　　Console.WriteLine("Box1　le volume : {0}", volume);
　　　　　　　　//　Box2　le volume
　　　　　　　　volume = Box2.getVolume();
　　　　　　　　Console.WriteLine("Box2　le volume : {0}", volume);
　　　　　　　　//　ajouter deux objets
　　　　　　　　Box3　Égal à Box1　+　Box2;
　　　　　　　　Console.WriteLine("Box3: {0}", Box3.ToString());
　　　　　　　　//　Box3　le volume
　　　　　　　　volume = Box3.getVolume();
　　　　　　　　Console.WriteLine("Box3　le volume : {0}", volume);
　　　　　　　　//comparant les boîtes
　　　　　　　　Si Box1　> Box2)
　　　　　　　　　　Console.WriteLine("Box1　supérieur à Box2");
　　　　　　　　else
　　　　　　　　　　Console.WriteLine("Box1　Non supérieur à Box2");
　　　　　　　　Si Box1　< Box2)
　　　　　　　　　　Console.WriteLine("Box1　Inférieur à Box2");
　　　　　　　　else
　　　　　　　　　　Console.WriteLine("Box1　Non inférieur à Box2");
　　　　　　　　Si Box1　Supérieur à Box2)
　　　　　　　　　　Console.WriteLine("Box1　Supérieur ou égal à Box2");
　　　　　　　　else
　　　　　　　　　　Console.WriteLine("Box1　Non supérieur ou égal à Box2");
　　　　　　　　Si Box1　Inférieur ou égal à Box2)
　　　　　　　　　　Console.WriteLine("Box1　Inférieur ou égal à Box2");
　　　　　　　　else
　　　　　　　　　　Console.WriteLine("Box1　Non inférieur ou égal à Box2");
　　　　　　　　Si Box1　Différent de Box2)
　　　　　　　　　　Console.WriteLine("Box1　Différent de Box2");
　　　　　　　　else
　　　　　　　　　　Console.WriteLine("Box1　Égal à Box2");
　　　　　　　　Box4　Égal à Box3;
　　　　　　　　Si Box3　Égal à Box4)
　　　　　　　　　　Console.WriteLine("Box3　Égal à Box4");
　　　　　　　　else
　　　　　　　　　　Console.WriteLine("Box3　Différent de Box4");
　　　　　　　　Console.ReadKey();
　　　　　　}
　　　　}
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

Box1：(6,　7,　5)
Box2：(12,　13,　10)
Box1　Le volume :　210
Box2　Le volume :　1560
Box3：(18,　20,　15)
Box3　Le volume :　5400
Box1　Non supérieur à Box2
Box1　Inférieur à Box2
Box1　Non supérieur ou égal à Box2
Box1　Inférieur ou égal à Box2
Box1　Différent de Box2
Box3　Égal à Box4
Espace de noms (Namespace) C#Polymorphisme C#