PureBasic

Emperor a écrit :Le type booléen en effet ne peut être autre que TRUE/FALSE, j'ai mal formulé ce que je voulais dire par là. Je veux tout simplement ajouter de la cohérence dans le code car exemple je ne trouve pas normal que la fonction eof retourne n'importe quoi lorsqu'on atteint la fin du fichier.

J'ai survolé l'ensemble du topic, effectivement c'est un projet intéressant !

en revanche attention si tu prévois une modification des valeurs de retour pour les fonctions de type eof().
Certaines retournent des valeurs qui pourraient sembler vide de sens, mais que sont souvent des pointeurs vers des objets internes et donc potentiellement utiles pour des programmeurs expérimentés.

mais pour eof, je ne sais pas quelle est la signification de la valeur retournée

graph100 a écrit :
Emperor a écrit :Le type booléen en effet ne peut être autre que TRUE/FALSE, j'ai mal formulé ce que je voulais dire par là. Je veux tout simplement ajouter de la cohérence dans le code car exemple je ne trouve pas normal que la fonction eof retourne n'importe quoi lorsqu'on atteint la fin du fichier.
J'ai survolé l'ensemble du topic, effectivement c'est un projet intéressant !

en revanche attention si tu prévois une modification des valeurs de retour pour les fonctions de type eof().
Certaines retournent des valeurs qui pourraient sembler vide de sens, mais que sont souvent des pointeurs vers des objets internes et donc potentiellement utiles pour des programmeurs expérimentés.

mais pour eof, je ne sais pas quelle est la signification de la valeur retournée

Haha merci! En effet pour le EOF, ça marche bien, mais on s'entend que pour OpenWindow, ça ne serait pas très intelligent....

Emperor a écrit :Haha merci! En effet pour le EOF, ça marche bien, mais on s'entend que pour OpenWindow, ça ne serait pas très intelligent....

Heu, au risque de dire une bétise, si on fait :
window = openwindow(#pb_any, ...)

Si window devient un booléen (0 ou 1), ça va poser un problème, non ?

Sinon, concernant les enumeration nommées, c'est maintenant le cas depuis la version purebasic 5.20. On peut faire :

Code : Tout sélectionner

Enumeration Gadget
   #gadget1
   #gadget2
   #gadget3
EndEnumeration

Pour les commentaires multilignes (;/**/), ce serait intéressant, idem pour les templates

.

Pour le reste :

Classes avec héritage multiple

Tu pourrais donner un exemple de code pour voir ce que ça donnerait, car je n'ai pas fait assez de c++ pour voir ce que ça donnerait en pb.
En C#, si je me rappelle ça existe aussi, mais je n'en ai pas fait depuis un an non plus ^^.

Override de procédures
Overload d'opérateurs

Idem pour ça, si tu avais un petit exemple de ce que ça donnerait, ce serait sympa

Sinon, une autre chose qui pourrait être intéressante (peut-être est-ce d'ailleurs présent dans ces derniers termes), ce serait de pouvoir introduire des procédures dans une structure, on aurait un peu de POO dans purebasic comme ça ^^:

Code : Tout sélectionner

Structure Personnage
X.w
Y.w
Life.w
Fight()
Run()
Die()
EndStructure
Player.Personnage
Ennemi.Personnage
Ennemi.Die() ; l'ennemi meurt , etc...

Je me demande si on ne peut faire ce genre de chose avec les Modules de la 5.20LTS cela dit ^^.
Faudrait que j'essaie pour voir.

blendman a écrit :Sinon, une autre chose qui pourrait être intéressante (peut-être est-ce d'ailleurs présent dans ces derniers termes), ce serait de pouvoir introduire des procédures dans une structure, on aurait un peu de POO dans purebasic comme ça ^^:
Code : Tout sélectionner
Structure Personnage
X.w
Y.w
Life.w
Fight()
Run()
Die()
EndStructure
Player.Personnage
Ennemi.Personnage
Ennemi.Die() ; l'ennemi meurt , etc...
Je me demande si on ne peut faire ce genre de chose avec les Modules de la 5.20LTS cela dit ^^.
Faudrait que j'essaie pour voir.

on peut déjà faire ça avec les interfaces de PB. Tu mêles une interface avec une structure. C'est pas super propre, mais ça marche super bien !
Je l'utilise pour mon projet customgadget.

graph100 a écrit :on peut déjà faire ça avec les interfaces de PB. Tu mêles une interface avec une structure. C'est pas super propre, mais ça marche super bien !

merci, je vais regarder ça alors

ça donne ça :

Code : Tout sélectionner

; PB 5.11

Interface Function
	Add()
	Ajouter_C_MsgBox(c.l, texte.s)
EndInterface


Structure mon_objet
	*zz_FunctionTable
	_Function.Function
	
	
	a.l
	b.l
EndStructure




Procedure Addition(*obj.mon_objet)
	ProcedureReturn *obj\a + *obj\b
EndProcedure

Procedure Addition_avec_parametre(*obj.mon_objet, c.l, texte.s)
	Protected res.l = *obj\a + *obj\b + c
	
	MessageRequester("Message", texte + Str(res))
	
	ProcedureReturn res
EndProcedure



DataSection
	function:
	Data.i @Addition()
	Data.i @Addition_avec_parametre()
EndDataSection



; Utilisation (peut etre initialisé dans une procédure, mais la procédure en elle même doit etre utiliser la 1er fois hors de l'interface, puisque les adresses des fonctions ne sont pas fixés

; Initialisation
obj.mon_objet\_Function = @obj
obj\zz_FunctionTable = ?function


; remplissage des valeurs :
obj\a = 2
obj\b = 4

; Utilisation :
Debug obj\_Function\Add()

Debug obj\_Function\Ajouter_C_MsgBox(5, "C'est un exemple, le résultat de " + #CRLF$ + "obj\a + obj\b + c = ")

Ben put... c'est de la haute voltige ce code

Ca fait 10 fois que je le lis et que je le comprend pas

Ca sert à ça les interfaces, à insérer des procédures dedans ?
En tout cas bravo et merci Graph100, je te remercierais encore plus si un jour je comprend

J'ai regardé les interfaces, et j'ai à peu près compris ^^.

Voici (pour KCC

) un code un petit peu plus simple à comprendre (y'a moins de pointeurs) :

Code : Tout sélectionner

Interface MonObjet  ; sert à créer un type spécial "MonObjet", et des procédures qui lui seront liées. 
; On pourra donc accéder ensuite directement aux procédures de ce type
  Create()
  MoveObj(x,y) 
  Destroy()
EndInterface

Structure PGC_Ob
  *Functions.MonObjet ; un pointeur pour "appeler" les fonctions  du type MonObjet
  x.w
  y.w
EndStructure

; les procédures de l'interface
; *this est le pointeur de type PGC_ob (la structure au dessus), qui permettra d'avoir accès aux procédures de MonObjet.
Procedure MoveObj(*this.PGC_Ob,xx,yy)
  *this\x = xx
  *this\y = yy
  Debug "move"
EndProcedure

Procedure Create(*this.PGC_Ob) 
  Debug "create"
EndProcedure

Procedure Destroy(*this.PGC_Ob)
  Debug "ben paf"
EndProcedure

; le "constructeur de l'objet
Procedure CreationObjet(); constructeur
  *obj.PGC_Ob = AllocateMemory(SizeOf(PGC_Ob))
  *obj\Functions = ?Functions
  *obj\x = 0
  Debug "creation obj"
  ProcedureReturn *obj
EndProcedure

; le destructeur de l'objet, pour le supprimer si on ne s'en sert plus
Procedure Free(*this.PGC_Ob); destructeur
  FreeMemory(*this)
EndProcedure

;on crée 2 "objets" de type "MonObjet.
; on pourra donc avoir accès aux procédures de l'interface monobjet (create(), move(), destroy())
Objet1.MonObjet = CreationObjet()
Objet2.MonObjet = CreationObjet()

; ensuite, on peut agir dessus
Objet1\MoveObj(10, 20)
Objet1\Destroy()

Objet2\Create()
Objet2\MoveObj(5, 2)
Objet2\Destroy()

; la data section
; permet de définir l'adresse des procédures lors de la création de l'objet 
; avec la ligne : *obj\Functions = ?Functions, on lui indique ici l'adresse du nom (en datasection) des procédures (ou quelque chose comme ça ^^)
DataSection
  Functions:
    Data.l @MoveObj(), @Destroy()
    Data.l @Create(), @Free() ;<-- on peut les placer sur plusieurs lignes
EndDataSection

Voilà, j'ai sans doute dit quelqeus bétises, car je découvre, n'hésitez pas à corriger si tel est le cas.

ça pourrait être pas mal d'ajouter un tutoriel sur les interface. D'après ce que j'ai compris, ça permet de créer un type spécial, avec lequel on a accès directement à des procédures. C'est donc d'une certaine manière un peu proche de la POO (enfin, dans l'idée de base).

Merci beaucoup BLENDMAN, je vais tacher de comprendre

Eh ben ! Merci Blendman, tu as codé le truc d'une façon qui fait ce que je cherchais à faire, c'est à dire accéder directement aux interfaces sans passer par un champ supplémentaire.
Une belle astuce de prog en PB : utiliser un type différent pour l'allocation et l'utilisation

En revanche, dans ton cas, pour accéder aux champs de la structure, il faut déclarer un autre pointeur avec la structure.

j'ai retouché très rapidement pour inclure ta procédure Free() que tu n'utilisais pas. De plus j'ai souligné que la fonction CreationObjet > AllocateObjet() sert à l'initialisation de l'objet et ne peut être interne (contrairement à de la PoO), alors que la Free() peut etre interne.

(tu dis que t'as moins de pointeur, mais je n'en suis pas sur

)

@Kcc : tu sais, pour l'écrire je suis allé chercher mes anciens codes ou c’était déjà fait parce que de mémoire, c'est pas évident

Code : Tout sélectionner

;{ Interface et structure

Interface MonObjet  ; sert à créer un type spécial "MonObjet", et des procédures qui lui seront liées. 
; On pourra donc accéder ensuite directement aux procédures de ce type
	Create()
	MoveObj(x,y) 
	Destroy()
	Free()
EndInterface

Structure PGC_Ob
	*Functions.MonObjet ; un pointeur pour "appeler" les fonctions  du type MonObjet
	x.w
	y.w
EndStructure

;}


;{ Procédures

; les procédures de l'interface
; *this est le pointeur de type PGC_ob (la structure au dessus), qui permettra d'avoir accès aux procédures de MonObjet.
Procedure MoveObj(*this.PGC_Ob,xx,yy)
	*this\x = xx
	*this\y = yy
	Debug "move"
EndProcedure

Procedure Create(*this.PGC_Ob) 
	Debug "create"
EndProcedure

Procedure Destroy(*this.PGC_Ob)
	Debug "ben paf"
EndProcedure


; le destructeur de l'objet, pour le supprimer si on ne s'en sert plus : PEUT etre appeler depuis la structure,
; faire attention à placer le Freememory() en dernier.
Procedure Free(*this.PGC_Ob); destructeur
	FreeMemory(*this)
EndProcedure



; le "constructeur de l'objet : NE peut pas etre appeler depuis la structure
Procedure AllocationObjet(); constructeur
	*obj.PGC_Ob = AllocateMemory(SizeOf(PGC_Ob))
	*obj\Functions = ?Functions
	*obj\x = 0
	Debug "creation obj"
	ProcedureReturn *obj
EndProcedure

;}


;on crée 2 "objets" de type "MonObjet.
; on pourra donc avoir accès aux procédures de l'interface monobjet (create(), move(), destroy(), free())
Objet1.MonObjet = AllocationObjet()
Objet2.MonObjet = AllocationObjet()

; ensuite, on peut agir dessus
Objet1\MoveObj(10, 20)
Objet1\Destroy()

Objet2\Create()
Objet2\MoveObj(5, 2)
Objet2\Destroy()

; libère la mémoire de l'objet. on ne peut plus l'utiliser ensuite, il faut le réalouer
Objet2\Free()




; la data section
; permet de définir l'adresse des procédures lors de la création de l'objet 
; avec la ligne : *obj\Functions = ?Functions, on lui indique ici l'adresse du nom (en datasection) des procédures (ou quelque chose comme ça ^^)
DataSection
	Functions:
		Data.l @MoveObj(), @Destroy()
		Data.l @Create(), @Free() ;<-- on peut les placer sur plusieurs lignes
	EndDataSection

@Kcc : tu sais, pour l'écrire je suis allé chercher mes anciens codes ou c’était déjà fait parce que de mémoire, c'est pas évident

Ouaihh !!! bah moi même en allant chercher sous le lit un code comme ça....j'suis pas pret de le pondre
Encore bravo...j'suis épaté

On dirait du GRom

...ça pointe ça pointe

Hummm PB avec une couche objet ce serait pas mal.

j'ai corrigé le code que j'avais fourni, car il y avait une erreur dans la data section :
il faut mettre les noms dans le même ordre que celui de l'interface.

Code : Tout sélectionner

Interface MonObjet  ; sert à créer un type spécial "MonObjet", et des procédures qui lui seront liées.
; On pourra donc accéder ensuite directement aux procédures de ce type
  Create()
  MoveObj(x,y)
  Destroy()
  free()
EndInterface

Structure PGC_Ob
  *Functions.MonObjet ; un pointeur pour "appeler" les fonctions du type MonObjet
  x.w
  y.w
EndStructure

; les procédures de l'interface
; *this est le pointeur de type PGC_ob (la structure au dessus), qui permettra d'avoir accès aux procédures de MonObjet.
Procedure MoveObj(*this.PGC_Ob,xx,yy)
  *this\x = xx
  *this\y = yy
  Debug "move en "+Str(xx)+"/"+Str(yy)
EndProcedure

Procedure Create(*this.PGC_Ob)
  Debug "create"
EndProcedure

Procedure Destroy(*this.PGC_Ob)
  Debug "ben paf"
EndProcedure

; le "constructeur de l'objet,  NE peut pas etre appeler depuis la structure
Procedure CreationObjet(); constructeur
  *obj.PGC_Ob = AllocateMemory(SizeOf(PGC_Ob))
  *obj\Functions = ?Functions
  *obj\x = 0
  Debug "creation obj"
  ProcedureReturn *obj
EndProcedure

; le destructeur de l'objet, pour le supprimer si on ne s'en sert plus
; PEUT etre appeler depuis la structure,
; faire attention à placer le Freememory() en dernier.
Procedure Free(*this.PGC_Ob); destructeur
  FreeMemory(*this)
  Debug "free !"
EndProcedure

;on crée 2 "objets" de type "MonObjet.
; on pourra donc avoir accès aux procédures de l'interface monobjet (create(), move(), destroy())
Objet1.MonObjet = CreationObjet()
Objet2.MonObjet = CreationObjet()

; ensuite, on peut agir dessus
Debug "---------- Move obj1 --------------"
Objet1\MoveObj(10, 20)
Debug "---------- Destroy obj1 --------------"
Objet1\Destroy()

Debug "*********************************"
Debug "OBJET 2"
Debug " "
Objet2\Create()
Debug "---------- Move obj2 --------------"
Objet2\MoveObj(5, 2)
Debug "---------- Destroy obj 2 -----------"
Objet2\Destroy()
Debug "---------- free obj2 -----------"
Objet2\free() ; ; libère la mémoire de l'objet. on ne peut plus l'utiliser ensuite, il faut le réalouer



; la data section
; permet de définir l'adresse des procédures lors de la création de l'objet
; avec la ligne : *obj\Functions = ?Functions, on lui indique ici l'adresse du nom (en datasection) des procédures (ou quelque chose comme ça ^^)
DataSection
  Functions:
  Data.l @Create(), @MoveObj(), @Destroy() , @Free() ;<-- on peut les placer sur plusieurs lignes, 
  ; attention, il faut les mettre dans le même ordre que celui de l'interface !!
EndDataSection

PureBasic

PureBasic ++

Re: PureBasic ++

Re: PureBasic ++

Re: PureBasic ++

Re: PureBasic ++

Re: PureBasic ++

Re: PureBasic ++

Re: PureBasic ++

Re: PureBasic ++

Re: PureBasic ++

Re: PureBasic ++

Re: PureBasic ++

Re: PureBasic ++

Re: PureBasic ++