[Résolu] Détruire un "objet de structure" ?

[Robrock55]

Bonjour bonsoir !

Voilà actuellement je code un pti jeu que j'ai vu sur BlackBerry (Bubble Army pour ceux qui connaissent).
Et je le fais en... fausse POO purebasic (pas taper !! je dis fausse POO car je n'utilise aucun acesseur et ne prend pas en compte l'encapsulation. Mais ceci est un autre débat )

Tout marche bien, mais j'ai peur qu'à terme cela mange trop de mémoire étant donné que je ne détruis pas mes objets.
J'ai pensé à FreeMemory() mais cela ne fonctionne pas. Et j'ai pas trouvé de fonction appropriée.

Voici comment est codé une classe :

Code : Tout sélectionner

Structure Classe
  attribut1.b
  attribut2.b

  *methode1
  *methode2
EndStructure

Procedure Methode1(*this.Classe)
 ;...
EndProcedure

Procedure Methode2(*this.Classe,argument)
 ;...
EndProcedure

;Le constructeur
Procedure New_Classe(*this.Classe,attribut1,attribut2)
  *this\attribut1 = attribut1
  *this\attribut2 = attribut2

  *this\methode1 = @Methode1()
  *this\methode2 = @Methode2()
EndProcedure

Et voici un exemple d'utilisation

Code : Tout sélectionner

objet.Classe
New_Classe(objet,12,13)
CallFunctionFast(objet\methode1,objet)
CallFunctionFast(objet\methode2,objet,15)

Et donc comme j'ai dis plus haut, j'ai peur qu'a terme, mes objets ne consomment trop de mémoire.
Si vous aviez une solution pour les effacer de la mémoire, je vous en serais reconnaissant

[G-Rom]

utilise des pointeurs a la place, et alloue dynamiquement :

Code : Tout sélectionner

Macro New(name,type)
  *name.type = AllocateMemory(SizeOf(type))
EndMacro


Structure MyClass
  Value.i
  *Method.i
EndStructure


Procedure ChangeValue(*this.MyClass, value.i)
  *this\Value = value
EndProcedure

New(Test,MyClass)

*Test\Method = @ChangeValue()

CallFunctionFast(*Test\Method, *test, 255)

Debug *Test\Value


FreeMemory(*Test)

[lepiaf31]

ClearStructure() de mémoire. Regarde la doc

[Mesa]

Malheureusement clearstructure ne détruit pas la structure mais elle met les champs à zéro.
a priori la doc ne dit rien sur la destruction des struct.

Le mot "interface" est intéressant pour la poo.

Mesa.

[kwandjeen]

Je sais pas si cela va t'aider mais cela peut t'inspirer peut être

Code : Tout sélectionner

Interface test
  proc1(texte.s)
  set_text(texte.s)
  texte()
EndInterface

Structure _test
  *vtable.i
  texte.s
EndStructure

NewMap retour.test()
Global NewMap deux._test()

Procedure proc1(*this._test,texte.s)
  MessageRequester(*this\texte,*this\texte)
  *this\texte = texte
   MessageRequester(*this\texte,*this\texte)
EndProcedure

Procedure set_text(*this._test,texte.s)
  *this\texte = texte
EndProcedure

Procedure.i create(texte.s)
  Protected *this._test
  *this = AllocateMemory(SizeOf(_test))
  *this\texte = texte
  *this\vtable = ?data_vt
  ProcedureReturn *this
EndProcedure

Procedure.s texte(*this._test)
  ProcedureReturn *this\texte
EndProcedure

  retour.test("1") = create("info")
  retour.test("2") = create("essai")
  
  retour("1")\proc1("salut")
  
  retour("1")\set_text("bravo")
  
  retour("1")\proc1("fin")


;Debug PeekS(retour("1")\texte())
Debug MapSize(retour())
DeleteMapElement(retour(),"1")
Debug MapSize(retour())
Debug PeekS(retour("2")\texte())
DataSection
  data_vt:
  Data.i @proc1()
  Data.i @set_text()
  Data.i @texte()
EndDataSection

[G-Rom]

en reprenant ton code :

Code : Tout sélectionner

Structure Classe
  attribut1.b
  attribut2.b

  *methode1
  *methode2
EndStructure

Procedure Methode1(*this.Classe)
;...
EndProcedure

Procedure Methode2(*this.Classe,argument)
;...
EndProcedure

;Le constructeur
Procedure.i New_Classe(attribut1,attribut2)
  *this.Classe    = AllocateMemory(SizeOf(Classe))
  *this\attribut1 = attribut1
  *this\attribut2 = attribut2

  *this\methode1 = @Methode1()
  *this\methode2 = @Methode2()
  
  ProcedureReturn *this
EndProcedure


*objet.Classe = New_Classe(12,13)
CallFunctionFast(*objet\methode1,objet)
CallFunctionFast(*objet\methode2,objet,15)
FreeMemory(*objet)

[Robrock55]

Tout d'abord, merci pour les réponses !

Lepiaf31 et Mesa => ClearStructure() ne convient pas en effet. Et j'avais fouillé la doc en faisant quelques recherches ciblées mais j'ai rien trouvé :/
Quant aux interfaces, j'ai pas voulu me lancer là-dedans. J'ai vu, quasiment LE seul tuto de POO Purebasic (Pour rappel, ici) mais j'ai préféré me tenir à la méthode simple, histoire de bien bosser avec les pointeurs et les structures (chose que je n'avais jamais vraiment pratiqué auparavant).

kwandjeen => Ton code utilise des maps et des interfaces. Je n'utilise ni l'un ni l'autre dans mon code. A priori ca ne répond pas à ma question. Cependant, je garde ton code pour quand je me pencherais sur la question

G-Rom => Tu as réussi là où j'ai échoué au niveau du constructeur (l'astuce *objet.Classe = New_Classe) Merci ^^.
Cependant par rapport à la destruction d'objet, après le freememory, le pointeur devrait être vide non ? Pourquoi quand je fais un debug après le freememory il me redonne l'adresse mémoire de l'objet ?

[G-Rom]

c'est un reste , la mémoire n'est plus valide quand même , elle sera realloué plus tard par ton programme, par sécurité tu peut écrire un null dessus :

Code : Tout sélectionner

Macro New(name,type)
  *name.type = AllocateMemory(SizeOf(type))
EndMacro

Macro Delete(name)
  FreeMemory(name)
  name = #Null
EndMacro

Structure MyClass
  Value.i
  *Method.i
EndStructure


Procedure ChangeValue(*this.MyClass, value.i)
  *this\Value = value
EndProcedure

New(Test,MyClass)

*Test\Method = @ChangeValue()

CallFunctionFast(*Test\Method, *test, 255)

Debug *Test\Value
Debug *Test
  Delete(*Test)
Debug *Test

[kwandjeen]

Tu n'est pas obligé d'utiliser une map. Le code de G-rom POO avec appel fonction direct.

Code : Tout sélectionner

Interface classei
  Methode1()
  Methode2(argument)
  retour()
EndInterface

Structure Classe
  *vtable.i  
  attribut1.b
  attribut2.b
  *methode1
  *methode2
EndStructure

Procedure Methode1(*this.Classe)
  MessageRequester("POO avec purebasic",Str(*this\attribut1))
EndProcedure

Procedure Methode2(*this.Classe,argument)
  *this\attribut1 = argument
EndProcedure

Procedure retour(*this.classe)
  ProcedureReturn *this\attribut1
EndProcedure

;Le constructeur
Procedure.i New_Classe(attribut1,attribut2)
  *this.Classe    = AllocateMemory(SizeOf(Classe))
  *this\attribut1 = attribut1
  *this\attribut2 = attribut2

  *this\vtable = ?data_vt  
  ProcedureReturn *this
EndProcedure


*objet.Classei = New_Classe(12,13)

*objet\Methode1()
*objet\Methode2(23)
*objet\Methode1()
Debug *objet\retour()

FreeMemory(*objet)

DataSection
  data_vt:
  Data.i @Methode1()
  Data.i @Methode2()
  Data.i @retour()
EndDataSection

[G-Rom]

c'est vraiment crado la poo sous pb

[case]

poo is poop

[Robrock55]

Merci G-Rom. La POO c'est crade sous Pure, oui certainement, totalement, mais le codage en POO reste plus simple et plus approprié à un jeu :p

kwandjeen, ton code me sera utile pour l'utilisation d'interfaces je pense. Hop hop, save

[Backup]

mais le codage en POO reste plus simple et plus approprié à un jeu

hum ! Simple et POO c'est plutot antinomique !

pour le jeux, je ne pense pas que la poo soit plus approprié que le procedurale !

ou alors faut m'expliquer pourquoi ?

depuis des années les langages procedurales (C,Ass,Basic) sont utilisés pour faire du jeux.. c'est peut etre pas par hasard !
je trouve (mais peut etre parce que je connais mal le sujet) , que la POO réinvente la roue, par rapport au procedurale

la simplicité c'est allez au plus simple.. je pense que le procedurale est le plus simple
pas besoin de réinventer la roue, on exécute en linéaire une procédure , (un sous-prg) , on en ressort , on passe a la suite
le probleme est résolu pas a pas , pas de déclaration, de mise en condition, plus simple que le procedurale tu meurt !

pour moi, la poo c'est : "pourquoi faire simple , quand on peut faire compliqué"

surtout qu'en Pb ont a les structures , qui regroupe les variables ...(peut etre un début de poo )

[Robrock55]

Tiens Dobro ! L'homme qui défend le procédurale *musique épique* :p

Alors quand je dis que c'est plus simple, je parle au niveau du système, pour le jeu que je suis en train de faire, en POO tout va bien et c'est clair. Je l'avais essayé en Procédurale et j'avais galéré comme pas permis. Mais c'est probablement parce que je code mal xP

Tu dis que le procédurale à créés des jeux, je suis ô combien d'accord avec toi. Des jeux de bonnes factures même pour certains. Mais pour moi, la simplicité du POO par rapport au procédurale se situe dans l'élaboration du système. Je me sens plus à l'aise en agissant sur mes objets de tel et tel classes que sur des sous programmes ou je risque plus facilement de me perdre.
Encore une fois, étant débutant je code surement mal, mais pour avoir essayer les deux systèmes, je m'en sors mieux en POO. La POO, à mon sens, tu créé tes concepts propres à ton programmes, tu initialises tout bien et après c'est un bonheur à utiliser.
Je suis pas assez pointu en progra pour vraiment "défendre" la POO. Mais je pense qu'il serait intéressant un jour de faire un jeu (ou un autre programme peut importe) strictement identique en Procédurale et en POO pour comparer. Si ca a déjà été fait, j'suis intéressé

Ma difficulté en Procédurale, c'est que j'arrive pas à vraiment "visualiser" mon jeu. Comme tu dis c'est un peu du pas à pas. Qu'en POO, tu établis tes classes, tes méthodes, tu testes, et après tu as plus qu'à faire ton main tranquillement.

[Backup]

je suis d'accord , le procedurale oblige a une rigueur dans la structure du code

c'est meme pour ça que nous avions crée un post sur le sujet ici :
http://www.purebasic.fr/french/viewtopic.php?f=1&t=8982

en procédurale la position claire des différentes sections d'un code est tres importante
ainsi que la convention d'écriture des variables , qui indique leur utilité, leur portées ,etc ...

ça force a une forme de réglementation d'ecriture , mais qui permet ensuite de reprendre un code meme plusieurs années apres
(ça m'arrive régulièrement) ..

cependant , je ne suis pas assez calé en programmation pour couler la POo , j'ai simplement connu QUE le procedurale .. ceci explique cela

Mais je pense qu'il serait intéressant un jour de faire un jeu (ou un autre programme peut importe) strictement identique en Procédurale et en POO pour comparer. Si ca a déjà été fait, j'suis intéressé

je pense qu'en procedurale, il y aura moins de lignes ..