[C++] Static Object?

[prometheus345479]

Hoi,

ik ben redelijk nieuw in het object georienteerd programmeren. En ik vroeg me af of iemand mij kon helpen...

Ik zou graag een static object willen maken.

In een functie blijven static variables bestaan nadat de functie gereturnd(?) wordt. En bij de volgende functiecall wordt de static variable niet opnieuw geinitialiseerd.

Ditzelfde gedrag wil ik met objecten doen. Ik heb dus een class Foo, en daarvan worden meerdere objecten gemaakt. Ieder object heeft zijn eigen parameters, die worden ingelezen uit een bestand. Ik wil het inlezen maar 1 keer doen, dus dat de opgeslagen parameters in ieder object blijven bestaan bij een nieuwe functiecall.

Het lijkt natuurlijk erg op een global, maar ik weet niet van tevoren hoeveel objecten er nodig zullen zijn, dus ik kan ze niet globaal declareren. (sowieso wil ik liever niet met globals werken...)

[RobIII]

Zolang je de instance van dat object 'vast houdt' gaat de inhoud toch niet verloren Of begrijp ik je nou verkeerd?

Je instantieert een object, de 'variabelen' worden gezet waar jij het over hebt en dan is het toch goed? Je moet alleen zorgen dat je het object niet wegmikkert als je de inhoud ervan wil bewaren...

[ Voor 46% gewijzigd door RobIII op 03-03-2009 11:50 ]

[VyperX]

Als ik je goed begrijp wil je objecten aanmaken, die langere tijd (dus niet gelimiteerd tot 1 functie-call) blijven bestaan...

Het idee is dan dat je met "new" je objecten aanmaakt. Hiervan krijg je dan een pointer die je moet bij gaan houden (bijvoorbeeld in een lijst). Zolang je de pointer onthoud, kan je bij je object komen.

(Mocht je klaar zijn met je object, dan is het wel de bedoeling dat je dit expliciet aangeeft door "delete" te gebruiken op je pointer.)

Anyway, dit is vrij basic OO programmeren...

[prometheus345479]

RobIII schreef op dinsdag 03 maart 2009 @ 11:48:
Zolang je de instance van dat object 'vast houdt' gaat de inhoud toch niet verloren Of begrijp ik je nou verkeerd?

Je instantieert een object, de 'variabelen' worden gezet waar jij het over hebt en dan is het toch goed? Je moet alleen zorgen dat je het object niet wegmikkert als je de inhoud ervan wil bewaren...

Zoals ik al zei, ik ben vrij nieuw in object georienteerd programmeren...

Hoe zorg ik ervoor dat een object niet wordt weggegooid als een functie returned? (of gebeurd dat nooit?)
Als dat zo is dan kan ik in de functie een static pointer naar ieder object maken, en is het probleem opgelost. (of kan het netter?)

[Rollo]

Dat gebeurt nooit, zodra je een object aanmaakt met fiets gazelle=new fiets(blauw); zal het object altijd blijven bestaan onder de naam gazelle totdat je het object destruct.

Als je niet van tevoren weet hoeveel objecten je nodig heb kan je ze het best in een object array stoppen. Dat static is niet handig.

[ Voor 28% gewijzigd door Rollo op 03-03-2009 11:58 ]

[.oisyn]

fiets gazelle=new fiets(blauw);

Je vergeet de *

[Woy]

peugeot106xsi schreef op dinsdag 03 maart 2009 @ 11:56:
Dat gebeurt nooit, zodra je een object aanmaakt met fiets gazelle=new fiets(blauw); zal het object altijd blijven bestaan onder de naam gazelle totdat je het object destruct.

Als je niet van tevoren weet hoeveel objecten je nodig heb kan je ze het best in een object array stoppen. Dat static is niet handig.

Je object blijft niet bestaan onder de naam gazelle, er word een object in het geheugen gemaakt, en gazelle bevat een geheugen adress die naar die gazelle wijst.

prometheus345479 schreef op dinsdag 03 maart 2009 @ 11:54:
[...]


Zoals ik al zei, ik ben vrij nieuw in object georienteerd programmeren...

Hoe zorg ik ervoor dat een object niet wordt weggegooid als een functie returned? (of gebeurd dat nooit?)
Als dat zo is dan kan ik in de functie een static pointer naar ieder object maken, en is het probleem opgelost. (of kan het netter?)

Je hebt 2 manieren van objecten creeeren ( en collecten ).

Als je ze op de volgende manier definieert

C++:

void MyFunc()
{
    Foo bar;
}

dan zal bar opgeruimd worden op het moment dat hij out of scope gaat.

Wil je dat een object een langer leven heeft dan kan je hem of in een hogere scope aanmaken, of je kan hem zelf aanmaken met het new keyword. Elk object wat je met new aanmaakt zal ergens weer met delete verwijderd moeten worden. Totdat een object ge delete word zal hij gewoon blijven bestaan, maar je moet natuurlijk wel zorgen dat je ergens nog de pointer naar het object hebt.

C++:

Foo* bar = new Foo();

delete bar;

[ Voor 4% gewijzigd door Woy op 03-03-2009 12:24 ]

[farlane]

In C++ mag je ook een object static maken, in een functie of op module niveau. Dat heeft verder niets met new/delete te maken trouwens.

[Woy]

farlane schreef op dinsdag 03 maart 2009 @ 12:48:
In C++ mag je ook een object static maken, in een functie of op module niveau. Dat heeft verder niets met new/delete te maken trouwens.

Nee het heeft niks met static te maken, maar dat is eigenlijk zijn vraag ook niet. Wat hij wil weten is

Hoe zorg ik ervoor dat een object niet wordt weggegooid als een functie returned?

[MLM]

Static is een manier om de storage-type van een variabele aan te geven:

C++:

int foo()
{
  static int bar;
  bar++;
  return bar;
}

void main()
{
  int a = foo(); //=1
  int b = foo(); //=2
  int c = foo(); //=3
}

de a b en c variabelen bevinden zich op de stack. Zodra de functie verlaten word, zijn die variabelen (en hun waarde) verdwenen. De static bar variabele bevind zich niet op de stack, en heeft een gereserveerd stukje geheugen zolang het programma draait. Hierdoor returned de functie foo telkens een andere waarde, immers de variabele bar blijft bestaan en bruikbaar in foo.

Dan nu in een object

C++:

class foo
{
  static int a;
  int b;

  void bar()
  {
    int c;
  }
};

a is static, en bestaat zolang het programma bestaat.
b is member, en hoort bij een instance van foo. Zolang die instance bestaat, bestaat b.
c is een variabele in een functie, en bestaat alleen als die functe uitgevoerd word, op de stack.

Wat ik DENK dat jij en andere mensen in dit topic niet weten/vergeten te vertellen is dat een pointer een storage type heeft, maar dat hoeft niet hetzelfde te zijn als het storage type van hetgene waarnaar verwezen word:
je kan bijvoorbeeld best een static pointer naar een object op de stack hebben. Over het algemeen echter, bewaar je je pointers in de scope van de class, en verwijzen ze naar een object op de heap. In de constructor haal je je objecten op, en in de destructor ruim je de objecten op. Dat object heeft dan een lifetime die jij bepaalt: het begint als je new doet, en eindigt als je delete doet, wat dan synoniem is voor de lifetime van het object zelf.

Uit jouw niet heel duidelijke omschrijving wil jij een bestand inlezen waar zich meerdere waarden in bevinden. Deze waarden zijn objecten van type Foo. Volgens mij wil je dan 2 soorten objecten, het waarde object Foo en een object dat alle waarden 1x inleest en dan bewaard, een Bestand object (een slechte naam, maar ik heb niet meer informatie )

C++:

#include <vector>

class Foo;

class Bestand
{
  std::vector<Foo> waardes;

public:
  Bestand()
  {
    //open file, lees waarden in, bewaar in waardes verzameling, sluit bestand
  }

  Foo &Get(unsigned index) { return waardes[i]; }
} *g_bestand;

void main()
{
  g_bestand = new Bestand();
  //de rest van je programma
  //je kan nu overal "g_bestand->Get(0)" doen voor de eerste waarde
  delete g_bestand;
}

[ Voor 19% gewijzigd door MLM op 03-03-2009 13:11 ]

[prometheus345479]

MLM schreef op dinsdag 03 maart 2009 @ 13:04:

Uit jouw niet heel duidelijke omschrijving wil jij een bestand inlezen waar zich meerdere waarden in bevinden. Deze waarden zijn objecten van type Foo. Volgens mij wil je dan 2 soorten objecten, het waarde object Foo en een object dat alle waarden 1x inleest en dan bewaard, een Bestand object (een slechte naam, maar ik heb niet meer informatie )

Sorry, ik zal een wat betere beschrijving geven van wat mijn probleem is. Erg bedankt voor je hulp in ieder geval...

Ik ben bezig met een dll voor een andere executable, waar ik niet bij kan. Wat de dll moet doen is natuurkundige grootheden die uit de exe komen omzetten in gemeten waarden.

daarvoor simuleer ik dus een sensor. De eigenschappen van een sensor staan opgeslagen in een tekstbestand. Iedere natuurkundige grootheid heeft zijn eigen sensor (b.v. magnetisch veld heeft een magnetische sensor, geluid heeft een microfoon als sensor, en stroom heeft een amperemeter als sensor)

Ik wil nu dus in mijn dll (buiten de scope van main, die in de executable staat) een object creeren genaamd Sensor. Het object Sensor moet gevuld worden door een tekstbestand in te lezen. (bijvoorbeeld via Sensor.Init(bestand).

Zodra het tekstbestand is ingelezen, moeten de instellingen bewaard blijven in het object. Ook als de dll returned naar de executable.

dat is dus wat ik wil.

En dan nu de oplossing, denk ik:

ik krijg info van de executable (b.v. een magnetisch veld)

C++:

//Ik kijk of er voor het eerst een magnetische sensor gebruikt wordt. met b.v.

static bool FirstRun; //true als ie voor het eerst gebruikt wordt, false daarna.

//Als eerste run, creer Sensor pointer, die ook statisch is. 
//(anders wordt ie weggegooid)

static Sensor* magneet = new Sensor;

//Dan sensorbestand uitlezen:

magneet.init(bestand);

//en dan de rest...

[.oisyn]

Als je in plaats van een aparte init methode het bestand aan de constructor van Sensor meegeeft, dan heb je die FirstRun ook niet meer nodig. De pointer wordt immers maar 1 keer geïnitialiseerd, waardoor de Sensor ook maar 1 keer aangemaakt wordt.

[MLM]

Okay, wat is je probleem dan nog? Ik neem aan dat je executable een functie in je DLL aanroept, en daar stop je die code hierboven in, dat kan prima werken. Je hebt alleen geen opruim functionaliteit.

Je zou eventueel met DllMain oid je objecten kunnen aanmaken of opruimen, als je dat echt wilt, hoef je je daar in de aangeroepen functie niet meer over na te denken.

[epic007]

Je zou een Singleton kunnen maken:

C++:

//code van http://www.inquiry.com/techtips/cpp_pro/10min/10min0200.asp
//in .h file
class Singleton 
{
  public:
    static Singleton* Instance();
  protected:
    Singleton();
  private:
    static Singleton* pinstance;
};


//in .cpp file
Singleton* Singleton::pinstance = NULL;

Singleton* Singleton::Instance () 
{
  if (pinstance == NULL)  // is it the first call?
  {
    pinstance = new Singleton; // create sole instance
  }
  return pinstance; // address of sole instance
}

Singleton::Singleton() 
{ 
//... perform necessary instance initializations 
}

Deze gebruik je vervolgens:

C++:

Singleton* var1 = Singleton::Instance();
Singleton* var2 = Singleton::Instance();

var1 en var2 wijzen uiteindelijk naar dezelfde instantie.

[ Voor 4% gewijzigd door epic007 op 03-03-2009 14:03 ]

[.oisyn]

Ah ja daar heb je het Singleton anti-pattern ook weer, wat de TS in dit geval bovendien niet eens helpt

Daarnaast zou ik het in C++ gewoon zo implementeren:

C++:

Singleton * Singleton::Instance()
{
    static Singleton s_instance;
    return &s_instance;
}

Jij leakt, ik niet.

[ Voor 47% gewijzigd door .oisyn op 03-03-2009 14:18 ]

[prometheus345479]

Bedankt voor de hulp!

Mijn probleem is inmiddels opgelost via een constructor die het bestand inleest, en vervolgens een static pointer naar een sensor object.

Een singleton is niet handig, want ik wil nu juist meerder objecten van dezelfde class hebben...

[farlane]

Woy schreef op dinsdag 03 maart 2009 @ 12:51:
[...]

Nee het heeft niks met static te maken, maar dat is eigenlijk zijn vraag ook niet. Wat hij wil weten is

[...]

Ehm, kun je me het nog een keer uitleggen dan hoe het zit dan, want of ik begrijp je post niet of ik heb al heel lang de betekenis van een static variabele verkeerd gehad.

[Woy]

farlane schreef op woensdag 04 maart 2009 @ 09:09:
[...]


Ehm, kun je me het nog een keer uitleggen dan hoe het zit dan, want of ik begrijp je post niet of ik heb al heel lang de betekenis van een static variabele verkeerd gehad.

Ik bedoelde dat hij eigenlijk niet wilde weten wat static precies deed, maar hoe hij de life-time van zijn object kan bepalen. Natuurlijk kan je die met static beinvloeden, maar jij gaat toch niet alle objecten die een langere life-time dan een method moeten hebben static maken. Dat is wat ik bedoelde.

[ Voor 10% gewijzigd door Woy op 04-03-2009 09:32 ]