Code : Tout sélectionner
;{-------------------------------------------
; AUTHOR : microdev
; DATE : 2020-03-01
; CLASS : MY_CLASS
; VERSION :
; PROCESS :
;}-------------------------------------------
DeclareModule MY_CLASS
Interface obj
getName.s()
setName(name.s)
EndInterface
Structure _members
*methods
name.s
EndStructure
Declare _super(*this._members,*s_daughter,*E_daughter)
Macro super()
MY_CLASS::_super(*this,?S_MET,?E_MET)
EndMacro
; Declare new(; Place your parameters here) for sigleton no constructor
Global instance.obj
EndDeclareModule
Module MY_CLASS
; super constructor
Procedure _super(*this._members,*s_daughter,*E_daughter)
With *this
; allocate memory
Protected motherLen = ?E_MET - ?S_MET,
daughterLen = *E_daughter - *s_daughter
\methods = AllocateMemory(motherLen + daughterLen)
; empilate methods address
MoveMemory(?S_MET,\methods,motherLen)
MoveMemory(*s_daughter,\methods + motherLen,daughterLen)
EndWith
EndProcedure
;{-------------------------------------------
; CONSTRUCTOR : new
; PARAMETER :
;}-------------------------------------------
Procedure new()
Protected *this._members = AllocateStructure(_members)
With *this
\methods = ?S_MET ; remove it if class extends of other class
;place your code here
ProcedureReturn *this
EndWith
EndProcedure
Procedure.s getName(*this._members)
With *this
ProcedureReturn \name
EndWith
EndProcedure
Procedure setName(*this._members,name.s)
With *this
\name = name
EndWith
EndProcedure
; create unique instance
instance = new()
DataSection
S_MET:
Data.i @getName()
Data.i @setName()
E_MET:
EndDataSection
EndModule
; test singleton
MY_CLASS::instance\setName("Pierre")
Debug MY_CLASS::instance\getName()
Si je m'étais posé que celle laGRom a écrit : pour ceux qui ce pose la question , mais qu'est ce donc un "singleton"
plus ça me fait peur 
Mais en PB, comme ce n'est pas oo friendly, une simple variable globale fait l'affaire...par ex :
Log::GetInstance().write("mon message");
Code : Tout sélectionner
Prototype Write(message.s)
Structure Logger
Write.Write
console.b
EndStructure
Global _LOGGER_.Logger
Procedure Write(message.s)
Debug message
If _LOGGER_\console = #True
PrintN(message)
EndIf
EndProcedure
_LOGGER_\Write = @Write()
Macro GetLoggerInstance():_LOGGER_:EndMacro
; Utilisation :
GetLoggerInstance()\Write("Hello KCC")Parce qu'à chaque fois que tu appelle une classe ça créé quelque chose en mémoire qui reste ?Maitre GimsRom a écrit :un singleton est pratique dans d'autres langage pour n'avoir qu'une seule copie en mémoire de l'objet
je savais pas non plus Ca me fait penser à l'OLE en VB6, le Createobject() et le GetObject()Maitre Maitre GimsRom a écrit : un simple appel à "Log::GetInstance()" et hop, tu as accès à l'objet
Code : Tout sélectionner
Prototype Write(message.s)
Structure Logger
Write.Write
console.b
EndStructure
Global _LOGGER_.Logger
Procedure Write(message.s)
Debug message
If _LOGGER_\console = #True
PrintN(message)
EndIf
EndProcedure
_LOGGER_\Write = @Write()
Macro GetLoggerInstance():_LOGGER_:EndMacro
; Utilisation :
GetLoggerInstance()\Write("Hello KCC")Je suis pas sûr que le but ai été de s'approcher de la POO, car FRED a toujours été plus que clair sur ce sujet et il a jamais lâché l'affaireMaitre GRom a écrit : c'est comme les Modules , j'ai plus l'impression qu'ils ont été créer pour faire plaisir à ceux qui voudrais faire du pseudo objet en PB,
) mais que j'ai en mémoire, disant à propos des interfaces, que c'était le début d'un moyen de s'approcher de la POO, que c'était pas le but recherché et qu'il regrettait presque de les avoir créé 
Cette parole m'avait surpris, et comme dab, me demande rien à ce sujet car j'avais rien compris 
Non, c'est exactement comme en procedural , en c++ il y a une chié de librairie opensource , quand des utilisateurs utilise une source quelconque , le créateur de la source peut s'assuré parfoisParce qu'à chaque fois que tu appelle une classe ça créé quelque chose en mémoire qui reste ?
Du tout , j'ai codé pas mal de petit outils en PB/c++ , j'ai toujours eu ce genre d'approche, j'ai même pu mettre un programme à jour plus de 10 ans après l'avoir programmer sans galérer à cherché qui fait quoi.Quand je vois ce code puissant, cela confirme que la POO n'est là que pour les gros projets ou avec de multiples développeurs
A ça... on est bien d'accordFRED il est super gentil, mais c'est un rottweiller de la prog...quand il a une idée en tête .....
Cela s'appelle faire des wrappers ou binding , cela se fait partout ou il y a besoin de faire des "jonctions" entre les langages.En tout cas moi ,c'est pas la POO que j'attends, mais le génie qui permettra de pouvoir utiliser les DLL POO dans PB aussi facilement que les procedurales...
Car là, pour PB, y'a du potentiel, imagine toutes ces supers librairies de oufs qui font papa maman et que l'on ne peut pas utiliser dans notre PB d'amour, sans passer par un langage POO
Code : Tout sélectionner
/* Class.hpp */
#ifndef CLASS_HPP
#define CLASS_HPP
#define API_EXPORT __declspec( dllexport )
class API_EXPORT Kcc{
public:
Kcc();
~Kcc();
void Message(int nb);
};
#endif
/* Class.cpp */
#include <iostream>
#include "Class.hpp"
Kcc::Kcc(){
std::cout << "Kcc est construit !" << std::endl;
}
Kcc::~Kcc(){
std::cout << "Kcc est détruit" << std::endl;
}
void Kcc::Message(int nb){
for(int i=0; i<nb; ++nb){
std::cout << "Hello Kcc !" << std::endl;
}
}Donc, c'est largement exploitable par PB , il faudra tout de même un wrapper pour éviter les problèmes de "name mangling" et obtenir un pointeur sur les objets , pb ne supporte pas les passage par référence, et les _ZN3... etc... , c'est pas des trucs au hasard : https://en.wikipedia.org/wiki/Name_mangling
- ; _ZN3Kcc7MessageEi <- methode
; _ZN3KccC1Ev <- constructeur
; _ZN3KccC2Ev <- "" de copie
; _ZN3KccD1Ev <- destructeur
; _ZN3KccD2Ev <- destructeur
L'utilité ? faire une surcouche reviens quasiment à refaire une partie d'un compilateur , quand tu en est là , autant ne pas convertir ta surcouche en asm comme le fait PB , mais dans un pseudo asm portable ( llvm ir par ex )qu'est ce qui empêche un génie de créer une bonne fois pour toute une surcouche POO à PB
Code : Tout sélectionner
Structure person
name.s
age.l
EndStructure
Global NewList myPerson.person()
Procedure addPerson(name.s,age)
AddElement(myPerson())
With myPerson()
\age = age
\name = name
EndWith
EndProcedure
Procedure displayPerson()
With myPerson()
ForEach myPerson()
Debug \name
Next
EndWith
EndProcedure
addPerson("Pierre",54)
addPerson("julien",24)
addPerson("fred",36)
displayPerson()
Code : Tout sélectionner
DeclareModule person
Global NewList myPerson()
Declare addPerson(name.s,age)
Declare.s getName(*this)
Declare setName(*this,name.s)
EndDeclareModule
Module person
Structure _person
name.s
age.l
EndStructure
Procedure addPerson(name.s,age)
*this._person = AllocateStructure(_person)
AddElement(myPerson())
myPerson() = *this
With *this
\age = age
\name = name
EndWith
EndProcedure
Procedure.s getName(*this._person)
With *this
ProcedureReturn UCase(Left(\name,1))+Mid(\name,2,Len(\name)-1)
EndWith
EndProcedure
Procedure setName(*this._person,name.s)
With *this
\name = name
EndWith
EndProcedure
EndModule
Procedure displayPerson()
ForEach person::myPerson()
Debug person::getName(person::myPerson())
Next
EndProcedure
person::addPerson("Pierre",54)
person::addPerson("julien",24)
person::addPerson("fred",36)
displayPerson()
Code : Tout sélectionner
DeclareModule person
Interface object ; les méthodes public
getName.s()
setName(name.s)
EndInterface
Global NewList myPerson.object()
Declare addPerson(name.s,age) ; le constructeur
EndDeclareModule
Module person
Structure _person
*methods ; on va stocker ici les adresses de méthodes (gèrer par interface)
name.s
age.l
EndStructure
Procedure addPerson(name.s,age)
*this._person = AllocateStructure(_person)
AddElement(myPerson())
myPerson() = *this
With *this
\methods = ?LABEL
\age = age
\name = name
EndWith
EndProcedure
Procedure.s getName(*this._person)
With *this
ProcedureReturn UCase(Left(\name,1))+Mid(\name,2,Len(\name)-1)
EndWith
EndProcedure
Procedure setName(*this._person,name.s)
With *this
\name = name
EndWith
EndProcedure
DataSection
LABEL: ; on passe ici les adresse dans le même ordre que l'interface
Data.i @getName()
Data.i @setName()
EndDataSection
EndModule
Procedure displayPerson()
ForEach person::myPerson()
Debug person::myPerson()\getName()
Next
EndProcedure
person::addPerson("Pierre",54)
person::addPerson("julien",24)
person::addPerson("fred",36)
displayPerson()
Grom a écrit :je t'assure, je pas très compliqué, si tu as du fric et de la bouffe , enferme moi chez toi pendant 15j , je fait de toi un dieu de la prog
Aaaahh d'accord !!!!Grom a écrit :le créateur de la source peut s'assuré parfois en mettant à disposition un objet quelconque sous forme de singleton
Mouaaaaihh !!! en un mot y'a de l'espoir....c'est déjà ça....mais ça sera pas pour demain que quelqu'un se lancera dans cette aventure, et encore si c'est possible de faire un wrapper qui fonctionne avec toutes les DLL C++Donc, c'est largement exploitable par PB , il faudra tout de même un wrapper pour éviter les problèmes de "name mangling" et obtenir un pointeur sur les objets , pb ne supporte pas les passage par référence, et les _ZN3... etc... , c'est pas des trucs au hasard : https://en.wikipedia.org/wiki/Name_mangling
Passé un temps FRED en avait parlé de ce fameux LLVM...et ça a fait pschiiiit comme aurait dit jackoGrom a écrit :dans un pseudo asm portable ( llvm ir par ex )
Aaaiiie !!!!Grom a écrit :tu aurais accès a plus de processeurs , ARM entre autre...
Tu as malheureusement raisonGrom a écrit :Le travail est titanesque , chronophage , qui seront les utilisateurs ? ceux d'aujourd'hui ? je ne pense pas qu'il y aura beaucoup de client... le pépère de 50 ans ou plus qui code avec PB n'a pas envie de ce faire chier à apprendre des concepts abstrait en poo pour faire la même chose en procédural qu'il maîtrise.
en tout cas mille mercis de toutes tes explications...je pourrais te lire des heures..... mais pas tes codes .... y'a tellement de pointeurs que même un fakir souffrirait ) du troufignard, je suis même pas arrivé à récupérer une string dans tous ce fatras de classes et en plus de format différents de variable du C 
Ah ben voilà... Des années de négociation à tenter de négocier une cave chez KCC, et paf... Niqué par la concurrence en moins de deux minutes...G-Rom a écrit :je t'assure, je pas très compliqué, si tu as du fric et de la bouffe , enferme moi chez toi pendant 15j , je fait de toi un dieu de la prog
un wrapper générique n'existe pas, tu fait un wrapper des methodes que tu veut importer :et encore si c'est possible de faire un wrapper qui fonctionne avec toutes les DLL C++
Code : Tout sélectionner
class MaClasseCplusplus{
public:
float add(float A, float B){
return A+B;
}
float sub(float A, float B){
return A-B;
}
};Code : Tout sélectionner
MaClasseCplusplus Test;
float resultat = Test.add(4,5);Code : Tout sélectionner
EXPORT MaClasseCplusplus* CreateMaClasse(){
return new MaClasseCplusplus();
}
EXPORT void FreeCreateMaClasse(MaClasseCplusplus* Objet){
delete Objet;
}
EXPORT float Add(MaClasseCplusplus* Objet, float x, float y){
return Objet->add(x,y);
}
EXPORT float Sub(MaClasseCplusplus* Objet, float x, float y){
return Objet->Sub(x,y);
}C'est du taf , après il faut aussi prendre en considération le fait que PB n'apporte rien économiquement, donc le gain n'en vaut surement pas la peine. Après , pour sortir un peu du sujet ,Passé un temps FRED en avait parlé de ce fameux LLVM...
Ca ne me fait pas peurparce que de la bouffe...j'en ai