# Speicherplatzfreigabe bei Vektoren



## cibal_gina (29. Juni 2005)

H i,

   In meinem Programm benutze ich aus der Standard Template Library die Vektoren, die ich mir so definiert habe:.

```
vector<double> val(m_Z);
```
   Wie kann ich den Speicher wieder freigeben?
   Habe schon so probiert:

```
for( unsigned int k = 0 ; k < m_Z ; k++ ) 
   	delete & val[k];
```
   Er kompiliert dabei zwar ohne einen Fehler, aber dann wird das weitere Programm nicht ausgeführt .


----------



## jokey2 (29. Juni 2005)

Da Du das val-Objekt auf dem Heap anlegst, sollte das derCompiler selber wieder aufräumen, sobald der zugehörige Scope verlassen wird. Nur wenn Du ein Objekt mit new anlegst, mußt Du es mit delete wieder löschen. In beiden Fällen wird der Destruktor von vector aufgerufen, der den allokierten Speicher wieder freigibt.
Dein Problem, daß das Programm nicht weiter ausgeführt wird, muß also woanders liegen. Welchen Wert hat denn m_Z?


----------



## deepthroat (29. Juni 2005)

Nee, nee. Des liegt schon an dem "delete &val[k];". Da versucht er auf irgendeine zufällige Adresse ein delete (welche nie mit new angefordert wurde). Das kann ja nur schiefgehen.

Wenn du Elemente aus dem Vektor löschen willst, solltest du die erase() Funktion nehmen. Wenn du den Vektor leeren bzw. verkleinern willst nimm einfach resize(). Dann wird evtl. auch Speicher wieder freigegeben, allerdings liegt das in den Händen der Systembibliothek da Speicher normalerweise in Blöcken vom Speichermanager angefordert wird. Auch bei einem expliziten delete wird nicht unbedingt Speicher freigegeben.


----------



## Endurion (29. Juni 2005)

Noch ein Nachtrag: Wenn du den Vector komplett löschen willst, tut das ein clear().

Anmerkung 2: Wenn du Pointer auf irgendetwas in einen Vektor (oder anderen STL-Container packst), die ge-new-t wurden, musst du die auch selbst wieder deleten. Alle STL-Container sind reine Container, keinen von denen pfuscht an deinen Daten rum.


----------



## Kachelator (29. Juni 2005)

Einen std::vector leeren:

```
std::vector<int> meinVector;
//... viele Integers in den Vektor tun...
// ... und dann leer machen:
meinVector.clear();
// fertig
```

Einen std::vector leeren, der Pointer enthält auf Kram, den man selber auf dem Heap alloziert hat (mit new):

```
std::vector<Dingsda*> meinVector;
//... viele Dingsda-Zeiger in den Vektor tun...
meinVector.push_back( new Dingsda() ); // usw.
// ... und dann leer machen:
std::vector<Dingsda*>::iterator it = meinVector.begin();
std::vector<Dingsda*>::iterator itEnd = meinVector.end();
for ( ; it != itEnd ; ++it)
  delete *it; // alle Dingsdas freigeben
meinVector.clear();
// fertig
```

Soweit mein Code (ungetestet). Hoffe, es hilft.


----------



## jokey2 (30. Juni 2005)

Also, daß das delete nicht da hingehört, da sind wir uns ja einig. Aber sollte das clear() bzw. das Freigeben des in vector allokierten Speicherplatzes nicht auf jeden Fall im Destruktor passieren? Und der wird ja automatisch aufgerufen, wenn der Scope (Gültigkeitsbereich) der Variablen verlassen wird.


----------



## Kachelator (30. Juni 2005)

> Aber sollte das clear() bzw. das Freigeben des in vector allokierten Speicherplatzes nicht auf jeden Fall im Destruktor passieren?


  Ja, das tut es auch.


----------

