[C++] Classes new()bee probleem

[Verwijderd]

Ik ben sinds kort met C++ (dev-C++) in de weer, en probeer nu gebruik te gaan maken van classes in C++
Ik heb wel diverse classes geschreven in Java, maar in C++ werkt het net even anders.

Belangrijk is dat ik een array van classes aan maak, en dat elke class weer variabele array(s) in zich hebben, nu lukt dat nu wel.

Maar mijn grote probleem is als ik op een gegeven moment eens zeg; a[0] opnieuw wil initialiseren. met nieuwe variabelen. In Java zou ze zoiets zeggen als;
a[0]=new test();

Maar dit gaat niet op in C++, Ik zit nu al sinds gisteren hier op kijken, en tutorials proberen te checken via google, maar nog steeds geen resultaat. Als iemand een kleine hint kan geven graag!

code:

#include <iostream>
using namespace std;

class test
{
    public:

    int number;
    int *myarray;
    
    test (void)      //constuctor               
    {
      number=(rand()%100)+1;
      myarray= new int [number];
      for (int i=0;i<number;i++)
      {
            myarray[i]=number-10;
      }
   }
     
   ~test (void)            //deconstructor              
   {
     if (myarray!=NULL){ delete [] myarray; }
   }
   
   void printstuff(int putty)
   {
      cout << "--> " << putty << endl;
   }   
};

 
int main ()
{
  srand(time(NULL));   //reset random seed
  
  test a[100];
  //now print some data
  a[0].printstuff(a[0].number);
  a[0].printstuff(a[0].myarray[0]);
  
  //next I want to reset a[0] like I can do in Java
       
  // mmm - won`t compile 
  //a[0]=new test();
   
  // mmm - just delete a[0] - won`t compile  
  //delete a[0];
   
  // mmm - or just delete a[] - will compile - gives an error 
  //delete [] a;
   
  // mmm - or just delete a - will compile - but a[0] is still the same..
  //delete a;
  //a[0].printstuff(a[0].number);
  //a[0].printstuff(a[0].myarray[0]);
      
  return 0;
}

[whoami]

Wat lukt er dan precies niet?
Krijg je een foutmelding, crashet je programma, ......

Geef eens een beetje meer info.

Is het niet zo dat je een array van pointers naar objecten nodig hebt, als je die new operator wilt gebruiken?

Als je nl dit doet met jouw code:

code:

test b;
a[0] = b;

dan zal het wel werken vermoed ik.

Ook als je dit doet, zal het werken:

code:

test* a[100];

a[0] = new test();

Je moet dan natuurlijk wel weten dat in het bovenstaande geval a[1] tem a[99] naar niet gealloceerd geheugen verwijzen, en je programma dus zal crashen als je die elementen aanspreekt vooraleer je geheugen gealloceerd hebt.

[ Voor 85% gewijzigd door whoami op 01-03-2004 21:15 ]

[Klippy]

Volgens mij staat dat in de code bij het commentaar

Ik ben er ff naar aan 't kijken
[edit]
Die new test() geeft idd een pointer terug naar de instantie van test.

Dus een pointer array lijkt mij mogelijk (zoals whoami net iets eerder zei ), of misschien een tijdelijke pointer maken en de data daarvan toewijzen aan a[0].

C++:

test* temp;

temp = new test();

a[0] = *temp;

Of is dat raar?

* Klippy probeert nog veel te leren van C++ ondaks dat ik al 2 projecten daarin gedaan heb met niet altijd al te nette code

[ Voor 77% gewijzigd door Klippy op 01-03-2004 21:16 ]

[Soultaker]

Het gaat waarschijnlijk mis doordat in Java alle types in principe 'reference types' zijn. Een variabele verwijst dus alleen naar een object. In C++ kun je zowel met 'value types' werken als met 'reference types'.

Met zulke code:

C++:

Foo f;

declareer je in C++ al een object met een identifier f. In Java zou je alleen maar een reference f declareren, die naar een (nog te maken) object kan verwijzen.

Arrays zijn hetzelfde verhaal. Als je in C++ declareert:

C++:

Foo f[10];

Dan krijg je een array met 10 objecten erin (en niet tien references!). Die object hoef je/kan je dus niet meer construeren met new (met een hack wel, maar daar ga ik niet eens over beginnen).

De situatie is wat dat betreft te vergelijken met arrays van primitive types in Java. Primitive types (ints, chars, floats, enzovoorts) zijn namelijk ook value types. "new int[10]" levert in Java ook een array van 10 integers op (al is een variabele "int[] x;" weer geen array, maar een reference naar een array).

Nu zou zo ongeveer duidelijk moeten zijn waar 't probleem vandaan komt. whoami geeft al twee nuttige suggesties om het op te lossen. Welke het beste is hangt een beetje van de situatie af (ik zou de variant met handmatige allocatie liever vermijden).

edit:

LiquidSilver schreef op 01 maart 2004 @ 21:11:
Misschien een tijdelijke pointer maken en de data daarvan toewijzen aan a[0].

C++:

test* temp;

temp = new test();

a[0] = *temp;

Of is dat raar?

Ja, dat is raar, want dan moet je dus eerst een object alloceren (wat relatief duur is), vervolgens kopiëren (wat niet gratis is) en tenslotte weer vrijgeven (wat ook weer niet gratis is en je hier zelfs vergeten was). Je kunt 'm dan net zo goed direct toekennen:

C++:

a[0] = test();

[ Voor 21% gewijzigd door Soultaker op 01-03-2004 21:22 ]

[Domokoen]

Soultaker schreef op 01 maart 2004 @ 21:20:

C++:

a[0] = test();

Dit hierboven is inderdaad de manier om dit te doen. Echter, impliciet gebeurt er precies hetzelfde als hierboven: er wordt eerst een object gemaakt en vervolgens wordt deze via de copy constructor in a[0] opgeslagen.
Alleen als a een array van pointers naar objecten was zou je kunnen werken met new test() en dit kunnen voorkomen:

C++:

test* a[100];
a[0] = new test();

Dit betekent echter wel dat je nu met de hand de objecten weer moet deleten, terwijl dat bij de gebruikte manier vanzelf gaat.

[whoami]

Soultaker schreef op 01 maart 2004 @ 21:20:

C++:

a[0] = test();

ff vergeten dat dit ook mogelijk was.

[Verwijderd]

Even wat achtergrond info, waarvoor ik dit aan het uitzoeken ben.

Was een tijdje terug bezig met openGL spul, (geschreven op windows met de SDL-library)
http://www.xs4all.nl/~elout/bbeez/
(n-videa versie, heb een andere voor ATI kaartjes.)

Een nieuwe Java-studie (processing.org) proberen een aantal diverse low-poly flowers te maken.
http://www.xs4all.nl/~elout/proce55ing/flower06/index.html

Nu ben ik sinds kort bezig in Dev-C++, en probeer voor het eerst nu classes te gaan gebruiken in C++
Mischien nieuwe opties zijn, in een functie binnen de class, delete de array, en maak dat een nieuwe array etc. aan. Maar het is voor mij nog lastig, vooral het pointer gebeuren..

Alvast bedankt voor de verheldering, ga alle replies ff goed doorlezen/uit-testen.

[Klippy]

Oh ja idd dat was raar van mij, gewoon test() kan ook

Toch te merken dat ik al 2 weken niet geprogrammeerd heb

[MSalters]

Overigens wil je new zoveel mogelijk vermijden. std::vector is veel handiger in je class, en daarbuiten misschien ook wel.

[Cuball]

als je met std:vector<T> werkt, en je maakt bv een vector van 100 aan, wat gebeurt er dan achter de schermen ? dit wordt dan toch ook gealloceerd via new ? maar waarom moet men dit dan niet terug vrijgeven in de desctructor ?

klink misschien beetje verwarrend, maar ben al enkele maanden teveel met java bezig en daar hoef je van vrijgeven en dergelijke niets van aan te trekken (garbage collection)

[Soultaker]

Mr.Chinchilla schreef op 01 maart 2004 @ 21:29:
Dit hierboven is inderdaad de manier om dit te doen. Echter, impliciet gebeurt er precies hetzelfde als hierboven: er wordt eerst een object gemaakt en vervolgens wordt deze via de copy constructor in a[0] opgeslagen.

Het is absoluut niet hetzelfde. Het maakt een wereld van verschil of een object in de heap of op de stack gealloceerd wordt (al gaat het alleen maar om de vraag wanneer en door wie het geheugen vrijgeven wordt). Daar komt nog bij dat in de variant van "a[0] = test()" de compiler uitgebreid de ruimte krijgt om te optimaliseren.

Cuball schreef op 02 maart 2004 @ 00:44:
als je met std:vector<T> werkt, en je maakt bv een vector van 100 aan, wat gebeurt er dan achter de schermen ? dit wordt dan toch ook gealloceerd via new ? maar waarom moet men dit dan niet terug vrijgeven in de desctructor ?

De vector klasse garandeert dat alles wat 'ie alloceert ook weer vrijgeven wordt. Jij hoeft je daar als gebruiker niet mee te bemoeien. Dat geldt in het algemeen ook voor object-georienteerd programmeren in C++: een object is in beginsel verantwoordelijk voor het opruimen van eigen gealloceerd geheugen, tenzij het eigendom expliciet overgedragen wordt (maar daar zitten nogal wat praktische haken en ogen aan).

Als een vector object dus geheugen alloceert met new, dan moet 'ie dat intern ergens bijhouden en in de destructor weer vrijgeven.

[Verwijderd]

Inderdaad a[0]=test(); werkt als een zonnetje.

Voor mij is de ~deconstructor iets nieuws, aangezien in Java hier nooit 'last' van had.

In mijn 1e voorbeeld delete ik in de deconstructor 'myarray'. Dit na aanleiding van diverse tutorials. En inderdaad wordt op het moment dat ik a[0] opnieuw aanmaak, de deconstructor ook aangeroepen.

Maar nu vraag ik mij af, op het moment dat ik a[0] opnieuw aanmaak. Of C++ niet zelf slim genoeg is, en al het 'oude' netjes voor mij 'opruimt' Als ik in de deconstructor niks delete, werkt het programma ook. Of krijg ik dan vroeg of laat te maken met enorme memory-leaks? En zou het niet netjes zijn om in de deconstrucor naast arrays ook de rest van de variabelen die ik in de class heb aangemaakt te deleten?

[whoami]

Aangezien je niet met pointers werkt, moet je je array toch ook zelf niet deleten ?

Mocht je nu met objecten werken die je op de heap alloceert, dan moet je ze wel zelf vrijgeven:

code:

test* a[5];
for( int i = 0; i < 5; i++ )
{
   a[i] = new test();
}

....

delete[] a;

[Verwijderd]

Ok na wat onderzoek,

- For every object allocated with new there should be a deallocation with delete.
- For every variable allocated with malloc there should be a deallocation with free.
- Remember to free the string when it is no longer being used.

c++_for_java_programmers

Dus volgens mij is het wel zo netjes om die array te deleten..

[Verwijderd]

Verwijderd schreef op 02 maart 2004 @ 10:24:
...

Maar nu vraag ik mij af, op het moment dat ik a[0] opnieuw aanmaak. Of C++ niet zelf slim genoeg is, en al het 'oude' netjes voor mij 'opruimt' Als ik in de deconstructor niks delete, werkt het programma ook. Of krijg ik dan vroeg of laat te maken met enorme memory-leaks? En zou het niet netjes zijn om in de deconstrucor naast arrays ook de rest van de variabelen die ik in de class heb aangemaakt te deleten?

als je de array niet delete in de destructor dan krijg je zoals je zelf al zegt een memory leak omdat c++ geen garbage collector heeft. Dit geld dus alleen maar voor de dingen die je zelf alloceerd. De rest van de variabelen worden zelf al vrijgegeven zonder dat je daar aandacht aan hoeft te besteden.
Zou je ze wel deleten dan krijg je access violations gezien dat je programma geheugen probeert te bereiken wat niet (meer) van hem is.

[.oisyn]

Vergeet natuurlijk niet de individuele objecten in de array ook te deleten (voordat je de array zelf delete natuurlijk )

[curry684]

Verwijderd schreef op 02 maart 2004 @ 10:24:
Inderdaad a[0]=test(); werkt als een zonnetje.

Voor mij is de ~deconstructor iets nieuws, aangezien in Java hier nooit 'last' van had.

Het ding heet destructor, en het feit dat Java 'm niet kent is voor veel mensen waaronder ikzelf de grootste reden om Java een volstrekt nutteloze k*ttaal te vinden

Maar nu vraag ik mij af, op het moment dat ik a[0] opnieuw aanmaak. Of C++ niet zelf slim genoeg is, en al het 'oude' netjes voor mij 'opruimt'

C++ is niet slim: C++ is een taal die snelle en mooie code maakt voor goede programmeurs. Voor slechte programmeurs is het een grammaticale ramp die aan de lopende band memory leaks produceert, en die mensen kunnen dan ook beter bij Java blijven

If there's no garbage in a language you don't have to collect it.

[MSalters]

.oisyn schreef op 02 maart 2004 @ 16:57:
Vergeet natuurlijk niet de individuele objecten in de array ook te deleten (voordat je de array zelf delete natuurlijk )

Nee nee nee - als je een array delete - met delete[] dus - dan worden alle elementen ook gedelete. Dus bij int *p = new int[10]; delete[] p; worden alle 10 de ints door de enkele delete[] opgeruimd.

De uitzondering die jij beschrijft waar je wel in twee rondes moet deleten is bij int**, maar das makkelijk te zien: Dan heb je ook twee ** en twee keer new moeten doen. Gelukkig is dat niet het geval, en gelukkig heb je in dat geval ook vector< vector< int > >

[.oisyn]

MSalters schreef op 02 maart 2004 @ 23:12:
[...]

Nee nee nee - als je een array delete - met delete[] dus - dan worden alle elementen ook gedelete. Dus bij int *p = new int[10]; delete[] p; worden alle 10 de ints door de enkele delete[] opgeruimd.

uiteraard, maar mijn post was een reactie op whoami in "[C++] Classes new()bee probleem" en Verwijderd in "[C++] Classes new()bee probleem", vooral die van whoami eigenlijk, alleen de post van degene die ertussen stond stond er nog niet toen ik de draad aan het lezen was, vandaar.

Hij zegt daar dat je de array moet deleten, maar het was een array van pointers die ie genew'd had, dus die moet je ook deleten. Maar ik zie nu trouwens wel dat whoami de array ook echt als array definieert, en niet een pointer. Hij hoeft de array dus niet eens te deleten (hier had ik eerder overheen gelezen), en de code van whoami is dus ook fout

[Verwijderd]

mmm... vandaag met wat hulp verder gekomen; wat source Dev-C++ dit keer..

http://www.xs4all.nl/~elout/temp/
Was verder wel een goede dag/Les vandaag. Kortom het werkte wel ondanks mijn eerdere comments, en ideeen.
Maar deleten van m`n arrray`s in de deconstructor bleek geen goede keus. Crash` links en rechts..
Ik kon beter die deconstructor links laten liggen.

ondanks een paar kleine flames in dit topic, ga ik nog even door. of het nu Java/C++ of VB?!?! is. Kort door de bocht ik ben hier om lekker te coden, niet om een of andere taal te promoten.

En tja over dat opensource stuff.. als je mijn source begrijpt, dan heb je waarschijnlijk geen tutorial nodig..

[Soultaker]

Hmz, ik heb geen geflame gezien hoor. Wel veel discussie, maar dat gaat wel vaker zo hier. Ga maar lekker doorcoden dan. Je leert een programmertaal tenslotte pas echt als je er mee aan de slag gaat.

Heb je nog behoefte om de code met die falende destructor te laten zien? Want het is natuurlijk niet de bedoeling dat je geheugen wel alloceert maar niet meer vrijgeeft. Misschien gebruik je 'delete' ipv 'delete[]'?

[ Voor 36% gewijzigd door Soultaker op 03-03-2004 01:41 ]

[whoami]

.oisyn schreef op 02 maart 2004 @ 23:46:
[...]


uiteraard, maar mijn post was een reactie op whoami in "[C++] Classes new()bee probleem" en Verwijderd in "[C++] Classes new()bee probleem", vooral die van whoami eigenlijk, alleen de post van degene die ertussen stond stond er nog niet toen ik de draad aan het lezen was, vandaar.

Hij zegt daar dat je de array moet deleten, maar het was een array van pointers die ie genew'd had, dus die moet je ook deleten. Maar ik zie nu trouwens wel dat whoami de array ook echt als array definieert, en niet een pointer. Hij hoeft de array dus niet eens te deleten (hier had ik eerder overheen gelezen), en de code van whoami is dus ook fout

Hoezo?
Ik dacht dat delete[] de volledige array incl. objecten vrijgaf?
Hoe moet het dan wel zijn?
Ik zal het vanavond nog eens dat C++ boek van onder het stof halen.

* whoami is dan ook geen C++'er

[farlane]

whoami schreef op 03 maart 2004 @ 08:27:
* whoami is dan ook geen C++'er

Haha, ik kan me herinneren dat al je vaker door .oisyn en curry op de vingers werd getikt.

[curry684]

farlane schreef op 03 maart 2004 @ 09:38:
[...]
Haha, ik kan me herinneren dat al je vaker door .oisyn en curry op de vingers werd getikt.

Zal ik whoami maar even helpen dan: je hebt 2 afzonderlijke operators new: new en new[]. De 2e wordt gebruikt om arrays te alloceren, zoals bijvoorbeeld char* X = new char[50]. Op deze manier staat het een implementatie vrij om voor array-allocaties andere slimme blockmethodes te hanteren dan voor simpele single allocs die rechtsstreeks uit een heap komen. Bij een andere manier van alloceren hoort vanzelfsprekend een andere manier van dealloceren, dus dan krijg je:

C++:

int* EenInt = new int;
int* VeelInts = new int[50];
delete EenInt;
delete [] VeelInts;    // <--- let op de [] hier!!!

Je kunt ze ook allemaal afzonderlijk overloaden

Wat doet delete [] dus expliciet niet:

C++:

MyClass**  Array = new MyClass*[50];
for(int i = 0; i != 50; i++)
  Array[i] = new MyClass;
delete [] Array;

Hier leak je dus strak 50 objecten! Vrijgeven moet dus als volgt:

C++:

for(int i = 0; i != 50; i++)
  delete Array[i];   // delete 50 objecten
delete [] Array;     // delete de array van pointers

Als je dit te complex wordt weet je overigens weer waarom men die vector heeft uitgevonden en zo

[ Voor 22% gewijzigd door curry684 op 03-03-2004 09:52 ]

[whoami]

Nee, 't is niet te complex hoor.

Ik dacht eerst dat die delete[] slim genoeg was om alles vrij te geven.

* whoami heeft ook enkel C++ op school gehad, en er verder geen ervaring mee.

* whoami heeft ook niet veel meer C++ gedaan dan

[MSalters]

Verwijderd schreef op 03 maart 2004 @ 00:29:
mmm... vandaag met wat hulp verder gekomen; wat source Dev-C++ dit keer..

http://www.xs4all.nl/~elout/temp/

Wat commentaar:
* gebruik const TYPE in plaats van #define, dus

code:

const int W = 800;               //screen width
const int H = 600;               //sceen height

* Niet elk Flower object heeft een aparte sinus table nodig
* ... en die table wil je mogelijk buiten Flower ook gebruiken.
* Je Flower destructor lekt 5 arrays, omdat je geen delete[] doet
* Als je een destructor hebt, heb je meestal ook een copy constructor
en assignment nodig - in elk geval voor Flower. Bij gebrek daaraan zou
je destructor kunnen crashen als je je een kopie maakt, en dus twee
keer een destructor aanroept op dezelfde pointer waarden.
* gebruik een std::vector voor je arrays, dan genereert de compiler een
correcte copy constructor, assignment operator en destructor voor
Flower. De defaults zijn namelijk memberwise copy/assignment/
destruction, en std::vector heeft wel bruikbare implementaties daarvan.

[.oisyn]

whoami schreef op 03 maart 2004 @ 09:57:
Ik dacht eerst dat die delete[] slim genoeg was om alles vrij te geven.

dat kan niet omdat delete[] niet weet of de objecten die je in de array hebt gebruikt wel met new gealloceerd zijn

C++:

int a, b, c;
int * array = new int *[3];
array [0] = &a;
array [1] = &b;
array [2] = &c;

delete[] array;  // en nu?

delete[] roept natuurlijk wel de destructors aan voor alle objecten in de array. Het type van een array element is hier int *, een int * heeft geen zinnige destructor (het is maar een basic type), en de int waar ie naar wijst wordt niet gedelete oid. Je kunt het wel inbouwen mbv een soort smartpointer object:

C++:

class intptr
{
    int * i;

public:
    intptr () : i () { }
    intptr (int * pI) : i (pI) { }
    ~intptr ()
    {
        delete i;
    }
};

int main ()
{
    intptr * array = new intptr[10];
    for (int i = 0; i < 10; i++)
        array[i] = new int ();

    delete[] array;
}

aangezien de destructor wordt aangeroepen voor elke intptr in array, en de ints in die destructors gedelete worden, wordt dus automatisch alles gedelete en lek je niets.

(De bovenste intptr is zoals ie hierboven staat natuurlijk geen zinnige klasse en nogal error-prone, maar het gaat even om het voorbeeld Sterker nog, het programma crasht met dit voorbeeld al omdat

C++:

array[i] = new int ();

Eigenlijk gelezen wordt als

C++:

array[i] = intptr (new int ());

Hier wordt een temporary object aangemaakt om vervolgens aan array[i] te kunnen assignen. Dit object moet ook weer gedestruct worden, waardoor de int waar naar verwezen wordt dus verwijderd wordt. De verwijzing blijft echter in de array staan en wordt bij het uitvoeren van delete[] nogmaals gedelete, en heap corruption is imminent Maar dit is simpel op te lossen door een operator = (int *) te definieren binnen intptr)

[ Voor 20% gewijzigd door .oisyn op 03-03-2004 15:44 ]