Sovraccarico degli operatori

Fa parte della sezione Programmazione orientata agli oggetti del percorso C# di Coddy. Lezione 36 di 70.

L'overloading degli operatori ti permette di definire come operatori come +, - o == si comportano con le tue classi personalizzate. Invece di chiamare metodi come point1.Add(point2), puoi scrivere la forma più naturale point1 + point2.

Per sovraccaricare un operatore, crea un metodo statico speciale usando la parola chiave 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);
    }
}

Ora puoi sommare i vettori in modo naturale:

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

Il metodo deve essere public static e almeno un parametro deve essere il tipo contenitore. Puoi sovraccaricare gli operatori aritmetici (+, -, *, /), gli operatori di confronto (==, !=, <, >) e gli operatori unari (-, !, ++).

Nota che gli operatori di confronto devono essere sovraccaricati a coppie: se definisci ==, devi definire anche !=.

Usa l'overloading degli operatori quando rende il tuo codice più intuitivo, in particolare per tipi matematici come vettori, numeri complessi o denaro. Evitalo quando il significato dell'operazione non è immediatamente chiaro.

Sfida

Facile

Creiamo una classe Fraction che renda naturale lavorare con le frazioni grazie all'overloading degli operatori. Invece di chiamare metodi come fraction1.Add(fraction2), potrai scrivere l'intuitivo fraction1 + fraction2.

Organizzerai il codice in due file:

Fraction.cs: crea una classe Fraction nello spazio dei nomi Math che rappresenti una frazione con numeratore e denominatore. La frazione deve avere:
- Due proprietà intere di sola lettura: Numerator e Denominator
- Un costruttore che accetti il numeratore e il denominatore (in quest'ordine)
- Un operatore + sovraccaricato che sommi due frazioni usando la formula: (a/b) + (c/d) = (a*d + c*b) / (b*d)
- Un operatore * sovraccaricato che moltiplichi due frazioni: (a/b) * (c/d) = (a*c) / (b*d)
- Un operatore == sovraccaricato che restituisca true se due frazioni sono uguali (confrontale moltiplicando i termini incrociati: a*d == c*b)
- Un operatore != sovraccaricato (necessario quando sovraccarichi ==) che restituisca l'opposto di ==
- Un metodo GetDisplay() che restituisca la frazione come stringa nel formato "{Numerator}/{Denominator}"
Program.cs: nel file principale, crea due frazioni usando i valori di input. Mostra gli operatori sovraccaricati sommandole, moltiplicandole e verificando se sono uguali. Stampa i risultati per mostrare come i tuoi operatori funzionino in modo naturale.

Riceverai quattro valori in input:

Numeratore della prima frazione (intero)
Denominatore della prima frazione (intero)
Numeratore della seconda frazione (intero)
Denominatore della seconda frazione (intero)

Stampa l'output in questo formato:

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

Ad esempio, se gli input sono 1, 2, 2 e 4, l'output dovrebbe essere:

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

Nota come 1/2 e 2/4 vengano riconosciute come uguali perché 1*4 == 2*2. La somma e il prodotto vengono calcolati senza semplificazione: va bene così per questa sfida. Il bello è che ora puoi lavorare con le frazioni in modo naturale usando operatori familiari!

Provalo tu

using System;
using Math;

class Program
{
    public static void Main(string[] args)
    {
        // Leggi l'input per la prima frazione
        int num1 = Convert.ToInt32(Console.ReadLine());
        int den1 = Convert.ToInt32(Console.ReadLine());
        
        // Leggi l'input per la seconda frazione
        int num2 = Convert.ToInt32(Console.ReadLine());
        int den2 = Convert.ToInt32(Console.ReadLine());
        
        // TODO: Crea due oggetti Fraction usando i valori di input
        
        // TODO: Usa l'operatore + sovraccaricato per sommare le frazioni
        
        // TODO: Usa l'operatore * sovraccaricato per moltiplicare le frazioni
        
        // TODO: Usa l'operatore == sovraccaricato per verificare l'uguaglianza
        
        // TODO: Stampa l'output nel formato richiesto:
        // Fraction 1: {GetDisplay()}
        // Fraction 2: {GetDisplay()}
        // Somma: {GetDisplay()}
        // Prodotto: {GetDisplay()}
        // Sono uguali: {True/False}
    }
}