String auflösen

[Kiffi]

Code: Alles auswählen

#PB_Key_Minus

reagiert ab der 4.51 nicht... zumindest bei mir.
Könnt Ihr das mal checken?

Konstanten haben noch nie reagiert.

Code?

Grüße ... Kiffi

[Skiller]

Das Gegenteil von #PB_Key_Add ist #PB_Key_Subtract und nicht #PB_Key_Minus, wie ich zuerst vermutete. Die Taste #PB_Key_Minus ist mir nicht klar. Der normale "-" neben rechts/shift ist es bei mir jedenfalls nicht. Wie auch immer. Ist im Moment auch nicht so wichtig.
so long...
Skiller

[Lord]

Das Gegenteil von #PB_Key_Add ist #PB_Key_Subtract und nicht #PB_Key_Minus, wie ich zuerst vermutete. Die Taste #PB_Key_Minus ist mir nicht klar. Der normale "-" neben rechts/shift ist es bei mir jedenfalls nicht. Wie auch immer. Ist im Moment auch nicht so wichtig.
so long...
Skiller

Wenn Du die Plus und Minus-Tasten für Shortcuts verwenden willst,
sind es auf dem NumPad #PB_Shortcut_Add und #PB_Shortcut_Subtract.
Auf einer deutschen Tastatur haben sie die Werte 187 für Plus und 189 für Minus.
PB-Konstanten habe ich dazu auf die Schnelle nicht gefunden.

[Skiller]

Hi, Experts.
Habe mich nun einige Zeit mit dem Code von "cxAlex" auseinandergesetzt und versucht, aus '@Func1())' eine '@FuncX())' zu machen, was mir allerdings bei meinen bescheidenen PB-Erfahrungen nicht möglich ist. Wenn es denn überhaupt möglich ist, oder vielleicht doch ??! Dann wäre die Sache echt perfekt!!!

DANKE !!! Skiller

Code: Alles auswählen

EnableExplicit
Define.b i
;------------------------------------
Prototype _Func()

Structure _Func_Dummy
  *_caller._Func
EndStructure

Global NewMap _Func._Func_Dummy()
;------------------------------------
Macro RegisterFunc(_Name, FunctionPointer)
  _Func(_Name)\_caller = FunctionPointer
EndMacro

Macro Func(_n)
  _Func(_n)\_caller
EndMacro
;-------------------------------------
Procedure Func1()
  Debug "Das ist Funktion 1"
EndProcedure

Procedure Func2()
  Debug "Das ist Funktion 2"
EndProcedure

For i = 1 To 2
   RegisterFunc(Str(i), @Func1())
  ;RegisterFunc(Str(i), @Func2())
   Func(Str(i))()
Next i

[NicTheQuick]

Du meinst so?

Code: Alles auswählen

EnableExplicit
Define.b i
;------------------------------------
Prototype _Func()

Structure _Func_Dummy
	*_caller._Func
EndStructure

Global NewMap _Func._Func_Dummy()
;------------------------------------
Macro RegisterFunc(_Name, FunctionPointer)
	_Func(_Name)\_caller = FunctionPointer
EndMacro

Macro Func(_n)
	_Func(_n)\_caller
EndMacro
;-------------------------------------
Procedure Func1()
	Debug "Das ist Funktion 1"
EndProcedure

Procedure Func2()
	Debug "Das ist Funktion 2"
EndProcedure

Procedure FuncX()
	Debug "Das ist Funktion X"
EndProcedure

RegisterFunc("1", @Func1())
RegisterFunc("2", @Func2())
RegisterFunc("X", @FuncX())

For i = 1 To 2
	Func(Str(i))()
Next i 


Func("X")()

[Skiller]

Da hab ich mich blöderweise nicht klar ausgedrückt

Code: Alles auswählen

For i = 1 To n
  X.s = Str(i)
  RegisterFunc(X, @FuncX())  ;<---  @Func + X  + () ...oder ähnlich auflösen
  Func(X))()
Next i

Die Frage ist, ob man @Func ebenfallls auflösen kann, so dass man X als Zähler verwenden kann. Das hätte den Vorteil, die RegisterFunc()´s einzusparen.

Frohe Ostern...
Gruß Skiller

[cxAlex]

Die Frage ist, ob man @Func ebenfallls auflösen kann, so dass man X als Zähler verwenden kann. Das hätte den Vorteil, die RegisterFunc()´s einzusparen.

Frohe Ostern...
Gruß Skiller

Nein. Alles hat Grenzen, und auch wenn man in PB viel mit Makros mehr oder weniger sinnvoll verdrehen kann ... das funktioniert (meines Wissens nach) nicht, btw. kann so nicht funktionieren. Man könnte das ganze natürlich mit einer weiteren Map/Array - Instanz koppel, die den anscheinen immer numerischen @Func{Index}() Index aufnimmt und mit ein, zwei weitern Macros könnte man's so hinbiegen das man dann wie gewohnt daruf zugreifen soll aber ich bezweifle das das noch irgendwie Sinnvoll ist.

Gruß, Alex

[Skiller]

Wobei es schon eine gewisse Erleichterung gewesen wäre, sich die If´s bzw. select´s einzusparen.
Vielleicht doch mehr eine Frage der Ästhetik. Jedenfalls danke noch mal, dass Du uns Dein Wissen zur Verfügung gestellt hast.

Gruß Skiller

[Sicro]

Hallo Skiller,

am einfachsten wäre es ja, wenn du die Procedures in einer DLL auslagerst. So könntest du dann beim Aufrufen den Procedure-Name zusammenbasteln und aufrufen:

DLL:

Code: Alles auswählen

ProcedureDLL Funktion1()
  
EndProcedure

ProcedureDLL Funktion2()
  
EndProcedure

ProcedureDLL Funktion3()
  
EndProcedure

Programm:

Code: Alles auswählen

If OpenLibrary(0, "Procedures.dll")
  For i = 1 To 3
    CallFunction(0,"Funktion" + Str(i))
  Next
  
  CloseLibrary(0)
EndIf

[NicTheQuick]

Da man den Procedures ja sowieso irgendwie Namen geben muss, könnte man das ganze auch mit einem Macro nochmal vereinfachen, sodass 'RegisterFunc' schon automatisch beim Erstellen einer Procedure aufgerufen wird.

Code: Alles auswählen

EnableExplicit
Define.b i
;------------------------------------
Prototype _Func()

Structure _Func_Dummy
	*_caller._Func
EndStructure

Global NewMap _Func._Func_Dummy()
;------------------------------------
Macro RegisterFunc(_Name, FunctionPointer)
	_Func(_Name)\_caller = FunctionPointer
EndMacro

Macro Func(_n)
	_Func(_n)\_caller
EndMacro

Macro ProcedureReg(name, number, type = i,)
	Declare.type name()
	RegisterFunc(number, @name())
	Procedure.type name()
EndMacro
	
;-------------------------------------
ProcedureReg(Func1, Str(1))
	Debug "Das ist Funktion 1"
EndProcedure

ProcedureReg(Func2, Str(2))
	Debug "Das ist Funktion 2"
EndProcedure

ProcedureReg(FuncX, "X")
	Debug "Das ist Funktion X"
EndProcedure

For i = 1 To 2
	Func(Str(i))()
Next i

Func("X")()