Prototypes

[Torp]

Salut,

J'ai essayé de comprendre une des utilisation des Prototypes... Je suis donc parti de ce code du forum anglais :

Code : Tout sélectionner

Prototype bar(z.i)
Prototype set(x.i, y.i)

Structure foobar
  ; Members
  x.i
  y.i
  ; Methods
  bar.bar
  set.set
EndStructure

Global Dim foo.foobar(1)

Procedure.i bar(z.i)
  result.i = (foo(0)\x + foo(0)\y) * z
  ProcedureReturn result
EndProcedure

Procedure set(x.i, y.i)
  foo(0)\x = x
  foo(0)\y = y
EndProcedure

foo(0)\bar = @bar()
foo(0)\set = @set()

foo(0)\set(10, 20)

result.i = foo(0)\bar(30)
Debug result

Cela m'a bien servi, mais j'ai sorti bar et set du tableau, remplacé ce même tableau par une liste et j'ai viré le "Global". Tout cela pour voir si j'avais bien saisi le truc.

Ca à l'air de fonctionner, mais c'est le genre de truc qui me font fumer le cerveau !
Alors si cela peut aider quelqu'un à piger l'utilité du bazar voici mon exemple :

Code : Tout sélectionner

Prototype get(z.i, *Coord.Coord)
Prototype set(x.i, y.i, *Coord.Coord)
Declare.i get(z.i, *Coord.Coord)
Declare.i set(x.i, y.i, *Coord.Coord)

Structure xy
  ; Members
  x.i
  y.i 
EndStructure

Structure Coords
  ; Members
  List Pos.xy()
  ; Methods
  get.get
  set.set
EndStructure

Coord.Coords
Coord\get = @get()
Coord\set = @set()

;Test ------
Coord\set(10, 20, @Coord)
result.i = Coord\get(30, @Coord)
Debug result
Coord\set(35, 9, @Coord)
result.i = Coord\get(30, @Coord)
Debug result
Coord\set(11, 8, @Coord)
result.i = Coord\get(30, @Coord)
Debug result

CallDebugger
;-----------

;{ Procedures }
Procedure.i get(z.i, *Coord.Coords)
  result.i = (*Coord\Pos()\x + *Coord\Pos()\y) * z
  ProcedureReturn result
EndProcedure

Procedure set(x.i, y.i, *Coord.Coords)
  AddElement(*Coord\Pos())
  *Coord\Pos()\x = x
  *Coord\Pos()\y = y
EndProcedure
;}

Bye

[Backup]

voici ma vision (un peu personel) des prototypes


dans leur fonctionnement je fait un parallèle de fonctionnement avec les Structures ...


lorsque je fais :
dan cette exemple :

Code : Tout sélectionner

Prototype.l appel_fonction (titre$,path$,filtre$) ; on creer une variable typé avec les parametres de la fonction qui se trouve dans la dll

If OpenLibrary(0, "dobro.dll") ; ouvre la dll
    appel_fonction.appel_fonction = GetFunction(0, "open_file") ; transmet les parametres de la fonction open_file de la dll dans notre variable typée (genre de structure)
    ;et transmission a la variable appel_fontion
    Debug PeekS(appel_fonction ( "ouvrir","c:\dobro\","*.txt")) ; on appel la fonction en transmettant les paramètres 
    ; a partir de notre variable typé (appel_fonction) puis on lit le retour de la fonction ....utilisation du peeks() obligatoire !
    
    CloseLibrary(0) ; on peut fermer la dll
EndIf 

explication :

Code : Tout sélectionner

 Prototype.l appel_fonction (titre$,path$,filtre$)

c'est un peu comme si je faisais une structure avec les paramètres (champs)

Code : Tout sélectionner

 
structure appel_fonction
 titre.s
 path.s
 filtre.s 
EndStructure
 appel_fonction.appel_fonction

et qu'ensuite on utilisait la fonction "

Code : Tout sélectionner

appel_fonction.appel_fonction =GetFunction(0, "open_file")

"
pour affecter la fonction avec cette structure !! ( sens Structure (et donc ses parametres) ---> qui affecte la procedure )
lors qu'avec les structures c'est plutot l'inverse ( sens procedure ----> qui affecte une Structure (et donc ses parametres) )

mais là bien sur , on affecte notre procedure avec notre prototype ... et pas avec une structure )

mais ... est-ce clair ?

[Torp]

Arf là je suis largué...

En fait je cherchais un moyen de mettre des procedures dans une stucture. La structure représente un objet avec des caractéristiques dont certaines sont introduites par l’utilisateur et d'autre sont calculées à partir de celles-ci (avec les procédures donc). Ensuite j’instancie la structure autant de fois que d'objet. C'est dans ce contexte que je pensais les prototypes utiles... D'un autre côté j'ai vaguement regardé du côté des Interfaces et ça à l'air de pouvoir faire le job aussi... En fait je nage un peu

[Cls]

Dobro l'a expliqué. Ça permet de déclarer la structure d'appel d'une fonction, donc ses paramètres. C'est utile quand on travaille avec des API externes. Ce n'est qu'une astuce permettant de simplifier l'écriture des appels de fonction.

Exemple : tu as une DLL contenant une fonction ayant cette signature :

Code : Tout sélectionner

ecrire(message.s)

Au lieu de faire un CallFunction pour l'appeler (ce qui peut vite devenir illisible si tu en utilises beaucoup) :

Code : Tout sélectionner

CallFunction(0, "ecrire", "Mon message")

Tu peux utiliser les prototype, ce qui améliore la lisibilité et la compréhension du code :

Code : Tout sélectionner

Prototype.l ecrireSignature(message.s)
ecrire.ecrireSignature = GetFunction(0, "ecrire") 
; le pointeur "ecrire" connait l'adresse de la fonction (renvoyé par GetFunction) et quels paramètres sont nécessaires à son éxecution (grâce au prototype) : elle peut donc être appelées.

ecrire("Mon message")

[Cls]

Arf là je suis largué...

En fait je cherchais un moyen de mettre des procedures dans une stucture. La structure représente un objet avec des caractéristiques dont certaines sont introduites par l’utilisateur et d'autre sont calculées à partir de celles-ci (avec les procédures donc). Ensuite j’instancie la structure autant de fois que d'objet. C'est dans ce contexte que je pensais les prototypes utiles... D'un autre côté j'ai vaguement regardé du côté des Interfaces et ça à l'air de pouvoir faire le job aussi... En fait je nage un peu

Si tu tiens vraiment aux structures, voici un exemple basique :

Code : Tout sélectionner

Structure OBJET
  _message.s
  _message2.s
EndStructure

Procedure ecrire(*this.OBJET)
  Debug *this\_message + " " + *this\_message2
EndProcedure

objet1.OBJET
objet1\_message = "C'est"
objet1\_message2 = "un test"


CallFunctionFast(@ecrire(), objet1)