PureBasic

;-********************
;-Auteur : Heis Spiter
;-Date : 23/12/2004
;-ID : 172312040301
;-Version de PB : 3.92
; Forum Français : http://purebasic.hmt-forum.com/viewtopic.php?t=2089
; 
; Cet exemple montre comment les class fonctionnent.
; Il est basé sur un code GreB, mais est plus facile ;) 
;-********************

; Interface avec les fonctions
Interface Count
  SetCounter(Number.l)
  UpCrease()
  DownCrease()
  CounterReturn()
  FreeCounter()
EndInterface
; Structure avec l'énumération des fonctions.
Structure Count_Functions
  SetCounter.l
  UpCrease.l
  DownCrease.l
  NumberReturn.l
  FreeCounter.l
EndStructure
; Structure avec les variables qui vont être partagées.
Structure Count_Vars 
  *VirtualTable.Count_Functions 
  Number.l 
EndStructure 
; Première fonction, pour défnir le compteur.
Procedure SetCounter(*this.Count_Vars, Number.l)
  *this\Number = Number
EndProcedure
; Seconde fonction pour rajouter un au nombre donné au compteur.
Procedure UpCrease(*this.Count_Vars)
  *this\Number = *this\Number+1
EndProcedure
; Troisième fonction pour enlever un au nombre donné au compteur.
Procedure DownCrease(*this.Count_Vars)
  *this\Number = *this\Number-1
EndProcedure
; Fonction pour retourner le nombre.
Procedure CounterReturn(*this.Count_Vars)
  ProcedureReturn *this\Number
EndProcedure
; Structure utilisée comme passerelle...
Structure Count_Holder 
  VT.Count_Functions 
  Impl.Count_Vars 
EndStructure 
; ...Et liste chaînée
NewList Instances.Count_Holder() 
; Fonction pour libérer le compteur (destruct)
Procedure FreeCounter(*this.Count_Vars)
  *this\Number = 0
  DeleteElement(Instances())
EndProcedure
; Fonction pour créer une instance du compteur (construct)
Procedure.l InitCounter()

  AddElement(Instances()) 
  Instances()\VT\SetCounter = @SetCounter() 
  Instances()\VT\UpCrease = @UpCrease() 
  Instances()\VT\DownCrease = @DownCrease() 
  Instances()\VT\NumberReturn = @CounterReturn()
  Instances()\VT\FreeCounter = @FreeCounter()
  Instances()\Impl\VirtualTable = Instances()\VT 
  Instances()\Impl\Number = 0 
  ProcedureReturn @Instances()\Impl 
  
EndProcedure 
; Exemples pour tester ;).
Counter.Count = InitCounter()
Counter2.Count = InitCounter()
Counter\SetCounter(5)
Counter2\SetCounter(5)
Counter\UpCrease()
Counter\UpCrease()
Counter2\DownCrease()
Counter2\DownCrease()
Counter\DownCrease()
Counter2\UpCrease()
Debug Counter\CounterReturn()
Debug Counter2\CounterReturn()
Counter\FreeCounter()
Debug Counter\CounterReturn()
Debug Counter2\CounterReturn()
Counter2\FreeCounter()
Debug Counter\CounterReturn()
Debug Counter2\CounterReturn()

Je ne pense pas que des explications supplémentaires soient nécessaires. Cependant, posez vos questions ici, si besoin est

.

Personnellement, j'y comprend rien, faudra bien que je m'y mette un jour.

C'est sur, on a du mal à comprendre les commentaires en français

@Heis:
Ce qui serait sympa, ce serait que tu commence par mettre les commentaires en français.

Je suis peut-être le seul dans ce cas, et mon opinion n'engage que moi, mais un code créé et posté par un français sur le forum français, si les commentaires sont en anglais, je ne l'essaye même pas.

Désolé, mais j'appelle ça se foutre du monde

Denis a écrit :C'est sur, on a du mal à comprendre les commentaires en français

Pardon

C'est parcequ'en faite, quand je fais ça généralement, c'est pour le mettre dans Bird Chat, et donc, en Anglais, donc, je commente en Anglais...

nico a écrit :Personnellement, j'y comprend rien, faudra bien que je m'y mette un jour.

Je ne comprennais pas non plus la POO de Pure (alors que celle du php, et du C, oui), et donc, je m'y suis mis

. Donc, motive-toi

Chris a écrit :Désolé, mais j'appelle ça se foutre du monde

Tu peux le dire plus poliement, ce sera ça de gagné. Et maintenant, j'ai justifé le comment du pourquoi.

Je vais recommenter en Français.
PS : J'en profite, il sera plus facile de comprendre, si vous comprenez les class en php.

il me semble que les interfaces ne sont pas faites pour faire de la POO proprement dite...

Après vérification :

Aide PureBasic a écrit : (les interfaces n'ont pas été concu pour ajouter une couche objet à PureBasic mais plutot pour accéder facilement à des objets dejà concus)

cederavic a écrit :il me semble que les interfaces ne sont pas faites pour faire de la POO proprement dite...

Après vérification :
Aide PureBasic a écrit : (les interfaces n'ont pas été concu pour ajouter une couche objet à PureBasic mais plutot pour accéder facilement à des objets dejà concus)

Ouaip, il n'en demeure pas moins que utilisé en POO, c'est pratique

Quelles fonctionalités supplémentaires cela peut apporter face à des procédures simple facile à créer?

nico a écrit :Quelles fonctionalités supplémentaires cela peut apporter face à des procédures simple facile à créer?

Il est clair qu'au début, ça parait complexe, et à juste titre. Mais après, ça permet de faire des programmes très structurés, où rien (ou presque

) ne se mélange sans que ce ne soit nécessaire. Ca permet aussi (ça ne se voit plus trop sur ces machines, sauf pour les jeux) une optimisation.

Pour l'optimisation, j'y crois pas trop, vu qu'un appel d'interface consiste à utiliser le pointeur sur l'objet pour récupérer le pointeur sur la table où on va trouver le pointeur sur la fonction qu'on va enfin pouvoir appeler.

Heis Spiter a écrit :
Chris a écrit :Désolé, mais j'appelle ça se foutre du monde
Tu peux le dire plus poliement, ce sera ça de gagné. Et maintenant, j'ai justifé le comment du pourquoi.

Oui, j'aurais pu...

Y a des jours comme ça.
Désolé

Code : Tout sélectionner

; Structure utilisée comme passerelle... 
Structure Count_Holder 
  VT.Count_Functions 
  Impl.Count_Vars 
EndStructure

On pourrait se passer de cette structure?

nico a écrit :
Code : Tout sélectionner
; Structure utilisée comme passerelle... 
Structure Count_Holder 
  VT.Count_Functions 
  Impl.Count_Vars 
EndStructure
On pourrait se passer de cette structure?

Pas trop, car elle sert à faire la liste chaînée, ceci dit, vais quand même regarder

Je viens de m'y mettre, ce n'est pas si compliqué que ça en a l'air en fait.
on associe une interface à une table de pointeurs qui pointe vers les fonctions correpondante de l'interface, c'est logique.

Avec la particularité que chaque procédure possède en plus un pointeur vers les fonctions et les variables communes.

Par contre la NewList ne me semble pas nécessaire si l'interface n'est pas accessible à d'autres programmes.

C'est très intéressant, mais je me demande ce qu'il ressort des interfaces au niveau de l'asm!

Il est clair qu'au début, ça parait complexe, et à juste titre. Mais après, ça permet de faire des programmes très structurés, où rien (ou presque ) ne se mélange sans que ce ne soit nécessaire. Ca permet aussi (ça ne se voit plus trop sur ces machines, sauf pour les jeux) une optimisation.

C'est vrai que pour des trucs longs et compliqués, ça permet de s'y retrouver plus facilement.
Mais je ne vois pas en quoi ça optimise.