Kann man Prozeduren in PB überladen?

[Danilo]

Es ist schon nett wenn man einige Funktionen mit vielen Datentypen aufrufen kann. Zum Beispiel bei der Funktion Str(),
die dann ohne Umwege mit Ascii, Byte, Character, Unicode, Word, Long, Integer, Quad, Float, Double, und Strukturen benutzt werden könnte.
Jedes mal gibt die Funktion Str() die String-Repräsentation des jeweiligen Datentyps zurück, und man braucht keine zig Funktionen
oder andere Workarounds dafür. So einfach geht es bei PB nicht, aber man gewöhnt sich daran.

Für komplexe Datentypen ist dann m.M.n. ein Interface besser, wo die Funktionen direkt mit dem Datentyp verknüpft sind,
man also statt dem globalen Str() dann Adresse\ToString(), Integer\ToString(), Node\ToString() usw. aufruft.

Oder man benutzt Module und schreibt Adresse::ToString(adr1), Integer::ToString(i), Node::ToString(n1).
Zwar alles erstmal etwas aufwendiger, ohne AutoComplete auch meist mehr zu schreiben, aber dafür bei der Wartung und Pflege des Codes
auf lange Zeit gut und klar verständlich/lesbar und eindeutig.

[STARGÅTE]

Ich glaube das ist gewohnheitssache, wie man seinen Code aufbaut.

Die einen schreiben gerne die Typ der Variable vor den Namen: sName, iAnzahl, fAbstand, listGegner
und benutzen dafü lieber für alle Type einen gleichen Procedurenamen: Compare()
Andere machen es lieber andersherum. Dass heißt, Variablen haben nur einen Namen: Name, Anzahl, Abstand, Gegener
und dafür haben halt die Proceduren unterschiedliche Vor- oder Nachsätze: CompareList(), CompareStrings() usw.

PB hat sich (vermutlich ungewollt) dafür zu entscheiden, eine Procedure eindeutig zu machen.

[Danilo]

PB hat sich (vermutlich ungewollt) dafür zu entscheiden, eine Procedure eindeutig zu machen.

Andersrum wird ein Schuh draus.

PB unterstützt kein Überladen von Funktionen, also müssen wir schreiben:

Code: Alles auswählen

Str(value)
StrF(value)
StrD(value)

StrU(value,#PB_Byte)
StrU(value,#PB_Ascii)
StrU(value,#PB_Word)
StrU(value,#PB_Unicode)
StrU(value,#PB_Long)
StrU(value,#PB_Quad)

Bin(value,#PB_Byte)
Bin(value,#PB_Ascii)
Bin(value,#PB_Word)
Bin(value,#PB_Unicode)
Bin(value,#PB_Long)
Bin(value,#PB_Quad)

Hex(value,#PB_Byte)
Hex(value,#PB_Ascii)
Hex(value,#PB_Word)
Hex(value,#PB_Unicode)
Hex(value,#PB_Long)
Hex(value,#PB_Quad)

Sollte PB es in Zukunft irgendwann einmal unterstützen, schreiben wir:

Code: Alles auswählen

Str(value)
Bin(value)
Hex(value)

Da es bei PB nicht einmal eine gewisse Typsicherheit / Typcasting gibt, ist es eher unwahrscheinlich erweiterte Features wie das Überladen erwarten zu können.

Code: Alles auswählen

b.b = i.i
a.a = *pointer
c.c = q.q

Von daher denke ich, dass das Überladen von Funktionen nicht so schnell kommen wird, wenn überhaupt.

Ein paar hundert oder tausend Leute verwenden PB auch ohne diese Features seit über 10 Jahren...
(...und bei dem günstigen, einmaligen Preis für (zur Zeit) 3 Plattformen, kann man kaum etwas falsch machen -
nur sollte man eventuelle Einschränkungen trotzdem vorher kennen, dann bereut man den Kauf später auch nicht)

[STARGÅTE]

Den Typen bei Hex und Bin anzugeben hat folgenden Grund:

Code: Alles auswählen

Debug Hex(-1,#PB_Byte)
Debug Hex(-1,#PB_Word)
Debug Hex(-1,#PB_Long)
Debug Hex(-1,#PB_Quad)

Somit ist dieser Parameter an diese Stelle durchaus notwenig.

Da es bei PB nicht einmal eine gewisse Typsicherheit / Typcasting gibt, ist es eher unwahrscheinlich erweiterte Features wie das Überladen erwarten zu können.

Naja wie ich finde zum Glück! Sonst würde einige Tips und Tricks nicht mehr gehen, gerade, was Pointer zu verschiedenen Strukturen angeht.
UNd auf sowas:
Integer.i = ToInt(Float.f) oder
Float.f = ToFloat(Integer.i)
habe ich eigentlich keine Lust, wenns so viel einfacher ist:
Integer.i = Float.f
Float.i = Integer.f

Ein paar hundert oder tausend Leute verwenden PB auch ohne diese Features seit über 10 Jahren...

Eben. Und Programmierer finden immer ein Weg, das eine oder andere, was nicht existiert, möglich zu machen.
Da muss ich wieder an damals denken, wo List, Arrays und Maps nicht in Strukturen möglich waren.
Heute unvorstellbar, wie man damals vernünftigen Codeaufbau betreiben konnte ^^

[GronkhLP]

Danke für die weiteren Antworten. Interessantes Thema.

[_sivizius]

und folgendes:

Code: Alles auswählen

Procedure AddZeuch(input$)
  For k=1 to CountString(input$, ",")+1
    output = Add(output, Val(Trim(StringField(input$, k, ","))))
  Next
  ProcedureReturn output
EndProcedure

Alles andere als toll, aber löst das Problem und lässt sich schnell erweitern...
Oder du bastelst dir Lambdakalkülzeug zusammen

[auser]

Naja wie ich finde zum Glück!

Wieso soll es ein Glück sein wenn ich mich um Sachen kümmern muss die das Programm eigentlich bereits längst wissen müsste? Es ist ja nicht so als ob ich in C nicht auch Strukturen verwenden könnte oder als ob es keine *void Pointer gibt. Also wenn dich das glücklich macht... du kannst dir in C sogar PeekI, PeekL für jeden Typ schreiben (auch wenn du das in C gar nicht musst weil * für beides genügt). Was ich jedenfalls nervig finde ist daß sich PB hier in eine Nische manövriert. Ich muss wenn ich eine C-Lib verwende nicht selten (und es gibt nun mal sehr, sehr viele davon) in den Header gehen und auf gut Glück hoffen daß ich die richtige Größe für jetzt und für immer errate. Ja richtig ... rate. Ich kann zwar mit sizeof() durchaus einfach mal eben die Größe rausfinden und das für 32bit und 64bit machen... nur leider kann sich das von OS zu OS ändern (Linux, BSD, ...). Ist kein Ding mit C ... da kompiliert das einfach mit dem neuen Header der die richtige Definition drin hat und der Programmierer braucht sich darüber gar keinen großen Kopf machen. *a = blub; funktioniert auch dann noch. Was musst du da in PB machen? Du musst dir das Header file nehmen eine andere Programmiersprache verwenden um eine Größe auf einem anderen OS rauszufinden und sofern sich die Größe vom Typ geändert hat im Code von PB rumwurschteln und z.B. workaround_struktur\l auf workaround_struktur\i umschreiben. Das finde ich überhaupt nicht vorteilhaft.

UNd auf sowas:
Integer.i = ToInt(Float.f) oder
Float.f = ToFloat(Integer.i)
habe ich eigentlich keine Lust,

Musst du doch gar ned:
float x;
int y;
y = x;
x = y;

Ein paar hundert oder tausend Leute verwenden PB auch ohne diese Features seit über 10 Jahren...

PB hat schon auch seine Vorzüge. Da wär z.B. die PB-Lib die dir Platformübergreifend einiges an Werkzeug zur Verfügung stellt ohne daß ich dazu gedrängt werde bei 'nem 10-Zeiler schon irgendwelche Objekte zu bemühen und trotzdem die Freiheit habe das ganze durchaus noch ziemlich komplex zu gestalten. Kurz gesagt die Geschwindigkeit eine Aufgabe mit einem Programm zu lösen (und dabei auch fertig zu werden) - sofern die Funktionen von PB reichen oder ich nicht all zu viele Teile von fremden Libs brauche - kann durchaus gelobt werden. Aber ich seh durchaus nicht überall nur Vorteile wenn etwas fehlt das in anderen Sprachen möglich und sinnvoll ist. Insbesondere wenn etwas fehlt fängt in PB durchaus schon mal das herumtricksen und rätselraten an. Man kann zwar Libs aufmachen aber da fühl ich mich z.B. auf Linux (wo ich zwar jedemenge Sourcen und Headerfiles hätte diese aber bei weitem nicht so bequem wie in C/C++ einbinden kann) sehr oft wie ein Alien.

[mk-soft]

Für die Übergabe von verschiedenen Parametertypen kann man sich auch selber etwas basteln ala Variant

Code: Alles auswählen

; Selbstgebauter Type Any ala Variant

Structure Any
  type.i
  StructureUnion
    bVal.b
    wVal.w
    lVal.l
    qVal.q
    iVal.i
    fVal.f
    dVal.d
  EndStructureUnion
  sVal.s ; String ausserhalb da String in einer Union nicht mehr erlaubt sind
EndStructure


Macro bVal(Value)
  Value\type = #PB_Byte : Value\bVal
EndMacro

Macro iVal(Value)
  Value\type = #PB_Integer : Value\iVal
EndMacro

Macro sVal(Value)
  Value\type = #PB_String : Value\sVal
EndMacro

Define.any var1, var2, var3

bVal(var1) = 100
iVal(var2) = -2000000000
sVal(var3) = "Hallo Welt ;)"

Procedure foo(*Value.Any)
  
  With *Value
    Select \type
      Case #PB_Byte
        Debug "Value ist von Type Byte: " + Str(\bVal) 
      Case #PB_Integer
        Debug "Value ist von Type Integer: " + Str(\iVal) 
      Case #PB_String
        Debug "Value ist von Type String: " + \sVal
    EndSelect
    
  EndWith
  
EndProcedure

foo(var1)
foo(var2)
foo(var3)

[mk-soft]

Geht noch etwas einfacher. Aber nicht mit Konstanten...

Ist keine echte Typeüberladung, aber man kann mit einen Trick die Varible als ByRef und den Type der Variable übergeben.

Code: Alles auswählen

Structure Any
  StructureUnion
    bVal.b
    wVal.w
    lVal.l
    iVal.i
  EndStructureUnion
EndStructure

Procedure CompareValue(*v1.Any, *v2.Any, type1, type2)
  
  Protected result
  Protected helpVar1.i, helpVar2.i , *s1.string, *s2.string
  
  If type1 = #PB_String And type2 = #PB_String
    *s1 = @*v1
    *s2 = @*v2
    result = Bool(*s1\s = *s2\s)
    ProcedureReturn result
  EndIf
  
  Select type1
    Case #PB_Byte    : helpVar1 = *v1\bVal
    Case #PB_Word    : helpVar1 = *v1\wVal
    Case #PB_Long    : helpVar1 = *v1\lVal
    Case #PB_Integer : helpVar1 = *v1\iVal
    Case #PB_String  : *s1 = @*v1 : helpVar1 = Val(*s1\s)
  EndSelect
  
  Select type2
    Case #PB_Byte    : helpVar2 = *v2\bVal
    Case #PB_Word    : helpVar2 = *v2\wVal
    Case #PB_Long    : helpVar2 = *v2\lVal
    Case #PB_Integer : helpVar2 = *v2\iVal
    Case #PB_String  : *s2 = @*v2 : helpVar2 = Val(*s2\s)
  EndSelect
  
  result = Bool(helpVar1 = helpVar2)
  
  ProcedureReturn result
  
EndProcedure

Macro Compare(Value1, Value2)
  CompareValue(@Value1, @Value2, TypeOf(Value1), TypeOf(Value2))
EndMacro

; Test

Define.b a, b
Define.i c, d
Define.s s1, s2, s3

a = 100
b = 200
c = 100
d = 200
s1 = "Hallo Welt"
s2 = "Hallo Welt"
s3 = "100"

Debug Compare(a, b)
Debug Compare(a, c)
Debug Compare(a, s3)
Debug Compare(s1,s2)
Debug Compare(s1,s3)

[NeoRon]

Hi Gronkh,

mit dir hätte ich hier in dem PB Forum nicht gerechnet ^^

Jetzt gibs hier auch noch Prominente im Forum. ^^

Und ich finde Purebasic toll. ^^

Kennste das kommerzielle Game Restricted Area?
http://www.amazon.de/Vidis-Restricted-A ... words=area

Das wurde in Purebasic programmiert. ^^
Ist nen tolles Action RPG in ner Scifi Cyberpunk Welt.^^

Grüße
Manuel