POO to PB

[Anonyme]

Voici un petit utilitaire fort pratique pour convertir du pseudo c++ ( classes) en code exploitable purebasic.

par exemple , voici un code en pseudo c++

Code : Tout sélectionner

class PERSONNAGE
{
SetName(Name$)
GetName.s()
Name$
}


PERSONNAGE::SetName(Name$)
{
*This\Name$ = Name$
}

PERSONNAGE::GetName.s()
{
ProcedureReturn *This\Name$
}

Les classes se font quasiment comme en c++
il n'y a pas de surchage de fonctions ou autre , mais c'est quand même moins long de faire du pseudo c++ que cela :

(code générer via l'utilitaire)

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 
; ---------------------------------------------------------------- 

Et voici comment on l'utilise :

Code : Tout sélectionner

IncludeFile "Personnage.pbc_Out.pbi"

New_PERSONNAGE(A)
A\SetName("Fred")

Debug A\GetName()

je dis pseudo code c++ , car ce n'est pas du c++, mais du c++ mélangé à du PureBasic se qui donne du pb++
j'ai fournis 2 exemple pour le moment.


Linux :
File:1->oop-pb.tar.gz


Ouvrez une console, allez dans le répertoire ou se trouve oop-pb
puis :

$ ./oop-pb MonFichier.pbc

il va générer MonFichier.pbc_Out.pbi si il n'y a pas d'erreurs.
je continue à améilliorer l'utilitaire , et si vous trouvez des bugs , faite passé l'info

Windows:
pas encore...

[nico]

Tu auras des problèmes à utiliser allocatememory au lieu d'une Newlist car tes allocations de chaines ne seront pas libérées. C'est un sujet discuter sur le forum anglais sur le Post de la macro New Delete que j'ai posté.

[Anonyme]

Ha... et malloc_() ? peut il ressoudre le problème ?


edit : je viens de trouvé le bug, dans le code générer , il n'y a pas d'allocation de chaine de caractère.

[minirop]

Tu auras des problèmes à utiliser allocatememory au lieu d'une Newlist car tes allocations de chaines ne seront pas libérées.

c'est marqué dans la doc que ce qui est alloué par allocatememory est automatiquement désalloué à la fin du prog

[djes]

Je n'avais pas vu ce code, qui est super intéressant. Ça demande une sacrée gymnastique intellectuelle (d'ailleurs faudrait mieux le commenter, si t'arrêtes de coder quelques temps tu vas t'en mordre les doigts!), et c'est une bonne démo des possibilités "cachées" de pure. Le problème des strings est résolu sur le forum anglais par une petite astuce de Fred.

[Anonyme]

Vu le flop , j'ai du virer les sources, ou elles traînent quelque part sur un de mes vieux DD...
c'est pas compliqué à faire , je pourrais même faire un convertisseur c/pb à la rigueur , mais bon , j'ai d'autres projets
la poo est vraiment un manque dans pb...

[Backup]

la poo est vraiment un manque dans pb...

ben j'y comprends rien, et franchement je vois pas ce que cela apporte de plus par rapport au procédurale ..
(aie ! pas si fort !)

[Ouaf-Ouaf]

J'etais resté sur l'impression que c'etait exactement la même chose.

En tout cas je trouve que ça à l'air plus élégant

[Anonyme]

j'vais pas te faire un cour sur la poo , mais je peut te garantir que cela change énormément.
j'vais te prendre l'exemple d'un moteur 3D


voici la classe Entity ( similaire à une structure sous pb à une chose près )

Code : Tout sélectionner

class Entity

position
rotation
scale

virtual FonctionDeRendu()

FonctionSetPosition()
FonctionSetRotation()
FonctionSetScale()

FonctionGetPosition()
FonctionGetRotation()
FonctionGetScale()


endclass

tu codes toute les méthodes ( fonction ) pour bouger les entité comme dans les exemples si dessus FonctionGet.. & FonctionSet...
elles serviront à positionner les objet dans l'espace 3D

La fonction de rendu est Virtuelle ( la force de la poo ) c'est une fonction vide , tu vas comprendre pourquoi , elle ne sera jamais appeler directement....


Ensuite , une fois cette classe basique écrite completement , tu n'y retouchera plus jamais , sauf un oubli majeur...

Dans un moteur 3D , tu as des cameras , des meshs , des lumière , des pivot , tout cela c'est des entitées...

prenons la classe mesh

Code : Tout sélectionner

class mesh : public entity
{

*ListeDesVertices
*ListeDesFaces
VariableDiverse
etc...

virtual FonctionDeRendu()

} 

Dans cette classe , tu peut observé quelle est associer à la classe entité
la classe mesh n'utilise pas de fonction pour gerer la position la rotation etc...
le seul point commun c'est la fonction de rendu , qui elle , contient la routine pour rendre un mesh.


Voila un exemple basique d'utilisation


*MyMesh = new Mesh

*MyMesh\FonctionSetPosition(10,50,20) <- Appelle la methode de la classe entity
*MyMesh\FonctionDeRendu() <-- Appelle la méthode de la classe mesh


pareil pour une camera , un pivot , etc...


*MyCamera = new Camera

*MyCamera\FonctionSetPosition(10,50,-20)
*MyCamera\FonctionDeRendu()



Voila en gros ce que permet la poo , chose faisable en pb , mais avec pas mal de manip de pointeur, et pas mal d'erreur du coup... on s'y perd vite

[Backup]

un system de structures évolués en quelques sortes..

[Gratteur]

un system de structures évolués en quelques sortes..

Pardon, on parle de la POO la. Un objet n'est pas une structure évolué, héritage et généricité, classe virtuelle, constructeur et destructeur, transmission de valeur par référence,...

Avec une classe tu peux manipuler des tonnes d'objets dérivés sans changer une ligne de code!

[djes]

un system de structures évolués en quelques sortes..

Pardon, on parle de la POO la. Un objet n'est pas une structure évolué, héritage et généricité, classe virtuelle, constructeur et destructeur, transmission de valeur par référence,...

Avec une classe tu peux manipuler des tonnes d'objets dérivés sans changer une ligne de code!

Avec une structure aussi

[Gratteur]

Ouais c'est ça et en assembleur aussi...

[Anonyme]

un system de structures évolués en quelques sortes..

Pardon, on parle de la POO la. Un objet n'est pas une structure évolué, héritage et généricité, classe virtuelle, constructeur et destructeur, transmission de valeur par référence,...

Avec une classe tu peux manipuler des tonnes d'objets dérivés sans changer une ligne de code!

Ouais c'est ça et en assembleur aussi...

Excuse moi , mais pas besoin de ramener "sa science" ni d'envoyer "chier" Djes.
Si t'es un malin , essaye d'expliquer clairement ce qu'est la POO à quelqu'un qui ne connais pas et n'en vois pas l'utilité.

[Gratteur]

Je n'essaye pas de ramener ma science, je voulais juste dire que la POO peut être vu comme un niveau d'abstraction supplémentaire permettant donc de produire un code généralement plus compliqué à créer (en tout cas pour le c++ puisque l'on peut vraiment garder le contrôle sur ce que fait le compilateur contrairement au java plus simpliste) mais plus beaucoup facile à maintenir et tellement plus parlant pour l'utilisateur.

En fait un langage objet est un sérieux atout pour tout gros projet ou travail en équipe car il permet de diviser le code en classes réutilisables.

---

Pour prendre un exemple simple, tu peux créer une classe "véhicule" générique comprenant toutes les fonctions communes aux voitures et des fonctions virtuelles pouvant être redéfinies. Cette classe n'est pas utilisable telle quelle mais tu peux ensuite l'étendre à des classes "voiture", "camion", "scooter", etc... Toutes ces nouvelles classes héritant des propriétés communes à la classe "véhicule" et redéfinissant les fonctions qui lui sont propres.

L'intérêt d'avoir fait tout cela est multiple. Déja, tu peux stocker tous les véhicules différents dans une même liste alors qu'il ne s'agit pas du même objet (ce qui permet de manipuler des objets différents très facilement juste en appelant leurs fonctions de même nom). Mais tu peux aussi manipuler ton objet à n'importe quel niveau dont il a hérité.

Tu peux aussi utiliser les objets un peu comme des structures bien sur, mais qui s'instancient, se recopient et se manipules (les opérateurs se redéfinissent en C++, il faut passer par des méthodes en java) toutes seules une fois codées!

Et d'autres concepts plus compliquées que je ne vais pas aborder ici...

Un langage objet avec un compilateur strict permet aussi de produire du code beaucoup plus propre et lisible à tous niveau (sans avoir à se retaper la lecture des sous-classes à chaque fois).

---

Enfin bref, je ne suis pas prof mais le message que je voulais faire passer est que le langage objet permet une manipulation beaucoup plus poussée car permet se libérer des contraintes des structures rigides. Finalement c'est un peu comme passer de l'assembleur au PureBasic pour pouvoir programmer à un autre niveau sans (vraiment) se soucier de comment sont programmées les fonctions ou classes que l'on utilises, juste en connaissant leur utilité.