Ein sehr schönes Feature, das komischerweise viel zu selten genutzt wird, ist die Operanden Überladung in .NET. In C war das eine ziemlich schräge Sache und so haben wohl viele noch die mahnenden Worte vieler C Entwickler im Ohr: "Tut das niemals wenn ihr Chaos vermeiden wollt"

Unter .NET ist es aber eine sehr praktische Sache, kleines Beispiel:
Wie haben eine Klasse Konto

Code :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

class Konto     {         private decimal _geld;         private String _besitzer;           public Konto(String Besitzer)         {             this._geld = 0;             this._besitzer = Besitzer;         }           public decimal Geld         {             get { return this._geld; }         }           public String Besitzer         {             get { return this._besitzer; }         }           public void BucheBetrag(decimal betrag)         {             this._geld += betrag;         } }

Im Normalfall würden wir, um den Betrag eines Kontos zu ändern die Methode "BucheBetrag" aufrufen. /* Sehen wir mal über irgendwelche Validierungen hinweg! */ Im Code würde das dann vielleicht so aussehen:

Code :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

class Program     {         static void Main(string[] args)         {             Konto k1 = new Konto("Exceptionfault");             Konto k2 = new Konto("Anonymous");               Console.WriteLine("Betrag : " + k1.Geld.ToString());             Console.WriteLine("Betrag : " + k2.Geld.ToString());             Console.WriteLine("==============================");                         k1.BucheBetrag(100);             k2.BucheBetrag(1000);             Console.WriteLine("Betrag : " + k1.Geld.ToString());             Console.WriteLine("Betrag : " + k2.Geld.ToString());             Console.WriteLine("==============================");         }     }

Ist sicher nicht falsch, und auch sehr leserlich, aber für interne Funktionen etc. ist mir das zu viel Code. Wie wärs denn damit ?

Code :

1 2 3 4 5 6 7 8

k1 += 100;             Console.WriteLine("Betrag : " + k1.Geld.ToString());             Console.WriteLine("Betrag : " + k2.Geld.ToString());             Console.WriteLine("==============================");               k1 = k1 + k2;             Console.WriteLine("Betrag : " + k1.Geld.ToString());             Console.WriteLine("Betrag : " + k2.Geld.ToString());

Was erwarten wir hier? Klar, der Betrag von k1 wird um 100 erhöht, danach wird der Betrag von k2 auf k1 addiert.
Um ganze Objekte addieren zu können habe ich in der Klasse Konto den "+" Operator überladen:

Code :

1 2 3 4 5 6 7 8 9 10 11 12

public static Konto operator +(Konto k, decimal betrag)         {             k._geld += betrag;             return k;         }           public static Konto operator +(Konto k1, Konto k2)         {             k1._geld += k2._geld;             k2._geld = 0;             return k1;         }

Ist nicht viel Aufwand, und der Code wird kurz und intuitiv (wenn mans nicht übertreibt ! )

Hi.

Nur so zur Info: Man kann Operatoren überladen - keine Operanden.

In C kann man gar nichts überladen - keine Funktionen und auch keine Operatoren; Operanden schon überhaupt nicht. Du meintest vermutlich die Programmiersprache C++ wo das allerdings gang und gäbe ist Operatoren zu überladen.

Gruß

Hallo,

Nur so zur Info: Man kann Operatoren überladen - keine Operanden.

Exceptionfault hat sicherlich Operatoren gemeint

Also meiner Meinung nach sollte man dieses "Feature" (außer in Mathematischen Bibliotheken oder bei der String-Verkettung) wirklich bleiben lassen. Auch bei deinem Konto Fall ist IMHO kein gutes Beispiel, denn die Semantik des + Operators ist in diesem Fall unklar. Man addiert ja keinen Betrag auf ein Konto (Account) sondern einen Kontostand (Balance) also der Wert den dieses Konto manifestiert. In diesem Fall führt die Verwendung dieses Operators zu Verwirrung.

Gruß Tom