Surcharge d'opérateurs

Fait partie de la section Programmation Orientée Objet du Journey C# de Coddy. Leçon 36 sur 70.

La surcharge d’opérateurs vous permet de définir le comportement d’opérateurs tels que +, - ou == avec vos classes personnalisées. Au lieu d’appeler des méthodes comme point1.Add(point2), vous pouvez écrire l’expression plus naturelle point1 + point2.

Pour surcharger un opérateur, vous créez une méthode statique spéciale à l’aide du mot-clé operator :

public class Vector
{
    public int X { get; }
    public int Y { get; }
    
    public Vector(int x, int y)
    {
        X = x;
        Y = y;
    }
    
    public static Vector operator +(Vector a, Vector b)
    {
        return new Vector(a.X + b.X, a.Y + b.Y);
    }
}

Vous pouvez maintenant additionner des vecteurs naturellement :

Vector v1 = new Vector(3, 4);
Vector v2 = new Vector(1, 2);
Vector v3 = v1 + v2;  // X = 4, Y = 6

La méthode doit être public static, et au moins un paramètre doit être le type conteneur. Vous pouvez surcharger les opérateurs arithmétiques (+, -, *, /), les opérateurs de comparaison (==, !=, <, >) et les opérateurs unaires (-, !, ++).

Notez que les opérateurs de comparaison doivent être surchargés par paires : si vous définissez ==, vous devez également définir !=.

Utilisez la surcharge des opérateurs lorsque cela rend votre code plus intuitif, en particulier pour les types mathématiques comme les vecteurs, les nombres complexes ou l’argent. Évitez-la lorsque la signification de l’opération n’est pas immédiatement évidente.

Défi

Facile

Construisons une classe Fraction qui rende la manipulation des fractions naturelle grâce à la surcharge des opérateurs. Au lieu d'appeler des méthodes comme fraction1.Add(fraction2), vous pourrez écrire l'expression intuitive fraction1 + fraction2.

Vous organiserez votre code sur deux fichiers :

Fraction.cs : créez une classe Fraction dans l'espace de noms Math qui représente une fraction avec un numérateur et un dénominateur. Votre fraction doit avoir :
- Deux propriétés entières en lecture seule : Numerator et Denominator
- Un constructeur qui accepte le numérateur et le dénominateur (dans cet ordre)
- Un opérateur + surchargé qui additionne deux fractions à l'aide de la formule : (a/b) + (c/d) = (a*d + c*b) / (b*d)
- Un opérateur * surchargé qui multiplie deux fractions : (a/b) * (c/d) = (a*c) / (b*d)
- Un opérateur == surchargé qui renvoie true si deux fractions sont égales (effectuez une multiplication croisée pour les comparer : a*d == c*b)
- Un opérateur != surchargé (obligatoire lorsque vous surchargez ==) qui renvoie l'opposé de ==
- Une méthode GetDisplay() qui renvoie la fraction sous forme de chaîne au format "{Numerator}/{Denominator}"
Program.cs : dans votre fichier principal, créez deux fractions à l'aide des valeurs saisies. Démontrez les opérateurs surchargés en les additionnant, en les multipliant et en vérifiant si elles sont égales. Affichez les résultats pour montrer que vos opérateurs fonctionnent naturellement.

Vous recevrez quatre entrées :

Numérateur de la première fraction (entier)
Dénominateur de la première fraction (entier)
Numérateur de la seconde fraction (entier)
Dénominateur de la seconde fraction (entier)

Affichez la sortie dans ce format :

Fraction 1: {GetDisplay()}
Fraction 2: {GetDisplay()}
Sum: {GetDisplay()}
Product: {GetDisplay()}
Are equal: {True/False}

Par exemple, si les entrées sont 1, 2, 2 et 4, la sortie doit être :

Fraction 1: 1/2
Fraction 2: 2/4
Sum: 8/8
Product: 2/8
Are equal: True

Remarquez que 1/2 et 2/4 sont reconnues comme égales, car 1*4 == 2*2. La somme et le produit sont calculés sans simplification — ce n'est pas un problème pour ce défi. Toute la beauté réside dans le fait que vous pouvez désormais manipuler les fractions très naturellement à l'aide d'opérateurs familiers !

Essayez vous-même

using System;
using Math;

class Program
{
    public static void Main(string[] args)
    {
        // Lire l'entrée pour la première fraction
        int num1 = Convert.ToInt32(Console.ReadLine());
        int den1 = Convert.ToInt32(Console.ReadLine());
        
        // Lire l'entrée pour la deuxième fraction
        int num2 = Convert.ToInt32(Console.ReadLine());
        int den2 = Convert.ToInt32(Console.ReadLine());
        
        // TODO: Créer deux objets Fraction en utilisant les valeurs d'entrée
        
        // TODO: Utiliser l'opérateur + surchargé pour additionner les fractions
        
        // TODO: Utiliser l'opérateur * surchargé pour multiplier les fractions
        
        // TODO: Utiliser l'opérateur == surchargé pour vérifier l'égalité
        
        // TODO: Afficher la sortie dans le format requis :
        // Fraction 1 : {GetDisplay()}
        // Fraction 2 : {GetDisplay()}
        // Somme : {GetDisplay()}
        // Produit : {GetDisplay()}
        // Are equal: {True/False}
    }
}