C# Academy · Lektion

Arithmetische Operatoren überladen

Definieren Sie +, -, * für eigene Typen.

Arithmetische Operatoren überladen ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C# Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

Warum arithmetische Operatoren überladen?

Die Operatorüberladung ermöglicht es Ihren eigenen Typen, vertraute Symbole wie +, - und * zu verwenden. Bei wertähnlichen Typen wie Vektoren, Geldbeträgen oder komplexen Zahlen liest sich der Code dadurch wie Mathematik statt wie eine Folge von Methodenaufrufen.

Die Syntax von operator +

Ein überladener Operator wird als public static-Methode deklariert, deren Name aus operator gefolgt vom Symbol besteht. Mindestens ein Parameter muss vom umgebenden Typ sein.

using System;

public struct Vector2
{
    public int X, Y;
    public Vector2(int x, int y) { X = x; Y = y; }

    public static Vector2 operator +(Vector2 a, Vector2 b)
        => new Vector2(a.X + b.X, a.Y + b.Y);

    public override string ToString() => "(" + X + ", " + Y + ")";
}

public class Program
{
    public static void Main()
    {
        var sum = new Vector2(1, 2) + new Vector2(3, 4);
        Console.WriteLine(sum);
    }
}

Subtraktion und Multiplikation

Sie können mehrere Operatoren für denselben Typ überladen. Hier fügen wir unserem Vektor Subtraktion und Skalarmultiplikation hinzu.

using System;

public struct Vector2
{
    public int X, Y;
    public Vector2(int x, int y) { X = x; Y = y; }

    public static Vector2 operator -(Vector2 a, Vector2 b)
        => new Vector2(a.X - b.X, a.Y - b.Y);
    public static Vector2 operator *(Vector2 a, int k)
        => new Vector2(a.X * k, a.Y * k);

    public override string ToString() => "(" + X + ", " + Y + ")";
}

public class Program
{
    public static void Main()
    {
        var v = new Vector2(5, 6) - new Vector2(2, 1);
        Console.WriteLine(v);
        Console.WriteLine(new Vector2(2, 3) * 4);
    }
}

Operatoren sind immer static

Überladene Operatoren müssen static sein. Sie wirken nicht auf ein verborgenes this, sondern die Operanden werden als explizite Parameter übergeben. Der Compiler ordnet das Symbol der Methode zu.

using System;

public struct Money
{
    public decimal Amount;
    public Money(decimal amount) { Amount = amount; }

    public static Money operator +(Money a, Money b)
        => new Money(a.Amount + b.Amount);

    public override string ToString() => "$" + Amount;
}

public class Program
{
    public static void Main()
    {
        var total = new Money(10.5m) + new Money(4.25m);
        Console.WriteLine(total);
    }
}

Unäre Operatoren

Unäre Operatoren wie die Negation verwenden einen einzigen Operanden. Überladen Sie operator - mit einem Parameter, um Ausdrücke wie -v zu unterstützen.

using System;

public struct Vector2
{
    public int X, Y;
    public Vector2(int x, int y) { X = x; Y = y; }

    public static Vector2 operator -(Vector2 a)
        => new Vector2(-a.X, -a.Y);

    public override string ToString() => "(" + X + ", " + Y + ")";
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(-new Vector2(3, -7));
    }
}

Operanden unterschiedlichen Typs

Ein Operand kann einen anderen Typ haben. Wenn Sie beide Reihenfolgen bereitstellen, können Benutzer den Ausdruck auf natürliche Weise in beiden Varianten schreiben.

using System;

public struct Temperature
{
    public double Celsius;
    public Temperature(double c) { Celsius = c; }

    public static Temperature operator +(Temperature t, double delta)
        => new Temperature(t.Celsius + delta);
    public static Temperature operator +(double delta, Temperature t)
        => new Temperature(t.Celsius + delta);

    public override string ToString() => Celsius + "C";
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(new Temperature(20) + 5);
        Console.WriteLine(5 + new Temperature(20));
    }
}

Neue Werte zurückgeben

Arithmetische Operatoren sollten ihre Operanden nicht verändern. Sie berechnen einen neuen Wert und geben ihn zurück, wobei die ursprünglichen Werte unverändert bleiben, genau wie bei int.

using System;

public struct Vector2
{
    public int X, Y;
    public Vector2(int x, int y) { X = x; Y = y; }
    public static Vector2 operator +(Vector2 a, Vector2 b)
        => new Vector2(a.X + b.X, a.Y + b.Y);
    public override string ToString() => "(" + X + ", " + Y + ")";
}

public class Program
{
    public static void Main()
    {
        var a = new Vector2(1, 1);
        var b = new Vector2(2, 2);
        var c = a + b;
        Console.WriteLine("a unchanged: " + a);
        Console.WriteLine("result: " + c);
    }
}

Arithmetische Ausdrücke verketten

Da jeder Operator denselben Typ zurückgibt, lassen sich Ausdrücke auf natürliche Weise verketten und berücksichtigen die normale Rangfolge und Assoziativität.

using System;

public struct Vector2
{
    public int X, Y;
    public Vector2(int x, int y) { X = x; Y = y; }
    public static Vector2 operator +(Vector2 a, Vector2 b) => new Vector2(a.X + b.X, a.Y + b.Y);
    public static Vector2 operator *(Vector2 a, int k) => new Vector2(a.X * k, a.Y * k);
    public override string ToString() => "(" + X + ", " + Y + ")";
}

public class Program
{
    public static void Main()
    {
        var result = new Vector2(1, 1) + new Vector2(2, 2) * 3;
        Console.WriteLine(result);
    }
}

Operatoren für Klassen

Die Operatorüberladung funktioniert auch für Klassen, nicht nur für Strukturen. Achten Sie auf null: Ein Klassenoperand kann null sein, daher müssen Sie ihn bei Bedarf absichern.

using System;

public class Complex
{
    public double Re, Im;
    public Complex(double re, double im) { Re = re; Im = im; }
    public static Complex operator +(Complex a, Complex b)
        => new Complex(a.Re + b.Re, a.Im + b.Im);
    public override string ToString() => Re + " + " + Im + "i";
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(new Complex(1, 2) + new Complex(3, 4));
    }
}

Ein vollständiger numerischer Typ

Hier sehen Sie einen kleinen Bruchtyp mit Addition. Er zeigt, wie die Überladung einen Domänentyp in etwas verwandelt, das sich wie eine integrierte Zahl verhält.

using System;

public struct Fraction
{
    public int Num, Den;
    public Fraction(int num, int den) { Num = num; Den = den; }

    public static Fraction operator +(Fraction a, Fraction b)
        => new Fraction(a.Num * b.Den + b.Num * a.Den, a.Den * b.Den);

    public override string ToString() => Num + "/" + Den;
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(new Fraction(1, 2) + new Fraction(1, 3));
    }
}

Probieren Sie es selbst aus

Fügen Sie einer geldähnlichen Struktur Addition und Skalarmultiplikation hinzu, und erstellen Sie anschließend einen Ausdruck, der wie gewöhnliche Arithmetik lesbar ist.

using System;

public struct Money
{
    public decimal Amount;
    public Money(decimal a) { Amount = a; }
    public static Money operator +(Money a, Money b) => new Money(a.Amount + b.Amount);
    public static Money operator *(Money a, int qty) => new Money(a.Amount * qty);
    public override string ToString() => "$" + Amount;
}

public class Program
{
    public static void Main()
    {
        var price = new Money(4.50m);
        var total = price * 3 + new Money(2.00m);
        Console.WriteLine(total);
    }
}

Kurztest

Rufen Sie sich die Signatur eines überladenen Operators in Erinnerung.

Zusammenfassung

Durch das Überladen arithmetischer Operatoren lassen sich wertähnliche Typen wie mathematische Ausdrücke verwenden.

Deklarieren Sie sie mit public static und dem Schlüsselwort operator.
Mindestens ein Parameter muss vom umgebenden Typ sein.
Geben Sie einen neuen Wert zurück und verändern Sie niemals die Operanden.
Stellen Sie für arithmetische Ausdrücke mit unterschiedlichen Typen beide Operandreihenfolgen bereit.

Häufig gestellte Fragen

Ist die Lektion „Arithmetische Operatoren überladen“ kostenlos?

Ja — der vollständige Text von „Arithmetische Operatoren überladen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C# Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Arithmetische Operatoren überladen“?

Definieren Sie +, -, * für eigene Typen. Du übst C# Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C# Academy zu starten?

Keine Vorkenntnisse erforderlich. C# Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Arithmetische Operatoren überladen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C# Academy-Lektion Code schreiben und ausführen?

Ja. Jede C# Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu C# Academy