ich bin relativ neu bei c++ und befasse mich gerade mit zeigern. Ich habe jetzt eine konzeptionelle frage was objekte und zeiger angeht.

Folgender pseudocode:

class TestClass
{
	public:
		explicit TestClass();
		virtual ~TestClass();

		void add(TestObject *tobj)
		{
			p_vector.push_back(tobj);
		}

	private:
		std::vector<TestObject*> p_vector;
}

class TestObject
{
	public:
		explicit TestObject(int id) : p_id(id);
		virtual ~TestObject();

	private:
		int p_id;
}

void main(...)
{
	std::vector<TestClass*> m_vec;

	TestClass *tc = NULL;

	//pseudocode - objecte anlegen
	for(i < 5)
	{
		tc = new TestClass();
		tc->add(new TestObject(1));
		tc->add(new TestObject(2));
		tc->add(new TestObject(3));

		m_vec.push_back(tc);
	}

	//pseudocode - objecte löschen
	it = m_vec.begin();
	while(it != m_vec.end())
	{
		it = m_vec.erase(it);
	}
}

Meine frage ist jetzt, ich erzeuge in der main methode in einer schleife mehrere objecte vom typ TestClass als zeiger, danach erzeuge ich drei objekte vom typ TestObject als zeiger und fülle diese in einen vector in TestClass. Dieses TestClass-objekt fülle ich wiederum in einen vector in main.

1. Ist es richtig, dass die TestObject-objecte weiterleben, wenn ich die TestClass-objekte mit erase lösche?

2. Wenn 1. zutrifft, wo und wie lösche ich dann die TestObject-objekte richtig? Im destruktor von TestClass? Obwohl ich sie nicht dort erzeugt habe?

Danke und Mfg,
Herbert

...
    private:
        std::vector<TestObject> p_vector;
...

    for(i < 5)
    {
        tc TestClass();
        tc->add(TestObject(1));
        tc->add(TestObject(2));
        tc->add(TestObject(3));

...

kommst Du ohne Zeiger aus und brauchst Dich um irgendwelche Aufräumarbeiten nicht zu kümmern.
Solange es nicht einen besonderen Grund gibt, sollte man das Erzeugen von Objekten mit new / delete vermeiden.

Ansonsten gilt natürlich:
Benutzt Du irgendwo ein new, gehört auch irgendwo ein dazu gehöriges delete hin.

1. Ist es richtig, dass die TestObject-objecte weiterleben, wenn ich die TestClass-objekte mit erase lösche?

Ja und noch mehr: Auch Dein TestClass-Objekt lebt weiter, denn Du löscht nur den Eintrag im Vector, nicht jedoch das, worauf der Eintrag im Vector zeigt.

HerbertB schrieb:

2. Wenn 1. zutrifft, wo und wie lösche ich dann die TestObject-objekte richtig? Im destruktor von TestClass? Obwohl ich sie nicht dort erzeugt habe?

Dein Zweifel an der Richtigkeit, die Objekte im Destruktor zu löschen, ist berechtigt. Es sollte immer der Erzeuger auch derjenige sein, der löscht.

Kurzes Stichwort zu der gesamten Problematik: Smartpointer. Wenn Du statt rohe Zeiger im Vector Smartpointer hälst, werden die bezeigten Objekte gelöscht, sobald der Smartpointer aus dem Vector verschwindet. Ein möglicher Kandidat wäre hier std::unique_ptr oder einer der ptr_container aus boost, die das für Dich machen.

@Belli: Ja, ist klar, dass ich nicht immer zeiger brauche, aber ich möchte eben die zeiger-dynamik besser verstehen.

@LordJaxom:

Zu 1.: erase löscht den eintrag aus dem vector, aber ruft doch auch den destruktor auf?

"This effectively reduces the vector size by the number of elements removed, calling each element's destructor before."
Quelle: http://www.cplusplus.com/reference/stl/vector/erase/

Bezüglich smartpointer, dazu komme ich sicher auch noch, aber momentan würde ich wie gesagt gerne die raw-pointer-dynamik verstehen.

Wie löscht man dann wirklich verschachtelte zeiger objekte, wenn der erzeuger das objekt auch wieder löschen sollte?

Danke und mfg,
Herbert

Zu 1.: erase löscht den eintrag aus dem vector, aber ruft doch auch den destruktor auf?

ja, aber nur den Destruktor vom Zeiger selbst, nicht von dem Object, auf das der Zeiger zeigt.

@LordJaxom:

Zu 1.: erase löscht den eintrag aus dem vector, aber ruft doch auch den destruktor auf?

Völlig richtig, aber das Element ist ein Zeiger. Und der Destruktor eines Zeigers tut garnichts. Es ist etwas anderes, ob Du ein Objekt vom Typ TestClass löscht oder ein Objekt vom Typ TestClass* (Zeiger-auf-TestClass).

Wie löscht man dann wirklich verschachtelte zeiger objekte, wenn der erzeuger das objekt auch wieder löschen sollte?

In diesem Fall, wenn Du die Regel "Erzeuger = Löscher" nicht brechen willst, nur mit brachialer Gewalt:

it = m_vec.begin();
    while(it != m_vec.end()) {
        it2 = it->p_vector.begin();
        while (it2 != it->p_vector.end()) {
            delete *it2;
            it2 = it->p_vector.erase(it2);
        }
        delete *it;
        it = m_vec.erase(it);
    }

Wobei in diesem Fall sinnvoller wäre, sich das erase zu sparen und am Ende einfach den kompletten vector zu clear()en.

HerbertB schrieb:

Zu 1.: erase löscht den eintrag aus dem vector, aber ruft doch auch den destruktor auf?

ja, aber nur den Destruktor vom Zeiger selbst, nicht von dem Object, auf das der Zeiger zeigt.

Aha, danke, also dann event. noch ein

delete (*it)

nachstellen, dann wird der zeiger komplett gelöscht?

//EDIT:

Ok, jetzt hab ich das verstanden, das zwar der destruktor aufgerufen wird, aber das eigentliche objekt dadurch nicht zerstört/gelöscht wird.

@LordJaxom:

Wenn das nur mit gewalt geht, dann wird es die sinnvollste alternative sein, einen ptr_container zu verwenden.

Was jetzt noch bleibt, ist, wenn ich einen raw-pointer mit new erzeuge, und diesen dann mit push_back in den ptr_container überführe, wird dann eine copie im ptr_container gespeichert, oder der tatsächliche raw-pointer?

Sonst hätte ich ja, den raw-pointer, und den smart-pointer, der verschwindet sobald ich ihn aus dem ptr_container lösche.

Danke!

Was jetzt noch bleibt, ist, wenn ich einen raw-pointer mit new erzeuge, und diesen dann mit push_back in den ptr_container überführe, wird dann eine copie im ptr_container gespeichert, oder der tatsächliche raw-pointer?

Sonst hätte ich ja, den raw-pointer, und den smart-pointer, der verschwindet sobald ich ihn aus dem ptr_container lösche.

push_back macht immer eine Kopie des Objekts. Du übergibst push_back einen Zeiger und push_back macht ganz artig eine Kopie des Zeigers.

HerbertB schrieb:

Was jetzt noch bleibt, ist, wenn ich einen raw-pointer mit new erzeuge, und diesen dann mit push_back in den ptr_container überführe, wird dann eine copie im ptr_container gespeichert, oder der tatsächliche raw-pointer?

Sonst hätte ich ja, den raw-pointer, und den smart-pointer, der verschwindet sobald ich ihn aus dem ptr_container lösche.

push_back macht immer eine Kopie des Objekts. Du übergibst push_back einen Zeiger und push_back macht ganz artig eine Kopie des Zeigers.

D.h. ich lege den raw-pointer mit new an, füge ihn mit push_back in den ptr_container (z.b. boost ptr_vector) ein, und zerstöre anschließend den raw-pointer mit delete gleich wieder?

D.h. ich lege den raw-pointer mit new an, füge ihn mit push_back in den ptr_container (z.b. boost ptr_vector) ein, und zerstöre anschließend den raw-pointer mit delete gleich wieder?

delete zerstört nicht den Zeiger, sondern das Objekt, auf das der Zeiger zeigt.

Mal eine kleine Analogie zum besseren Verständnis: (ich habe bewusst verzichtet, im folgenden Text C++-Ausdrücke wie delete, vector, pointer zu verwenden, wenn du ein wenig darüber nachdenkst, sollte es dir klar werden - ansonsten frag einfach)

Stell es dir so vor: du hast ein wichtiges Dokument gut versteckt in deinem Schreibtisch. Weil es so wichtig ist, schreibst du dir auf einen Zettel, wo genau du das Dokument versteckt hast. Und weil du viele wichtige Dokumente versteckt hast, hast du auch viele Zettel. Diese sind alle säuberlich in einer Mappe eingeheftet. Jetzt hast du dein neues Dokument versteckt, und den Zettel mit dem Ort möchtest du auch einheften. Du kopierst dir den Zettel und heftest die Kopie in die Mappe. Anschließend zerreißt du das Original.

Wenn du jetzt die Mappe verlieren solltest, sind die Dokumente zwar noch da, nur findest du sie nie wieder.

Und wenn du ein Dokument vernichten willst, dann schaust du in der Mappe nach, wo sich das Dokument befindet und zerreißt das Dokument. Der Zettel mit dem Ort des Dokumentes ist dann zwar immer noch da, aber nutzlos.

Der vector ist die mappe, wo ich den kleinen zettel abhefte? Und der raw pointer ist das eigentliche dokument?

du legst ein neues Dokument mit "new" an. Den Rückgabewert - die Adresse des Objektes - speicherst du in einem Pointer (der kleine Zettel). Bei push_back wird der Pointer kopiert, also hast du nun zwei Pointer, die auf ein Objekt zeigen. Mit delete löschst du das eigentliche Objekt (zerreißen des Dokumentes). Die Pointer existieren anschließend immer noch, nur sind sie nicht mehr verwendbar.

Ich habe ein objekt mit new angelegt, und die adresse steht im pointer, wenn ich jetzt push_back mache, habe ich einen zweiten pointer auf das gleiche objekt.

Wenn ich das objekt zerstöre, zeigen beide pointer irgendwo hin --> undefiniertes verhalten.

Mein problem:

Ich habe die adresse auf ein objekt in dem raw pointer und ich habe die adresse auf ein objekt im vektor.

Ich hole mir über die adresse aus dem vektor das objekt und zerstöre es mit delete, anschließend lösche ich die adresse aus dem vektor.

Jetzt bleibt aber noch immer die adresse im raw-pointer, die ins nirgendwo zeigt.

Was mache ich jetzt damit? Einfach NULL setzen? Oder wie werde ich den pointer los?

@Braunstein

Danke für die videos, aber die funktionieren bei mir nicht. Vielleicht leigt das am browser oder fehlenden codecs bei mir.

Ich habe ein objekt mit new angelegt, und die adresse steht im pointer, wenn ich jetzt push_back mache, habe ich einen zweiten pointer auf das gleiche objekt.

Richtig.

HerbertB schrieb:

Wenn ich das objekt zerstöre, zeigen beide pointer irgendwo hin --> undefiniertes verhalten.

Naja, zeigen dürfen sie schon darauf, sie dürfen nur nicht schreibend darauf zugreifen.

HerbertB schrieb:

Ich habe die adresse auf ein objekt in dem raw pointer und ich habe die adresse auf ein objekt im vektor.

Ich hole mir über die adresse aus dem vektor das objekt und zerstöre es mit delete, anschließend lösche ich die adresse aus dem vektor.

Jetzt bleibt aber noch immer die adresse im raw-pointer, die ins nirgendwo zeigt.

Was mache ich jetzt damit? Einfach NULL setzen? Oder wie werde ich den pointer los?.

Da kannst du nichts machen. Den Zeiger bekommst du erst am Ende des Gültigkeitsbereichs los. Du kannst also nur den Gültigkeitsbereich verkleinern.
Natürlich kannst du ihn auch NULL-setzen. Aber was bringt dir das? Egal ob NULL oder nicht NULL, in beiden Fällen wirst du den Zeiger doch nicht mehr verwenden.

@Braunstein

Danke für die videos, aber die funktionieren bei mir nicht. Vielleicht leigt das am browser oder fehlenden codecs bei mir.

Du brauchst da wohl Quicktime dafür.

Abschließend noch, wenn ich mehrere zeiger auf ein objekt habe, das objekt aber dann zerstöre, ist der speicher wieder freigegeben und es entsteht kein speicherleck. Die zeiger darauf sind noch vorhanden, und verschwinden erst wenn der gültigkeitsbereich verlassen wird.

Kann man eigentlich irgendwie überprüfen, ob das objekt auf das der zeiger zeigt, noch existiert?

Kann man eigentlich irgendwie überprüfen, ob das objekt auf das der zeiger zeigt, noch existiert?

Nein, das musst du dir schon selber merken wenn du das wirklich brauchst.