ich habe mal eine Frage zu Destuktoren.
Wenn ich eine neue UNIT erzeuge und in dieser eine Klasse definiere, dann
kann es ja sein, dass ich bestimmte BCB-Komponenten als Membervariablen der Klasse definiere. Speicher reserviere ich dann im Konstruktor der Klasse, wie z.B.:
(ist nur ein Bsp-Programm)

c_Klasse::c_Klasse()
{
   m_pSMTP = new TNMSMTP(Application);
   m_pStringList = new TStringList();

}

den Destruktor habe ich folgendermaßen definiert:

c_Klasse::~c_Klasse()
{
   delete m_pSMTP;
   delete m_pStringList;
}

Wenn ich nun mein Programm laufen lasse, wird dann der Destuktor automatisch aufgerufen, wenn z.B. ein

exit(0);

im Programmcode auftaucht, oder muss man diesen explizit aufrufen?
Und ist es so, dass wenn ich ein

new

benutze ich dieses Objekt dann immer wieder killen muss oder wird dieser Speicher bei Programmende generell wieder freigegeben?

Vielen Dank für die Antworten!

Hier mal der komplette Code des Beispielprogramms:

Klasse.cpp:

c_Klasse::c_Klasse()
{
   m_pSMTP = new TNMSMTP(Application);
   m_pStringList = new TStringList();

}

void c_Klasse::macheWas()
{
   m_pStringList->Add("Das ist ein Test");
   m_pStringList->Add("Ende.");
}

c_Klasse::~c_Klasse()
{
   delete m_pSMTP;
   delete m_pStringList;
}

Klasse.h:

class c_Klasse
{
   private:

   TNMSMTP   *m_pSMTP;

   public:

   c_Klasse();
   ~c_Klasse();

   TStringList    *m_pStringList;

   void macheWas();

};

Test.cpp:

#include <vcl.h>
#pragma hdrstop

#include "Test.h"
#include "Klasse.h"

//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
c_Klasse *cklasse = new c_Klasse();

//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
   : TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)
{
   cklasse->macheWas();

   AnsiString asText = cklasse->m_pStringList->Text;

   exit(0);

}

"delete objekt" gleichzeitig die Komponenten auch deleted oder muss dieses explizit noch passieren?

werden dann mit
"delete objekt" gleichzeitig die Komponenten auch deleted...

Solange diese innerhalb der Klasse erzeugten Objekte im Destruktor der Klasse wieder 'deleted' werden: Ja.
Es geschieht also implizit, da durch das delete der Destruktor aufgerufen wird.
Das kannst Du (fast) beliebig tief schachteln.

[Edit] Oder meinst Du Klassen, die von anderen Klassen abgeleitet sind? Aber auch hier: Ja. Der Destruktor der Basisklasse wird ebenfalls durchlaufen, wenn der Destruktur der abgeleiteten Klasse aufgerufen wird.

allerdings ist dein Codebeispiel zum Beispiel Beispiel für ein Speicherloch. Denn der Speicher von

c_Klasse *cklasse = new c_Klasse();

wird niht wieder freigegeben, und auch der Destruktor davon wird nicht aufgerufen.
Zum einen solltest du aus der globalen Instanz eine Memberinstanz des Forms machen. Denn dann kannst du std::auto_ptr verwenden, um automatisch mit beenden des Forms auch die Instanz löschen zu lassen, ohne extr noch den Destruktor des Forms schreiben zu müssen.

bis bald
akari

Globale Variablen sind böse. Siehe auch den FAQ-Beitrag dazu.

Meint ihr das dann vielleicht so:

Test.cpp:

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Test.h"

//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;

//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
   : TForm(Owner)
{

   cklasse = new c_Klasse();

   cklasse->macheWas();

   AnsiString asText = cklasse->m_pStringList->Text;

   delete cklasse;

   exit(0);

}
//---------------------------------------------------------------------------

Test.h:

//---------------------------------------------------------------------------

#ifndef TestH
#define TestH
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include "Klasse.h"
//------

//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published:	// Von der IDE verwaltete Komponenten
   TButton *Button1;
private:	// Anwender-Deklarationen
public:		// Anwender-Deklarationen
   __fastcall TForm1(TComponent* Owner);

   c_Klasse *cklasse;

};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

Klasse.cpp

//---------------------------------------------------------------------------

#pragma hdrstop

#include "Klasse.h"

//---------------------------------------------------------------------------

c_Klasse::c_Klasse()
{
   m_pSMTP = new TNMSMTP(Application);
   m_pStringList = new TStringList();

}

void c_Klasse::macheWas()
{
   m_pStringList->Add("Das ist ein Test");
   m_pStringList->Add("Ende.");
}

c_Klasse::~c_Klasse()
{
   delete m_pSMTP;
   delete m_pStringList;
}

Klasse.h:

//---------------------------------------------------------------------------

#include <vcl.h>
#include "NMsmtp.hpp"
#ifndef KlasseH
#define KlasseH

class c_Klasse
{
   private:

   TNMSMTP   *m_pSMTP;

   public:

   c_Klasse();
   ~c_Klasse();

   TStringList    *m_pStringList;

   void macheWas();

};
//---------------------------------------------------------------------------
#endif

@akari:

Denn dann kannst du std::auto_ptr verwenden...

Was meinst du damit? Kannst du mal ein kleines Beispiel geben wie man das anwendet?

Wenn ich jetzt das Programm wie oben hätte, würden dann noch speicherlöcher entstehen?

Gruß

dein neues Beispiel hat nun kein Speicherloch mehr, allerdings ist so natürlich die Membervariable sinnfrei, weil si ja nur lokal verwendet wird.

Das mit dem auto_ptr sieht dann so aus:

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Test.h"

//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;

//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
   : TForm(Owner), cklasse(new c_Klasse()) // Initialisierungsliste mit Ini. des  auto_ptr
{

   cklasse->macheWas();

   AnsiString asText = cklasse->m_pStringList->Text;

   exit(0);

}
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------

#ifndef TestH
#define TestH
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <memory> // Include für auto_ptr
#include "Klasse.h"
//------

//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published:    // Von der IDE verwaltete Komponenten
   TButton *Button1;
private:    // Anwender-Deklarationen
public:        // Anwender-Deklarationen
   __fastcall TForm1(TComponent* Owner);

   std::auto_ptr<c_Klasse> cklasse; // Deklaration des auto_ptr

};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

So kannst du 100% sicher sein, das mit dem Löschen jeder Instanz der Form (also auch beim Beenden des Programms) auch die jeweilige Instanz von c_KLasse gelöscht wird.

bis bald
akari

Das exit stammt aus dem Quellcode von skluge, da hab ich diesmal nicht aufgepasst

bis bald
akari

Vielen Dank!

So kannst du 100% sicher sein, das mit dem Löschen jeder Instanz der Form (also auch beim Beenden des Programms) auch die jeweilige Instanz von c_KLasse gelöscht wird.

Nur damit ich jetzt richtig verstanden habe. Wenn ich z.B. das Programm durch
"Application->Terminate();" beende, wird automatisch "cklasse" gelöscht und dessen Speicher wieder freigegeben?!
Benötige ich dann noch einen Destruktor für c_Klasse, oder muss dieser nicht mehr definiert werden?
Du hast ja gesagt, dass die Instanz "cklasse" durch das Beenden des Programms auch gelöscht wird (wenn ich das jetzt richtig verstanden habe ), muss ich dann kein delete explizit angeben?

So wie ich das jetzt verstanden habe, braucht man sich um die Speicheraufhebung jetzt keine Gedanken mehr zu machen, wenn man diesen auto_ptr benutzt. DAs Programm sorgt doch jetzt dafür, dass alle Instanzen und dessen Speicher wieder freigegeben werden (zusätzlich der Speicher, der durch mögliche komponentenreservierungen im konstruktor der jeweiligen Instanz), oder?

Nochmals danke für die Antwort!

Gruß

Nur damit ich jetzt richtig verstanden habe. Wenn ich z.B. das Programm durch
"Application->Terminate();" beende, wird automatisch "cklasse" gelöscht und dessen Speicher wieder freigegeben?!

In meinem Beispiel ja. Und zwar weil dann die Instanz des Formes gelöscht wird, und damit über den auto_ptr auch die c_Klasse-Instanz.
Achtung : das Form wird gelöscht, weil es so erstellt wird das es in dem Application-Objekt registriert ist. Man kann auch Form-Instanzen dynamisch erstellen, und diese nicht bei App. registrieren (new TForm1(0); ).
In diesem Fall wird diese Instanz nicht automatisch mit Programmende gelöscht, und damit auch nicht der auto_ptr ausgelöst.

Benötige ich dann noch einen Destruktor für c_Klasse, oder muss dieser nicht mehr definiert werden?

Ob du für c_Klasse einen Destruktor brauchst oder nicht hat nichts mit auto_ptr oder der Lebenszeit zu tun. Sondern nur ob c_Klasse selber Speicher allokiert hat (in deinem Fall m_pSMTP, m_pStringList). Dieser muß wieder freigegebene werden, gleichgültig in welchem Zustand die Instanzen sind.

bis bald
akari

m_pPlaintext = new TIdText(m_pMessage->MessageParts,m_pStringListHTML);
   m_pPlaintext->ContentType="text/plain";

kommt beim "delete m_pPlaintext" ein Fehler!

m Projekt Projektname sind zu viele aufeinanderfolgende Exceptions aufgetreten: Anwendungsdefinierte Exception (Code xxxx) bei xxxx. Prozeß wurde angehalten. Fortsetzen mit Einzelne Anweisung oder Start.

Woran kann das denn liegen? Weiß jemand eine Lösung