MODULE Le polymorphisme avec Pb

[microdevweb]

Le polymorphisme constitue dans le fait d'avoir le même appel de méthodes (procédure ) avec du code qui diverge selon l'objet concerné.

Cela peut être bien souvent pratique...

Exemple:
Imaginer un logiciel de dessin, le dessin en lui-même se compose de différentes formes géométriques, des cercles; des carrés; des rectangles etc...

D'avance on ne peux pas connaitre le type de forme qui compose le dessin. Avec une même méthode pour dessiner le dessin cela devient vraiment pratique.

Car si par après je veux faire évoluer le logiciel et ajouter par exemple des triangles il me suffira de créer une nouvelle classe triangle.

Comment faire avec Pb:

On crée une interface (abstraite) qui va uniquement prendre les méthodes communes au objets.

Toutes les interfaces des objets hériteront de cette interface.

ATTENTION: le datasection doit scrupuleusement respecté l'ordre de l'interface (abstraite) suivi des méthodes propre ) l'objet

Exemple ci-dessous avec un calcul de surface:
remarque: pour une meilleur compréhension, je n'ai ajouté aucune méthode propre au objets

Code : Tout sélectionner

Interface form
  getSurface.s()
EndInterface

; class pour les carré
DeclareModule Carre
  Declare new(mySize)
EndDeclareModule
Module Carre
  Structure _object
    *methods
    size.l
  EndStructure
  Procedure new(mySize)
    Protected  *this._object = AllocateStructure(_object) 
    With *this
      \size=mySize
      \methods=?METHODS
      ProcedureReturn *this
    EndWith
  EndProcedure
  Procedure.s getSurface(*this._object)
    With *this
      Protected.f s=\size * \size
      ProcedureReturn "La surface du carré est de "+StrF(s,2)
    EndWith
  EndProcedure
  DataSection
    METHODS:
    Data.i @getSurface()
  EndDataSection
EndModule
; class pour les rectangle
DeclareModule Rectangle
  Declare new(width,height)
EndDeclareModule
Module Rectangle
  Structure _object
    *methods
    width.l
    height.l
  EndStructure
  Procedure new(width,height)
    Protected  *this._object = AllocateStructure(_object) 
    With *this
      \width=width
      \height=height
      \methods=?METHODS
      ProcedureReturn *this
    EndWith
  EndProcedure
  Procedure.s getSurface(*this._object)
    With *this
      Protected.f s=\width * \height
      ProcedureReturn  "La surface du rectangle est de "+StrF(s,2)
    EndWith
  EndProcedure
  DataSection
    METHODS:
    Data.i @getSurface()
  EndDataSection
EndModule
; class pour les cercle
DeclareModule Circle
  Declare new(radius)
EndDeclareModule
Module Circle
  Structure _object
    *methods
    radius.l
  EndStructure
  Procedure new(radius)
    Protected  *this._object = AllocateStructure(_object) 
    With *this
      \radius=radius
      \methods=?METHODS
      ProcedureReturn *this
    EndWith
  EndProcedure
  Procedure.s getSurface(*this._object)
    With *this
      Protected.f s=Pow(\radius,2) * 3.14
      ProcedureReturn  "La surface du cercle est de "+StrF(s,2)
    EndWith
  EndProcedure
  DataSection
    METHODS:
    Data.i @getSurface()
  EndDataSection
EndModule

Global NewList myForm.form()
; Ajout d'un carré
AddElement(myForm())
myForm()=Carre::new(15)
; Ajout d'un rectangle
AddElement(myForm())
myForm()=Rectangle::new(25,32)
; Ajout d'un cercle
AddElement(myForm())
myForm()=Circle::new(18)

;lecture des surfaces
ForEach myForm()
  Debug myForm()\getSurface()
Next

[Micoute]

Mais c'est tout bonnement remarquable, les modules simplifient grandement le développement, merci pour le partage.

[Zorro]

Ce qui du coup reviens a faire ceci en Procedurale

Code : Tout sélectionner

Declare.s Create_myform(forme.s,larg.i=1,haut=1)

Global NewList myForm.s()
; Ajout d'un carré
AddElement(myForm())
myForm()= Create_myform("carre",15)
; Ajout d'un rectangle
AddElement(myForm())
myForm()= Create_myform("rectangle",25,32)
; Ajout d'un cercle
AddElement(myForm())
myForm()= Create_myform("cercle",18)

;lecture des surfaces
ForEach myForm()
		Debug myForm()
Next

;************************************************************
Procedure.s Create_myform(forme.s,Larg.i=1,Haut=1)		
		Protected.f s
		select forme.s
				Case "carre"
				s=Larg.i* Larg.i		
				ProcedureReturn "La surface du carré est de "+StrF(s,2)
				Case "rectangle"				
				s=Larg.i * Haut
				ProcedureReturn "La surface du rectangle est de "+StrF(s,2)
				Case "cercle"
				s=Pow(Larg.i,2) * 3.14
					ProcedureReturn  "La surface du cercle est de "+StrF(s,2)
		EndSelect
Endprocedure
; **********************************************************

désolé, je prefere le Procedural

[Kwai chang caine]

Perso.... moi ça m'intéresse
Des tonnes de fois, j'ai lu ce mot et jamais osé demander ou pire...j'ai osé demander....et pas osé redemander à la fin de l'explication

Je trouve ça super que tu ai toujours la patience de te casser la tête à continuer d'essayer de faire comprendre les rouages de la POO en code PB
A un public quelque peu..... comment dirais-je ??? Etanche

Ce peut être un avantage pour enfin comprendre certains des termes "barbares" (dont celui ci) de ce style de prog

Bon.. c'est trop tard pour que je bourre le mou au bidet qui me sert de cerveau, mais j'y reviendrais pour essayer de comprendre ce "PolyEnTunisie" qui m'intéresse
Du coup..l'exemple de ZORRO va être aussi très utile pour comprendre, car il devrait nous parler dans notre langue..en fin de compte un style de "traducteur"

Donc encore merci de ton partage...et de ta patience

[Zorro]

PolyEnTunisie"

que j'ai pu le caresser en Vrais, au Parc de Saint-Vrain ou il a été pendant un temps (année 1978-79)

par la suite il a fini ses jours dans un petit près a la sortie de Fitz James (60)
et il semble qu'il a été tué, et découpé en morceaux !! probablement par des voleur de viandes comme il y en a quelques fois
le proprio a retrouvé le cheval a moité decoupé.... oui ...... ça calme !

[G-Rom]

désolé, je prefere le Procedural

C'est pas une question d'aimer ou pas la POO, la POO facilite le code sur certain aspects , certain pattern de programmation sont plus facile à faire en POO qu'en procédural ( singleton, state, observer, etc... ) faire, ou essayer de faire un semblant de POO en PB est une hérésie , perte de temps, et perte de lisibilité ( les constructeurs en pseudo POO en PB sont horrible, à la rigueur , il faut utilisé massivement les macros... )

Ce peut être un avantage pour enfin comprendre certains des termes "barbares" (dont celui ci) de ce style de prog

C'est pas en PB que tu vas apprendre la POO, c'est pas non plus un "style", mais des concepts concret, inapplicable tel quel en procédurale, mais si tu veut apprendre l'objet avec un vrai langage de prog en poo, je t'invite cordialement sur le tchat de falsam ou je me ferais un plaisir de t'initier à cet art

[microdevweb]

Bonsoir G-Rom,

Encore une fois de plus je sais que Pb n'est pas un langage orienté objet. Et ne tiens d'ailleurs pas à recopier scrupuleusement la syntaxe, raison pour la quel je n'utilise pas de macro.

Je dirais plutôt que c'est un autre manière d'utiliser les modules en prenant les grands principes tel que

• l'encapsulation
• éventuellement l'héritage et le polymorphisme.

Passer par des interfaces plutôt que par des appels de procédures à certains avantages, comme par exemple de ne plus dépendre de l'ordre de la déclaration de modules.

Pour ma part la Poo n'est un langage x ou y mais un philosophie d'analyse de développement. Et j'avoue franchement que si je n'avais pas trouvé ce style de développement en Pb j'aurais purement arrêter de l'utiliser.

[G-Rom]

Loin de moi de dénigré la POO, je l'utilise sous d'autres cieux, mais je maintiens que faire de la POO c'est comme essayer de faire voler une LADA dans le ciel , c'est pas prévu pour, c'est bancal de mon point de vue, la maintenance est moins aisée qu'un code standard, je reprend ton exemple avec les formes géométrique,
PB te permet de faire du slicing , ou des unions,

Le slicing :

Code : Tout sélectionner

#TRIANGLE  = "Triangle"
#RECTANGLE = "Rectangle"

Structure Forme
  couleur.l
  type.s
  Array vertices.f(1)
EndStructure

Global NewList *Formes.Forme()

Structure Triangle Extends Forme
  ; ... prop du triangle
  MessageBidon.s
EndStructure

Structure Rectangle Extends Forme
  ; ... prop du rectangle
  MessageEncoreBidon.s
EndStructure


Procedure InitTriangle(*t.Triangle)
  ReDim *t\vertices(6)
  *t\type = #TRIANGLE
  *t\vertices(0) = 0.5
  *t\vertices(1) = 0
  
  *t\vertices(2) = 1
  *t\vertices(3) = 1
  
  *t\vertices(4) = 0
  *t\vertices(5) = 1
  
  *t\MessageBidon = "Je suis un triangle"
EndProcedure

Procedure InitRectangle(*t.Rectangle)
  ReDim *t\vertices(8)
  *t\type = #RECTANGLE
  *t\vertices(0) = 0
  *t\vertices(1) = 0
  
  *t\vertices(2) = 1
  *t\vertices(3) = 0
  
  *t\vertices(4) = 1
  *t\vertices(5) = 1
  
  *t\vertices(6) = 0
  *t\vertices(7) = 1
  
  *t\MessageEncoreBidon = "Je suis un rectangle"
EndProcedure

Procedure DessineForme(*f.Forme)
  Debug "Dessine : " + *f\type
  For i = 0 To ArraySize(*f\vertices()) 
    If i%2=0
      Debug "X:"+StrF(*f\vertices(i))
    Else 
      Debug "Y:"+StrF(*f\vertices(i))
    EndIf 
  Next 
  
  If *f\type = #TRIANGLE
    *TrianglePtr.Triangle = *f
    Debug *TrianglePtr\MessageBidon
  EndIf 
  
  If *f\type = #RECTANGLE
    *RectanglePtr.Rectangle = *f
    Debug *RectanglePtr\MessageEncoreBidon
  EndIf 
  Debug ""
EndProcedure

A.Triangle  : InitTriangle(@A)
B.Rectangle : InitRectangle(@B)
C.Triangle  : InitTriangle(@C)
D.Rectangle : InitRectangle(@D)

AddElement(*Formes()) : *Formes() = @A
AddElement(*Formes()) : *Formes() = @B
AddElement(*Formes()) : *Formes() = @C
AddElement(*Formes()) : *Formes() = @D

ForEach *Formes()
  DessineForme(*Formes())
Next 

Les unions :

Code : Tout sélectionner

Enumeration
  #TRIANGLE
  #RECTANGLE
  #ROND
EndEnumeration


Structure Triangle
    ; point du triangle
EndStructure

Structure Rectangle
  ; point du rectangle
  ; taille w,h
EndStructure

Structure Cercle
  ; rayon
EndStructure


Structure Forme
  type.l 
  StructureUnion
    T.Triangle
    R.Rectangle
    C.Cercle
  EndStructureUnion
EndStructure

Pour ma part, j'aime bien la première méthode. , ca équivaut a de l'encapsulation, héritage ( via extends ) et polymorphisme ( le slicing, avec la liste global qui contient toutes les formes géométrique sans couiner. ) , ca , c'est du vrai PB ! quand je fait du C , je fait du C , si j'ai besoin de OO , je passe au C++

[microdevweb]

@G-Rom,

Les avis ce partage et sont toujours intéressant et chacun à sont mode de développement ce qui compte surtout c'est le résultat. Je sais par exemple que dans mon école on va devoir faire du c style objet (pas du c++ que nous faisons également), alors ne me demande pas comment je n'en sais encore rien et ceci surtout pour le développement de micro-chips.

Pour tester mon petit soft "Class maker" en situation réel je vais faire un petit soft de dessin (très simple) mais qui devra surtout être évolutif, je suis en train de faire l'analyse uml de ce dernier suivant le cahier des charges suivant .

Code : Tout sélectionner

Logiciel de dessin cahier des charges
L’utilisateur peut créer un nouveau document et choisir le format de document aux choix
En pixel ou en millimètre 
D’une taille personnalisée ou prédéfinie.
Il peut sauver le document, ouvrir un document précédemment enregistrer,
Fonction de dessin
Il peut ajouter de nouvelle formes géométriques en choisissant le type de forme dans un menu ou une barre d’outils et en cliquant sur la zone de dessin.
Il peut sélectionner une ou plusieurs forme géométrique
Si une seule forme est sélectionnée il peut,modifié la taille  uniformément ou non suivant une combinaison de touche et action de la souris à définir,
Si une ou plusieurs formes sont sélectionnée(s) l’utilisateur peut modifier la couleur de remplissage ou de contour, il peut également déplacé la ou les formes sur la zone de dessin.
Il peut grouper plusieurs formes entre elles.
Il peut désactivé la modification d’une forme ou d’un groupe.
Il peut masqué une forme ou un groupe.
Il peut changé l’ordre d’affichage d’une forme ou d’un groupe.
Les groupes ainsi que les forme seront visible dans un arbre d’affichage.
Une grille de positionnement pourra être affichée et éventuellement magnétique.
Les forme proposée seront des rectangles,cercles,lignes. D’autres formes devront pouvoir être ajoutée facilement dans les futures versions.

Cela ouvrira certainement le débat

[G-Rom]

@G-Rom,

Les avis ce partage et sont toujours intéressant et chacun à sont mode de développement ce qui compte surtout c'est le résultat. Je sais par exemple que dans mon école on va devoir faire du c style objet (pas du c++ que nous faisons également), alors ne me demande pas comment je n'en sais encore rien et ceci surtout pour le développement de micro-chips.

Pour tester mon petit soft "Class maker" en situation réel je vais faire un petit soft de dessin (très simple) mais qui devra surtout être évolutif, je suis en train de faire l'analyse uml de ce dernier suivant le cahier des charges suivant .

Cela ouvrira certainement le débat

En C, l'utilisation des pointeurs rend plus souple le langage comparé à PB , tu peu avoir des pointeurs de fonctions dans les structures , comme cela par exemple :

Code : Tout sélectionner

#include <stdio.h>

typedef struct MaClass MaClass;
struct MaClass{

	int A;
	int B;
	
	void (*initialize)(MaClass*);

};

void initialize(MaClass* this){
	this->A  = 512;
	this->B  = 256;
}



int main(){


	MaClass test;
	test.initialize = initialize;
	
	
	test.initialize(&test);
	
	
	
	printf(" test.A vaut %i : test B vaut : %i \n",test.A,test.B);


	return 0;
}

compile avec 'gcc code.c -o Test.exe' , même si le C n'est pas fait pour de la POO, l'exercice est intéressant, car le code reste très clair à comprendre, pas de vtable, d'interface, de module, etc... pour faire une pseudo poo. et avec des macros pour "simplifier" la lecture du code :

Code : Tout sélectionner

#include <stdio.h>

typedef struct MaClass MaClass;
struct MaClass{

	int A;
	int B;
	
	void (*constructor)(MaClass*);

};

void MaClass_constructor(MaClass* this){
	this->A  = 512;
	this->B  = 256;
}


#define new(_VAR_,_CLASS_)\
_VAR_.constructor = _CLASS_ ## _constructor;\
_VAR_.constructor(&_VAR_);




int main(){

	MaClass test;
	new(test,MaClass)
		
	printf(" test.A vaut %i : test B vaut : %i \n",test.A,test.B);


	return 0;
}

[Kwai chang caine]

PolyEnTunisie"

que j'ai pu le caresser en Vrais, au Parc de Saint-Vrain ou il a été pendant un temps (année 1978-79)...a moité découpé.... oui ...... ça calme !

Putain..à te dégouter d'être carnassier Rien n'est respecté dans ce bas monde
D'un autre coté...il ne devait plus avoir son siège d'acteur à coté de lui, ni les accessoires....

Alors pour des tocquards...c'était un cheval comme les autres l'excuse aurait moins été valable pour MEHDI
Ce feuilleton je le regardais de temps en temps, enfant... le cheval j'aurais pas pu le reconnaitre, mais MEHDI même adulte oui...
Évidement quand je trouve des disques je le achète aussi...triste histoire

C'est pas en PB que tu vas apprendre la POO, c'est pas non plus un "style", mais des concepts concret, inapplicable tel quel en procédurale, mais si tu veut apprendre l'objet avec un vrai langage de prog en poo, je t'invite cordialement sur le tchat de falsam ou je me ferais un plaisir de t'initier à cet art

Oui à force que tout le monde répète que c'est impossible en PB, je commence à en être persuadé
Par contre, personne n'a jamais pu me répondre, sur le POURQUOI c'est impossible

Tu viens de donner un exemple en C qui pourrait faire de la POO

]En C, l'utilisation des pointeurs rend plus souple le langage comparé à PB , tu peu avoir des pointeurs de fonctions dans les structures

Peut être est ce la barrière que PB ne peut pas franchir ? et qui l’empêche de faire de la vraie POO
Car la POO a bien été crée avec le C, ou bien en assembleur ?
C'est surtout ça que j'aurais aimé comprendre...
Tu sais quant on dit à un gosse.....touche pas ça...la premiere question qui germe dans son cerveau vide de débile inconscient, c'est POURQUOI

mais si tu veut apprendre l'objet avec un vrai langage de prog en poo, je t'invite cordialement sur le tchat de falsam ou je me ferais un plaisir de t'initier à cet art

Ta proposition me touche beaucoup MAITRE, tu peux pas savoir
Faire ma formation en quelque sujet que ce soit, à coté ...toutes les marches commandos et parcours du combattant que tu as pu faire....c'est de la roupie de sansonnet
Et je t'aime et t'admire trop pour t'imposer ce genre de sacrifice.....mais vraiment j'suis fier d'avoir eu une telle proposition venant de toi

[microdevweb]

Bon je pense que pour mettre fin au débat, je ne vais plus utilisé (du moins en PB) le mot POO je parlerais maintenant de module interfacé.

Donc voila fini la POO avec Pb il n'est pas fait pour, juste la programmation modulaire et l'usage d'interfaces.

[G-Rom]

Cela ouvrira certainement le débat

Bon je pense que pour mettre fin au débat

Il est court le débat ^^, tu peu t'amuser a faire de la pseudo POO si tu le souhaite, faut pas prendre la mouche, en plus je t'ai fait un petit exemple en C ^^
qui montre la différence fondamentale entre PureBasic & le C , les pointeurs de fonction, tu peu faire la même chose en PB, mais c'est de la gym ^^

[microdevweb]

@G-Rom,

Je te rassure je ne prend la mouche et merci pour le code. J'avoue de toute façon me détourné de Pb et approfondir d'autre langages tel que java qui sont porteur d'emploi alors que malheureusement ce n'est pas le cas de Pb.

[G-Rom]

J'avoue de toute façon me détourné de Pb et approfondir d'autre langages tel que java qui sont porteur d'emploi alors que malheureusement ce n'est pas le cas de Pb.

Si tu cherches toujours un emploi, peut être que c'est ton secteur qui n'est pas porteur d'emploi, Pourquoi ne tente tu pas le monde indépendant , y a des secteurs qui marche, le casual game sur mobile, sur desktop , même si les marché sont saturé, y a toujours la possibilité de sortir sont épingle du jeu, tu utiliseras le langage que tu veut, y a qu'a regardé un peu les post mortem de petit jeu, du nombres des ventes de certain petit titre, y a de quoi en vivre largement, je ne dit pas que c'est facile et que tu vas devenir riche, mais , soit ta chance, n'attend pas , ou , ne te plie pas au désir de ceux qui créer l'emploi, créer ton emploi.