Was muss ich beachten, wenn ich per new ein neues Array erzeuge (zB. map.index = new WORD[vertices];) und dann in einen std::vector packe? (mapList.push_back(map);)

MfG

rüdiger schrieb:

du musst dich um die Freigabe des Speichers kümmern.

Wie mache ich das?

MfG

zb:

int main( ) {

    int *number = new int;

    // ...

    delete number;

    // aber:

    int *numbers = new int[ 10 ];

    // ...

    delete [ ] numbers;
}

Greetz, Swordfish

MfG

[...] dann die clear Funktion von der std::vector Klasse aufrufen ...

Ist aber nicht unbedingt nötig .

Also @ceplusplus, hier mal ein Beispiel:

#include <vector>

class CFoo
{
  // ...
};

typedef std::vector<CFoo*> CFooVector;

// ...

CFooVector cFoos;
CFoo* pNew;

// mit 10 Elementen füllen:
for(int i = 1; i <= 10; i++)
{
  pNew = new CFoo(/*evtl. Parameter*/);
  cFoos.push_back(pNew);
}

// ... Damit arbeiten ...

// Den Speicher der Elemetne auf dem Heap wieder freigeben, der Rest sollte vom std::vector-Destruktor erledigt werden:
for(int i = 0; i < cFoos.size(); i++)
   delete cFoos[i];

struct Map
{
    // ...
	struct Vertex
	{
		float x, y, z;
	};

	Vertex* vertex;
    // ...
};

// ...
Map map;
map.vertex = new Map::Vertex[24];
// ...

// ...
std::vector<Map> mapList;
// ...
mapList.push_back(map);
// ...

Also muss ich dann

delete [] mapList[x].vertex;

schreiben?

MfG

struct Map
{
    // ...
    Map( size_t size )
    {
        vertex = new Vertex[size];
    }
    ~Map()
    {
        delete[] vertex;
    }        
    struct Vertex
    {
        float x, y, z;
    };
    Vertex* vertex;
    // ...
};

Dann kümmert sich map selbst um den Speicher und du kannst den vector ganz normal benutzen.

MfG

Mach lieber so:

struct Map
{
    // ...
    Map( size_t size )
    {
        vertex = new Vertex[size];
    }
    ~Map()
    {
        delete[] vertex;
    }        
    struct Vertex
    {
        float x, y, z;
    };
    Vertex* vertex;
    // ...
};

Dann kümmert sich map selbst um den Speicher und du kannst den vector ganz normal benutzen.

Als erster Schritt schon mal 'ne gute Sache. Sauber wird es, wenn man die sogenannte 'Regel der drei' befolgt, die da lautet: "Falls ein nicht trivialer Destruktor (oder Zuweisung-Operator oder Kopier-Konstruktor) in der Klasse auftaucht, so muss man auch die anderen beiden implementieren."

Für den Anfang würde es auch reichen, diese einfach 'lahm zu legen' - inden man sie private macht.

struct Map
{
    // ...
    explicit Map( size_t size ) // explicit verhindert implizite Konvertierung
        : vertex( new Vertex[size] ) // Initialisierungslisten verwenden
    {}
    ~Map()
    {
        delete[] vertex;
    }        
    struct Vertex
    {
        float x, y, z;
    };
private:  // 'vertex' bessser auch private machen
    Vertex* vertex;
    // ...
private:
    Map( const Map& );
    Map& operator=( const Map& );
};

.. falls Dein Code anschließend nicht mehr compiliert, hat Dich diese Konstruktion vor einem bösen Laufzeitfehler bewart.

Gruß
Werner

Verstehe ich nicht.

MfG

Eventuell meint er Konstruktor

Nein, er meint Destruktor.
Ein Destruktor gilt als nicht trivial, wenn er z.B. eine delete enthält oder auch einen anderen Aufruf, der eine Ressource gleich welcher Art wieder freigibt.

Beim (automatischen) Kopieren eines Objekt mit Zeiger (hier vertex) wird natürlich nur der Zeiger kopiert, wird jetzt eines der beiden Objekte, also die Kopie oder das Original gelöscht, so wird sein Konstruktor aufgerufen und die Ressource freigegeben. Das andere Objekt läuft dann mit einem Zeiger herum der nicht mehr gültig ist und spätestens beim Löschen des Zweiten Objekts kracht es dann.

Mehr dazu wenn man 'rule of three c++' bei google eingibt. Unter anderen ist es hier ganz gut beschrieben. In deutsch gibt's das auch hier

Gruß
Werner

struct Map
{
    // ...
	struct Vertex
	{
		float x, y, z;
	};

	Vertex* vertex;
    // ...
};

// ...
Map map;
map.vertex = new Map::Vertex[24];
// ...

// ...
std::vector<Map> mapList;
// ...
mapList.push_back(map);
// ...

Allerdings schreibe ich nach push_back():

delete [] map.vertex;

Trotzdem arbeite ich dann wie gewohnt mit dem Objekt im Vektor.

MfG

ceplusplus schrieb:

std::vector<Map> mapList;
// ...
mapList.push_back(map);
// ...

Allerdings schreibe ich nach push_back():

delete [] map.vertex;

Trotzdem arbeite ich dann wie gewohnt mit dem Objekt im Vektor.

Ja, da haben wir es ja schon

Dringender Tipp: Füge einen Kopier- und einen Zuweisungs-Operator für Map hinzu, in Deinem Fall public und wenn Du nicht weist wie das geht, so frag' noch mal nach. Ich gehe jetzt Fernsehen schauen - aber die anderen können Dir auch helfen.

Gruß
Werner

Aber warum funktioniert es eigentlich auch ohne dem? Der Zeiger des Objekts zeigt auf ein array. Wenn man nun push_back() aufruft, wird das Objekt also kopiert... und somit auch der Zeiger. Der zeigt dann eigentlich auf die alte Adresse, die aber von delete schon wieder freigegeben wurde.

Warum sind die Daten dann immer noch da?

MfG

Warum sind die Daten dann immer noch da?

wahrscheinlich weil bis dahin niemand in den Speicher hineingeschrieben hat. Aber was nicht ist, kann noch kommen. Ist auch eine Frage Deiner verwendeten Umgebung. Das VisualStudio z.B. überschreibt freigegebenen Speicher im Debug-Mode und es erkennt zweimal freigegebenen Speicher als Fehler; das scheint bei Dir nicht der Fall zu sein.

Wenn ich's so recht überlege gäbe es für Dich eine sehr einfache Lösung. Nutze einfach einen std::vector um die Vertex zu speichern.

struct Map
{
    struct Vertex
    {
        float x, y, z;
    };

    explicit Map( size_t size )
        : vertex( size ) // legt 'size' Vertex-Objekte an
    {}

    std::vector< Vertex > vertex;
};

und das war's schon. Destruktor, Kopie-Konstruktor und Zuweisung-Operator von Map macht alles der vector und der Compiler - und Du musst Dich um nichts mehr kümmern. Ansonsten sollte sich Dein Code dadurch nicht wesentlich verändern - wenn überhaupt, so wird er einfacher.

Gruß
Werner

MfG

EDIT:
Wozu " : vertex( size ) // legt 'size' Vertex-Objekte an " ? Verstehe ich nicht. Der std::vector wird doch die Vertexobjekte speichern.

Dadurch erhälst du nun zwei Möglichkeiten:

//1.
Map map1;

//2.
Map map2(10);

Damit hast du mit map1 ein Objekt, bei dem ein Vector enthalten ist, der relativ früh (wahrscheinlich nach dem 1. Einfügen) seine Größe ändern muss, d.h. auch die alten Daten kopieren. Während der Vector in map2 erst nach 10 Einfügeoperationen seine Größe ändern muss.

Edit: Fast vergessen: für die 1. Möglichkeit, musst du aber noch den "normalen" Konstruktor explizit einfügen, weil du einen anderen bereits definiert hast. D.h.:

Map()
{ }

Der tut zwar nichts, aber sonst fällt die Erstellung von map1 beim kompilieren fehl.
[/edit]

Siehe:
http://www.cppreference.com/cppvector/vector_constructors.html

Und:

[2] Memory will be reallocated automatically if more than capacity() - size() elements are inserted into the vector. Reallocation does not change size(), nor does it change the values of any elements of the vector. It does, however, increase capacity(), and it invalidates [5] any iterators that point into the vector.

[3] When it is necessary to increase capacity(), vector usually increases it by a factor of two. It is crucial that the amount of growth is proportional to the current capacity(), rather than a fixed constant: in the former case inserting a series of elements into a vector is a linear time operation, and in the latter case it is quadratic.

[4] Reserve() causes a reallocation manually. The main reason for using reserve() is efficiency: if you know the capacity to which your vector must eventually grow, then it is usually more efficient to allocate that memory all at once rather than relying on the automatic reallocation scheme. The other reason for using reserve() is so that you can control the invalidation of iterators. [5]

Von http://www.sgi.com/tech/stl/Vector.html . Eine Beispielhafte Implementation. Die Verdoppelung der Kapazität ist aber nicht bei jeder Vectorimplementation gegeben, aber sehr verbreitet.

MfG

struct Map 
{ 
    struct Vertex 
    { 
        float x, y, z; 
    }; 

    explicit Map( size_t size ) 
        : vertex( size )
    {} 

    std::vector< Vertex > vertex; 
};

Im Elementinitialisierer ist also das vector- "vertex" Objekt gemeint?
Würde dann

" : vertex (2) "

dasselbe wie

" push_back();
push_back(); "

bedeuten? Also es wird nichts eingefügt, aber der Platz wird schon mal reserviert? Und bedeutet das dann, dass wenn ich vorher zB " : vertex (100) " schreibe, dass ich dann bis zu 100x push_back() schreiben kann, ohne dass das array vergrößert werden muss/wird?

MfG