Surcharge des opérateurs en C#

septembre 15, 2019février 11, 2020 Thomas Aucun commentaire

Vous pouvez surcharger la plupart des opérateurs disponibles en C#. Les opérateurs surchargés sont des fonctions avec des noms spéciaux, le mot-clé « operator » suivi du symbole de l’opérateur. Comme toute autre fonction, un opérateur surchargé a un type de retour et une liste de paramètres.

Syntaxe :

public static returnType operator op (argumentList)

« op » est l’opérateur à surcharger et « operator » est le mot clé requis. Pour surcharger les opérateurs unaires, il n’y a qu’un seul argument et pour surcharger un opérateur binaire, il y a deux arguments. N’oubliez pas qu’au moins un des arguments doit être un type défini par l’utilisateur, tel que class ou struct.

Les opérateurs disponible en C#

OPÉRATEURS	DESCRIPTION
+, -,!, ~, ++, – –	Les opérateurs unaires prennent un seule opérande et peuvent être surchargés.
*+, -, , /, %**	Les opérateurs binaires prennent deux opérandes et peuvent être surchargés.
==,! =, =	Les opérateurs de comparaison peuvent être surchargés.
&&, \|\|	Les opérateurs logiques conditionnels ne peuvent pas être surchargés directement
*+=, -+, =, /=, %=, =**	Les opérateurs d’affectation ne peuvent pas être surchargés.

Surcharge des opérateurs unaires

Le programme suivant surcharge l’opérateur unaire – à l’intérieur de la classe Point.

using System;  

class Point  
{  
    private int x;  
    private int y;  
	
    public Point()  
    {  
   }  
	
    public Point(int i, int j)  
    {  
        x = i;  
        y = j;  
    }  
	
    public void display()  
    {  
        Console.WriteLine("{0} {1}", x, y);  
    }  
	
    public static Point operator -(Point p)  
    {  
        Point point = new Point();  
        point.x = -p.x;  
        point.y = -p.y;  
        return point;  
    }  
}  
public class WayToLearnX  
{  
    public static void Main()  
    {  
        Point p1 = new Point(2, 4);  
        p1.display(); 
        Point p2 = new Point();  
        p2.display();   
        p2 = -p1;  
        p2.display(); 
    }  
}

La sortie :

2 4
0 0
-2 -4

Programmation orientée objet en C#La programmation orientée objet (POO) est le composant principal du framework .NET. La programmation orientée objet est tellement importante avant de se lancer dans .NET,…Lire plus

Surcharge des opérateurs binaires

L’opérateur binaire surchargé doit prendre deux arguments.

using System;  

class Point  
{  
    private int x;  
    private int y;  
	
    public Point()  
    {  
   }  
	
    public Point(int i, int j)  
    {  
        x = i;  
        y = j;  
    }  
	
    public void display()  
    {  
        Console.WriteLine("{0} {1}", x, y);  
    }  
	
	public static Point operator +(Point p1, Point p2)  
	{  
		Point point = new Point();  
		point.x = p1.x + p2.x;  
		point.y = p1.y + p2.y;  
		return point;  
	}  
}  
public class WayToLearnX  
{  
    public static void Main()  
    {  
        Point p1 = new Point(2, 4);  
        p1.display(); 
        Point p2 = new Point(1, 2);  
        p2.display(); 
        Point p3 = new Point();  
        p3.display();  
        p3 = p1 + p2; 
        p3.display(); 
    }  
}

La sortie :

Surcharger l’opérateur == et !=

using System;  

class Point  
{  
    private int x;  
    private int y;  
	
    public Point()  
    {  
   }  
	
    public Point(int i, int j)  
    {  
        x = i;  
        y = j;  
    }  
	
    public void display()  
    {  
        Console.WriteLine("{0} {1}", x, y);  
    }  
	
    public override int GetHashCode()  
    {  
        return this.ToString().GetHashCode();  
    }
	
    public override bool Equals(object o)  
    {  
        var p = (Point)o;
        if (p.x == this.x && p.y == this.y)  
            return true;  
        else  
            return false;  
    }
	
    public static bool operator == (Point p1, Point p2)  
    {
        return p1.Equals(p2);  
    }
	
    public static bool operator != (Point p1, Point p2)  
    {  
        return ! p1.Equals(p2);  
    }   
}  

public class WayToLearnX  
{  
    public static void Main()  
    {  
        Point p1 = new Point(2, 4);  
        p1.display(); 
        Point p2 = new Point(2, 4);  
        p2.display(); 
        if (p1 == p2)  
            Console.WriteLine("p1 et p2 sont égale.");  
        else  
            Console.WriteLine("p1 et p2 ne sont pas égale.");
    }  
}

La sortie :

2 4
2 4
p1 et p2 sont égale.

La méthode Equals() par défaut compare les références. Rappelez-vous que les valeurs des objets p1 et p2 sont identiques. Mais ils ont des références différentes.

N’oubliez pas que lorsque nous surchargeons la méthode Equals() à l’intérieur d’une classe, nous devrons également surcharger la méthode GetHashCode(). Également si nous surchargeons l’opérateur == à l’intérieur d’une classe, nous devons également surcharger l’opérateur !=.
QCM C# – Framework .NET – Partie 1QCM sur C# avec des réponses pour la préparation des entretiens d’embauche, des tests en ligne, aux examens et aux certifications. Ces questions et réponses…Lire plus

QCMs qui pourraient vous intéresser :

Syntaxe :

Les opérateurs disponible en C#

Surcharge des opérateurs unaires

Surcharge des opérateurs binaires

Surcharger l’opérateur == et !=

Vous pourrez aussi aimer

Insérer un élément à un index donné dans une liste en C#

Gestion des exceptions en C#

Héritage multiple en C#

Laisser un commentaire Annuler la réponse