PureBasic

Merci CPL, c'est vrai que j'avais jamais fait le rapport avec les structures

Et deja ça ouvre un peu le brouillard.

Reste encore que le procedural, au moins ça avait le merite d'avoir un sens pour le lire.

Moi, comme dab, j'suis dans les seuls qui trouve pas ça super.
D'ailleur c'est peut etre aussi pour ça que j'ai aimé PB

Pareil , au début j'ai pas accroché , mais en réalité c'est le top , et c'est très puissant , une fois la classe écrite ( c'est le plus chiant ) c'est du bonheur à l'utilisation

Ex:

Code : Tout sélectionner

Class Vecteur2D
  x.f : y.f
endclass

Vecteur2D(x.f,y.f)
{
this->x = x
this->y = y
}

Vecteur2D operator * ( *A.Vecteur2D , *B.Vecteur2D )
{
  this->x = A.x * B.x
  this->y = A.y * B.y
}

MonPointA.Vecteur2D(100,50)
MonPointB.Vecteur2D(150,550)

MonPointC.Vecteur2D = MonPointA * MonPointB

c'est un exemple grossier pour que tu comprenne bien

c équivaut en pb à

Code : Tout sélectionner

Structure Vecteur2D
x.f
y.f
endstructure

etc...

Si tu veut additionner 2 vecteurs , y a pas 36 solutions , une macro spécifique au vecteur qui additionne tout les champs , ou une fonction , ou a la main comme les romains... tu ne pourras pas utilisé des opérateurs standard...

Tandis qu'avec la poo :

Code : Tout sélectionner

MonPointC.Vecteur2D = MonPointA * MonPoint

C'est pas plus clair ?

C'est un des nombreux concept de la POO...

C'est vrai que pour ce genre de realisation ce doit etre utile.
Mais tu sais, comme je fait pas de graphisme.....

La ou j'ai du mal a me projeter, c'est dans l'utilisation de tous les jours.
Le fenetres, les gadgets, les evenements....
C'est vrai que j'ai compris que pas mal de variable systeme etait structurée.
J'ai deja mis un temps fou a m'en rendre compte

Mais hors mis ça ....

Je ne peux pas dire que j'ai l'impression de manquer quelque chose en faisant du procedural.
Je viens d'acheter VB2003 , et la il parait que TOUT est objet.
C'est pour ça que j'me fait un soucis, je l'ai ouvert, c'est beau

Et pour l'instant, je reste VB6 quand j'suis forcé, et PB autrement.

Mais j'suis pres, si il faut, il faut.
Ca me rappelle quand j'avais acheté VB3, et que je l'ai ouvert et vite refermé à ce moment je faisais du QB45

En fait, je l'ai acheté, jamais utilisé, et je ne m'y suis mis par la force des choses qu'au VB6, quand y'a fallu abandonner le DOS

J'crois encore une fois que mon caractere colle pas a ma passion
J'suis un nostalgique, j'aime pas le changement ...... et les PC ça change tous les jours

@Cpl.bator

Est-ce que ce code ci-dessous est orienté objet ?

Code : Tout sélectionner

Structure Dms
   L.L
   H.L
   P.L
EndStructure

Structure Bureau
   Dms.Dms
   *Examiner
EndStructure

Structure Ecran
   Dms.Dms
   *HndBureau
   *Initialiser
   *Preparer
   *Ouvrir
   *Fermer
EndStructure

Structure Clavier
   *Initialiser
   *AttendreTouche
EndStructure

Procedure BureauExaminer(*This.Bureau)
   ExamineDesktops()
   With *This\Dms
      \L = DesktopWidth(0)
      \H = DesktopHeight(0)
      \P = DesktopDepth(0)
   EndWith
EndProcedure

Procedure EcranInitialiser()
   InitSprite()
EndProcedure

Procedure EcranPreparer(*This.Ecran)
   Protected *Bureau.Dms
   *Bureau = *This\HndBureau
   CopyMemory(*Bureau, *This\Dms, SizeOf(Dms) )   
EndProcedure

Procedure EcranOuvrir(*This.Ecran)
   With *This
      OpenScreen(\Dms\L, \Dms\H, \Dms\P, "")
   EndWith
EndProcedure

Procedure EcranFermer()
   CloseScreen()
EndProcedure

Procedure ClavierInitialiser()
   InitKeyboard()
EndProcedure

Procedure ClavierAttendreTouche()
   Repeat
      ExamineKeyboard()
   Until KeyboardPushed(#PB_Key_Escape)
EndProcedure

   Dms.Dms

   Bureau.Bureau
   Bureau\Examiner        = @BureauExaminer()
   
   Ecran.Ecran
   Ecran\HndBureau        = Bureau
   Ecran\Initialiser      = @EcranInitialiser()
   Ecran\Preparer         = @EcranPreparer()
   Ecran\Ouvrir           = @EcranOuvrir()
   Ecran\Fermer           = @EcranFermer()
   
   Clavier.Clavier
   Clavier\Initialiser    = @ClavierInitialiser()
   Clavier\AttendreTouche = @ClavierAttendreTouche()
   
   CallFunctionFast(Bureau\Examiner, Bureau)
   CallFunctionFast(Ecran\Initialiser, Ecran)
   CallFunctionFast(Ecran\Preparer, Ecran)
   CallFunctionFast(Ecran\Ouvrir, Ecran)
   CallFunctionFast(Clavier\Initialiser, Clavier)
   CallFunctionFast(Clavier\AttendreTouche, Clavier)
   CallFunctionFast(Ecran\Fermer, Ecran)

d'une certaine manière oui , mais franchement , tu te vois faire des CallFunctionFast() a tire la rigo

Regarde du coté des interfaces

L'utilisation des interfaces n'interdit-il pas la modification de ton programme DURANT son exécution. Je dis cela parce que peut-être que, quite à faire de la POO et donc subir ses contraintes, autant user des atouts de ce concept, non?

Bah non , au contraire , le code de l'utilisateur finale est plus claire , regarde l'aide au sujet des interfaces. ca ne pose pas de problème.
Sinon pour la poo , sur le fofo anglais , y a un bon article.
Y a celui de dräc aussi qui trainne quelques part sur le forum.

N'aurais-tu pas aussi un exemple?

Code : Tout sélectionner

;******************************************************************
;    Object-oriented programming to Purebasic Converter           
;
;                      Par Cpl.Bator
;
;******************************************************************
;-Constructor(s) & Destructor(s)
; ----------------------------------------------------------------
Macro New_PERSONNAGE(Pointeur)
*Pointeur_.PERSONNAGE_=AllocateMemory(SizeOf(PERSONNAGE_))
*Pointeur_\Vtable=?Vtable_PERSONNAGE
Pointeur.PERSONNAGE=@*Pointeur_\Vtable
EndMacro
; ----------------------------------------------------------------
Macro Free_PERSONNAGE(Pointeur)
  Pointeur#_.Class#_=Pointeur
  FreeMemory(Pointeur)
EndMacro
; ----------------------------------------------------------------
;-Interfaces
Interface PERSONNAGE
   SetName(Name$)
   GetName.s()
EndInterface
; ----------------------------------------------------------------
; ----------------------------------------------------------------
;-Structures
Structure PERSONNAGE_

Vtable.l
Name$

EndStructure
; ----------------------------------------------------------------



; ----------------------------------------------------------------
;-Methodes
Procedure SetName(*This.PERSONNAGE_,Name$)

*This\Name$ = Name$
EndProcedure

; ----------------------------------------------------------------
Procedure.s GetName(*This.PERSONNAGE_)

ProcedureReturn *This\Name$
EndProcedure

; ----------------------------------------------------------------
; ----------------------------------------------------------------
;-DataSections
DataSection
VTable_PERSONNAGE:
Data.l @SetName(),@GetName()
; ----------------------------------------------------------------
EndDataSection
; ----------------------------------------------------------------

extrait de http://www.purebasic.fr/french/viewtopi ... hlight=poo

Je suis désolé Cpl.Bator mais j'ai du mal avec ton code. Je pense que tu as fait en partant de tes connaissances en c++. Seulement, j'ai l'impression qu'il y a du superflu. Maintenant, je ne veux pas émmettre plus de jugements, n'ayant JAMAIS fait de la POO de A à Z, tu dois sûrement avoir des centaines de lignes de code concrètes. J'ai juste vu qu'il fallait construire et détruire les objets (un objet = un thread par exemple).

Maintenant, mon exemple utilise des objets permanents, donc je ne rentre pas dans le concept. Mais je pense que ce n'est pas fortement plus compliqué.

Ce que je veux dire, c'est que l'on devrait peut-être faire deux ou trois codes de concepts différents qui aborderait l'orienté objet car le forum manque vraiment de code uni et fini à ce sujet.

En passant, j'ai viré les CallFunctionFast(). Si ce code est, d'une certaine manière de l'orienté objet, peut-être que ça revient à dire que la POO c'est du procédural organisé de telle sorte que l'on puisse le faire évoluer facilement.

Code : Tout sélectionner

Structure Dms 
   L.L 
   H.L 
   P.L 
EndStructure 

Structure Bureau 
   Dms.Dms 
   *Examiner 
EndStructure 

Structure Ecran 
   Dms.Dms 
   *HndBureau 
   *Initialiser 
   *Preparer 
   *Ouvrir 
   *Fermer 
EndStructure 

Structure Clavier 
   *Initialiser 
   *AttendreTouche 
EndStructure 

Procedure BureauExaminer(*This.Bureau) 
   ExamineDesktops() 
   With *This\Dms 
      \L = DesktopWidth(0) 
      \H = DesktopHeight(0) 
      \P = DesktopDepth(0) 
   EndWith 
EndProcedure 

Procedure EcranInitialiser() 
   InitSprite() 
EndProcedure 

Procedure EcranPreparer(*This.Ecran) 
   Protected *Bureau.Dms 
   *Bureau = *This\HndBureau 
   CopyMemory(*Bureau, *This\Dms, SizeOf(Dms) )    
EndProcedure 

Procedure EcranOuvrir(*This.Ecran) 
   With *This 
      OpenScreen(\Dms\L, \Dms\H, \Dms\P, "") 
   EndWith 
EndProcedure 

Procedure EcranFermer() 
   CloseScreen() 
EndProcedure 

Procedure ClavierInitialiser() 
   InitKeyboard() 
EndProcedure 

Procedure ClavierAttendreTouche() 
   Repeat 
      ExamineKeyboard() 
   Until KeyboardPushed(#PB_Key_Escape) 
EndProcedure 

   Dms.Dms 

   Bureau.Bureau 
   Bureau\Examiner        = @BureauExaminer() 
    
   Ecran.Ecran 
   Ecran\HndBureau        = Bureau 
   Ecran\Initialiser      = @EcranInitialiser() 
   Ecran\Preparer         = @EcranPreparer() 
   Ecran\Ouvrir           = @EcranOuvrir() 
   Ecran\Fermer           = @EcranFermer() 
    
   Clavier.Clavier 
   Clavier\Initialiser    = @ClavierInitialiser() 
   Clavier\AttendreTouche = @ClavierAttendreTouche() 
    
   BureauExaminer(Bureau) 
   EcranInitialiser() 
   EcranPreparer(Ecran) 
   EcranOuvrir(Ecran) 
   ClavierInitialiser() 
   ClavierAttendreTouche() 
   EcranFermer()

PureBasic

La POO version PureBasic