PureBasic • Mot clé "this"?

Page 1 sur 3

Mot clé "this"?

Publié : lun. 29/janv./2024 4:17

par jph

Bonjour,

Je suis en train de convertir un petit programme, que j'ai trouvé sur ce forum, de PB vers SB et j'ai presque résolu tous les problèmes. Je bute encore sur un aspect de PB que je ne connais pas. J'ai une procédure Draw() qui s'écrit Procedure Draw(*this.sRec), où sRec est une structure, et qui se lance par Draw() sans argument.

Ma question est: Est-ce que le mot "this" fait partie du language comme c'est le cas en Java? Sinon je ne comprends pas le fonctionnement de ce programme. J'ai cherché dans l'aide et je n'ai rien trouvé, c'est pourquoi je m'adresse ici.

C'est à la ligne 94. Voici le programme en PB. Je précise qu'il n'est pas de moi et que je l'ai trouvé sur ce site.

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

Je vous remercie d'avance.

Re: Mot clé "this"?

Publié : lun. 29/janv./2024 9:26

par boddhi

Bonjour,

Tu as mal interprété le code... Ce n'est pas "this" mais "*this" qu'il faut lire.
Ce n'est donc pas un mot-clé mais, pour simplifier, un pointeur qui détermine l'adresse mémoire où est stockée le contenu d'"une variable" structurée de type sRec.

Code : Tout sélectionner

a=1000

Procedure X(*this)
  Debug "Adresse mémoire *this : "+*this
  Debug "Valeur contenu adresse mémoire *this : "+PeekI(*this)
EndProcedure

Debug "Valeur variable a : "+a
Debug "Adresse mémoire variable a : "+@aa
Debug "Valeur contenu adresse mémoire variable a : "+PeekI(@a)
Debug "------"

x(@a)

Re: Mot clé "this"?

Publié : lun. 29/janv./2024 10:38

par jph

boddhi a écrit : lun. 29/janv./2024 9:26 Bonjour,

Tu as mal interprété le code... Ce n'est pas "this" mais "*this" qu'il faut lire.
Ce n'est donc pas un mot-clé mais, pour simplifier, un pointeur qui détermine l'adresse mémoire où est stockée le contenu d'"une variable" structurée de type sRec.

Ok, merci. Mais donc, le problème reste entier car, à moins que j'ai mal lu le code, la fonction Draw() est appelée sans argument alors qu'elle est définie avec un argument en entrée de type pointeur sur sRec. C'est ça que je n'arrive pas à comprendre. Et pourtant ça marche... Et c'est à ce niveau (à la ligne 94 rec1\Draw()) que ça bloque. C'est-à-dire à l'appel de la fonction Draw() depuis une structure de type sRec. Mais comme je ne comprends pas vraiment à fond cette façon de programmer, en simili POOO, je suis bloqué pour traduire ça en SpiderBasic. Mais j'aimerais y arriver car je trouve que essayer d'encapsuler les données est une bonne chose. Ça facilite le lecture et l'écriture de programmes un peu gros.

Re: Mot clé "this"?

Publié : lun. 29/janv./2024 12:15

par boddhi

jph a écrit : lun. 29/janv./2024 10:38 Mais donc, le problème reste entier

Je ne suis pas très au fait des techniques de POO sous PB et je ne voudrais pas faire d'ultracrépidarianisme mais je note que :

Code : Tout sélectionner

; Cheminement de l'interprétation du code
Procedure New(idCanvas,x,y,w,h,color)
  [...]
  With *Rec
    [...]
    \VPRO=?VPRO ; Ici cela renvoie à des valeurs stockées dans la DataSection ayant l'étiquette VPRO
  EndWith
  [...]
EndProcedure
; Ici la DataSection
DataSection 
  VPRO: ; Renvoie à des adresses-mémoire où sont stockées les procédures Draw() & Free()
  Data.i @Draw() 
  Data.i @Free() 
EndDataSection
;
Structure sRec
  *VPRO ; Sachant, qu'ici, la structure, utilisée avec le pointeur *this, contient elle-même un pointeur qui renvoie vers les adresses desdites procédures
  [...]
EndStructure

Après, le mieux est probablement de t'adresser à MicrodevWeb directement qui voudra bien peut-être te fournir de plus amples explications.

Re: Mot clé "this"?

Publié : lun. 29/janv./2024 13:30

par Demivec

jph a écrit : lun. 29/janv./2024 10:38 Ok, merci. Mais donc, le problème reste entier car, à moins que j'ai mal lu le code, la fonction Draw() est appelée sans argument alors qu'elle est définie avec un argument en entrée de type pointeur sur sRec. C'est ça que je n'arrive pas à comprendre. Et pourtant ça marche... Et c'est à ce niveau (à la ligne 94 rec1\Draw()) que ça bloque. C'est-à-dire à l'appel de la fonction Draw() depuis une structure de type sRec. Mais comme je ne comprends pas vraiment à fond cette façon de programmer, en simili POOO, je suis bloqué pour traduire ça en SpiderBasic. Mais j'aimerais y arriver car je trouve que essayer d'encapsuler les données est une bonne chose. Ça facilite le lecture et l'écriture de programmes un peu gros.

Draw() est accessible via l'interface _Rect et fait partie de cette interface. Chaque procédure de l'interface _Rect reçoit un pointeur vers la structure sRec de l'objet d'interface en tant que paramètre de l'objet qui appelle la procédure d'interface. Le paramètre draw a été nommé *this.sRec pour rappel, mais il aurait pu être nommé n'importe quoi tant qu'il s'agissait d'un pointeur vers la structure correcte (par exemple, il aurait pu être nommé *Blue.sRec).

Re: Mot clé "this"?

Publié : lun. 29/janv./2024 14:23

par jph

Demivec a écrit : lun. 29/janv./2024 13:30 Draw() est accessible via l'interface _Rect et fait partie de cette interface. Chaque procédure de l'interface _Rect reçoit un pointeur vers la structure sRec de l'objet d'interface en tant que paramètre de l'objet qui appelle la procédure d'interface. Le paramètre draw a été nommé *this.sRec pour rappel, mais il aurait pu être nommé n'importe quoi tant qu'il s'agissait d'un pointeur vers la structure correcte (par exemple, il aurait pu être nommé *Blue.sRec).

Merci, c'est exactement le genre d'infos qui me manquaient. Par contre je ne sais pas où l'on trouve ce genre de renseignement sur le language PB.

J'ai une autre question. En SpiderBasic on n'a pas toutes les options de PB mais presque. En cherchant à droite à gauche, j'ai trouvé que l'on peut imiter le fonctionnement d'une instruction comme ?LABEL qui renvoie une syntax error en SB (le ? n'existe pas pour accéder à l'adresse d'un label), en la remplaçant par une ligne de javascript inline. Ma question est: Comme ça bloque au niveau de la ligne rec1\Draw(), est-ce que je peux poster mon code modifié pour que ça fonctionne avec SB, mais ça risque d'être hors charte de ce forum.? Sinon j'essayerai sur le forum en anglais.

En tout cas merci de m'avoir appris quelque-chose.

Re: Mot clé "this"?

Publié : lun. 29/janv./2024 16:59

par jph

boddhi a écrit : lun. 29/janv./2024 12:15 Après, le mieux est probablement de t'adresser à MicrodevWeb directement qui voudra bien peut-être te fournir de plus amples explications.

Oui, bonne idée. Je vais essayer de le retrouver, mais ce n'est pas sûr qu'il connaisse SB comme il connaît PB.

Re: Mot clé "this"?

Publié : lun. 05/févr./2024 22:10

par Ollivier

Je pense que tu devrais te simplifier la chatte, l'attache : il faut se simplifier la tâche. Sinon, tu te retrouves à analyser des codes source aussi drus que poétique est mon phrasé. Un exemple simple : zappe tout ce texte, et va direct au tout dernier paragraphe de ce message.

Alors, voici une structure fourre-tout :

Code : Tout sélectionner

Structure ft
 array ex(0) ; "ex" comme EXtension(s)
EndStructure

Pour créer un fourre-tout, voici une procédure :

Code : Tout sélectionner

Procedure ftCreate()
 Protected *this.ft
 *this = AllocateMemory(Sizeof(ft) )
 InitializeStructure(*this, ft)
 ProcedureReturn *this
EndProcedure

Pour défoncer un fourre-tout, le réduire à néant une bonne fois pour toute, c'est-à-dire le supprimer, voici une autre procédure :

Code : Tout sélectionner

Procedure ftDestroy(*this.ft)
 ClearStructute(*this, ft)
 FreeMemory(*this)
EndProcedure

Et puis, si la passion nous prenait de vouloir faire usage de ce fourre-tout, entre l'étape "Création", et l'étape "Défonce", voici un exemple de procédure qui va redimensionner un fourre-tout existant :

Code : Tout sélectionner

Procedure ftRedim(*this.ft, size.i)
 With *this
  Redim \ex(size)
 EndWith
EndProcedure

Voilà. Tu as 3 procédures :
- une qui crée
- une qui détruit
- et une qui modifie.

Celle qui crée et celle qui détruit, à part l'expression ft que j'ai choisie (initiales de Fourre-Tout) et que tu dois remplacer par un nom parmi tes propres structures, il n'y a rien à ajouter ni supprimer : c'est toujours le même principe, le strict nécessaire pour créer et détruire (vulgairement) un objet (moins vulgairement, une "instance") en mémoire vive.

Pour la procédure qui modifie, c'est aussi le même principe : tu remplaces ft par un nom d'une de tes structures, et puis toute ta liberté de programmation se compose en deux manières élémentaires :

1) une liberté qualitative en insérant autant de lignes de code que tu veux entre With *this et EndWith.

2) une liberté quantitative en clonant autant de procédures que l'envie te prend à partir de la procédure ftRedim() qui est aussi rudimentaire que quasiment élémentaire.

Pour te faciliter cet aspect, on peut créer deux procédures (ou "méthodes") absolument inutiles, mais fonctionnelles :

Code : Tout sélectionner

Procedure ftSetValue(*this.ft, index, value)
 With *this
  \ex(index) = value
 EndWith
EndProcedure

Procedure ftGetValue(*this.ft, index)
 With *this
  ProcedureReturn \ex(index)
 EndWith
EndProcedure

Enfin, pour bien te situer concrètement dans cette syntaxe, voici un exemple :

Code : Tout sélectionner

Define *x.ft = ftCreate()
ftRedim(*x, 50) ; alloue (~) 50 registres
ftSetValue(*x, 50, 1111) ; stocke la valeur 1111 en 50ième position
Debug ftGetValue(*x, 50) ; affiche 1111
ftRedim(*x, 0) ; efface toute valeur

ftRedim(*x, 50) ; réalloue 50 registres
Debug ftGetValue(*x, 50) ; affiche 0 parce '1111' n'existe plus
ftDestroy(*x)

Pour l'aspect pragmatique, l'équivalent rudimentaire, c'est ça :

Code : Tout sélectionner

Dim x(50)
x(50) = 1111
Debug x(50) ; affiche 1111
Redim x(0)

Redim x(50)
Debug x(50) ; affiche 0
Redim x(0)

Alors, quel(s) avantage(s) de se défoncer le bulbe à ériger des structures, des procédures, etc... plutôt que de, juste, programmer 7 instructions directes ?

Je dirais, de haut en bas :
1- la souplesse de programmation, c'est-à-dire la facilité à modifier quelquechose (on va y venir plus bas à tout ça, et suivants) ;
2- la compréhension de sa programmation;
3- la volatilité
4- enfin, le fait que souplesse, compréhension et volatilité sont accessibles simultanément.
5- je l'exclus un peu, mais il y a le portage aussi, avec l'aspect virtualisable (pas sûr que SB suive, les connaisseurs pourront préciser si @myProcedure() est traitable.

Les défauts de cette syntaxe (pseudo POO) :
a- la vitesse
b- le rapport au temps d'exécution, complètement détruit (et donc à savoir intégrer avec une classe dite chronometry ou autre nom, rapport détruit surtout par rapport au bas niveau et temps matériels.

Alors les défauts, je les zappe. Pas besoin d'approfondir.

Les avantages, je zappe le #5. Je zappe le #4 (il suffit de comprendre que si on stocke tout en variable, on peut effectivement simultanément "tout" modifier.

Il reste les souplesse, compréhension et volatilité.

La volatilité, c'est le fait de pouvoir tout détruire et que la mémoire soit complètement gérée de manière réversible. Tant que l'on ne crée pas, ou bien que l'on a tout détruit, le programmeur est face à un système vierge (mémoire entièrement disponible, absence de conflit).

La compréhension, c'est le fait de travailler avec des procédures nommées (attention : il manque les caractères avec accent de la langue française !), plutôt que des instruction directes.

Code : Tout sélectionner

nombreAjoute(*x, 300)

plutôt que

Code : Tout sélectionner

nombre(x) + 300

C'est long, c'est suant, mais, au milieu d'une usine, c'est un confort plutôt nécessaire.

Enfin, la ...

SOUPLESSE.

On est parti, en effet, d'un fourre-tout qui est, techniquement, un simple tableau dynamique d'entiers dans une structure. Rappel :

Code : Tout sélectionner

Structure ft
 array ex(0)
EndStructure

Mais, admettons que l'on souhaite être libre de choisir le type de données : des entiers, mais aussi des chaînes et des nombres à virgule flottante en double précision. Et on va appeler ça le fts (Fourre-Tout Sophistiqué) :

Code : Tout sélectionner

Structure fts
 type.i
 array natural.i(0)
 array text.s(0)
 array real.d(0)
EndStructure

Voilà. Donc
1) on copie/colle toutes les procédures/méthodes déjà existantes;
2) on change le préfixe des noms de procédures de ft à fts. Idem pour les types, c'est-à-dire les suffixes précédés par un point. (.ft )
3) on copie/colle chaque procédure pour traiter chacun des trois types.

Et voilà... L'équivalent en déclarations, ça donnerait ça :

Code : Tout sélectionner

Declare ftsCreate()
Declare ftsRedimNatural(*this.fts, i)
Declare ftsRedimText(*this.fts, i)
Declare ftsRedimReal(*this.fts, i)
Declare.i ftsGetNatural(*this.fts, i)
Declare.s ftsGetText(*this.fts, i)
Declare.d ftsGetReal(*this.fts, i)
Declare ftsSetNatural(*this.fts, i, natural)
Declare ftsSetText(*this.fts, i, text.s)
Declare ftsSetReal(*this.fts, i, real.d)
Declare ftsDestroy(*this.fts)

Il y a un champ, le champ type.i qui n'asservit rien en l'état. Mais, on peut considérer que notre liste de méthodes ci-dessus est une première couche basse : ça lit, ça écrit et redimensionne purement, nettement et simplement.

On peut, toujours inutilement, à 1ère vue, pondre un traitement I/O pour le champ type.i.

Code : Tout sélectionner

Declare ftsSetType(*this.fts, type.i)
Declare.i ftsGetType(*this.fts)

On peut admettre une convention de valeurs :

Code : Tout sélectionner

; respectivement 0, 1, 2 et 3 :
Enumeration
 #typeNone
 #typeNatural
 #typeText
 #typeReal
EndEnumeration

On peut utiliser un pointeur pour simuler le polymorphisme. Ce qui permet ce type de déclarations :

Code : Tout sélectionner

Declare ftsSetValue(*this.fts, *value)
Declare ftsGetValue(*this.fts)

Pour rappel de conversion, pointeur/variable et variable/pointeur (respectivement) :

Code : Tout sélectionner

; brouillon hors contexte

; p/v
natural.i = PeekI(*p)
text.s = PeekS(*p)
real.d = PeekD(*p)

; v/p
PokeI(*p, natural)
PokeS(*p, text)
PokeD(*p, real)

Il y a un sucre divin, c'est CallFunctionFast(@start() ) Pour résumer, on a :
- des constantes énumérées
- une structure fts
- des déclarations
- des procédures rangées en deux couches : une 1ère basse, et une 2nde haute.

La couche haute va appeler la couche basse via CallFunctionFast(). Mais il nous manque ce que nécessite CallFunctionFast() : un tableau d'adresses des procédures.

Un tableau ? No problem, il y a la classe ft considérée plus basse pour allouer cette liste.

Des adresses valides de procédure ? Ça se corse. Chaque procédure doit contenir un en-tête.

Code : Tout sélectionner

ftSetValue(*vt, vti, @myProc() )
vti + 1
Procedure myProc()
...

C'est lourd, mais une macro est possible.

Maintenant, admettons que SB ne supporte pas le sucre divin dont j'ai profonde addiction, ceci :

Code : Tout sélectionner

Procedure start()
 Debug "euh..."
EndProcedure

CallFunctionFast(@start() ) ; qui est l'équivalent de :
start()

Que nous reste-t-il alors ?

La sélection (embranchement). Ce n'est pas très souple. Ce n'est pas très compréhensible, mais ça reste buvable.

Code : Tout sélectionner

Select figure
 Case 1: Box(x, y, w, h, c)
 Case 2: Line(x,y, w, h, c)
 Case 3: LineXY(x, y, w, h, c)
 Case 4: Ellipse(x + w/2, y + h/2, w/2, h/2, c)
EndSelect

Re: Mot clé "this"?

Publié : mar. 06/févr./2024 16:10

par jph

Bonjour Ollivier,

J'ai vaguement compris ta méthode, mais c'est compliqué. En fait, celle de Microdevweb utilise les Modules et les Interfaces et est plus simple. Cela permet d'encapsuler les données et de rendre les programmes muitifenêtres plus fonctionnels, du moins en SB. Il y a un exemple nommé Mutiwindows.sb qui fonctionne très bien, mais quand je l'applique à mon programme à moi, ça ne fonctionne plus. C'est pour ça que j'étais intéressé par cette façon de programmer en utilisant les Modules et les Interfaces, mais il semblerait que ça ne puisse pas fonctionner sous SB. Quelqu'un , sur le forum anglais, m'a dit d'où venait l'erreur mais je ne crois pas pouvoir la résoudre... Je ne sais pas si c'est un bug de SB ou de moi?

Mais merci pour ta réponse.

Re: Mot clé "this"?

Publié : mar. 06/févr./2024 18:41

par Mindphazer

jph a écrit : mar. 06/févr./2024 16:10 J'ai vaguement compris ta méthode, mais c'est compliqué.

C'est normal. Pour suivre Ollivier, il faut débrancher son cerveau. Ou le brancher sur du 380V, avec les risques que ça entraîne. Bref, pas facile à suivre

Re: Mot clé "this"?

Publié : ven. 09/févr./2024 21:53

par Ollivier

2.21 gigot-ouates...

@jph

N'hésite pas à repasser voir ce sujet, car je t'ai mis le mécanisme des interfaces. Du moins, c'est la substitution aux interfaces. En gros, les interfaces en PB servent à simplifier toute cette syntaxe assez lourde. Moi, "malheureusement", comme les modules ensuite, je n'ai pas jugé suffisamment souples les interfaces, et je me suis habitué à garder explicites, les appels de fonction.

Il manque une suite : les divers traitements entre deux objets. Mais comme c'est assez chargé, autant y venir à un moment où quelqu'un veut le mécanisme des interfaces sans les interfaces.

Re: Mot clé "this"?

Publié : sam. 10/févr./2024 3:18

par jph

Ollivier a écrit : ven. 09/févr./2024 21:53 2.21 gigot-ouates...

C'est un lien vers un extrait de retour vers le futur? (je ne sais pas quelle version)

N'hésite pas à repasser voir ce sujet, car je t'ai mis le mécanisme des interfaces. Du moins, c'est la substitution aux interfaces. En gros, les interfaces en PB servent à simplifier toute cette syntaxe assez lourde. Moi, "malheureusement", comme les modules ensuite, je n'ai pas jugé suffisamment souples les interfaces, et je me suis habitué à garder explicites, les appels de fonction.

Il manque une suite : les divers traitements entre deux objets. Mais comme c'est assez chargé, autant y venir à un moment où quelqu'un veut le mécanisme des interfaces sans les interfaces.

Oui mais en PB pas de problème. Le bout de code de Microdevweb fonctionne très bien. C'est sous SB qu'il y a un problème, et je ne sais pas si c'est un bug ou si c'est impossible à faire en SB? Mais bon, je me contenterai d'utiliser les Modules pour cloisoner mes différentes fenêtres.

Re: Mot clé "this"?

Publié : sam. 10/févr./2024 20:53

par Ollivier

jph a écrit : sam. 10/févr./2024 3:18
Ollivier a écrit : ven. 09/févr./2024 21:53 2.21 gigot-ouates...
C'est un lien vers un extrait de retour vers le futur? (je ne sais pas quelle version)

N'hésite pas à repasser voir ce sujet, car je t'ai mis le mécanisme des interfaces. Du moins, c'est la substitution aux interfaces. En gros, les interfaces en PB servent à simplifier toute cette syntaxe assez lourde. Moi, "malheureusement", comme les modules ensuite, je n'ai pas jugé suffisamment souples les interfaces, et je me suis habitué à garder explicites, les appels de fonction.

Il manque une suite : les divers traitements entre deux objets. Mais comme c'est assez chargé, autant y venir à un moment où quelqu'un veut le mécanisme des interfaces sans les interfaces.
Oui mais en PB pas de problème. Le bout de code de Microdevweb fonctionne très bien. C'est sous SB qu'il y a un problème, et je ne sais pas si c'est un bug ou si c'est impossible à faire en SB? Mais bon, je me contenterai d'utiliser les Modules pour cloisoner mes différentes fenêtres.

Il y a une section dédiée pour les questions SB en bas de la page générale du forum.

Re: Mot clé "this"?

Publié : sam. 10/févr./2024 22:38

par Ollivier

Essaie ça :

Code : Tout sélectionner

; ************************************************************************************************************************
; AUTHORs    : MicrodevWeb
;               jph
;               Ollivier
; PROJECT   : Pb POO
; REQUIERED : PB 5.60 --> "required"
; ************************************************************************************************************************
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

 GLOBAL dim VPRO(1)
VPRO(0) = @FREE()
VPRO(1) = @DRAW()
  ;}----------------------------------------------------------------------------------------------------------------------
  ;=======================================================================================================================
  ;-* 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(0)
    EndWith
    ProcedureReturn *Rec
  EndProcedure
  ;}----------------------------------------------------------------------------------------------------------------------
  ;=======================================================================================================================
  ;-* DATA SECTION 
  ; ----------------------------------------------------------------------------------------------------------------------
  
  ;}----------------------------------------------------------------------------------------------------------------------

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

Re: Mot clé "this"?

Publié : dim. 11/févr./2024 0:35

par threedslider

Hello @Ollivier,

T'as oublié de mettre endmodule à la ligne 78 et après ça ya une ligne 102 pour rec1\Free() : ça donne -> accès mémoire invalide... donc ça marche pas

Sinon cool bonne idée ton code et sympa qui stimule comme java

Alors tu dois fixé certaine chose dans ton code, merci.