PureBasic

Une des raisons pour lesquels je n'aime pas la POO bien que je sois contraint de l'utiliser en JavaScript ou Php par exemple, c'est que je ne suis pas dans la tete de celui qui a conçu une classe.

Définir une variable avec une constante clavier est simple avec PureBasic !

Code : Tout sélectionner

leftKey = #PB_Key_A ou leftKey = 30

si j'utilise le framework Kiwi.js en JavaScript je vais devoir faire :

Code : Tout sélectionner

this.leftKey = this.game.input.keyboard.addKey( Kiwi.Input.Keycodes.A );

Je pense qu'il est inutile de faire un commentaire supplémentaire pour une chose si simple.

Pfff !!!! mais jusqu'à ou s'arreteront ils ????

Jamais je ne pourrais me faire à ce genre de trucs, comment osent ils utiliser ne serait ce que la premiere lettre du mot "Simple" pour qualifier cette daube

Il y a deux éléments qui caractérisent la POO:

1. Un programme réalisé en POO est plus lent à l'exécution qu'un programme procédural.
2. La POO pour être efficace demande un très gros travail préparatoire.

Des constatations perso:
- À la compilation, c'est pénible, il faut bien plusieurs secondes pour un messagebox "hello world" en .net

- Installation: .NET plusieurs Go, Lazarus 750 Mo, ... PureBasic 75 Mo et rien à ajouter

- Langages POO pure jus, ex: Python: très beau, mais horriblement pénible à écrire et plein de modules tiers... mais dont certains (et même de plus en plus) sont abandonnés.

Non, je suis de l'avis de Fred, PB est très bien comme cela

mouais,
mais on est obligé de faire du .net si on veut programmer pour AutoCAD ou Autre CAD, c'est LE passage obligé...
il serait intéressant d'avoir nativement dans PureBasic des fonctions de discussion avec les objets COM, ActiveX....
parce que j'avoue qu'après les premiers émois passé sur C#, c'est très chiant. et c'est pas parce que l'on a effleurer le langage, que l'on peut faire une applli pour AutoCAD ou autres, faut encore se retaper le framework de l'appli... grrrrrrrrrrr

Pat

Moi ce qui m'étonne, c'est que aucun cerveau amoureux du procédural ai tenté de faire de la résistance.....des wrappers, ou bien des convertisseurs, une librairie que tu lui ecrirait en procedural et elle pourrait convertir ça en POO

Apparement pour ce qui est de taper de la POO et la convertir en procedural, car sur le forum US ils en ont parlé, et "quinquin" (je sais plus qui

) a dit que ce serait possible, beaucoup de travail, mais possible.

Et le fan de POO a répondu que le probleme resterait le debugger qui lui, remonterait l'erreur dans le code procedural, et non pas dans le code POO
Un peu comme si, FRED avait fait un debugger qui comme dans le C parfois, te donne l'erreur au milieu des "pouches" et des "mouves (the bus)" , on serait bien avancé avec ça

J'en parlais avec ma chef encore ce matin, qu'est ce que je donnerais pour être un cerveau informatique, un FRED, SROD, NETMAESTRO, SPARKIE etc..il suffit qu'ils aient envie pour au moins savoir si c'est possible et quelle route prendre..

aprés reste le temps...notre pire ennemis

mais quand t'es devant un probleme comme une poule devant une fourchette, t'as beau avoir du temps..ça fait pas avancer le schmilblick

Moi la seule envie qui me vient quand je réfléchis à fond à tout ça et en faisant des efforts surhumains pour comprendre, et poussant fort ce qui me sert de neurones, c'est d'aller aux toilettes

Alors y'aura t'il un jour un nouveau "robin des bits" qui prendra aux connaissances riches pour distribuer aux pauvres

après la POO, créons le KCC

zut il existe déja !

Bonjour à tous,

ce n'est pourtant pas sorcier

Code : Tout sélectionner

;{ MODULE Classe

CompilerIf Defined(Classe, #PB_Module) = #False
  
  DeclareModule Classe
    
    Structure InfoClasse
      *tableVirtuelle
      NomClasse.s
      *ClasseParent.InfoClasse      
      Compteur_Fonction.i      
      Instance_Objet.i
    EndStructure
    
    Global InfoClasse.InfoClasse   
    
    ; Fonction
    Interface Fonction
      Liberer()
      ObtenirInfoClasse.i()
    EndInterface
    
    ; Structure gestion données
    Structure Struct_Donnees
      *tableVirtuelle
      *Classe.InfoClasse
    EndStructure   
    
    ; Déclaration créateur ((une macro pour convenance)
    Macro Init(_obj_)
      _obj_ = AllocateMemory(SizeOf(Struct_Donnees))
      InitializeStructure(_obj_, Struct_Donnees)      
      _obj_\tableVirtuelle = InfoClasse\tableVirtuelle
      _obj_\Classe = @InfoClasse      
      InfoClasse\Instance_Objet + 1
    EndMacro
    
    Macro Detruire(_obj_)
      FreeMemory(_obj_)
      InfoClasse\Instance_Objet - 1
    EndMacro   
    
    ; Macro pour manipulation tableVirtuelle
    Macro Fonction_Heritee_de_la_Classe(_Classe_)
      InfoClasse\tableVirtuelle = AllocateMemory(SizeOf(Fonction))
      InfoClasse\NomClasse = #PB_Compiler_Module
      InfoClasse\ClasseParent = _Classe_#@InfoClasse
      
      ; héritage
      CopyMemory(_Classe_#InfoClasse\tableVirtuelle, InfoClasse\tableVirtuelle, SizeOf(_Classe_#Fonction))
      InfoClasse\Compteur_Fonction = SizeOf(_Classe_#Fonction) / SizeOf(Integer)
    EndMacro
    
    Macro Fonction_Surcharge(_Fonction_)
      PokeI(InfoClasse\tableVirtuelle + OffsetOf(Fonction\_Fonction_), @_Fonction_)
    EndMacro
    
    Macro Ajouter_Fonction(_Fonction_)
      PokeI(InfoClasse\tableVirtuelle + InfoClasse\Compteur_Fonction * SizeOf(Integer), @_Fonction_)
      InfoClasse\Compteur_Fonction + 1
    EndMacro   
    
  EndDeclareModule
  
  Module Classe
    InfoClasse\tableVirtuelle = AllocateMemory(SizeOf(Fonction))
    InfoClasse\NomClasse = #PB_Compiler_Module   
    
    ; Commodité
    Procedure.i Obtenir_Classe_Info(*obj.Struct_Donnees)
      ProcedureReturn *obj\Classe
    EndProcedure
    
    ; Destructeur
    Procedure Liberer(*obj.Struct_Donnees)     
      ClearStructure(*obj, Struct_Donnees)      
      Detruire(*obj)
    EndProcedure
    
    ; Fonction Ajouter dans la tableVirtuelle
    Ajouter_Fonction(Liberer())
    Ajouter_Fonction(Obtenir_Classe_Info())
  EndModule
  
CompilerEndIf
;}


;{ MODULE Nom_Classe_Ici : parent =  Nom_Classe_Parent_Ici (Modele)

CompilerIf 0 ; à supprimer
  
  DeclareModule Nom_Classe_Ici    
    Global InfoClasse.Classe::InfoClasse
    
    ; Fonction
    Interface Fonction Extends Nom_Classe_Parent_Ici::Fonction
      ; TODO : votreNouvelle_Fonction.i(param1)
    EndInterface
    
    ; Structure gestion données
    Structure Struct_Donnees Extends Nom_Classe_Parent_Ici::Struct_Donnees
      ; TODO : champ1.i
    EndStructure
    
    ; Héritage de fonctions éxistantes
    Classe::Fonction_Heritee_de_la_Classe(Nom_Classe_Parent_Ici::)    
    
    ; Déclaration créateur
    Declare.i Creer()
    
  EndDeclareModule  
  
  Module Nom_Classe_Ici    
    
    ; Constructor
    Procedure.i Creer()
      Classe::Init(*obj.Struct_Donnees)
      
      ; TODO : *obj\champ1 = ...
      
      ProcedureReturn *obj
    EndProcedure
    
    
    ; Méthodes
    
    ; TODO : Procedure.i Votre_Nouvelle_Fonction(*obj.Struct_Donnees, param1, ...)
    
    ; Destructeur
    Procedure Liberer(*obj.Struct_Donnees)
      ; TODO : ClearStructure(*obj, Struct_Donnees)      
      Classe::Detruire(*obj)
    EndProcedure
    
    ; Destructeur surcharge
    Classe::Fonction_Surcharge(Liberer())
    
    ; Fonction Ajouter dans la tableVirtuelle
    
    ; TODO : Classe::Ajouter_Fonction(Votre_Nouvelle_Fonction())
    
  EndModule
  
CompilerEndIf ; à supprimer

Exemple d'utilisation:

Code : Tout sélectionner

; EXEMPLE :

IncludeFile "MODULE_Classe.pb"


;{ MODULE Rectangle : parent = Classe

DeclareModule Rectangle
   
   Global InfoClasse.Classe::InfoClasse
   
   ; Fonction
   Interface Fonction Extends Classe::Fonction
     Longueur.d()
     Largeur.d()
     Diagonale.d()
   EndInterface
   
   ; Structure gestion des données
   Structure Struct_Donnees Extends Classe::Struct_Donnees
      longueur.i
      largeur.i
      diagonale.i      
   EndStructure
   
   ; Héritage de fonctions éxistantes
   Classe::Fonction_Heritee_de_la_Classe(Classe::)   
   
   ; Déclaration créateur
   Declare.i Creer()
   
EndDeclareModule


Module Rectangle
   
   
   ; Constructeur
   Procedure.i Creer()
      Classe::Init(*obj.Struct_Donnees)
      
      *obj\longueur = 100
      *obj\largeur = 50
      *obj\Diagonale = Sqr((*obj\longueur * *obj\longueur) + (*obj\largeur * *obj\largeur))
      
      ProcedureReturn *obj
   EndProcedure
   
   
   ; Méthodes
   Procedure Longueur(*v.Struct_Donnees)      
      
      Debug "Longueur : " + *v\longueur
    EndProcedure
    
    Procedure Largeur(*v.Struct_Donnees)
      
      Debug "Largeur : " + *v\largeur
   EndProcedure
   
   Procedure.i Diagonale(*v.Struct_Donnees)
     
      Debug "Diagonale = " + *v\Diagonale
   EndProcedure
   
   
   ; Destructeur
   Procedure Liberer(*obj.Struct_Donnees)
      
      Debug "Destructeur pour la Classe : Rectangle"
      
      ClearStructure(*obj, Struct_Donnees)
      
      Classe::Detruire(*obj)
   EndProcedure
   
   
   ; Destructeur surcharge
   Classe::Fonction_Surcharge(Liberer())
   
   ; Fonction Ajouter dans la tableVirtuelle
   Classe::Ajouter_Fonction(Longueur())
   Classe::Ajouter_Fonction(Largeur())
   Classe::Ajouter_Fonction(Diagonale())
   
EndModule

;MODULE Carre:parent = Rectangle

DeclareModule Carre
  Global InfoClasse.Classe::InfoClasse
  
  ;Fonction
  Interface Fonction Extends Rectangle::Fonction
    Cote.d()
   EndInterface
   
   ; Structure gestion des données
   Structure Struct_Donnees Extends Rectangle::Struct_Donnees
     Cote.i      
   EndStructure
   
   ; Héritage de fonctions éxistantes
   classe::Fonction_Heritee_de_la_Classe(Rectangle::)   
   
   ; Déclaration créateur
   Declare.i Creer()
   
 EndDeclareModule
 
 Module Carre
   
   ;Constructeur
   Procedure Creer()
     Classe::Init(*Obj.Struct_Donnees)
     
     *obj\Cote = 50
     *Obj\diagonale = *Obj\Cote * Sqr(2)
     
     ProcedureReturn *Obj
   EndProcedure
   
   ; Méthodes
   Procedure Cote(*v.Struct_Donnees)      
      
      Debug "Côté : " + *v\Cote
    EndProcedure
   
   
   ; Destructeur
   Procedure Liberer(*obj.Struct_Donnees)
      
      Debug "Destructeur pour la Classe : Cote"
      
      ClearStructure(*obj, Struct_Donnees)
      
      Classe::Detruire(*obj)
   EndProcedure
   
   
   ; Destructeur surcharge
   Classe::Fonction_Surcharge(Liberer())
   
   ; Fonction Ajouter dans la tableVirtuelle
   Classe::Ajouter_Fonction(Cote())
 EndModule  
;{ MODULE Rectangle : parent = Classe

DeclareModule TriangleRectangle
   
   Global InfoClasse.Classe::InfoClasse
   
   ; Fonction
   Interface Fonction Extends Rectangle::Fonction
     CoteA.d()
     CoteB.d()
     Hypothenuse.d()
   EndInterface
   
   ; Structure gestion des données
   Structure Struct_Donnees Extends Rectangle::Struct_Donnees
      CoteA.i
      CoteB.i
      Hypothenuse.i      
   EndStructure
   
   ; Héritage de fonctions éxistantes
   Classe::Fonction_Heritee_de_la_Classe(Rectangle::)   
   
   ; Déclaration créateur
   Declare.i Creer()
   
EndDeclareModule


Module TriangleRectangle
   
   
   ; Constructeur
   Procedure.i Creer()
      Classe::Init(*obj.Struct_Donnees)
      
      *obj\CoteA = 120
      *obj\CoteB = 60
      *obj\Hypothenuse = Sqr((*obj\CoteA * *obj\CoteA) + (*obj\CoteB * *obj\CoteB))
      
      ProcedureReturn *obj
   EndProcedure
   
   
   ; Méthodes
   Procedure CoteA(*v.Struct_Donnees)      
      
      Debug "Côté A : " + *v\CoteA
    EndProcedure
    
    Procedure CoteB(*v.Struct_Donnees)
      
      Debug "Côté B : " + *v\CoteB
   EndProcedure
   
   Procedure.i Hypothenuse(*v.Struct_Donnees)
     
      Debug "Hypothénuse = " + *v\Hypothenuse
   EndProcedure
   
   
   ; Destructeur
   Procedure Liberer(*obj.Struct_Donnees)
      
      Debug "Destructeur pour la Classe : TriangleRectangle"
      
      ClearStructure(*obj, Struct_Donnees)
      
      Classe::Detruire(*obj)
   EndProcedure
   
   
   ; Destructeur surcharge
   Classe::Fonction_Surcharge(Liberer())
   
   ; Fonction Ajouter dans la tableVirtuelle
   Classe::Ajouter_Fonction(CoteA())
   Classe::Ajouter_Fonction(CoteB())
   Classe::Ajouter_Fonction(Hypothenuse())
   
EndModule
;}




Debug "Classe Rectangle"
Debug ""
*Rectangle.Rectangle::Fonction = Rectangle::Creer()

*Rectangle\Longueur()
*Rectangle\Largeur()
*Rectangle\Diagonale()
Debug ""
Debug "Classe Carre"
Debug ""
*Carre.Carre::Fonction = Carre::Creer()

*Carre\Cote()
*Carre\Diagonale()
Debug ""
Debug "Classe TriangleRectangle"
Debug ""
*TriangleRectangle.TriangleRectangle::Fonction = TriangleRectangle::Creer()

*TriangleRectangle\CoteA()
*TriangleRectangle\CoteB()
*TriangleRectangle\Hypothenuse()
Debug ""
Debug "info générale : "
Debug ""
Debug "Classe : " + Rectangle::InfoClasse\NomClasse
Debug "Nb instance : " + Rectangle::InfoClasse\Instance_Objet
Debug "Classe Parent : " + Rectangle::InfoClasse\ClasseParent\NomClasse
Debug ""
Debug "Classe : " + Carre::InfoClasse\NomClasse
Debug "Nb instance : " + Carre::InfoClasse\Instance_Objet
Debug "Classe Parent : " + Carre::InfoClasse\ClasseParent\NomClasse
Debug ""
Debug "Classe : " + TriangleRectangle::InfoClasse\NomClasse
Debug "Nb instance : " + TriangleRectangle::InfoClasse\Instance_Objet
Debug "Classe Parent : " + TriangleRectangle::InfoClasse\ClasseParent\NomClasse
Debug ""

Autre exemple:

Code : Tout sélectionner

IncludeFile "MODULE_Classe.pb"


;{ MODULE Voiture : parent = Classe

DeclareModule Voiture
   
   Global InfoClasse.Classe::InfoClasse
   
   ; Fonction
   Interface Fonction Extends Classe::Fonction
      Avance(Vitesse.d)
      ObtenirPuissance.i()
   EndInterface
   
   ; Structure gestion des données
   Structure Struct_Donnees Extends Classe::Struct_Donnees
      Puissance.i
      Couleur.i
      
      x.i
   EndStructure
   
   ; Héritage de fonctions éxistantes
   Classe::Fonction_Heritee_de_la_Classe(Classe::)
   
   
   ; Déclaration créateur
   Declare.i Creer()
   
EndDeclareModule


Module Voiture
   
   
   ; Constructeur
   Procedure.i Creer()
      Classe::Init(*obj.Struct_Donnees)
      
      *obj\x = 50
      *obj\Puissance = 1000
      
      ProcedureReturn *obj
   EndProcedure
   
   
   ; Méthodes
   Procedure Avance(*v.Struct_Donnees, v.d)
      
      *v\x + v
      
      
      Debug "Avance : " + *v\x
   EndProcedure
   
   Procedure.i Obtenir_Puissance(*v.Struct_Donnees)
      ProcedureReturn *v\Puissance
   EndProcedure
   
   
   ; Destructeur
   Procedure Liberer(*obj.Struct_Donnees)
      
      Debug "Destructeur pour la Classe : Voiture"
      
      ClearStructure(*obj, Struct_Donnees)
      
      Classe::Detruire(*obj)
   EndProcedure
   
   
   ; Destructeur surcharge
   Classe::Fonction_Surcharge(Liberer())
   
   ; Fonction Ajouter dans la tableVirtuelle
   Classe::Ajouter_Fonction(Avance())
   Classe::Ajouter_Fonction(Obtenir_Puissance())
   
EndModule

;}


;{ MODULE Peugeot : parent = Voiture

DeclareModule Peugeot
   
   Global InfoClasse.Classe::InfoClasse
   
   ; Fonction
   Interface Fonction Extends Voiture::Fonction
      ObtenirNom.s()
   EndInterface
   
   ; Structure gestion des données
   Structure Struct_Donnees Extends Voiture::Struct_Donnees
      Nom.s
   EndStructure
   
   ; Héritage de fonctions éxistantes
   Classe::Fonction_Heritee_de_la_Classe(Voiture::)
   
   
   ; Déclaration créateur
   Declare.i Creer()
   
EndDeclareModule


Module Peugeot
   
   
   ; Constructeur
   Procedure.i Creer()
      Classe::Init(*obj.Struct_Donnees)
      
      *obj\x = 50
      *obj\Puissance = 2000
      
      *obj\Nom = "Ma belle peugeot"
      
      ProcedureReturn *obj
   EndProcedure
   
   
   ; Méthodes
   Procedure.s Obtenir_Nom(*v.Struct_Donnees)
      ProcedureReturn *v\Nom
   EndProcedure
   
   
   ; Destructeur
   Procedure Liberer(*obj.Struct_Donnees)
      
      Debug "Destructeur pour la Classe : Peugeot"
      
      ClearStructure(*obj, Struct_Donnees)
      
      Classe::Detruire(*obj)
EndProcedure
   
   
   ; Destructeur surcharge
   Classe::Fonction_Surcharge(Liberer())
   
   ; Fonction Ajouter dans la tableVirtuelle
   Classe::Ajouter_Fonction(Obtenir_Nom())
   
EndModule

;}




Debug "Classe voiture"
Debug " "

*Voiture.Voiture::Fonction = Voiture::Creer()

*Voiture\Avance(1)


Debug "*Voiture\ObtenirPuissance() = " + *Voiture\ObtenirPuissance()


Debug " "
Debug "Classe Peugeot"
Debug " "

*ma_voiture.Peugeot::Fonction = Peugeot::Creer()

*ma_voiture\Avance(10)
Debug "*ma_voiture\ObtenirPuissance() = " + *ma_voiture\ObtenirPuissance()

Debug *ma_voiture\ObtenirNom()

Debug ""
Debug "info générale : "

Debug ""

Debug "Classe : " + Voiture::InfoClasse\NomClasse
Debug "Nb instance : " + Voiture::InfoClasse\Instance_Objet
Debug "Classe Parent : " + Voiture::InfoClasse\ClasseParent\NomClasse

Debug ""

Debug "Classe : " + Peugeot::InfoClasse\NomClasse
Debug "Nb instance : " + Peugeot::InfoClasse\Instance_Objet
Debug "Classe Parent : " + Peugeot::InfoClasse\ClasseParent\NomClasse


Debug ""
Debug "info sur '*ma_voiture' : "

Debug ""

*Classe_info.Classe::InfoClasse = *ma_voiture\ObtenirInfoClasse()

Debug "Classe : " + *Classe_info\NomClasse
Debug "Nb instance : " + *Classe_info\Instance_Objet
Debug "Classe Parent : " + *Classe_info\ClasseParent\NomClasse

à propos des objets, en fouillant sur le net, je suis tombé sur ce post de Flype
http://forums.purebasic.fr/french/viewt ... &view=next

Flype a écrit : concernant la question pointeur/id il est vrai que çà fait souvent débat.

à mon avis,
les pointeurs meme s'ils permettent un accès direct, donc plus rapide
ne sont pas pour autant dans l'esprit basic.

les identifiants, eux, le sont !

la grande majorité des fonctions purebasic sont avec des Id dont le fameux #PB_Any. c'est bien pratique, et çà émule entre guillemets des objets.

le SDK purebasic propose justement un fichier ObjectManager.lib spécialement dédié à la programmation des Id pour être le proche de l'esprit purebasic.
Code : Tout sélectionner
Import #PB_Compiler_Home + "Compilers/ObjectManager.lib"
  PB_Object_GetOrAllocateID (Objects, Object.l)
  PB_Object_GetObject       (Objects, Object.l)
  PB_Object_IsObject        (Objects, Object.l)
  PB_Object_EnumerateAll    (Objects, ObjectEnumerateAllCallback, *VoidData)
  PB_Object_EnumerateStart  (Objects)
  PB_Object_EnumerateNext   (Objects, *object.Long)
  PB_Object_EnumerateAbort  (Objects)
  PB_Object_FreeID          (Objects, Object.l)
  PB_Object_Init            (StructureSize.l, IncrementStep.l, ObjectFreeFunction)
  PB_Object_GetThreadMemory (MemoryID.l)
  PB_Object_InitThreadMemory(Size.l, InitFunction, EndFunction)
EndImport 
à noter que la meme API est dispo aussi en C si tu as besoin.

donc on pourrais "traduire" / "convertir" les appels aux objet C en PureBasic ?

Pat

Merci MICOUTE, je ne te savais pas si calé en POO

Spock a écrit :en POO ils utilisent des bout de codes tout fait sans se preoccuper de comment le resultat est obtenu

En fait ce qui me rend fou, c'est que on peut bien souvent faire une analogie entre ce que fait la POO et le procedural.
Quand on utilise COMATE par exemple, on a aucune idée de ce qu'a fait SROD en PB en traduisant Dishelper venant du C.
On appelle simplement une fonction, mais quand on regarde son code ce sont des procedures de procedures, elles s'appellent toute entre elles à vitesse grand V, comme un tas de fourmis trouvant un bout de calandos...
Quand on appelle une DLL on en sait pas mieux..et pourtant ça marche aussi bien

Autre chose, une classe s'etend à partir d'une autre, ouaaaaihhh super on a découvert l'instanciation et l'extension..ouaaaaahh !!!

Mais si on appelle une procedure qui appelle une autre, on peut tres bien recuperer le retour la sous procedure, y ajouter des parametres dans la mere mixer avec le retour de la fille et on etend bien la fille, non ???

Et je suis sur que quelqu'un de plus calé que moi pourrait recréer chaque opération soit disant exeptionnelle de la POO
Au passage c'est peut etre ce que viens de démontrer MICOUTE, mais je suis pas assez connaisseur pour savoir ce qui est différent entre son code et la vraie POO

A une epoque ou on arrive à emuler un OS complet dans un autre, à rendre tout portable, à avoir des librairies qui coutaient des milliers de francs à l'epoque et qui maintenant sont non seulement gratuite, mais open source..

Alors qu'est ce qui coince vraiment, j'arrive pas à avoir la réponse ????
On va me faire croire que on peux pas faire un pont entre deux façon de coder

tiens....temps mort... c'est pas bien de faire rire les vieux... je vais aller faire pipi

Parfois je me dis que j'aurais du parler que des interfaces sans parler de Pseudo POO. Au moins personnes n'aurait lu. Je le regrette bien.

@ falsam, il ne faut jamais regretter une action, quand elle peut projeter quelqu'un d'autre en avant, par exemple moi, quand j'avais 20 ans, il y a 45 ans, j'ai été appelé à servir la France dans les transmissions et c'est là que j'ai appris toutes les bases de la programmation orientée objet, bien sûr qu'avec mon a.v.c., j'ai perdu des pans entiers de ma mémoire, mais par chance en changeant ma façon de vivre, j'en reçois la récompense tous les jours et ma mémoire revient un peu par ici, un peu par là, j'avance précepte par précepte et je me réjouis de vivre avec ce que j'ai et pas avec ce que je pourrais avoir, donc je te dois un grand merci pour avoir parlé de Pseudo POO, car c'est vraiment de la Pseudo-POO que je fais avec PB et merci de m'avoir éclaici le chemin des interfaces.

Bien souvent je me répete à ce sujet, je l'ai souvent dit à GALLY

Mais lorsque l'on parle de quelque chose, ou que l'on créé quelque chose, on a envie bien evidemment d'en parler.
Ce qui est dur à comprendre c'est que les autres n'aient pas immédiatement ce même besoin

Comme quand on est amoureux d'une "guunzesse", et que de son côté on a du mal à croire qu'elle ne porte même pas les yeux sur soi

Mais l'avantage des forums, c'est que c'est écrit, et on sait que les paroles s'envolent.

Et bien souvent aprés, voir même bien apres, "quinquin" fait une recherche et a donc ce jour là, la même motivation que l'auteur au moment de la création.
Et comme le dit si bien MICOUTE, c'est ici que prend toute la valeur du travail effectué

Le seul probleme à gérer c'est le laps de temps qui sécoule entre la réalisation du travail et le "paiement"...à coté les 3 mois des administrations c'est du pipi de chat

Il n'en reste pas moins que même si comme dab, ce que tu as ecrit c'est trop compliqué pour moi, je suis toujours heureux de profiter de tes nombreuses connaissances et découvertes, à chaque fois que tu as la générosité de les partager, c'est à dire presque tout le temps

Ce dont je te remercie pour la Xieme fois

Donc tanpis pour la POO, ou je viens juste d'apprendre, comme l'a aussi dit MICOUTE (Il devrait faire prophete

), qu'en fin de compte PB serait tout à fait capable de la créer entierement (Ca me rassure)

Et apres les "prototrucs" (rien compris

), .............. plaaaaaaaaaaaaaace aux "intertrucs"

PureBasic

Interface & Pseudo POO (Un peu pompeux ce terme)

Re: Interface & Pseudo POO (Un peu pompeux ce terme)

Re: Interface & Pseudo POO (Un peu pompeux ce terme)

Re: Interface & Pseudo POO (Un peu pompeux ce terme)

Re: Interface & Pseudo POO (Un peu pompeux ce terme)

Re: Interface & Pseudo POO (Un peu pompeux ce terme)

Re: Interface & Pseudo POO (Un peu pompeux ce terme)

Re: Interface & Pseudo POO (Un peu pompeux ce terme)

Re: Interface & Pseudo POO (Un peu pompeux ce terme)

Re: Interface & Pseudo POO (Un peu pompeux ce terme)

Re: Interface & Pseudo POO (Un peu pompeux ce terme)

Re: Interface & Pseudo POO (Un peu pompeux ce terme)

Re: Interface & Pseudo POO (Un peu pompeux ce terme)

Re: Interface & Pseudo POO (Un peu pompeux ce terme)

Re: Interface & Pseudo POO (Un peu pompeux ce terme)