class CTest
{
public:
	CTest(void) // ist die void-Angabe eigentlich Standardkonform?
	{
		this->m_strText = "standard"; // gibt es eine andere Möglichkeit, das zu setzen, außer im Konstruktor?
	}

	~CTest(void)
	{
		// muss ich hier was aufräumen?
	}

	std::string receive(void)
	{
		return this->m_strText; // hier entsteht eine Kopie auf dem Stack, also kein Memoryleak oder?
	}

	void change(std::string strNew)
	{
		this->m_strText = strNew;
	}

private:
	std::string m_strText;
};

void test()
{
	CTest *pTest = new CTest;
	pTest->change("omg");
	std::string strTest = pTest->receive(); // Kopie auf Stack, richtig?
	strTest = "bla"; // nur diese Kopie, also nicht der String in der Klasseninstanz selbst, wird verändern, richtig?
	delete pTest;
}

Gruß

Was die Frage nach der Initialisierung angeht: Guck dir mal an, was eine Initialisierungsliste ist.

Die anderen beiden Fragen:
Ja, strTest ist eine Kopie des Strings aus der Klasse. Die Aussage, dass diese auf dem Stack liegt ist mit Vorsicht zu genießen. Die Verwaltungsdaten des Strings liegen auf dem Stack, die Daten irgendwo auf dem Heap. Wenn du aber std::strings einander mit = zuweist, dann werden auch die Daten kopiert, es ist also alles so wie man es erwartet und deine Änderung von strTest in der nächsten Zeile hat keine Auswirkung auf m_strText.

Danke!

Gruß

class CContainer
{
public:
    CContainer(void)
    {
        cout << "Container Ctor" << endl;
    }

    ~CContainer(void)
    {
        cout << "Container Dtor" << endl;
    }
}

class CHolder
{
public:
    CHolder(void)
    {
        cout << "Holder Ctor" << endl;
    }

    ~CHolder(void)
    {
        cout << "Holder Dtor" << endl;
    }

private:
    CContainer m_Container;
}

// ...
int main(int argc, char *argv[])
{
    CHolder *pHolder = new CHolder;
    delete pHolder;
    // ist m_Container von pHolder dann auch gelöscht?
    // wenn ja, müsste die Ausgabe wie folgt sein:
    //   Holder Ctor -> Container Ctor -> Container Dtor -> Holder Dtor
    // stimmt das?

    return 0;
}

Gruß

Jeweils im Konstruktor bzw. Destruktor der Klasse in der das Objekt liegt beim zerstören des Objekts.

Faustregel: Pro new ein delete. Pro new[] ein delete[].

Faustregel: Pro new ein delete. Pro new[] ein delete[].

Bekannteste Abweichung von der Regel: Smart Pointer.

@theliquidwave

Dekonstruktor

Destruktor!

Und hast du denn das Programm nicht getestet?! - Da hättest du gesehen, dass genau diese Reihenfolge ausgegeben wird.. (oder wolltest du nur wissen, ob das so auch definiert ist?)

class CTest /*Warum immer C davor? Ungarische Notation ist recht veraltet...*/
{
public:
	CTest(void) // F ist die void-Angabe eigentlich Standardkonform?
                    /* Sie ist erlaubt. Aber unnötig. Eigentlich nur ein
                       C-Relikt, dort wars obligatorisch */
	{
		this->m_strText = "standard"; // gibt es eine andere Möglichkeit, das zu setzen, außer im Konstruktor?
                /* Jein, da gehört eigentlich in die Initialisierungsliste.
                   Und ja, du kannst den Wert in jeder Methode ändern, da er
                   nicht const ist. 
                   Das ständige this-> vorneweg ist übrigens nicht nötig,
                   seltene Spezialfälle mal ausgenommen.  
                   Das m_ am Variablennamen grenzt wieder an ungarische
                   Notation, ist aber Geschmackssache.*/
	}
	
	~CTest(void)
	{
		// muss ich hier was aufräumen?
                /* nein. Destruktoren von Membern werden automatisch 
                   aufgeräumt, std::string verwaltet seinen Soecher selbst
                   und sorg für dessen Freigabe. */
	}
	
	std::string receive(void)
	{
		return this->m_strText; // hier entsteht eine Kopie auf dem Stack, also kein Memoryleak oder?
                /* richtig, es wird ein temporäres Objekt erzeugt. */
	}
	
	void change(std::string strNew)
	{
		this->m_strText = strNew;
                /* zum this-> siehe oben. 
                   strNew ist hier eine lokale Kopie, die nur 
                   einmal gelesen wird für die Zuweisung. Eine 
                   konstante Referenz hätte es hier auch getan. */

	}

private:
	std::string m_strText;
};

void test()
{
	CTest *pTest = new CTest;
	pTest->change("omg");
	std::string strTest = pTest->receive(); // Kopie auf Stack, richtig?
                         /* Ja... */
	strTest = "bla"; // nur diese Kopie, also nicht der String in der Klasseninstanz selbst, wird verändern, richtig?
                         /* Ja, weils eine Kopie ist, also ein anderes 
                            Objekt und keine Referenz auf das string-Objekt
                            hinter pTest */
	delete pTest;    /* Das new und delete ist unnötig. Du hättest dein
                            CTest-Objekt auch gleich auf dem Stack anlegen
                            können. Hat nur Vorteile in diesem Fall. */
}

Du scheinst von irgendeiner anderen Programmiersprache zu stammen, zumindest lassen dein new/delete und die ganzen Fragen nach den automatischen Destruktor-Aufrufen usw. darauf schließen. Ein gutes C++-Buch sollte da Abhilfe schaffen. Das wichtigste dabei: vergiss was du in der anderen Sprache gelernt hast. Solche Dinge lassen sich meist nicht ohne weiteres von einer Sprache auf die andere übertragen.

Ja.

Jeweils im Konstruktor bzw. Destruktor der Klasse in der das Objekt liegt beim zerstören des Objekts.

Gut :>

drakon schrieb:

Destruktor!

Danke

drakon schrieb:

Und hast du denn das Programm nicht getestet?! - Da hättest du gesehen, dass genau diese Reihenfolge ausgegeben wird.. (oder wolltest du nur wissen, ob das so auch definiert ist?)

Ich wollte wissen wie es im Standard definiert ist. Ich habe zu viel gesehen um zu glauben, dass es auch im GCC so aussieht wie mit dem MSVC...

pumuckl schrieb:

Warum immer C davor? Ungarische Notation ist recht veraltet...

Keine Ahnung... Ich habe es mal in einem Tutorial gesehen, und auch in einigen Sourcecodes. Ich fand es praktisch. Aber stimmt, durch die heutigen IDEs ist es eigentlich nicht mehr nötig.

pumuckl schrieb:

// F ist die void-Angabe eigentlich Standardkonform?
Sie ist erlaubt. Aber unnötig. Eigentlich nur ein
C-Relikt, dort wars obligatorisch

Ok, ich habe echt kein Plan wo ich das her hab.

pumuckl schrieb:

Jein, da gehört eigentlich in die Initialisierungsliste.
Und ja, du kannst den Wert in jeder Methode ändern, da er nicht const ist.

Gut

pumuckl schrieb:

Das ständige this-> vorneweg ist übrigens nicht nötig,
seltene Spezialfälle mal ausgenommen.
Das m_ am Variablennamen grenzt wieder an ungarische
Notation, ist aber Geschmackssache.

So finde ich es übersichtlicher. Aber eins von beiden würde sicher reichen.

pumuckl schrieb:

strNew ist hier eine lokale Kopie, die nur
einmal gelesen wird für die Zuweisung. Eine
konstante Referenz hätte es hier auch getan.

Also so, und es wäre trotzdem eine Kopie in m_strText?

void change(const std::string &strNew)
{
    this->m_strText = strNew;
}

pumuckl schrieb:

Das new und delete ist unnötig. Du hättest dein
CTest-Objekt auch gleich auf dem Stack anlegen können. Hat nur Vorteile in diesem Fall.

Jo, war auch nur ein Beispiel auf mein speziellen Anwendungsfall bezogen. Hätte ich vielleicht dazuschreiben können.

pumuckl schrieb:

Du scheinst von irgendeiner anderen Programmiersprache zu stammen, zumindest lassen dein new/delete und die ganzen Fragen nach den automatischen Destruktor-Aufrufen usw. darauf schließen.

Ich komme aus der Welt voller GCs.

pumuckl schrieb:

Ein gutes C++-Buch sollte da Abhilfe schaffen. Das wichtigste dabei: vergiss was du in der anderen Sprache gelernt hast.

Guter Tipp - ich schleppe wohl wirklich ein paar "Altlasten" mit mir herum.

Danke an alle!!!

pumuckl schrieb:

Ein gutes C++-Buch sollte da Abhilfe schaffen. Das wichtigste dabei: vergiss was du in der anderen Sprache gelernt hast.

Guter Tipp - ich schleppe wohl wirklich ein paar "Altlasten" mit mir herum.

In einem solchem Fall ist imo "The C++ programming language" sehr geeignet. Ist ein rechtes Buch, aber wenn du schon Erfahrung hast, dann kannst du da enorm profitieren und erhälst einen guten Einblick, wie alles in C++ läuft.

Gruß

Gruß

class CHolder
{
private:
    CBla m_Bla;
 CHolder ()
   :
 m_Bla ( 2 ) // oder m_Bla ( "blub" )
 {}
}

pumuckl schrieb:

strNew ist hier eine lokale Kopie, die nur
einmal gelesen wird für die Zuweisung. Eine
konstante Referenz hätte es hier auch getan.

Also so, und es wäre trotzdem eine Kopie in m_strText?

void change(const std::string &strNew)
{
    this->m_strText = strNew;
}

Ich wollte mal pushen...
Wann genau soll ich eine Referenz benutzen?
Landet in m_strText trotzdem noch eine Kopie, die ich dann unabhängig vom echten strNew verändern kann? Ist strNew selbst die Kopie, oder wird der String erst beim operator= kopiert?

Gruß

m_strText erhält durch das = eine Kopie.
strNew ist nicht die kopie, durch die Übergabe per Referenz hast du dafür gesagt, das der Parameter nicht kopiert wird.

Gruß