Tutorial

Überladen von Prozeduren und Operatoren (Overload)

von

Seite 3 von 9

Nun aber genug von den Grundlagen und ab in die interessanten Gebiete der Verwendung.
Overloading ist unbezahlbar, wenn es um UDTs geht und als allererstes: Das Keyword 'OverLoad' ist dabei NICHT nötig, da alle Member eines Types automatisch überladen werden.

Also bauen wir uns mal ein UDT:

Type eigentlich_ein_string

    daten As String



    Declare Constructor

    Declare Constructor (x As Integer)

    Declare Constructor (x As Double)

    Declare Constructor (x As String)

    Declare Constructor (x As eigentlich_ein_string)

    Declare Destructor



    Declare Function gibZahl (x As Integer) As Integer

    Declare Function gibZahl (x As Double) As Double



    Declare Property proGib As Double

    Declare Property proGib (x As Double)



    Declare Operator Cast As Integer

    Declare Operator Cast As Double

    Declare Operator Cast As String



    Declare Operator += (x As Integer)

    Declare Operator += (x As Double)

    Declare Operator Let (x As Integer)

    Declare Operator Let (x As Double)

    Declare Operator Let (x As String)

    Declare Operator Let (x As eigentlich_ein_string)

    Declare Operator For

    Declare Operator Step

    Declare Operator Next (x As eigentlich_ein_string) As Integer

    Declare Operator For (x As eigentlich_ein_string)

    Declare Operator Step (x As eigentlich_ein_string)

    Declare Operator Next (x As eigentlich_ein_string, y As eigentlich_ein_string) As Integer

    Declare Operator @ () As ZString Ptr

End Type

Ja, das ist schon mal sehr viel, ist aber halb so schlimm. Man sieht aber schon, was man alles mit UDTs machen kann und was alles überladen wird.
Da haben wir:

(Möglich wäre auch Sub)

Ein Constructor wird immer aufgerufen, wenn eine Variable des eigenen Types deklariert wird. Damit kann man praktischerweise Startwerte setzen.
Ein Destructor ist genau das Gegenteil. Er wird als letztes aufgerufen, wenn eine Variable gelöscht wird, weil sie etwa nur in einem Scope definiert war.
Function sollte soweit bekannt sein, deswegen wird nicht näher darauf eingegangen.
Property ist eine Geschichte für sich. Um dieses Tutorial nicht auch noch damit zu füllen, habe ich es ausgelagert: Property Tutorial
Operatoren sind mathematische Zeichen wie '+', '-' usw. 'Let' steht dabei für den Zuweisungsoperator '='. Es können aber auch andere Zeichen sein, wie etwa das @-Symbol, als Zeichen für die Adresse einer Variable im Speicher. Hier gibt es Ausnahmen, auf die gleich eingehen werde.
Eine Sonderform dabei sind die Operatoren For, Next und Step, es sind sogenannte Iteratoren. Dazu aber auch erst später mehr.

Gehe zu Seite 1 2 3 4 5 6 7 8 9

Zusätzliche Informationen und Funktionen

Das Tutorial wurde am 03.06.2010 von MOD angelegt.
Die aktuellste Version wurde am 23.11.2013 von MOD gespeichert.

Bearbeiten

Versionen

Impressum • Nutzungsbedingungen • Datenschutz

Microsoft, Windows, Windows NT, XBOX und Visual Basic sind entweder eingetragene Marken oder Marken der Microsoft Corporation in den USA und/oder anderen Ländern. Weitere auf dieser Homepage aufgeführten Produkt- und Firmennamen können geschützte Marken ihrer jeweiligen Inhaber sein.