[c++] static pointer variabelen

[knopper]

Hoi allemaal,

Even puur voor mijn eigen informatie, stel je hebt een class die enkel uit statische variabelen en functies bestaat. Echter, de variabelen declareer je als pointer en in een functie waarin dingen worden geinitialiseerd (maar wat dus geen constructor is) maak je hier pointer classes van m.b.v. van "new".

Hoe zit het dan als het programma wordt afgesloten? Wordt bij het afsluiten ook de destructor aangeroepen (ik vraag me dat af omdat het dus geheel statisch is) van die betreffende class en kun je daarin de pointers weer vrijgeven of moet dit anders worden gedaan?

Even wat code ter verduidelijking:

C++:

class A {

    public:
        static initialize ();

    private:
        static int * id;

};

int * A::id;

A::initialize () {

    id = new int;
}

Stel, A::initialize () wordt ergens in het programma aangeroepen, wat gebeurt er bij het afsluiten van het programma?

[Zoijar]

Ja en nee. De 'dtor' van een pointer wist het object niet, dus wat dat betreft: nee. Statische objecten worden echter wel destructed. Je kan/moet dus een statisch object aanmaken die de singleton destroyed. Daar zitten wel weer veel haken en ogen aan, want de orde van destructie van statics is niet gedefinieerd. Dus als een de ene singelton de andere gebruikt heb je een probleem. Het boek "Pattern Hatching" besteed hier een heel hoofdstuk aan.

Maar in principe dus iets als:

C++:

class Singleton {
   class Dtor {
      Dtor(Singleton* s = 0) : obj_(s) {}
      ~Dtor() {delete obj_;}

      Singleton* obj_;
   };
public:
   static Singleton* instance() { 
      //create as:
       obj_ = new Singleton;
       dtor_.obj_ = obj_;
 }
protected:
   ~Singleton() {}
   friend class Dtor;

private:
   static Singleton* obj_;
   static Dtor dtor_;
}

Redelijk lastig probleem eigenlijk.

[ Voor 3% gewijzigd door Zoijar op 01-09-2005 18:47 ]

[Verwijderd]

als het programma wordt afgesloten, wordt al het geheugen sowieso al weer vrijgegeven door het OS.
en dat is maar goed ook, want anders zou je wel erg vaak moeten resetten

het is natuurlijk wat moeilijker als je pointer naar bestanden e.d. wijst die netjes gesloten moeten worden.

[Zoijar]

Verwijderd schreef op donderdag 01 september 2005 @ 21:02:
als het programma wordt afgesloten, wordt al het geheugen sowieso al weer vrijgegeven door het OS.
en dat is maar goed ook, want anders zou je wel erg vaak moeten resetten

het is natuurlijk wat moeilijker als je pointer naar bestanden e.d. wijst die netjes gesloten moeten worden.

Ja dat is wel waar, maar het kan ook dat je bv een remote database lock moet releasen. Als het zuiver en alleen om geheugen gaat hoef je dit allemaal idd niet te doen.

[knopper]

Dus als je enkel de statische instantie gebruikt dan maakt het allemaal niet uit eigenlijk?

[MisterData]

knopper schreef op donderdag 01 september 2005 @ 21:16:
Dus als je enkel de statische instantie gebruikt dan maakt het allemaal niet uit eigenlijk?

Alle statische instanties (ik denk dat je objecten op de stack bedoelt, dus alles wat *niet* met new is gemaakt) worden automatisch verwijderd voordat het programma daadwerkelijk uitgaat dus daarvan worden inderdaad netjes de destructors aangeroepen. Je kunt een pointer natuurlijk 'verpakken' in een wat jij noemt 'statische instantie' waarvan de dtor als enige taak heeft die pointer te delete-en

[knopper]

Maar de integer "id" is wel degelijk met "new" aangemaakt, hoe loopt het daarmee af dan? Die zit dus niet op de stack.

[Zoijar]

knopper schreef op donderdag 01 september 2005 @ 22:45:
Maar de integer "id" is wel degelijk met "new" aangemaakt, hoe loopt het daarmee af dan? Die zit dus niet op de stack.

dat geheugen wordt niet expliciet vrijgegeven. (alleen als je process eindigt wordt alles sowieso vrijgegeven) (overigens kan je mijn voorbeeld boven ook simpel met een std::auto_ptr doen, maar nu was het duidelijker)

[.oisyn]

Zoijar schreef op donderdag 01 september 2005 @ 18:47:
Maar in principe dus iets als:

C++:

class Singleton {
   class Dtor {
      Dtor(Singleton* s = 0) : obj_(s) {}
      ~Dtor() {delete obj_;}

      Singleton* obj_;
   };
public:
   static Singleton* instance() { 
      //create as:
       obj_ = new Singleton;
       dtor_.obj_ = obj_;
 }
protected:
   ~Singleton() {}
   friend class Dtor;

private:
   static Singleton* obj_;
   static Dtor dtor_;
}

Of gewoon een std::auto_ptr gebruiken
.edit: euh right, dat zei je ook op het laatst

MisterData schreef op donderdag 01 september 2005 @ 22:10:
[...]


Alle statische instanties (ik denk dat je objecten op de stack bedoelt, dus alles wat *niet* met new is gemaakt)

Globals staan niet op de stack en worden niet met new aangemaakt . Een static class member is natuurlijk in feite ook gewoon een global in een andere namespace, evenals voor static variabelen gedefinieerd in local scope. Ze staan geen van alle op de stack

[ Voor 33% gewijzigd door .oisyn op 02-09-2005 10:46 ]