PureBasic

Dans mon projet de RAD, j'ai le souhait d'être vraiment orienté objet. Donc voici une petit exemple teste qui va faire je pense mon bonheur. Bon çà ne gère pas l'héritage mais c'est un bon début

Code : Tout sélectionner

; ************************************************************************************************************************
; AUTHOR    : MicrodevWeb
; PROJECT   : Pb POO
; REQUIERED : PB 5.60
; ************************************************************************************************************************
DeclareModule RECT
  ;=======================================================================================================================
  ;-* PUBLIC INTERFACE
  ; ----------------------------------------------------------------------------------------------------------------------
  Interface _RECT
    Draw()
    Free()
  EndInterface
  ;}----------------------------------------------------------------------------------------------------------------------
  ;=======================================================================================================================
  ;-* PUBLIC PROTOTYPE
  ; ----------------------------------------------------------------------------------------------------------------------
  Declare New(idCanvas,x,y,w,h,color)
  ;}----------------------------------------------------------------------------------------------------------------------
EndDeclareModule
Module RECT
  EnableExplicit
  ;=======================================================================================================================
  ;-* PRIVATE STRUCTURES
  ; ----------------------------------------------------------------------------------------------------------------------
  Structure sRec
    *VPRO
    idCanvas.l
    x.l
    y.l
    w.l
    h.l
    color.l
  EndStructure
  ;}----------------------------------------------------------------------------------------------------------------------
  ;=======================================================================================================================
  ;=======================================================================================================================
  ;-* PRIVATE FUNCTION
  ; ----------------------------------------------------------------------------------------------------------------------
  Procedure Draw(*this.sRec) 
    With *this
      StartVectorDrawing(CanvasVectorOutput(\idCanvas))
      VectorSourceColor(\color)
      AddPathBox(\x,\y,\w,\h)
      FillPath()
      StopVectorDrawing()
    EndWith
  EndProcedure
  Procedure Free(*this.sRec) 
    ClearStructure(*this,sRec)
  EndProcedure
  ;}----------------------------------------------------------------------------------------------------------------------
  ;=======================================================================================================================
  ;-* PUBLIC FUNCTION 
  ; ----------------------------------------------------------------------------------------------------------------------
  Procedure New(idCanvas,x,y,w,h,color)
    Protected *Rec.sRec
    *Rec=AllocateMemory(SizeOf(sRec))
    With *Rec
      \idCanvas=idCanvas
      \x=x
      \y=y
      \w=w
      \h=h
      \color=color
      \VPRO=?VPRO
    EndWith
    ProcedureReturn *Rec
  EndProcedure
  ;}----------------------------------------------------------------------------------------------------------------------
  ;=======================================================================================================================
  ;-* DATA SECTION 
  ; ----------------------------------------------------------------------------------------------------------------------
  
  ;}----------------------------------------------------------------------------------------------------------------------
  DataSection 
    VPRO:
    Data.i @Draw() 
    Data.i @Free() 
  EndDataSection
EndModule
Procedure OpenMainForm()
  Protected.RECT::_RECT rec1,rec2,rec3,rec4
  Protected TimeDelay=400
  OpenWindow(0,0,0,800,600,"Teste POO",#PB_Window_SystemMenu|#PB_Window_ScreenCentered)
  CanvasGadget(0,0,0,800,600)
  rec1=RECT::New(0,0,0,60,60,$FF2FFFAD)
  rec2=RECT::New(0,70,0,60,60,$FF0000FF)
  rec3=RECT::New(0,140,0,60,60,$FFFF0000)
  rec4=RECT::New(0,0,70,60,60,$FFFF00FF)
  rec1\Draw()
  Delay(TimeDelay)
  rec2\Draw()
  Delay(TimeDelay)
  rec3\Draw()
  Delay(TimeDelay)
  rec4\Draw()
  rec1\Free()
  rec2\Free()
  rec3\Free()
  rec4\Free()
EndProcedure

OpenMainForm()

Repeat
  WaitWindowEvent()
Until Event()=#PB_Event_CloseWindow

Et aussi un tutoriel pas à pas sur ce lien http://www.purebasic.fr/french/viewtopi ... 21&t=15656

Toujours trés intéressant le coté POO, et il y a des possibilités à exploiter

Par contre toujours ce GROS bémol du "\" pour l'appel d'une "méthode" au lieu du "." ! Ca me pique les yeux

A mon avis il faudrait modifier cette syntaxe, comme pour l'accés au structures en fait.... j'aime pas vraiement le \ qui demande DEUX touches à taper au lieu d'une pour le point... Deux touches ! Vous vous rendrez compte? Deux fois plus de tavail !

tu peux aussi utiliser le "."
puis a la fin du code faire un "chercher remplacer par" "."--->"\"

En fait la poo, c'est le top, la poo c'est simple, la poo ca lave meme la crasse qui est dans le noeud du "tochon"...

Je sais pas si c'est si simple, mais ça fait la xieme version de poo que des copains offrent généreusement

, on les compte même plus, et à chaque fois il manque un truc.
Comme une voiture sans roue, une poubelle sans poignée, une femmr sans sous vêtements...enfin bref...des tonnes de ligne de code et jamais un truc qui fait comme java, c++, etc...

Moi j'y comprends rien à cette poo, et je ne l'aime pas, mais je me dit, que primo c'est pas si simple que ça, puisque x projets incomplets (ca me rapelle les vd) hantent nos forums, et secundo ça doit être faisable en pb, car la poo est née du c, et pb c'est comme du c, donc qu'est ce qui fait que il manque toujours un truc pour être comme la vraie et rajouter un pbi, et pouvoir enfin programmer en poo ou procédural dans le même code comme en c++ ?

Microdevweb nous dit qu'il manque juste l'héritage....bon qu'a celà ne tienne, ...ya qu'a tuer le grand père et on aura enfin le "jus de fruit" d'un pbi complet

@Kwai chang caine,

La POO n'est pas si complexe si on ne rentre pas trop dans les détailles, par contre c'est génial pour faire des codes réutilisables.

Je modifie mon RAD dans ce sens et le posterais bientôt. Maintenant Pb reste un langage procédural et ses possibilités en POO sont limitées, mais pour ce que je veux faire c'est je pense suffisant.

Je n'y connait rien en POO... mais à ce que j'ai pu lire ici, ça ressemble tout de même beaucoup à du procédural.

Si on remplace les "Class" par des structures le résultat est tout de même très ressemblant non ?
Ensuite je lis que vous parlez d'héritage. Selon votre façon de coder en PB je ne vois pas en quoi l'héritage entre données/gadgets ne peut pas se faire non plus.
Bref cette POO me perturbe

D'une certaine manière on en a déjà de la POO dans PB:

SetGadget..., GetGadget... = Méthodes
...Item..., ...Attribut... = Propriétés

Merci de ta réponse MicroDevWeb

Je comprends que tu n'ai pas le temps de nous éclairer sur le sujet, mais tu as gratté là ou ça fait mal

En fait je suis comme ARS, enfin ...sauf son respect bien sûr

Je me suis fait exactement la même réflexion, c'est plus ou moins des structures
Bon on y a appelé CLASS, mais on aurait pu y appeler "Récréation", ou comme PB appeler ça des modules....

Cette POO, elle est comme la chaude pisse, ça gratte mortel noir de membres, tout le monde en parle, puis on dit que PB y peut pas (Ca c'est le médicament) et hop plus rien
Et ça revient quelques mois après...ça regratouille "quinjquin" qui remet 100 balles dans le nourrin

On lit noir de codes de ouf, avec des pointeurs et des hiéroglyphes à faire pâlir la meilleure équipe égyptienne de jeu de boules

On se dit, ayait..on va enfin pouvoir essayer...et ça fait pschiiiiiit comme dirait notre ex "super menteur"

Est ce "quinquin" qui a tout bien lu Freud en POO, pourrait nous faire un dessin, une image, un tracé d'urine dans le sable, enfin n'importe quoi qui pourrait nous faire comprendre ce que PB ne pourra jamais faire en POO ??
Et comme je l'ai dit plus haut, vu que PB peut presque tout faire ce que fait le C, qu'est ce qui est dans le presque et qui empeche de faire un PBI, comme l'a fait SROD pour son COMATE et qui permet de faire du "crosoft like" avec PB...et pourtant c'était pas gagné au départ.

C'est dingue sur le US, y'a noir de défenseur de la POO, et pas des lapins trois semaines en prog, et ils sont pas capable de faire ce que CROSOFT a fait en transformant le C en C++
Tous les codes qu'on trouve sur le US, si "quinquin" les réunissait, il arriverait pas à ce que ce soit complet ???

C'est vrai...pour ceux qui entravent quedal à ce monde....on aimerait bien savoir pourquoi on aura jamais de dessert avec PB

même si ce dessert là on le mangerait pas

Ce n'est pas MS qui a inventé le C++ c'est Bjarne Stroustrup

La programmation objet n'est intéressante que pour de (très) grands programmes, ce qui n'est pas la cible des utilisations de PB (le plus souvent)

@Marc56

Marc56 a écrit : La programmation objet n'est intéressante que pour de (très) grands programmes, ce qui n'est pas la cible des utilisations de PB (le plus souvent)

J'avoue ne pas être de ton avis, mais il est vrai que cela ne doit pas être imposé par le langage comme par exemple Java

Ar-S a écrit : Si on remplace les "Classes" par des structures le résultat est tout de même très ressemblant non ?

a ce que j'ai compris les Classes c'est plutot comme nos Modules (un ensemble de Procedures )
et les Procedures sont appelées des "Methodes"

donc les "Classes" sont des ensemble de "Methodes"

comme nos modules (ou Librairies) sont des ensemble de Procedures

pour ce qui concerne "l’héritage" , alors là .... si deja ils utilisaient les Termes "normaux" c'est a dire les nôtres, ceux du procédural

alors peut être qu'on arriverai a capter un truc ....

je suis sur qu'on a l’équivalent de tout ça en procédural .... le concept d'Objets
c'est en fait une forme de nos Modules , réutilisable a souhait en ne changeant que les paramètres !!

enfin ... a ce que j'ai compris hein ....

Marc56 a écrit :D'une certaine manière on en a déjà de la POO dans PB:

SetGadget..., GetGadget... = Méthodes

...Item..., ...Attribut... = Propriétés

en fait .... presque ..
il faudrai qu'il y ai une information supplémentaire du genre :

Gadget.SetGadget() , histoire de préciser dans la syntaxe qu'on pique la fonction (la methode) "SetGadget()" dans la Classe "Gadget"

et un Window.OpenWindow() pour dire qu'on prend la Methode "OpenWindow()" dans la Classe "Window"

c'est simplement en la syntaxe que ça rappel les Structures , mais les Structures ne sont que des Variables !!
alors qu'une Classe fait appel a des Methodes (des Procedures ) donc c'est beaucoup plus puissant

tout comme une structure ne peut pas etre comparé a une librairie de fonctions Purebasic ...

j'espere ne pas avoir dit trop de bétises

La Poo, c'est contre intuitif si on sait déja programmer.

En Assembleur, il n'existe que le code spaghetti.
Pour optimiser nos programmes, il faut avoir une bonne intuition de ce que notre code donne en assembleur.
En Poo, il est trop compliqué de se représenter le code assembleur généré.(bonjour la course après plusieurs niveaux de pointeurs)

Certes le concept de programmation en poo est plus intuitif pour quelqu'un qui ne sait pas ce qu'est l'assembleur. Ca parait plus propre: "je met dans un objet des données, d'autres objets et des choses a exécuter, tout ce qui concerne cet objet".
Mais ça revient vite à résoudre des problèmes existentiels quand le code se complexifie.
En plus, généralement tu n'as qu'une prise très limité sur la gestion de la mémoire, notamment la destruction d'objets et la ré allocation de la place disponible.

Bref, je n'aime pas et je ne maîtrise pas non plus la matière plus que ça... Vive Purebasic !

Perso, j'ai eu beaucoup de mal aussi ! Et puis il y a quelques années, je me suis mis à Java, j'avais un très bon éditeur (non pas eclipse mais visual cafe), et j'ai pu tester rapidement et facilement mes programmes, ce qui est essentiel pour moi. Ca n'a pas été facile, mais franchement, il y a quand même beaucoup d'avantages, surtout pour de gros projets.

Cependant, je trouve que c'est encore très perfectible.

Ainsi, je verrais bien un super PB qui gérerait d'une façon très souple et inédite les objets. Ce qui plait dans PB, c'est le côté bas niveau, la rapidité de test, la grande visibilité de l'ensemble. Dans la plupart des programmes pro, il faut une grande organisation, une hiérarchie, rédiger une documentation au fur et à mesure, de façon à tous s'y retrouver. On peut facilement "casser" un projet en modifiant un fichier.

J'imagine un programme "Super PB" comme un fichier hypertexte, avec des liens entre objets, une facilité d'édition ou d'édition des paramètres. Pour le polymorphisme, à titre d'exemple, en passant ou en cliquant sur une variable, avec une simple liste de tous les types de variables existants à l'instant "t", on pourrait facilement voir et créer les méthodes manquantes.

Le tout objet par contre, pour moi, c'est une horreur. Bientôt, chaque octet sera considéré comme un objet, alors qu'il faut que cela reste une donnée "atomique".

Enfin, je pense que la gestion temporelle du code devient nécessaire dans la programmation. Les programmeurs le font depuis toujours, mais les compilateurs ne raisonnent pas assez dans ce sens et sont vites perdus par les programmes difficiles à suivre. En gros, cela signifie qu'à chaque modification de ligne, le compilateur compile/exécute le programme jusque là, afin de savoir où il en est en réalité. L'éditeur "suit" toute modification et toute inclusion de trucs sensibles (objets, pointeurs, chaînes...) afin de prévenir l'utilisateur des changements de version, de noms pour l'héritage, etc. Evidemment, ça fait penser à un compilateur "une ligne", mais pourquoi pas...

Enfin, voilà, quelques idées au hasard.

edit: modifié eclipse pour visual cafe

Et puis il y a quelques années, je me suis mis à Java, j'avais un très bon éditeur (eclipse)

Sauf que ces bourrins de GOOGLE y ont terminé leur association avec Eclipse et son plugin ADT
Comme toi, j'ai commencé avec lui pour faire mes 3 petites daubes, puis quand j'ai lu que eclipse était destitué de la couronne GOOGLE royale depuis qu'ils avaient créé leur AndroidStudio basé sur Intelij, j'ai essayé de compiler mes codes avec AS, pour être pour une fois "dans le vent"

En fait ça marche pas du premier coups, faut encore modifier des trucs

Puis, avant hier, je suis retourné sur Eclipse, car vraiment AS il me gonflait avec son "gras double" (Graddle) de merde

Un truc qui n’arrête pas de faire des updates (alors je t'explique pas derriere le proxy

) , qui met des plombes à compiler.
En plus pas moyen de le rendre vraiment portable...donc back in time, et en fin de compte, je trouve vraiment plus simple d’utiliser Eclipse

Plus je fais du JAVA, plus je le hais, et encore si un codeur JAVA regardais mes codes, il me demanderais comment j'ai fait pour faire du procedural avec JAVA

PureBasic

POO avec PB

POO avec PB

Re: POO avec PB

Re: POO avec PB

Re: POO avec PB

Re: POO avec PB

Re: POO avec PB

Re: POO avec PB

Re: POO avec PB

Re: POO avec PB

Re: POO avec PB

Re: POO avec PB

Re: POO avec PB

Re: POO avec PB

Re: POO avec PB

Re: POO avec PB