Wer ist online?
Buchempfehlung
FreeBASIC-Chat
FreeBASIC-Nachrichten jetzt auch über Twitter erhalten. Follow us!Tutorial
Type als Objekt - Das UDT-Tutorial Teil 1
von  MOD | Seite 6 von 8 |
Operator overloading (Operatoren überladen)
Operator overloading ist ein Weg, dem Compiler mitzuteilen, was zu tun ist, falls wir irgendeine Operation ausführen wollen, die unseren Type betrifft. Z.B.:
Type bar
n As Integer
End Type
Dim As bar x, y, z
z = x + y
Nun würde der Compiler normalerweise einen Fehler melden, wenn er hierauf trifft, da er keine Ahnung hat, wie zwei Types addiert werden könnten, aber wir können festlegen, was wir da durchgeführt haben möchten. So geht's:
Type bar
n As Integer
End Type
Operator +(ByRef lhs As bar, ByRef rhs As bar) As bar
Operator = Type(lhs.n + rhs.n)
End Operator
Dim As bar x, y, z
x.n = 5
y.n = 10
z = x + y
Print z.n
In diesem Beispiel, dienen lhs und rhs dem Bezug auf die linke und rechte Seite des Operators. Beachte auch den Ausdruck Type(lhs.n + rhs.n), welcher uns einen temporären Type erstellt, der zurückgegeben wird. Wäre der Type von der Form:
Type bar
x As Integer
y As Integer
z As Integer
End Type
Dieser wäre dann folgendermaßen zu erzeugen: Type(x-part, y-part, z-part)
Die meisten Operatoren lassen sich überladen und die meisten von ihnen sind binär-Operatoren, d.h. sie haben zwei Operanden wie das + im obigen Beispiel. Einige sind unäre Operatoren, die nur die rechte Seite haben, wie Not oder das unäre Minus.
Es gibt einige Spezialfälle, wo sie innerhalb des Types deklariert werden müssen, das sind die Zuweisungsoperatoren und Casts.
Zuweisungsoperatoren sind z.B. += -= Mod= etc und auch Let.
Let wird benutzt in Anweisungen wie:
Dim As bar foo
Dim As Integer x
foo = x
Und Casts sind ungefähr das Umgekehrte, sie werden verwendet, beim Umwandeln in einen anderen Datentyp wie:
Dim As bar foo
Dim As Integer x
x = foo
Es folgt ein kurzs Beispiel für Let und Cast:
Type bar
n As Integer
Declare Operator Let(ByRef rhs As Integer)
Declare Operator Let(ByRef rhs As String)
Declare Operator Cast() As String
End Type
Operator bar.Let(ByRef rhs As Integer)
n = rhs
End Operator
Operator bar.Let(ByRef rhs As String)
n = Val(rhs)
End Operator
Operator bar.Cast() As String
Operator = Str(n)
End Operator
Operator +(ByRef lhs As bar, ByRef rhs As bar) As bar
Operator = Type(lhs.n + rhs.n)
End Operator
Dim As bar x, y, z
x = 5
y = "10"
z = x + y
Print zEs müssen verschiedene Lets und Casts vorhanden sein für jeden Datentyp, der vom Programm unterstützt werden soll. Die Operatoren, die im Type deklariert werden müssen, werden 'nonstatic' genannt, diejenigen, wo das nicht nötig ist, nennt man 'global'. Es gibt einen technischen Grunddafür: Die 'nonstatic'-Operatoren müssen wissen, auf welche Instanz (in technischem Jargon, in unserem Beispiel oben könnten wir sagen, dass x eine Instanz von bar ist) des Types sie sich beziehen und dies wird durch ein verstecktes 'this'-Element erreicht. Dieser versteckte 'this'-Bezug legt fest, wie die anderen Elemente, wie Operatoren und Methoden erkennen, welcher Instanz des Types der Aufruf gilt. Die meisten Operatoren lassen sich überladen, hier ist eine Liste derjenigen, bei denen es momentan funktioniert:
Eine Liste der vorhandenen Operatoren lässt sich in der Referenz nachsehen: OPERATOR
Gehe zu Seite | Zusätzliche Informationen und Funktionen | |||||||
|---|---|---|---|---|---|---|---|
|
|||||||
Bearbeiten
Versionen