Purebasic et concepts de POO

[G-Rom]

Merci Ollivier.
KCC , Voici un autre exemple un peu plus "parlant"

Code : Tout sélectionner

Interface Vector2f
  Add(Other.Vector2f)
  GetX.f()
  GetY.f()
  DotProduct.f(Other.Vector2f)
  Free()
EndInterface

Prototype Add(Other.Vector2f)
Prototype GetX()
Prototype GetY()
Prototype Free()
Prototype DotProduct(Other.Vector2f)

Structure sVector2fMethod
  Add.Add
  GetX.GetX
  GetY.GetY
  DotProduct.DotProduct
  Free.Free
EndStructure

Structure sVector2f
  *proc.sVector2fMethod ; pointeur sur méthodes
  x.f
  y.f
EndStructure

Declare Vector2f_Add(*this.sVector2f, Other.Vector2f)
Declare.f Vector2f_GetX(*this.sVector2f)
Declare.f Vector2f_GetY(*this.sVector2f)
Declare.f Vector2f_DotProduct(*this.sVector2f, Other.Vector2f)
Declare Vector2f_Free(*this.sVector2f)

Procedure Vector2f_New(x.f, y.f)
  *objet.sVector2f = AllocateStructure(sVector2f)
  *objet\proc      = AllocateStructure(sVector2fMethod)
  
  *objet\proc\Add        = @Vector2f_Add()
  *objet\proc\GetX       = @Vector2f_GetX()
  *objet\proc\GetY       = @Vector2f_GetY()
  *objet\proc\DotProduct = @Vector2f_DotProduct()
  *objet\proc\Free       = @Vector2f_Free()
  
  *objet\x = x
  *objet\y = y
  
  ProcedureReturn *objet
EndProcedure

Procedure Vector2f_Add(*this.sVector2f, Other.Vector2f)
  *otherPtr.sVector2f = Other
  *this\x = *this\x + *otherPtr\x
  *this\y = *this\y + *otherPtr\y
EndProcedure

Procedure.f Vector2f_GetX(*this.sVector2f)
  ProcedureReturn *this\x  
EndProcedure

Procedure.f Vector2f_GetY(*this.sVector2f)
  ProcedureReturn *this\x  
EndProcedure

Procedure.f Vector2f_DotProduct(*this.sVector2f, Other.Vector2f)
  *otherPtr.sVector2f = Other
  ProcedureReturn   (*this\x * *otherPtr\x) + (*this\y * *otherPtr\y) 
EndProcedure

Procedure Vector2f_Free(*this.sVector2f)
  FreeStructure(*this\proc)
  FreeStructure(*this)
EndProcedure

A.Vector2f = Vector2f_New(10,10)
B.Vector2f = Vector2f_New(10,10)

A\Add(B) ; A = A+B

Debug A\GetX() ; A est modifié 
Debug B\GetX() ; B ne l'est pas !

Debug A\DotProduct(B)

A\Free()
B\Free()

C'est comme la technique citée plus haut, sauf qu'il n'y a pas de datasection, mais une structure avec des pseudo fonction dedans que j'adresse à la construction de l'objet. cette méthode évite des fonctions du genre : A\add(A,B) mais on écrira plutôt A\Add(B) dans le cadre d'une addition de 2 objets par exemple ( ici des vecteur 2D ) , c'est uniquement l'interface qui donne l'impression de code OO ( l'interface cache le premier paramètre de la fonction ( l'objet en somme...) ) , mais il n'en est rien.
Le code "est lourd" à écrire, mais son utilisation reste agréable et si bien écrit plus intuitif par la suite.

[Ollivier]

A partir du moment où l'on ne reste pas sur l'éditeur natif, on peut vraiment se simplifier la vie. Si je poste un code qui fonctionne, tandis que les noms de procédures et de variables supportent des accents, je parie que je vais me faire virer du forum...

[Kwai chang caine]

@GRom et @Falsam
Merci beaucoup à vous deux pour vos exemples
Ils se ressemblent pas vraiment et pourtant sont dans le même registre, j'suis impressionné, faut du neurone pour alimenter tout ça
Qu'est ce que j'aimerais savoir jongler avec les pointeurs comme vous faites
Maintenant, quand on vois ça...j'ai un peu du mal à associer le mot simplicité avec POO
Encore merci

[falsam]

Maintenant, quand on vois ça...j'ai un peu du mal à associer le mot simplicité avec POO

Je confirme

[G-Rom]

Maintenant, quand on vois ça...j'ai un peu du mal à associer le mot simplicité avec POO
Encore merci

Déjà, PB ne fait pas de POO, tout ce qui fait de la pseudo POO en PB , c'est de la bricolette et c'est lourd à mettre en place, mais agréable à utilisé.
après, poo ou pas poo, c'est un débat philosophique... mais dans d'autre langage , comme le c++ que je maîtrise, la poo est plus simple que la "poo sauce pb".
sincèrement, je ne vois pas l'utilité de la poo en PB, c'est de la branlette qui ne sert à rien, j'ai utilisé PB récemment pour faire un logiciel qui automatise une partie de la compta, pas de trace de poo dans mon code... le logiciel marche parfaitement, mission accomplie.

[microdevweb]

Oui la Poo avec Pb n'est pas évidente surtout si l'on souhaite utilisé l'héritage, et comme tout l'intérêt est la.

Par contre avec d'autre langage, comme java,c# ce n'est pas beaucoup plus difficile que le procédurale.

Comme le dis G-rom c'est une philosophie et un choix, mais quand je voie les possibilités et la simplicité que cela offre comme par exemple la création d'un jeu avec Unity 3D ou Godot Engine qui sont purement orienté objet, je trouve vraiment regrettable que Pb n'offre pas cette possibilité.

[Ollivier]

@G-Rom

Pas entièrement d'accord avec toi : le compilateur PB permet de faire à peu près n'importe quoi, même du C et la syntaxe qui va avec. C'est l'éditeur qui limite. Et comme cet éditeur s'est sophistiqué, ça ferme la porte à un équivalent simple à réaliser.

La POO ça reste du procédural : l'intérieur des méthodes est impératif, c'est la manière de gérer les appels de méthode, point de vue programmeur et point de vue compilateur, qui rend la POO non impérative. Et on peut utiliser 4 macros pour ça : New(), Get(), Set() et Destroy().

Code : Tout sélectionner

;********************************************************************************************************************************************************************
*Desktop = DesktopCreate() ; création de l'objet (avec instanciation si nécessaire)
DesktopDestroy(*Desktop)

New(*Desktop, Desktop) ; création de l'objet via macro (instanciation si nécessaire)

; pas forcément besoin de synchroniser la mise à jour du bureau ici.
; On sait que le bureau existe ici et que ses caractéristiques immédiates sont accessibles.
; Mais avec une règle de syntaxe :
Debug *Desktop\Width ; si création threadée.
Debug DesktopGetWidth(*Desktop) ; indifférent (mais prend de la ressource)
Debug Get(*Desktop, Desktop, Width) ; indifférent (ressource prise à la compilation)

Destroy(*Desktop, Desktop)

Debug *Desktop\Width ; syntaxe instable (risques IMA ou résultat incertain)
Debug DesktopGetWidth(*Desktop) ; syntaxe instable (mêmes risques)
Debug Get(*Desktop, Desktop, Width) ; syntaxe stable (bien que retour de méthode nul)

Les réglage d'instanciation ou de thread peuvent se faire à la volée par un jeu de swap de macros, vu qu'une macro peut être désactivée.

En fait, ce qui freine et fait penser à de la branlette, c'est d'avoir des mot-clés de type "EndProcedure" au lieu d'une simple accolade de fermeture "}", et que le seul moyen "natif" de rejoindre cette simplicité, c'est d'utiliser les parenthèses via les macros. Ça a 3 inconvénients :
1) confondre tout et n'importe quoi avec des calculs ;
2) risquer un détection de récursivité de macro ;
3) ne pas pouvoir localiser une erreur.

C'est assez critique et amène effectivement à des moments de solitude (sans grand plaisir).
Mais il reste une solution d'en-tête de compilation, qui saute les problèmes (1) et (2), voire le compilateur en mode standby qui enlève absolument tous les problèmes... (et met C++ par terre)

[Kwai chang caine]

comme le c++ que je maîtrise, la poo est plus simple que la "poo sauce pb".

Tu m'épates, je sais j'suis un vieux con, je me répète.
Je me rappelle encore il y a quelques années ou tu avais écrit alors que tu ne connaissais rien du tout au C++ et que tu commençait à t'y intéresser
De l'eau a coulé sous les ponts depuis ce temps, mais toi apparemment tu l'as pas passé à compter les grenouilles

J'aurais tant rêvé être neurocapable d'un tel exploit, apres plus de 10 ans avec le simple PB, j'ai encore pas tout compris, alors le C, je suis lucide....pour moi...C pas bien
Mais ce qui me coupe aussi un peu l'envie, c'est justement en outre le fait qu'il soit un langage bien moins abordable que PB, il est aussi moins pratique, bien souvent il est monstrueux en terme de GO (Si tu veux avoir un bon debugger qui t'aide bien en tant que débutant) et pas portable USB, et c'est aussi bien souvent une usine à gaz

C'est dommage, que presque personne n'est pensé à simplifier l'environnement C comme FRED l'a fait pour PB, le rendre portable, ne se concentrer que sur le debugger de qualité et enlever toutes ces fenetres qui ne servent qu'à ceux qui maitrisent le langage
Il existe ce type de logiciel il me semple, que je surveille d'un oeil depuis des années, car FRED lui donne toute sa confiance donc c'est pour moi un gage de qualité et fiabilité (D'ailleurs il utilise dans PB plusieurs de ces éléments) c'est PellesC
Il ressemble en IDE à PB, il peut être portable et me parait abordable pour un débutant.
Mais j'ai appris que chaque code C n'était pas forcément compatible avec les autres, et je me suis toujours demandé si coder en PellesC ne fermait pas les portes de compilateur reconnus mondialement et utilisés par les cadors du C comme GCC ou autres mastodontes de l'open source.....

Pour la POO, c'est attirant mais tu as raison, à chaque fois qu'on en parle sur les forums PB, et crois moi on en parle tout le temps et qu'on voit des dizaines de maitres créer des dizaines aussi de pseudos POO, mais jamais un projet qui dirait ayait....voici le code d'une POO et ben ça commence vraiment à me donner de moins en moins envie de regarder

C'est vraiment dommage, car si tous les cerveaux de PB s'étaient réunis pour participer à un projet commun de création d'une vraie POO, comme l'ont fait les tronches du monde pour LINUX et autre open sources, et ben je suis sûr qu'ils y serait arrivés
Au lieu de ça, comme la ruée vers l'or, tout le monde se lance dans son coin, repart de zéro à chaque fois, perds son temps à créer une xieme pseudo POO, avec des centaines de lignes, on a au minimum 20 exemples qui une fois réunis, en alliant la puissance des neurones de ces maitres et surtout le temps qu'ils y ont passés sortirait quelque chose de finit.
Et devant ce genre de projet, je suis sûr que FRED ferait l'effort de créer les quelques fonctions qui bloquent en PB pour aider à finir le projet, regarde il a déjà créé les interfaces en disant lui même qu'il aurait pas vraiment du, car c'est un début d'ouverture de PB à la POO
Ce serait une association gagnant/gagnant, regarde il y a quelques années jamais il aurait voulu entendre parler d'argent et de participation à la création de nouvelles fonctions, il est revenu sur sa décision, et c'est intelligent, le monde a changé et les us et coutumes aussi.
Prochainement, peut être que pour "quelques dollars de plus" on pourra avoir une fonction qui nous tient à coeur, créée et surveillée par la PB TEAM

Le problème de PB, on l'a dit bien souvent, c'est qu'il est pas assez utilisé par les pros, et que les passionnés n'ont pas assez de patience pour tenir un projet plusieurs années sans lâcher l'affaire comme l'on fait tous les open sources avec le C
La définition de la passion, c'est l'amour, la fougue, l'impatience, la rapidité...et ce ne sont pas des qualités adéquates, de mon point de vue, à de grands projets communautaires

En tout cas encore merci mon bon GRom que j'aime, de m'avoir expliqué tout ça à ton boulet de KCC

[G-Rom]

comme par exemple la création d'un jeu avec Unity 3D ou Godot Engine qui sont purement orienté objet, je trouve vraiment regrettable que Pb n'offre pas cette possibilité.

Pour parlé jeu, je maitrise aussi très bien Godot Engine, ca n'a absolument rien a voir avec PB , godot est précompilé, et le langage est un script , d'ou "la puissance" par rapport à PB, il y a aussi le support du c#... mais ca reste toujours différent de PB, PB fait mieux les applications que Godot, PB fait mieux les application qu'unity.
Et puis la mode dans les jeux, c'est pas l'objet, mais l'ecs. ( entity component system ) , là PB, encore une fois réponds au critère, pas besoin de poo pour faire un jeu.
A toi de faire tes code en PB , tes propres base, comme en C , comme en C++ , et puis ensuite codé avec tes propres outils.

https://www.supinfo.com/articles/single ... t-system-c

C'est dommage, que presque personne n'est pensé à simplifier l'environnement C comme FRED l'a fait pour PB

http://www.raylib.com
Tu télécharges, il est livré avec notepad++, un compilateur, tu compiles en lancant le script de compilation fourni (F6) , pas plus simple... pas d'usine a gaz, un environement de dev pret sous windows !

Au lieu de ça, comme la ruée vers l'or, tout le monde se lance dans son coin, repart de zéro à chaque fois, perds son temps à créer une xieme pseudo POO,

Quand je fait du PB, j'ai pas envie de faire de la poo.

J'aurais tant rêvé être neurocapable d'un tel exploit, apres plus de 10 ans avec le simple PB

Boarf... faut juste se sortir les doigts du cul, et si cela t'intéresse et uniquement SI, tu apprends, regarde, j'aime pas le cobol, j'y connais donc rien... c'est aussi simple. Savoir sortir de sa zone de confort, être curieux, etc...

@++

[Marc56]

Il existe ce type de logiciel il me semple, que je surveille d'un oeil depuis des années, car FRED lui donne toute sa confiance donc c'est pour moi un gage de qualité et fiabilité (D'ailleurs il utilise dans PB plusieurs de ces éléments) c'est PellesC

Oui, mais, Pelles C ne fait pas de C++, uniquement du C, donc pas de POO.

Le C et le C++ ne sont pas difficiles à maitriser étant donné qu'à la base, il n'y a pas grand chose comme "vocabulaire". Peu de libs (et c'est voulu, pour rester léger et multi-plateforme).
Rien pour le graphisme, le son, la compression etc. Il faut aller chercher à droite et à gauche et assembler avec plus ou moins de bonheur des libs souvent obsolètes à la fin du téléchargement.
Alternative: les usines à gaz (code::blocks etc)

L'interface graphique en C ou C++ se programme à grand coup d'API (mais tu adores ça ) Pour ceux qui adorent les pointeurs, adresses (pas moi), le C c'est le pied. Les chaines de caractères sont par exemple des tableaux de caractères, ce qui rend la manipulation de chaine facile.

Pelles C (comme les autres compilateurs avec IDE) sait faire des applications consoles, donc oui, printf "hello world\n"; et F5 et ça va vite.

Il peut faire grâce à ses assistants toute la base d'un programme Windows, donc tu peux étudier comment ça marche.

Il n'est pas multiplateforme.

Si tu veux véritablement commencer en C il faut commencer par lire le K&R (Kernighan and Ritchie: Le Langage C) dont on trouve un exemplaire qui prend la poussière depuis 30 ans dans tout service informatique qui se respecte.
C'est le seul livre info qui se lit comme un roman (y compris la préface), même sans avoir de PC à côté. Même s'il n'est plus "à jour" (des dernières normes) il aide à la compréhension du pourquoi et comment le C a été créé.
Une fois terminé, tu attaques, le C++ par son auteur Bjarne Stroustrup, là ça devient plus ardu. Mais tu peut faire du C++ sans utiliser la forme la plus "tordue" du C++
Contrairement à ce qu'on pense, le but du C(++) était/est de rester simple.

[microdevweb]

KCC,

Voici les gros concepts de la POO (concepts qui mon été enseigné à l'école et qui ne viennent donc pas de moi)

En POO on attache plus d'importance au données (variables) qu'aux fonctions.
On dois pouvoir modifier une classe sans que cela n' influence le programme qui les utilise et sans modifier autre chose que la classe.

Une classe doit être facile à maintenir et doit être évolutive.

En Poo quelque soit le langage, on ne développe pas directement mais on passe par une analyse Uml (qui est en lui même un langage)

• Encapsulation
  Cela consiste à rendre les variables (membres ou attributs en Poo) inaccessible depuis une autre classe.
  Pour accéder à ces membres on implémente des Getters / Setters. Cela permet de pouvoir effectué des testes ou modifications interne sans être obligé de modifier du code qui appel la dite classe.
• Héritage
  Une classe peut hérité d'une autre classe elle hérite ainsi de tous ses attributs et méthodes.
• Polymorphisme
  Une classe mère et ses filles peuvent avoir des méthodes similaire mais qui effectuent des taches différente. Le compilateur sera en mesure de trouver la bonne méthode.

Voici pour illustrer le concept un petit soft à faire avec une analyse procédural et une analyse Poo.

Énoncé:

Un logiciel qui peut créer une feuille de dessin qui pourra contenir, des cercles, des rectangles ainsi que des carrés à différente positions et leur propres attributs.

En procédurale:

On aura une structure pour le dessin,le cercle et le rectangle sachant que le carré est une rectangle.

La structure dessin aura 1 liste pour les cercles un liste pour les rectangles.

La structure cercle aura les positions X,Y ainsi que le rayon.
La structure rectangle aura les positions X,Y ainsi que la largeur et hauteur.

On implémentera des fonctions pour créer le dessin ajouter des cercles, carré et rectangle ainsi que pour dessiner le rectangle et le cercle.

Il faudra également trouvé une astuce pour respecter l'ordre des ajout étant donné que l'on fait appel à 2 listes différentes.

Si l'on faire évoluer le programme il faudra ajouté une structure pour la nouvelle forme et ajouté les fonction adéquates

En POO:

On va partir du principe que les dessin est constitué de formes géométrique.

On créera un classe (Dessin) qui aura pour membres une liste de formes (géométrique)
Ainsi que les méthodes :
Dessiner
Ajouter_Forme

Un classe Forme, cette classe sera abstraite (on ne pourra pas l'instancier) elle servira juste de moule pour les autres classes.

Elle aura pour membres les positions X et Y. (ainsi que les getters et setters)
Et une méthode (abstraite: ce qui implique que seul le prototype de fonction sera renseigné le contenu sera spécifique à chaque classe fille ) Dessiner

Une classe Cercle qui hérite de Forme

Elle aura pour membre Rayon
Et pour méthode Dessiner (cette fois ci avec le corps de méthode)

Une classe Rectangle qui hérite de Forme

Elle aura pour membres les tailles largeur et hauteur
Et pour méthode Dessiner (cette fois ci avec le corps de méthode)

Une classe Carre qui hérite de Rectangle

Elle n' aura pas de membre.
Et pour méthode Dessiner (cette fois ci avec le corps de méthode)

Pour ajouté une possibilité d'autre forme à notre programme il suffira de créer une nouvelle classe de la forme qui hérite de Forme ou d'une classes qui hérite Forme.

Grasse au Polymorphisme la méthode Dessiner de Dessin appellera la méthode Dessiner de chaque classe appropriée sans que l'on ne se soucie de rien de plus.


On comprend tout de suite dans cette exemple qu'un concept objet est plus facile à tenir à jour et qu'il est plus facilement évolutif.


Donc le développement Poo est un concept et est indépendant du langage, il est applicable à Pb, mais difficile car non inclus à Pb.

Quant au autre langage cela n'est pas plus difficile que le procédurale mais demande une certaine réflexion.

De très bon ide permettent de mâcher la tache (avec implémentation automatique) des getters / setters méthodes abstraite etc...

Concernant Pb (et je sais que cela n'arrivera jamais) mais imaginons qu'il deviendrais objet. Un fenêtre aurais donc des Gadgets (abstrait) et pourrais faire nos propre gadget par simple héritage (se serais coll non )

[Ollivier]

Contrairement à ce qu'on pense, le but du C(++) était/est de rester simple.

Et il est simple sur le plan syntaxique. Les inclusions quand on veut être multi-plateforme, c'est, par contre, une autre paire de manches. Il y a de la recherche à faire pour chaque fonction. Ça se trouve de mieux en mieux, mais ça reste une sacrée affaire.

[microdevweb]

Extrait de mon court sur l'historique du c.

C a trois ancêtres:

CPL : (pour Combined Programming Language) a été conçu
au début des années 1960 - universités de Cambridge
et de Londres. Fortement typé mais trop complexe
disparition dans les années 70

BCPL : (pour Basic CPL) Cambridge en 1966 par Martin
Richards. Version simplifiée. Ecriture d’un 1er
Compilateur et de divers systèmes d’exploitations
B : Ken Thompson vers 1970 dans les laboratoires Bell
Version simplifiée du BCPL

C fut développé par un collègue de Ken Thompson, Dennis
Ritchie qui ajouta les tableaux, les pointeurs, les nombres
à virgule flottante, les structures...

1972 fut l'année de développement la plus productive et
sans doute l'année de baptême de C.

En 1973, C fut suffisamment au point pour que 90% de
UNIX puisse être récrit avec.

Une 1ère définition du langage est apparue en 1978 avec
l’ouvrage de Ritchie etKernighan:

« The C Programming Language ».

Son succès international a contribué à sa normalisation:

1. ANSI (American National Standard Institute)
2. ISO (International StandadizationOrganisation)
3. CEN (Comité Européen de Normalisation) en 1993

Le langage C est un langage de bas niveaux, dans le sens où il
permet la manipulation de données que manipulent les
ordinateurs (Bit, octet, adresse) contrairement à des langages plus
évolués(Pascal, Fortran,ADA)

Il est suffisamment général pour permettre de développer des
application de type scientifique ou de gestion basée sur l’accès aux
bases de données(Word et Excel sont écrits à partir de C ou C++)

Il est un des 1ers langages offrant des possibilités de
programmation modulaire:
Un programme peut être constitué de plusieurs module
(module = fichier.c)

Un langage de programmation a pour finalité de communiquer
avec la machine. Le langage maternel de la machine n'utilise
que deux symboles(0 et 1): c'est le langage machine.

La difficulté du C réside principalement dans l'obligation de passé par des pointeurs pour passé des paramètres aux fonctions.

Les chaines de caractère sont traitée sous forme de tableaux.

Le C++ permet quant à lui le passage de paramètres par référence ce qui est plus simple et étant orienté objet possèdes une classe String pour la manipulation des chaines de caractère.

Ou cela se complique vraiment autant en c que en c++ c'est l'utilisation d'une ui (user interface) de type fenêtrée.

Si vous voulez faire de l'objet d'autres sont nettement plus simple Java, C#, Python font partie maintenant du trio des langages les plus utilisé.

[G-Rom]

Énoncé:

Un logiciel qui peut créer une feuille de dessin qui pourra contenir, des cercles, des rectangles ainsi que des carrés à différente positions et leur propres attributs.

En procédurale:

On aura une structure pour le dessin,le cercle et le rectangle sachant que le carré est une rectangle.

La structure dessin aura 1 liste pour les cercles un liste pour les rectangles.

La structure cercle aura les positions X,Y ainsi que le rayon.
La structure rectangle aura les positions X,Y ainsi que la largeur et hauteur.

On implémentera des fonctions pour créer le dessin ajouter des cercles, carré et rectangle ainsi que pour dessiner le rectangle et le cercle.

Il faudra également trouvé une astuce pour respecter l'ordre des ajout étant donné que l'on fait appel à 2 listes différentes.

Si l'on faire évoluer le programme il faudra ajouté une structure pour la nouvelle forme et ajouté les fonction adéquates

Non ! ca démontre que tu ne connais pas bien ton sujet, tu peu très bien appliqué une structure Forme de base
puis des sous structure étendue à Forme. pas besoin de deux listes ou je ne sais quoi...

En PB, et sans syntaxe pseudo "POO", tu peut faire EXACTEMENT la même chose.
une structure de Base, qui contient le minimum , dans ton exemple x,y & un prototype dessiner() propre à chaque forme.
je te laisse étudier l'exemple que j'ai fait pour toi :

Code : Tout sélectionner

Prototype dessiner(*forme)

Structure Forme
  x.f
  y.f
  dessiner.dessiner
EndStructure

Procedure DessinerForme(*forme.Forme)
  *forme\dessiner(*forme)  
EndProcedure


; ////////////////////////////////////////////////////////////////////////
; CERCLE
; ////////////////////////////////////////////////////////////////////////
Structure Cercle Extends Forme
  rayon.f
EndStructure

Procedure dessiner_cercle(*c.Cercle)
  Circle(*c\x,*c\y,*c\rayon,0)  
EndProcedure

Procedure Cercle(x.f,y.f,rayon.f)
  *f.Cercle = AllocateStructure(Cercle)
  *f\dessiner = @dessiner_cercle()
  *f\x = x
  *f\y = y
  *f\rayon = rayon
  ProcedureReturn *f
EndProcedure

; ////////////////////////////////////////////////////////////////////////
; RECTANGLE
; ////////////////////////////////////////////////////////////////////////
Structure Rectangle Extends Forme
  w.f
  h.f
EndStructure

Procedure dessiner_rectangle(*r.Rectangle)
  Box(*r\x,*r\y,*r\w,*r\h,0)
EndProcedure

Procedure Rectangle(x.f,y.f,w.f, h.f)
  *r.Rectangle = AllocateStructure(Rectangle)
  *r\dessiner = @dessiner_rectangle()
  *r\x = x
  *r\y = y
  *r\w = w
  *r\h = h
  ProcedureReturn *r
EndProcedure



; ////////////////////////////////////////////////////////////////////////
; TEST
; ////////////////////////////////////////////////////////////////////////
OpenWindow(0,0,0,800,600,"")

Cercle = Cercle(256,256,100)
Rectangle = Rectangle(400,200,200,300)


; on peu même les stocker dans une liste, peu importe si c'est un rectangle ou un cercle !
NewList *Geometrie.Forme()

AddElement(*Geometrie())
*Geometrie() = Cercle

AddElement(*Geometrie())
*Geometrie() = Rectangle

While 1
  Repeat
    event = WindowEvent()
    If event = #PB_Event_CloseWindow
      End
    EndIf
  Until event = 0
  
  
  StartDrawing(WindowOutput(0))
  
  ;DessinerForme(Cercle)
  ;DessinerForme(Rectangle)
  
  ForEach *Geometrie()
    DessinerForme(*Geometrie())  
  Next
  
  
  StopDrawing()
  
Wend

[microdevweb]

Merci pour l'exemple G-rom qui est très intéressant et à étudié en lieu et place des interface,

Mais tu à pensé en objet, la plupart d'entre nous n'aurais pas réaliser cela comme cela (du moins je le pense).

On peut programmé en procédural avec un concept objet et certaines limites. Mais on ne m'enlèvera pas l'idée que si pb passait en poo il deviendrais une véritable bombe.