Der Sachverhalt meiner Anwendung ist der, dass ein Formular mit new erzeugt wird. Mich interessiert was mit dem Speicher passiert den ich mit new angelegt habe passiert wenn die Anwendung geschlossen wird? Wird dieser Freigegeben oder muss ich selber diesen Freigeben?

void __fastcall TF::FormClose(TObject *Sender, TCloseAction &Action)
{
   Action = caFree;
   F=NULL;
}

Anlegen von einem Formular:

if(F)
   {
       delete F;
   }

   F = new TF(Owner);
   F->Show();

Kann mir bitte jemand helfen?
*
Mit freundlichen Grüßen
coder24h
*

F = new TF(Owner);
F->Show();

Jetzt schließt der Anwender das Formular. Ist der Speicher frei oder nicht? Wenn nicht, wie kann ich daführ sorgen, dass der Speicher nach dem Schließen auch frei wird?
*
MfG
coder24h*

Aber -> siehe Antwort von owner

christian schrieb:

Das Schließen des Fensters bedeutet nicht, dass das Formular "zu Abschuss freigegeben" ist.

Das ist im allgemeinen richtig, aber coder24h hat ja in OnClose ja Action = caFree;, was das Form nach dem ersten schließen tatsächlich automatisch löscht und damit ungültig macht.

bis bald
akari

Anwendung die DLL nutzt:

bool TFormDLLLoader::LoadConComDLL(void)
{
	if(!this)	return false;    // TFormDLLLoader besitzt keine Instanz
    if(ConComDLL !=0) return true;

	ConComDLL = LoadLibrary("DomkeDLL01.dll"); // Laden

    if (ConComDLL !=0)	return true; // Laden erfolgreich
    return false;          // Laden fehlgeschlagen
}

bool TFormDLLLoader::FreeConComDLL(void)
{
	if(!this) return false;	// TFormDLLLoader besitzt keine Instanz

    FreeLibrary(ConComDLL); // Entaden
    if(ConComDLL !=0) return true; // Entaden fehlgeschlagen
    return false; // Entaden erfolgreich
}

bool TFormDLLLoader::OpenConComForm(void)
{
	if(!this || ConComDLL ==0) return false;	// TFormDLLLoader besitzt keine Instanz
    if(!pOpenConComForm) //CloseConComForm(); // Bereits geöffnet, also schließen

    pOpenConComForm = (TOpenForm*)GetProcAddress(ConComDLL, "_OpenForm");
    if(!pOpenConComForm)	return false; // Öffnen fehlgeschlagen
    pOpenConComForm(this); // Öffnen
    return true; // Öffnen erfolgreich
}

void __fastcall TFormDLLLoader::miDNConComClick(TObject *Sender)
{
	LoadConComDLL();
    OpenConComForm();
}

in der DLL:

extern "C" __declspec (dllexport) void OpenForm(TComponent* Owner)
{
	if(F)
    {
        delete F;
    }

    F = new TF(Owner);
	F->Show();
}

void __fastcall TF::FormClose(TObject *Sender, TCloseAction &Action)
{
   Action = caFree;
   F=NULL;
}

denn wenn die Aussage stimmt, dass der Speicher nicht freigegeben wird

BCB-Hilfe schrieb:

caFree : Das Formular wird geschlossen und sein Speicher freigegeben.

Desweiteren :

::LoadConComDLL(void)

das ist veralteter C-Stil, in C++ solltest du da kein void schreiben.

if(!this)    return false;

Diese Zeile ist überflüssig. Solltest du die tatsächlich aber brauchen (weil du die Mehtode irgendwo für eine NULL-Instanz aufrufst), hast du einen Konzepzfehler, den du beheben solltest und nicht durch solche Symptom-Behandlung überspringst.

bis bald
akari

warum man nicht den gleichen Speicher, im diesen Fall des Formulars, mehrmals freigeben kann?

Ich verstehe nicht was du meinst, Speicher darf man immer nur einmal wieder freigeben. Aber je nachdem was das für ein Datentyp ist, kann der Aufruf des Destruktors durch das delete auch zu verschiedenen undefinierten Fehlern führen.

bis bald
akari

diese Frage stellt sich nicht. Das mehrmalige Freigeben kann jeden beliebigen Fehlerverursachen, weil es undefiniert ist. Möglichweise merkt der User nichts davon, möglicherweise stürtzt auch der ganze PC sofort ab...

bis bald
akari