 |
Das deutsche QBasic- und FreeBASIC-Forum Für euch erreichbar unter qb-forum.de, fb-forum.de und freebasic-forum.de!
|
Vorheriges Thema anzeigen :: Nächstes Thema anzeigen |
Autor |
Nachricht |
chutullu
Anmeldungsdatum: 18.10.2005 Beiträge: 77
|
Verfasst am: 21.05.2007, 14:14 Titel: Überladen von Operatoren |
|
|
Hallo Forum,
die neue Vers. unterstützt das Überladen von Operatoren. Ich möchte gern ein paar Arrayfunktionen schreiben welche an die PHP Syntax angelehnt sind.
So in der Art :
Code: | dim test as Array
dim a as integer
dim pr as Array
for a = 1 to 10
test[] = a
next a
for a = test.length to test.length+10
test["assoziativ"+a] = a
next a
test.sort
for a = 1 to test.length
pr = test.current(a)
print pr.key, pr.value
next a
test.ksort
for a = 1 to test.length
pr = test.current(a)
print pr.key, pr.value
next a |
soll die Syntax aussehen.
Hat jemand ein paar Beispiele für das Überladen von Operatoren oder schon mal so etwas in der Art programmiert ? |
|
Nach oben |
|
 |
MisterD

Anmeldungsdatum: 10.09.2004 Beiträge: 3071 Wohnort: bei Darmstadt
|
Verfasst am: 21.05.2007, 18:39 Titel: |
|
|
du programmierst komisch o_O
in der ersten for schleife: test[]=a ist eine zuweisung eines integers als array, das funktioniert nicht.
die zweite forschleife: Assoziative arrays in Freebasic gibts nicht und wirds auch nicht geben, du könntest höchstens über preprozessoren sowas machen oder einfach über konstanten:
Code: | #define eingeschaft 5
const wert=3
test(eigenschaft)=42
test(wert)=42 |
wenn du unbedingt [] benutzen willst musst du über pointer arbeiten, integer ptr zB wenn du zahlen speichern willst, wenn du verschiedene variablentypen speichern willst müsstest du einfach any ptr nehmen und dir jeweils merken, was für ein typ an welcher stelle steht und dich außerdem selbst ums allozieren/deallozieren des zugehörigen speichers kümmern. garbage collection sobald eine referenz auf eine variable nicht mehr existiert funktioniert über pointer nicht.
test.sort() wäre "objektorientiert", dafür müsstest du test als array von einem selbstdefinierten typen machen der ungefähr so aussieht:
Code: | type array
daten(10) as integer
declare sub sort()
end type |
oder so ähhhnlich. dabei könntest du übrigens den UDT auch so bauen, dass du statt daten(10) as integer ein daten(10) as any ptr machst und dann ein zweites array typen(10) as uint in dem du konstanten string=1, integer=2 usw speicherst und dir damit merkst, welchen variablentyp du an welchem index gespeichert hast, auf jeden fall musst du das halt von hand machen.
und die letzte for-schleife, du kannst for a=lbound(test) to ubound(test) machen, damit erreichst du ungefähr das selbe, den zugriff über .key und .value kriegst du aber so nicht da es keine .current funktion gibt, müsste st du auch wieder nen "type arraydata : key as integer : value as string : end type" oder so machen und in denen array-type eine "declare function current(int key) as arraydata" einbauen die dir dann eben eine instanz dieses types zurück gibt.
schlussendlich: Dynamische arrays in freebasic in der form findest du auch nicht, du kannst ein array mit "redim test(neuegröße) as integer" in der größe ändern, da das aber zusammenhängende array sind und keine listen oder sowas ist das äußerst zeitaufwendig und ineffizient.
/edit: ach jetz versteh ich auch was du beim ersten ding meinst, a an das array anhängen, sowas gabs bei php ja dazu siehe mein letzer absatz. mit Operatorern überladen bist du auf jeden fall auf der falschen schiene. _________________ "It is practically impossible to teach good programming to students that have had a prior exposure to BASIC: as potential programmers they are mentally mutilated beyond hope of regeneration."
Edsger W. Dijkstra |
|
Nach oben |
|
 |
chutullu
Anmeldungsdatum: 18.10.2005 Beiträge: 77
|
Verfasst am: 22.05.2007, 09:43 Titel: |
|
|
Zitat: | in der ersten for schleife: test[]=a ist eine zuweisung eines integers als array, das funktioniert nicht. |
Ich Programmiere nicht komisch, sonder der Syntax ist an PHP angelehnt. Dort bedeutet der "[]" Operator das an ein bestehendes Array ein Element angefügt wird.
Zitat: | wenn du unbedingt [] benutzen willst musst du über pointer arbeiten, integer ptr zB wenn du zahlen speichern willst, wenn du verschiedene variablentypen speichern willst müsstest du einfach any ptr nehmen und dir jeweils merken, was für ein typ an welcher stelle steht und dich außerdem selbst ums allozieren/deallozieren des zugehörigen speichers kümmern. garbage collection sobald eine referenz auf eine variable nicht mehr existiert funktioniert über pointer nicht. |
Weil Pointer den gleichen Speicherplatz benötigen und ich nicht mehr unterscheiden kann ob ein Pointer "integer ptr" oder "short ptr" ist, leider habe ich noch nicht herausgefunden wie man testen kann um welchen Datentyp es sich handelt.
Zitat: | test.sort() wäre "objektorientiert", dafür müsstest du test als array von einem selbstdefinierten typen machen der ungefähr so aussieht: |
Richtig.
Zitat: | /edit: ach jetz versteh ich auch was du beim ersten ding meinst, a an das array anhängen, sowas gabs bei php ja happy dazu siehe mein letzer absatz. mit Operatorern überladen bist du auf jeden fall auf der falschen schiene. |
Wie soll's denn anders gehen ? Schließlich möchte ich Freebasic nicht grundlegend verändern, eher nur ein paar für mich sinnvolle Tools schreiben. Und bei meinen paar 1000 Datensätzen kommt es auf die eine Sekunde Laufzeit mehr oder weniger auch nicht an. |
|
Nach oben |
|
 |
MisterD

Anmeldungsdatum: 10.09.2004 Beiträge: 3071 Wohnort: bei Darmstadt
|
Verfasst am: 22.05.2007, 16:33 Titel: |
|
|
das geht einfach überhauptnicht so wie du dir das vorstellst. Du musst dir ne art Library schreiben, wo du dann halt sowas schreiben kannst wie
Dim myArray as array
myArray.add("Hallo") 'ne sub add(data as string)
myArray.add(123) 'ne sub add(data as integer), überladen halt
myArray.add(somethingElse) 'ne sub add(data as somethingElseType)
die add müsste eben entsprechend dem parameter typ speicher allozieren und die daten da reinkopieren oder sowas, gleichzeitig speichern, welcher typ an der stelle steht, dafür konstanten anlegen
ENUM types
TYPE_POINTER
TYPE_INTEGER
TYPE_STRING
TYPE_wasauchimmer
END ENUM
so oder so ähnlich ging das, die elemente werden dabei durchnummeriert, also TYPE_POINTER=1, TYPE_INTEGER=2, TYPE_STRING=3 usw
myArray.getType(2) 'würde dir eben ne konstante TYPE_INTEGER oder so geben, mit select verarbeiten dann
myArray.get(2) 'wäre in dem fall ein pointer auf die int-speicherstelle wo 123 steht
zum ausgeben zB:
SUB array_print_element(myArray as array, n as integer)
DIM data as any ptr
data=myArray.get(n)
SELECT CASE myArray.get(n)
CASE TYPE_POINTER: PRINT str(*cptr(any ptr ptr, data)+" (pointer)"
CASE TYPE_INTEGER: PRINT *cptr(integer ptr, data)
CASE TYPE_STRING: PRINT *cptr(zstring ptr, data)
END SELECT
END SUB
array_print_element(myArray, 2)
oder sowas ähnliches in der richtung
sub myArray.sort()
sub myArray.removeIndex(n as integer) 'um element n zu entfernen
'bsp: myArray.removeIndex(2)
eventuell dann noch für jeden typ ne removeItem:
sub myArray.removeItem(data as integer) 'um alle elemente, die data sind, zu entfernen
'sprich, den eintrag aus dem array entfernen und vor allem den allozierten speicher wieder freigeben
'als beispiel myArray.remove(123)
sub myArray.removeItem(data as string)
sub myArray.removeItem(data as somethingElseType)
und ganz wichtig, du musst das array von hand auflösen wenn du's nicht mehr brauchst, dazu so ne art funktion
sub myArray.deallocate()
was eben für ausnahmslos jedes noch im array vorhandene element ein removeIndex (oder removeItem) ausführt und der ganze speicher wieder freigegeben wird.
du hast auf jeden fall unendlich viel arbeit und wirst ebenfalls wenn du nicht aufpasst, massive memoryleaks produzieren, alleine schon weil freebasic intern bugs hat, die meldet dir der compiler aber dann als warning, irgendwas von wegen "dynamic types in function return" oder so, passiert wenn man zB n UDT mit nem Stringarray drin als funktionsrückgabe hat. du müsstest in so nem fall den rückgabeUDT mit zstring ptr array statt string array ausstatten und die ganzen strings wieder von hand allozieren und deallozieren, noch mal viel mehr arbeit.
also überleg dir, ob du sowas wirklich machen willst  _________________ "It is practically impossible to teach good programming to students that have had a prior exposure to BASIC: as potential programmers they are mentally mutilated beyond hope of regeneration."
Edsger W. Dijkstra |
|
Nach oben |
|
 |
chutullu
Anmeldungsdatum: 18.10.2005 Beiträge: 77
|
Verfasst am: 23.05.2007, 09:45 Titel: |
|
|
Zitat: | das geht einfach überhauptnicht so wie du dir das vorstellst. Du musst dir ne art Library schreiben, wo du dann halt sowas schreiben kannst wie |
So sieht das Grundgerüst für jeden Array Eintrag aus und damit habe ich gleichzeitig mein "Typen" Problem gelöst :
Code: |
Type ArrayItem
_type As Byte
value As String
Declare Constructor ()
Declare Constructor (a As UByte)
Declare Constructor (a As Byte)
Declare Constructor (a As UShort)
Declare Constructor (a As Short)
Declare Constructor (a As UInteger)
Declare Constructor (a As Integer)
Declare Constructor (a As ULong)
Declare Constructor (a As Long)
Declare Constructor (a As ULongInt)
Declare Constructor (a As LongInt)
Declare Constructor (a As Single)
Declare Constructor (a As Double)
Declare Constructor (a As String)
Declare Operator Cast () As String
End Type
Constructor ArrayItem ()
this.value = ""
this._type = 0
End Constructor
Constructor ArrayItem (a As UByte)
this.value = Str(a)
this._type = 1
End Constructor
Constructor ArrayItem (a As Byte)
this.value = Str(a)
this._type = 2
End Constructor
Constructor ArrayItem (a As Ushort)
this.value = Str(a)
this._type = 3
End Constructor
Constructor ArrayItem (a As Short)
this.value = Str(a)
this._type = 3
End Constructor
Constructor ArrayItem (a As UInteger)
this.value = Str(a)
this._type = 4
End Constructor
Constructor ArrayItem (a As Integer)
this.value = Str(a)
this._type = 5
End Constructor
Constructor ArrayItem (a As ULong)
this.value = Str(a)
this._type = 6
End Constructor
Constructor ArrayItem (a As Long)
this.value = Str(a)
this._type = 7
End Constructor
Constructor ArrayItem (a As ULongInt)
this.value = Str(a)
this._type = 8
End Constructor
Constructor ArrayItem (a As LongInt)
this.value = Str(a)
this._type = 9
End Constructor
Constructor ArrayItem (a As Single)
this.value = Str(a)
this._type = 10
End Constructor
Constructor ArrayItem (a As Double)
this.value = Str(a)
this._type = 11
End Constructor
Constructor ArrayItem (a As String)
this.value = a
this._type = 12
End Constructor
Operator ArrayItem.Cast () As String
Return this.value
End Operator
Dim tt As ArrayItem
tt = 1234
Print tt
If tt._type = 5 Then Print "das ist ein Integer"
Print : Print
tt = "test"
Print tt
If tt._type = 12 Then Print "das ist ein String"
Sleep
|
Der Datentype Array wird wahrscheinlich so in der Art :
Code: | Type Array
Item As ArrayItem
Key As ArrayKey
_nxt As Array ptr
...
Delcare Operator [] (ByRef rhs as ArrayItem)
Declare Overload Operator [] (ByRef lhs as ArrayKey,ByRef rhs as ArrayItem)
...
End Type
|
aussehen.
Nun ist hier das Problem das beim Declarieren des "[]" Operators zwei grundlegende Varianten :
array[] = value
array[key] = value
und diese Art von Zuweisung :
array = {1,2,3; 4,5,6}
möglich sein soll. Nun funktioniert es bei mir nicht das ich einen überladenen Operator noch einmal übladen kann. Hat jemand ein paar Beispiele zum Thema "Operatoren" überladen ? |
|
Nach oben |
|
 |
MisterD

Anmeldungsdatum: 10.09.2004 Beiträge: 3071 Wohnort: bei Darmstadt
|
Verfasst am: 23.05.2007, 16:53 Titel: |
|
|
was soll denn 1,2,3;4,5,6 darstellen? oO
und, naja, wenn du das so machst hast du am ende kein array sondern eine liste.. der aufwand, auf ein bestimmtes element auf diese art zuzugreifen wächst je mehr elemente drin sind, du kannst nicht mehr direkt zugreifen sondern musst alle vorgängerelemente durchlaufen. Was du da programmierst ist kein array sondern eine verkettete Liste. _________________ "It is practically impossible to teach good programming to students that have had a prior exposure to BASIC: as potential programmers they are mentally mutilated beyond hope of regeneration."
Edsger W. Dijkstra |
|
Nach oben |
|
 |
chutullu
Anmeldungsdatum: 18.10.2005 Beiträge: 77
|
Verfasst am: 23.05.2007, 17:32 Titel: |
|
|
Besser gesagt eine verkettete Liste mit der Syntax wie ein Array in PHP.
{1,2,3;4,6,7}
bedeutet :
array[1][1] = 1
array[1][2] = 2
...
array[2][3] = 7 |
|
Nach oben |
|
 |
ytwinky

Anmeldungsdatum: 28.05.2005 Beiträge: 2624 Wohnort: Machteburch
|
Verfasst am: 23.05.2007, 17:36 Titel: |
|
|
Hat das vllt. irgendwas mit der Initialisierung von Arrays zu tun: Befehlsreferenz zum Thema Dim hat Folgendes geschrieben: | DIM Array(1 TO 3, 2) => { {1, 2, 3}, _
{4, 5, 6}, _
{7, 8, 9} } | ?
Gruß
ytwinky _________________
v1ctor hat Folgendes geschrieben: | Yeah, i like INPUT$(n) as much as PRINT USING.. | ..also ungefähr so, wie ich GOTO.. |
|
Nach oben |
|
 |
MisterD

Anmeldungsdatum: 10.09.2004 Beiträge: 3071 Wohnort: bei Darmstadt
|
Verfasst am: 23.05.2007, 19:04 Titel: |
|
|
für normale arrays funktioniert das, ka.. aber das ganze überladen auf seine UDT-Arrays zu bringen wird glaube ich nicht so leicht möglich.. Michael! hack plz!  _________________ "It is practically impossible to teach good programming to students that have had a prior exposure to BASIC: as potential programmers they are mentally mutilated beyond hope of regeneration."
Edsger W. Dijkstra |
|
Nach oben |
|
 |
Michael712 aka anfänger, programmierer
Anmeldungsdatum: 26.03.2005 Beiträge: 1593
|
Verfasst am: 23.05.2007, 20:05 Titel: |
|
|
Ähm...
Gib mir bis morgen Zeit, dann mach ich das
Hab grad nur nicht so viel Zeit  _________________
Code: | #include "signatur.bi" |
|
|
Nach oben |
|
 |
volta
Anmeldungsdatum: 04.05.2005 Beiträge: 1876 Wohnort: D59192
|
Verfasst am: 30.05.2007, 19:58 Titel: |
|
|
chutullu hat Folgendes geschrieben: | Hat jemand ein paar Beispiele zum Thema "Operatoren" überladen ? | Sieh mal unter examples\real10...
Code: | 'some real10 routines by srvaldez (jbklassen[=at=]warpdriveonline.com)
#inclib "real10"
Union ext
As Integer fl(0 to 4-1)
As Ushort fw(0 to 8-1)
As Ubyte tb(0 to 16-1)
Declare constructor ( Byref rhs As ext )
Declare constructor ( Byval rhs As Integer = 0 )
Declare constructor ( Byval rhs As Single )
Declare constructor ( Byval rhs As Double )
Declare constructor ( Byref rhs As String )
Declare operator let( byref rhs As ext )
Declare operator let( byval rhs As Integer )
Declare operator let( byval rhs As Single )
Declare operator let( byval rhs As Double )
Declare operator let( byref rhs As String )
Declare operator cast( ) As Integer
Declare operator cast( ) As Single
Declare operator cast( ) As Double
Declare operator cast( ) As String
End Union
Declare Operator + ( Byref lhs As ext, Byref rhs As ext ) As ext
Declare Operator + ( Byref lhs As ext, Byval rhs As Integer ) As ext
Declare Operator + ( Byval lhs As Integer, Byref rhs As ext ) As ext
Declare Operator + ( Byref lhs As ext, Byval rhs As Single ) As ext
Declare Operator + ( Byval lhs As Single, Byref rhs As ext ) As ext
Declare Operator + ( Byref lhs As ext, Byval rhs As Double ) As ext
Declare Operator + ( Byval lhs As Double, Byref rhs As ext ) As ext
Declare Operator - ( Byref lhs As ext, Byref rhs As ext ) As ext
Declare Operator - ( Byref lhs As ext, Byval rhs As Integer ) As ext
Declare Operator - ( Byval lhs As Integer, Byref rhs As ext ) As ext
Declare Operator - ( Byref lhs As ext, Byval rhs As Single ) As ext
Declare Operator - ( Byval lhs As Single, Byref rhs As ext ) As ext
Declare Operator - ( Byref lhs As ext, Byval rhs As Double ) As ext
Declare Operator - ( Byval lhs As Double, Byref rhs As ext ) As ext
Declare Operator - ( Byref lhs As ext ) As ext
Declare Operator * ( Byref lhs As ext, Byref rhs As ext ) As ext
Declare Operator * ( Byref lhs As ext, Byval rhs As Integer ) As ext
Declare Operator * ( Byval lhs As Integer, Byref rhs As ext ) As ext
Declare Operator * ( Byref lhs As ext, Byval rhs As Single ) As ext
Declare Operator * ( Byval lhs As Single, Byref rhs As ext ) As ext
Declare Operator * ( Byref lhs As ext, Byval rhs As Double ) As ext
Declare Operator * ( Byval lhs As Double, Byref rhs As ext ) As ext
Declare Operator / ( Byref lhs As ext, Byref rhs As ext ) As ext
Declare Operator / ( Byref lhs As ext, Byval rhs As Integer ) As ext
Declare Operator / ( Byval lhs As Integer, Byref rhs As ext ) As ext
Declare Operator / ( Byref lhs As ext, Byval rhs As Single ) As ext
Declare Operator / ( Byval lhs As Single, Byref rhs As ext ) As ext
Declare Operator / ( Byref lhs As ext, Byval rhs As Double ) As ext
Declare Operator / ( Byval lhs As Double, Byref rhs As ext ) As ext
Declare Operator ^ ( Byref lhs As ext, Byref rhs As ext ) As ext
Declare Operator ^ ( Byref lhs As ext, Byval rhs As Integer ) As ext
Declare Operator ^ ( Byval lhs As Integer, Byref rhs As ext ) As ext
Declare Operator ^ ( Byref lhs As ext, Byval rhs As Single ) As ext
Declare Operator ^ ( Byval lhs As Single, Byref rhs As ext ) As ext
Declare Operator ^ ( Byref lhs As ext, Byval rhs As Double ) As ext
Declare Operator ^ ( Byval lhs As Double, Byref rhs As ext ) As ext
'rel ops
Declare Operator <> ( Byref lhs As ext, Byref rhs As ext ) As Integer
Declare Operator <> ( Byref lhs As ext, Byval rhs As Integer ) As Integer
Declare Operator <> ( Byval lhs As Integer, Byref rhs As ext ) As Integer
Declare Operator <> ( Byref lhs As ext, Byval rhs As Single ) As Integer
Declare Operator <> ( Byval lhs As Single, Byref rhs As ext ) As Integer
Declare Operator <> ( Byref lhs As ext, Byval rhs As Double ) As Integer
Declare Operator <> ( Byval lhs As Double, Byref rhs As ext ) As Integer
Declare Operator < ( Byref lhs As ext, Byref rhs As ext ) As Integer
Declare Operator < ( Byref lhs As ext, Byval rhs As Integer ) As Integer
Declare Operator < ( Byval lhs As Integer, Byref rhs As ext ) As Integer
Declare Operator < ( Byref lhs As ext, Byval rhs As Single ) As Integer
Declare Operator < ( Byval lhs As Single, Byref rhs As ext ) As Integer
Declare Operator < ( Byref lhs As ext, Byval rhs As Double ) As Integer
Declare Operator < ( Byval lhs As Double, Byref rhs As ext ) As Integer
Declare Operator <= ( Byref lhs As ext, Byref rhs As ext ) As Integer
Declare Operator <= ( Byref lhs As ext, Byval rhs As Integer ) As Integer
Declare Operator <= ( Byval lhs As Integer, Byref rhs As ext ) As Integer
Declare Operator <= ( Byref lhs As ext, Byval rhs As Single ) As Integer
Declare Operator <= ( Byval lhs As Single, Byref rhs As ext ) As Integer
Declare Operator <= ( Byref lhs As ext, Byval rhs As Double ) As Integer
Declare Operator <= ( Byval lhs As Double, Byref rhs As ext ) As Integer
Declare Operator = ( Byref lhs As ext, Byref rhs As ext ) As Integer
Declare Operator = ( Byref lhs As ext, Byval rhs As Integer ) As Integer
Declare Operator = ( Byval lhs As Integer, Byref rhs As ext ) As Integer
Declare Operator = ( Byref lhs As ext, Byval rhs As Single ) As Integer
Declare Operator = ( Byval lhs As Single, Byref rhs As ext ) As Integer
Declare Operator = ( Byref lhs As ext, Byval rhs As Double ) As Integer
Declare Operator = ( Byval lhs As Double, Byref rhs As ext ) As Integer
Declare Operator >= ( Byref lhs As ext, Byref rhs As ext ) As Integer
Declare Operator >= ( Byref lhs As ext, Byval rhs As Integer ) As Integer
Declare Operator >= ( Byval lhs As Integer, Byref rhs As ext ) As Integer
Declare Operator >= ( Byref lhs As ext, Byval rhs As Single ) As Integer
Declare Operator >= ( Byval lhs As Single, Byref rhs As ext ) As Integer
Declare Operator >= ( Byref lhs As ext, Byval rhs As Double ) As Integer
Declare Operator >= ( Byval lhs As Double, Byref rhs As ext ) As Integer
Declare Operator > ( Byref lhs As ext, Byref rhs As ext ) As Integer
Declare Operator > ( Byref lhs As ext, Byval rhs As Integer ) As Integer
Declare Operator > ( Byval lhs As Integer, Byref rhs As ext ) As Integer
Declare Operator > ( Byref lhs As ext, Byval rhs As Single ) As Integer
Declare Operator > ( Byval lhs As Single, Byref rhs As ext ) As Integer
Declare Operator > ( Byref lhs As ext, Byval rhs As Double ) As Integer
Declare Operator > ( Byval lhs As Double, Byref rhs As ext ) As Integer
.......
| frag mich nicht nach Einzelheiten ??? _________________ Warnung an Choleriker:
Dieser Beitrag kann Spuren von Ironie & Sarkasmus enthalten.
Zu Risiken & Nebenwirkungen fragen Sie Ihren Therapeuten oder Psychiater. |
|
Nach oben |
|
 |
|
|
Du kannst keine Beiträge in dieses Forum schreiben. Du kannst auf Beiträge in diesem Forum nicht antworten. Du kannst deine Beiträge in diesem Forum nicht bearbeiten. Du kannst deine Beiträge in diesem Forum nicht löschen. Du kannst an Umfragen in diesem Forum nicht mitmachen.
|
|