Überladen von Operatoren

Teil des Abschnitts Objektorientierte Programmierung der C#-Journey von Coddy. Lektion 36 von 70.

Operatorüberladung ermöglicht dir festzulegen, wie sich Operatoren wie +, - oder == mit deinen benutzerdefinierten Klassen verhalten. Anstatt Methoden wie point1.Add(point2) aufzurufen, kannst du das natürlichere point1 + point2 schreiben.

Um einen Operator zu überladen, erstellst du eine spezielle statische Methode mit dem Schlüsselwort 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);
    }
}

Jetzt kannst du Vektoren ganz natürlich addieren:

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

Die Methode muss public static sein, und mindestens ein Parameter muss der enthaltende Typ sein. Du kannst arithmetische Operatoren (+, -, *, /), Vergleichsoperatoren (==, !=, <, >) und unäre Operatoren (-, !, ++) überladen.

Beachte, dass Vergleichsoperatoren paarweise überladen werden müssen – wenn du == definierst, musst du auch != definieren.

Verwende die Operatorüberladung, wenn sie deinen Code intuitiver macht, insbesondere bei mathematischen Typen wie Vektoren, komplexen Zahlen oder Geldbeträgen. Vermeide sie, wenn die Bedeutung der Operation nicht unmittelbar offensichtlich ist.

Aufgabe

Einfach

Erstellen wir eine Fraction-Klasse, mit der sich dank der Überladung von Operatoren ganz natürlich mit Brüchen arbeiten lässt. Statt Methoden wie fraction1.Add(fraction2) aufzurufen, kannst du den intuitiven Ausdruck fraction1 + fraction2 schreiben.

Du organisierst deinen Code auf zwei Dateien:

Fraction.cs: Erstelle eine Fraction-Klasse im Math-Namespace, die einen Bruch mit einem Zähler und einem Nenner darstellt. Dein Bruch sollte Folgendes enthalten:
- Zwei schreibgeschützte ganzzahlige Eigenschaften: Numerator und Denominator
- Einen Konstruktor, der den Zähler und den Nenner (in dieser Reihenfolge) akzeptiert
- Einen überladenen +-Operator, der zwei Brüche mithilfe der Formel addiert: (a/b) + (c/d) = (a*d + c*b) / (b*d)
- Einen überladenen *-Operator, der zwei Brüche multipliziert: (a/b) * (c/d) = (a*c) / (b*d)
- Einen überladenen ==-Operator, der true zurückgibt, wenn zwei Brüche gleich sind (multipliziere zum Vergleichen über Kreuz: a*d == c*b)
- Einen überladenen !=-Operator (erforderlich, wenn du == überlädst), der das Gegenteil von == zurückgibt
- Eine Methode GetDisplay(), die den Bruch als Zeichenfolge im Format "{Numerator}/{Denominator}" zurückgibt
Program.cs: Erstelle in deiner Hauptdatei mithilfe von Eingabewerten zwei Brüche. Führe die überladenen Operatoren vor, indem du die Brüche addierst, multiplizierst und überprüfst, ob sie gleich sind. Gib die Ergebnisse aus, um zu zeigen, dass deine Operatoren ganz natürlich funktionieren.

Du erhältst vier Eingaben:

Zähler des ersten Bruchs (Ganzzahl)
Nenner des ersten Bruchs (Ganzzahl)
Zähler des zweiten Bruchs (Ganzzahl)
Nenner des zweiten Bruchs (Ganzzahl)

Gib die Ausgabe in diesem Format aus:

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

Wenn die Eingaben beispielsweise 1, 2, 2 und 4 lauten, sollte die Ausgabe wie folgt aussehen:

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

Beachte, dass 1/2 und 2/4 als gleich erkannt werden, weil 1*4 == 2*2 gilt. Die Summe und das Produkt werden ohne Kürzen berechnet – das ist für diese Aufgabe in Ordnung. Das Schöne daran ist, dass du jetzt dank der vertrauten Operatoren ganz natürlich mit Brüchen arbeiten kannst!

Probier es selbst

using System;
using Math;

class Program
{
    public static void Main(string[] args)
    {
        // Eingabe für den ersten Bruch lesen
        int num1 = Convert.ToInt32(Console.ReadLine());
        int den1 = Convert.ToInt32(Console.ReadLine());
        
        // Eingabe für den zweiten Bruch lesen
        int num2 = Convert.ToInt32(Console.ReadLine());
        int den2 = Convert.ToInt32(Console.ReadLine());
        
        // TODO: Erstelle zwei Fraction-Objekte mit den Eingabewerten
        
        // TODO: Verwende den überladenen +-Operator, um die Brüche zu addieren
        
        // TODO: Verwende den überladenen *-Operator, um die Brüche zu multiplizieren
        
        // TODO: Verwende den überladenen ==-Operator, um die Gleichheit zu prüfen
        
        // TODO: Gib die Ausgabe im erforderlichen Format aus:
        // Fraction 1: {GetDisplay()}
        // Fraction 2: {GetDisplay()}
        // Sum: {GetDisplay()}
        // Product: {GetDisplay()}
        // Are equal: {True/False}
    }
}