Interface & Pseudo POO (Un peu pompeux ce terme)

[falsam]

Ok POO est une appellation tendancieuse car ce que je vais tacher d'expliquer n'a qu'un rapport lointain avec la POO tel qu'il existe.

■ Objectif : Créer une classe Rectangle contenant les procédures :
   - Perimetre()
   - Surface()
   - Destroy()

A la fin de ce tutoriel vous saurez initialiser un terrain ou n'importe quelle forme rectangulaire avec cette classe Rectangle

Code : Tout sélectionner

MonTerrain.NewRectangle = RectangleInit(20,10)

et de calculer par exemple la surface

Code : Tout sélectionner

Debug MonTerrain\Surface()

■ Nous allons définir une interface contenant ces procédures

Code : Tout sélectionner

Interface NewRectangle
  Perimetre.i()
  Surface.i()
  Destroy.i()
EndInterface

■ Puis nous allons définir une structure contenant les données à exploiter à savoir pour un rectangle : la longueur et la largeur.

Code : Tout sélectionner

;Définition des parametres du rectangle
Structure Rectangle
  *DSVT ;Data Section Virtual Table
  
  Longueur.i
  Largeur.i
EndStructure

■ ARhhHHHhh mais qu'est ce que c'est que ce *DSVT !! ? C'est un handle qui pointe dans une DataSection contenant les adresses des procédures référencées dans l'interface.

Code : Tout sélectionner

DataSection 
  Class: 
  Data.i @Perimetre()
  Data.i @Surface()
  Data.i @Destroy()
EndDataSection 

pas trop compliqué pour le moment je pense. Passons à la suite qui va consister à instancier la classe.

■ Instancier notre classe rectangle consiste à l'initialiser avec des valeurs. Il s'agira de lui fournir la longueur et la largeur de notre rectangle via une procédure. Nous appellerons cette procédure RectangleInit()

Code : Tout sélectionner

;Initialisation d'un rectangle (Instancialisation)
Procedure.i RectangleInit(Longueur=0, Largeur=0)
  Protected *Object.Rectangle
  ;Allocation mémoire pour un nouveau modèle de classe.
  *Object = AllocateMemory(SizeOf(Rectangle))
  
  ;L'objet est prêt : Quels  sont les pointeurs de procédures ?
  If *Object
    *Object\DSVT = ?Class 
    
    ;Initialise la longueur et la largeur d'un rectangle.
    *Object\Longueur = Longueur
    *Object\Largeur = Largeur
  EndIf
  
  ;Retourne un pointeur de notre objet.
  ProcedureReturn *object
EndProcedure

■ Reste à créer les méthodes c'est à dire les deux procédures permettant de calculer le Perimetre et la Surface ainsi que la procédure permettant de de détruire une allocation mémoire d'un rectangle quand on en a plus besoin.

Pour le moment on va juste créer les 3 procédures juste avec un débug de passage dans chacune d'elle.

Code : Tout sélectionner

Procedure Perimetre()
  Debug "Hello de périmetre"
EndProcedure

Procedure Surface()
  Debug "Hello de Surface"
EndProcedure

Procedure Destroy()
  Debug "Hello de Destroy"
EndProcedure

■ Voila pour les préliminaires. Reste plus qu'a effectuer un test.

L'initialisation d'un rectangle de longueur 3 et de largeur 2 va s'effectuer de cette manière :

Code : Tout sélectionner

Rectangle.NewRectangle = RectangleInit(3, 2)

L'appel des procédures se fera de cette manière:

Code : Tout sélectionner

Rectangle\Perimetre()
Rectangle\Surface()
Rectangle\Destroy()

■ Le code complet que vous pouvez tester.

Code : Tout sélectionner

;Définition d'une interface contenant les procédures 
Interface NewRectangle
  Perimetre.i()
  Surface.i()
  Destroy.i()
EndInterface

;Définition des parametres du rectangle
Structure Rectangle
  *DSVT ;Data Section Virtual Table
  
  Longueur.i
  Largeur.i
EndStructure

;Initialisation d'un rectangle (Instancialisation)
Procedure.i RectangleInit(Longueur=0, Largeur=0)
  Protected *Object.Rectangle
  ;Allocation mémoire pour un nouveau modèle de classe.
  *Object = AllocateMemory(SizeOf(Rectangle))
  
  ;L'objet est pret : Quels  sont les pointeurs de procédures ?
  If *Object
    *Object\DSVT = ?Class 
    
    ;Initialise la longueur et la largeur d'un rectangle.
    *Object\Longueur = Longueur
    *Object\Largeur = Largeur
  EndIf
  
  ;Retourne un pointeur de notre objet.
  ProcedureReturn *object
EndProcedure

;Les procédures référencées dans l'interface NewRectangle (Les méthodes)
Procedure Perimetre()
  Debug "Hello de périmetre"
EndProcedure

Procedure Surface()
  Debug "Hello de Surface"
EndProcedure

Procedure Destroy()
  Debug "Hello de Destroy"
EndProcedure

;Reférencement des adresses de procédures disponibles pour cette classe
DataSection 
  Class: 
  Data.i @Perimetre()
  Data.i @Surface()
  Data.i @Destroy()
EndDataSection 

;Zone de test

;Initialisation d'un nouveau rectangle
MonTerrain.NewRectangle = RectangleInit(2,3)

;Test des procédure disponible pour cette class
MonTerrain\Perimetre()
MonTerrain\Surface()
MonTerrain\Destroy()

Pour le moment il n'y a aucun calcul. Ce sera l'objet du chapitre ci-dessous.

[falsam]

Nous allons maintenant uniquement modifier les trois méthodes. Ooops pardon les trois procédures.

Chacune des procédures aura besoin de la structure de notre classe Rectangle en paramètre. Vous savez comment calculer un périmètre et une surface alors je ne vais pas épiloguer dessus.

■ Modifiez vos trois procédures comme ci-dessous:

Code : Tout sélectionner

Procedure Perimetre(*this.Rectangle)
  ProcedureReturn (*this\Longueur + *this\Largeur) * 2
EndProcedure

Procedure Surface(*this.Rectangle)
  ProcedureReturn *this\Longueur * *this\Largeur
EndProcedure

Procedure Destroy(*this.Rectangle)
  FreeMemory(*this)
EndProcedure

■ Et la zone de test comme ci-contre :

Code : Tout sélectionner

;Initialisation d'un nouveau rectangle
Rectangle.NewRectangle = RectangleInit(3,2)

;Test des procédure disponible pour cette class
Debug "Perimetre est de " + Rectangle\Perimetre()
Debug "Surface est de "  + Rectangle\Surface()
Rectangle\Destroy()

■ Vous devriez avoir ce résultat.

Perimetre est de 10
Surface est de 6

Dans le prochain chapitre nous allons voir comment modifier les données à travers notre classe Rectange.

[falsam]

Nous allons voir maintenant comment modifier les données dans notre classe Rectangle.

■ Nous allons créer deux nouvelles méthodes
  - La méthode Longueur() pour modifier la longueur d'un rectangle.
  - La méthode Largeur() pour modifier la largeur d'un rectangle.

l'interface aura cette tête là

Code : Tout sélectionner

  Interface NewRectangle
    Perimetre.i()
    Surface.i()
    Longueur.i(Valeur)
    Largeur.i(Valeur)
    Destroy.i()
  EndInterface

Reste à créer les deux procédures.

Code : Tout sélectionner

Procedure Longueur(*this.Rectangle, Valeur)
  *this\Longueur = Valeur
EndProcedure

Procedure Largeur(*this.Rectangle, Valeur)
  *this\Largeur = Valeur
EndProcedure

Procedure Destroy(*this.Rectangle)
  FreeMemory(*this)
EndProcedure

et la data section dans le même ordre que l'interface.

Code : Tout sélectionner

DataSection 
  Class: 
  Data.i @Perimetre()
  Data.i @Surface()
  Data.i @Longueur()
  Data.i @Largeur()
  Data.i @Destroy()
EndDataSection 

■ Passons à un test avec ce code complet. La zone de test est à la fin du code.

Code : Tout sélectionner

;Définition d'une interface contenant les procédures 
Interface NewRectangle
  Perimetre.i()
  Surface.i()
  Longueur.i(Valeur)
  Largeur.i(Valeur)
  Destroy.i()
EndInterface

;Définition des parametres du rectangle
Structure Rectangle
  *DSVT ;Data Section Virtual Table
  
  Longueur.i
  Largeur.i
EndStructure

;Initialisation d'un rectangle (Instancialisation)
Procedure.i RectangleInit(Longueur=0, Largeur=0)
  Protected *Object.Rectangle
  ;Allocation mémoire pour un nouveau modèle de classe.
  *Object = AllocateMemory(SizeOf(Rectangle))
  
  ;L'objet est pret : Quels  sont les pointeurs de procédures ?
  If *Object
    *Object\DSVT = ?Class 
    
    ;Initialise la longueur et la largeur d'un rectangle.
    *Object\Longueur = Longueur
    *Object\Largeur = Largeur
  EndIf
  
  ;Retourne un pointeur de notre objet.
  ProcedureReturn *object
EndProcedure

;Les procédures référencées dans l'interface NewRectangle (Les méthodes)
Procedure Perimetre(*this.Rectangle)
  ProcedureReturn (*this\Longueur + *this\Largeur) * 2
EndProcedure

Procedure Surface(*this.Rectangle)
  ProcedureReturn *this\Longueur * *this\Largeur
EndProcedure

Procedure Longueur(*this.Rectangle, Valeur)
  *this\Longueur = Valeur
EndProcedure

Procedure Largeur(*this.Rectangle, Valeur)
  *this\Largeur = Valeur
EndProcedure

Procedure Destroy(*this.Rectangle)
  FreeMemory(*this)
EndProcedure

;Reférencement des adresses de procédures disponibles pour cette classe
DataSection 
  Class: 
  Data.i @Perimetre()
  Data.i @Surface()
  Data.i @Longueur()
  Data.i @Largeur()
  Data.i @Destroy()
EndDataSection 

;Zone de test

;Initialisation d'un nouveau rectangle
MonTerrain.NewRectangle = RectangleInit(20,10)

;Test des procédure disponible pour cette class
Debug "Perimetre est de " + MonTerrain\Perimetre()
Debug "Surface est de "  + MonTerrain\Surface()

Debug ""

;Modifions les données du terrain
MonTerrain\Longueur(40)
MonTerrain\Largeur(20)
Debug "Perimetre est de " + MonTerrain\Perimetre()
Debug "Surface est de "  + MonTerrain\Surface()

;C'est terminé : Libérons un peu de mémoire
MonTerrain\Destroy()

[Micoute]

Bonjour falsam, c'est un très bon tuto que tu as fait, mais j'aurais aimé que tu parles de l'héritage, par exemple le carré est un rectangle spécial où tous les côtés sont égaux ou par exemple le rapport du rectangle avec le triangle rectangle, mais ça n'enlève rien à la qualité de ton travail, alors merci pour ce tuto.

[falsam]

Bonjour Micoute.

Le rectangle n'était qu'un prétexte pour ce tuto et je souhaitais en fait développer un peu plus la notion d'interface qui est trés peu exploitée en PureBasic.

J'aurais aimé que tu parles de l'héritage

L'héritage est simple. PureBasic a tout prévu.

Code : Tout sélectionner

Interface NewCarre Extends NewRectangle
EndInterface

- NewCarre va hériter des methodes de NewRectangle.
- NewCarre hérite le la procédure d'initialisation mais tu peux en créer une autre.

Exemple un peu plus Rock End Roll dans l’après midi.

[Micoute]

Merci falsam pour ta réponse, c'est vrai que ton titre était peu explicite et c'est vrai aussi qu'on n'utilise que trop peu les interfaces qui sont très puissantes et qui permettent entre-autres de faire de la pseudo POO, je ne voudrais casser ton élan et je t'encourage donc à poursuivre tes efforts qui, je n'en doute pas, seront à la hauteur.

[falsam]

ton titre était peu explicite

Ha !! Interface & Pseudo POO c'est pas assez explicite ? je vais réfléchir à un titre plus explicite mais ça va être dur

[falsam]

Héritage d'une classe .


Hello à la demande générale ( ) me revoilà pour un nouveau chapitre consacré cette fois-ci à l'héritage d'une classe. : Nous pourrons créer une ou des classes héritées d'une classe mère.

Passons à la pratique avec une classe Sprite. (Les rectangles c'est pas drôle)

■ Nous allons créer une classe NewSprite architecturée de cette façon.
- Interface

Code : Tout sélectionner

Interface NewSprite
  x()           ;Retourne la position x d'un Sprite
  y()           ;Retourne la position y d'un Sprite
  
  Destroy.i()   ;Destruction 
EndInterface

- Structure

Code : Tout sélectionner

Structure Sprite
  *DSVT ;Data Section Virtual Table
  x.i
  y.i
EndStructure

Je ne rentre pas dans les détails. Les explications sont dans les messages précédents.


■ Nous allons créer maintenant une classe NewMagician héritée de la classe NewSprite architecturée de cette façon en ajoutant le paramétre Extends.

Cette classe sera alimentée par deux nouvelle méthodes :
- SetPower(Power) pour Attribution de forces au magicien
- GetPower() pour savoir combien de force lui reste t'il.

Pour mémoriser cette force, nous allons ajouter une variable dans une structure héritée de la classe NewSprite.

-Interface

Code : Tout sélectionner

Interface NewMagician Extends NewSprite
  ;Creation d'une méthode qui ne sera propre qu'au magicien
  SetPower(Power) ;Attribution de forces
  GetPower()      ;De combien de force lui reste t'il ?
EndInterface

-Structure

Code : Tout sélectionner

Interface NewMagician Extends NewSprite
  ;Creation d'une méthode qui ne sera propre qu'au magicien
  SetPower(Power) ;Attribution de forces
  GetPower()      ;De combien de force lui reste t'il ?
EndInterface

■ Le code complet de ce nouveau chapitre.

Code : Tout sélectionner

;Définition de la classe NewSprite
Interface NewSprite
  x()           ;Retourne la position x d'un Sprite
  y()           ;Retourne la position y d'un Sprite
  
  Destroy.i()   ;Destruction 
EndInterface

;Définition des parametres du sprite par défaut
Structure Sprite
  *DSVT ;Data Section Virtual Table
  x.i
  y.i
EndStructure

;HERITAGE 
;Pour procéder à un héritage qui va 
;hériter des attributs et méthodes d'une autre classe, 
;il suffit d'utiliser le mot-clé Extends. 

;Création d'un magicien à partir du sprite de base 
Interface NewMagician Extends NewSprite
  ;Creation d'une méthode qui ne sera propre qu'au magicien
  SetPower(Power) ;Attribution de forces
  GetPower()      ;De combien de force lui reste t'il ?
EndInterface

;Creation de la structure du magicien à partir du sprite de base
Structure Magician Extends Sprite
  Power.i
EndStructure

;INSTANCIALISATION de la class
Procedure Init(x=0, y=0, width=32, height=32)
  Protected *Object.Sprite
  
  ;Allocation mémoire pour un nouveau modèle de classe.
  *Object = AllocateMemory(SizeOf(Sprite))
  
  ;L'objet est pret :
  ;- Quels  sont les pointeurs de procédures ?
  ;- Initialisation de la class
  If *Object
    *Object\DSVT = ?Class 
    
    ;Initialisation
    *Object\x = x
    *Object\y = y
  EndIf
  
  ProcedureReturn *object
EndProcedure


;METHODE
Procedure SetPosition(*this.Sprite, x, y)
  *this\x = x
  *this\y = y
EndProcedure

Procedure x(*this.Sprite)
  ProcedureReturn *this\x
EndProcedure

Procedure y(*this.Sprite)
  ProcedureReturn *this\y
EndProcedure

Procedure SetPower(*this.Magician, Power)
  *this\Power = Power
EndProcedure

Procedure GetPower(*this.Magician)
  ProcedureReturn *this\Power
EndProcedure

Procedure Destroy(*this.Sprite)
  FreeMemory(*this)
EndProcedure

;Class Handle Procedure
DataSection 
  Class: 
  ;NewSprite
  Data.i @x()
  Data.i @y()
  Data.i @Destroy()
  
  ;NewMagician Extends NewSprite
  Data.i @SetPower()
  Data.i @GetPower()
EndDataSection 

;//
;// Zone de test                                   
;//

;Initialisation d'un joueur
Player.NewSprite = Init(10, 10, 50, 50)

;On peut aussi créer un guerrier 
Warrior.NewSprite = Init(20, 20, 50, 50)

;Testons la position du joueur et du guerrier
Debug "Le joueur et le guerrier"
Debug Player\x()
Debug Warrior\x()

;Au tour du magicien
Debug "Le magicien"
BlackMagician.NewMagician = init(30, 25)
Debug BlackMagician\x()

;Donnons lui un peu de pouvoir
BlackMagician\SetPower(100)

;Vérifions maintenant son nombre de pouvoir
Debug BlackMagician\GetPower()

;C'est terminé : Libérons un peu de mémoire
Player\Destroy()
Warrior\Destroy()
BlackMagician\Destroy()

Attention de bien respecter l'ordre de création des procédures dans la DataSection sinon ça ne fonctionne pas.

[Micoute]

Merci falsam, tout à fait à la hauteur de mes espérances et contrairement à ce que tu dis, les rectangles ça peut être très drôles quand ils sont bien domestiqués.

[falsam]

les rectangles ça peut être très drôles quand ils sont bien domestiqués.

Oui mais je préféres les magiciens

[Kwai chang caine]

Eeeeet ben !!!! et tout le monde dit que la POO c'est plus simple
En tout cas, ca fait couler beaucoup d'encre cette POO, même sur le US, y'a des prises de tetes, des coups de gueule de FRED qui en a marre de repeter in vitam eternam que PB, si il ne doit en rester qu'un, restera celui la à ne jamais passer à la POO, et que celui qui n'est pas content peut aller voir sous un autre ciel voir si le soleil de la POO bronze mieux que celui du procedural
Moi pour une fois, je soutiens haut et fort mon bon FRED

http://www.purebasic.fr/english/viewtop ... 70#p403070

Y'a quand même un truc que je ne comprend pas, pour faire de la POO, les developpeurs sont bien parti du procedural, non ?
Puisque il n'existait que ça avant...

Alors pourquoi comme tu viens de le faire, et plein d'autres aussi, quelqu'un passionné de POO ne creerait as un PBI qui permettrait de programmer en POO.
Apres tout si je ne m'abuse, le Visual C++ arrive bien à avaler du procedural ET de la POO dans le même IDE, non (2) ??
Le probleme ne provient que du debugueur qui ne serait pas adapté ???

Ce combat Procedural versus POO n'a pas fini de faire parler de lui

En tout cas merci beaucoup de ce TUTO, bien que la POO ne m'attire pas, j'aime bien ce genre de code qui montre un peu comment elle fonctionne

[falsam]

Mon bon Kwai chang caine tu sais quoi ? je n'aime pas la POO ^^

Avec ce topic je parle surtout Interface Purebasic et possibilité de créer un ou plusieurs héritages d'une interface. D’où cette précision de Pseudo POO.

Cette notion bien gérer, tu peux considérablement faciliter un code de jeu par exemple comme tu as pu le voir dans la zone de test du dernier code.

[Marc56]

KCC, Pour beaucoup, la POO, c'est objet.propriété et objet.methode, donc bien souvent juste une lisibilité accrue mais la POO c'est bien plus que ça.

Ce n'est véritablement utile que quand on a besoin de programmer au raz des pâquerettes, c'est à dire programmer tous les éléments et évènements d'une application (constructeurs et destructeurs inclus)

C'est (c'était) utile quand le programme lui-même ne sait rien faire, même pas une fenêtre et que l'os n'a aucune API.

J'avais créé un petit lanceur en Borland C++ il y a 20 ans, sous DOS

Dans ces cas-là, par exemple pour afficher une fenêtre, il fallait
- Vérifier qu'il y ai assez de RAM dispo (rôle du constructeur)
- Sauvegarder la zone écran où s'affiche la fenêtre
- Tracer la fenêtre (fenêtre héritée d'une autre)
Puis quand l'utilisateur fermait la fenêtre il fallait le gérer (une fenêtre ne s'efface pas, on remet le dessous dessus)
- Restaurer la zone écran
- Libérer la mémoire (destructeur)

Pour tout ça, la POO permettait de gagner en lisibilité, mais maintenant, les langages de haut niveau (basic) et les API font ça tout seul.

[Kwai chang caine]

Mon bon Kwai chang caine tu sais quoi ? je n'aime pas la POO ^^

Ouaaaah alors on est deux ????
En fait ce qui serait cool, c'est de faire un sondage, mais je crois que personne n'ose, car on va encore se faire jeter par la TEAM, et aussi relancer une baston entre les pro et les anti POO
C'est dommage par curiosité, j'aurais bien aimé savoir, si la "Pé-au-au-aine" en programmation (L'equivalent de la grangraine pour une guibole) est en train de progresser, à quel stade on en est, combien de "pure100" on est à l'aimer ou la détester, et tout le toutim ....
En fait, la reponse me ferait peur je crois, car je crains que petit à petit on devienne des fossiles .... le coté sympa c'est qu'on va devenir recherché

KCC, Pour beaucoup, la POO, c'est objet.propriété et objet.methode, donc bien souvent juste une lisibilité accrue mais la POO c'est bien plus que ça.

Tu as raison...quand on aime pas, et quand plus on a une mauvaise irrigation neuronale comme moi, on arrive pas à imaginer la puissance de la bete ..
J'en parle autour de moi, et je suis quand même arrivé à faire dire à "quinquin" qui aime la POO et ne fait que ça, que ça ne sert à rien, voir même c'est plus compliqué quand on fait une toute petite appli qui n'est pas destinée à être modifiée, ou evoluer si ce n'est qu'en rajoutant des fonctions.

En fin de compte, je me demande si on pourrait pas faire la paix entre les rigolus et les tristus (a vous de choisir de quel coté se placer )



et pouvoir coder les deux dans le même IDE....mais bon....c'est pas moi qui serait capable de faire ça...

[Kwai chang caine]

C'est vrai...je m'en rappelle, mais je les lisait pas et donc les aimait pas ....tout comme la POO d'ailleurs