Das deutsche QBasic- und FreeBASIC-Forum Foren-Übersicht Das deutsche QBasic- und FreeBASIC-Forum
Für euch erreichbar unter qb-forum.de, fb-forum.de und freebasic-forum.de!
 
FAQFAQ   SuchenSuchen   MitgliederlisteMitgliederliste   BenutzergruppenBenutzergruppen  RegistrierenRegistrieren
ProfilProfil   Einloggen, um private Nachrichten zu lesenEinloggen, um private Nachrichten zu lesen   LoginLogin
Zur Begleitseite des Forums / Chat / Impressum
Aktueller Forenpartner:

Überladen von Operatoren

 
Neues Thema eröffnen   Neue Antwort erstellen    Das deutsche QBasic- und FreeBASIC-Forum Foren-Übersicht -> Allgemeine Fragen zu FreeBASIC.
Vorheriges Thema anzeigen :: Nächstes Thema anzeigen  
Autor Nachricht
chutullu



Anmeldungsdatum: 18.10.2005
Beiträge: 77

BeitragVerfasst am: 21.05.2007, 14:14    Titel: Überladen von Operatoren Antworten mit Zitat

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
Benutzer-Profile anzeigen Private Nachricht senden
MisterD



Anmeldungsdatum: 10.09.2004
Beiträge: 3071
Wohnort: bei Darmstadt

BeitragVerfasst am: 21.05.2007, 18:39    Titel: Antworten mit Zitat

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 happy 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
Benutzer-Profile anzeigen Private Nachricht senden
chutullu



Anmeldungsdatum: 18.10.2005
Beiträge: 77

BeitragVerfasst am: 22.05.2007, 09:43    Titel: Antworten mit Zitat

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
Benutzer-Profile anzeigen Private Nachricht senden
MisterD



Anmeldungsdatum: 10.09.2004
Beiträge: 3071
Wohnort: bei Darmstadt

BeitragVerfasst am: 22.05.2007, 16:33    Titel: Antworten mit 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
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 zwinkern
_________________
"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
Benutzer-Profile anzeigen Private Nachricht senden
chutullu



Anmeldungsdatum: 18.10.2005
Beiträge: 77

BeitragVerfasst am: 23.05.2007, 09:45    Titel: Antworten mit Zitat

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
Benutzer-Profile anzeigen Private Nachricht senden
MisterD



Anmeldungsdatum: 10.09.2004
Beiträge: 3071
Wohnort: bei Darmstadt

BeitragVerfasst am: 23.05.2007, 16:53    Titel: Antworten mit Zitat

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
Benutzer-Profile anzeigen Private Nachricht senden
chutullu



Anmeldungsdatum: 18.10.2005
Beiträge: 77

BeitragVerfasst am: 23.05.2007, 17:32    Titel: Antworten mit Zitat

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
Benutzer-Profile anzeigen Private Nachricht senden
ytwinky



Anmeldungsdatum: 28.05.2005
Beiträge: 2624
Wohnort: Machteburch

BeitragVerfasst am: 23.05.2007, 17:36    Titel: Antworten mit Zitat

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
Benutzer-Profile anzeigen Private Nachricht senden E-Mail senden Website dieses Benutzers besuchen
MisterD



Anmeldungsdatum: 10.09.2004
Beiträge: 3071
Wohnort: bei Darmstadt

BeitragVerfasst am: 23.05.2007, 19:04    Titel: Antworten mit Zitat

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! grinsen
_________________
"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
Benutzer-Profile anzeigen Private Nachricht senden
Michael712
aka anfänger, programmierer


Anmeldungsdatum: 26.03.2005
Beiträge: 1593

BeitragVerfasst am: 23.05.2007, 20:05    Titel: Antworten mit Zitat

Ähm...
Gib mir bis morgen Zeit, dann mach ich das durchgeknallt
Hab grad nur nicht so viel Zeit Zunge rausstrecken
_________________
Code:
#include "signatur.bi"
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden E-Mail senden
volta



Anmeldungsdatum: 04.05.2005
Beiträge: 1876
Wohnort: D59192

BeitragVerfasst am: 30.05.2007, 19:58    Titel: Antworten mit Zitat

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 verlegen ???
_________________
Warnung an Choleriker:
Dieser Beitrag kann Spuren von Ironie & Sarkasmus enthalten.
Zu Risiken & Nebenwirkungen fragen Sie Ihren Therapeuten oder Psychiater.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen
Beiträge der letzten Zeit anzeigen:   
Neues Thema eröffnen   Neue Antwort erstellen    Das deutsche QBasic- und FreeBASIC-Forum Foren-Übersicht -> Allgemeine Fragen zu FreeBASIC. Alle Zeiten sind GMT + 1 Stunde
Seite 1 von 1

 
Gehe zu:  
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.

 Impressum :: Datenschutz