dynamischen Speicher freigeben

life_drake

Hallo...

Folgendes Problem:

char const *foo (char const *irgendwas) {

int const laenge = strlen(irgendwas);

char static *text = new char[laenge];

.... // da passiert irgendwas

return text;
}

Wie kann ich nun den allokierten Speicherplatz wieder freigeben? (mit delete[]; das ist schon klar )

Ich rufe die Funktion mehrmals vom Hauptprogramm aus auf ... erst nach dem letzten Aufruf, will ich den Speicherplatz freigeben. Aber zuvor muss der text wieder zurueck ans Hauptprogramm geliefert werden.

akari

Hallo

benutzt std::string anstatt char*, das verwaltet seinen Speicher selber.

Denn so wie du es jetzt hast must du dir die Pointer auf die allokierten speicher merken und nach gebrauch löschen, was das Programm fehleranfällig und unübersichtlich werden läßt.

bis bald
akari

life_drake

Danke akari!

Doch leider ist das auch mein Problem.
Meine erste Variante war mit strings. Um die Aufgabenstellung etwas hoeher zu gestalten, will ich mein Programm eben mit char* schreiben.
Deswegen bin ich eigentlich auf diesen Fehler "der Nicht-Freigabe" gestossen.

lolz

Dann schreib dir eine eigene String Klasse die intern mit char* arbeitet und benutze die.
In C++ wrappt man seine dynamischen Objekte damit man sie scheinbar auf dem Stack ablegen kann, denn da wird der Destruktor automatisch und immer aufgerufen und somit das dynamische Objekt immer freigegeben.

finix

life_drake schrieb:

Um die Aufgabenstellung etwas hoeher zu gestalten, will ich mein Programm eben mit char* schreiben.

Andromeda

life_drake schrieb:

Ich rufe die Funktion mehrmals vom Hauptprogramm aus auf ... erst nach dem letzten Aufruf, will ich den Speicherplatz freigeben. Aber zuvor muss der text wieder zurueck ans Hauptprogramm geliefert werden.

Hallo,
Dadurch, daß die Variable static ist, wird new nur einmal aufgerufen.
Es reicht also, wenn du ganz am Schluß einmal den Speicher wieder freigibst.

hustbaer

char* GlobalCharBuffer(size_t requestedLength, bool doDeallocate = false);

void __cdecl FreeGlobalCharBuffer()
{
    GlobalCharBuffer(0, true);
}

char* GlobalCharBuffer(size_t requestedLength, bool doDeallocate)
{
    static char* buffer = 0;
    static size_t allocatedLength = 0;
    static bool isCleanupRegistered = false;

    if(!isCleanupRegistered)
    {
        atexit(FreeGlobalCharBuffer);
        isCleanupRegistered = true;
    }

    if((requestedLength > allocatedLength)
        || ((requestedLength == 0) && doDeallocate))
    {
        delete [] buffer;
        buffer = 0;
        allocatedLength = 0;
        if(requestedLength)
        {
            buffer = new char[requestedLength];
            allocatedLength = requestedLength;
        }
    }

    return buffer;
}

char const *foo (char const *irgendwas)
{
    int const laenge = strlen(irgendwas);
    char* text = GlobalCharBuffer(laenge);

    // da passiert irgendwas

    return text;
} 

int main()
{
    printf("%s\n", foo("bar"));
    printf("%s\n", foo("baz baz baz"));

    return 0;
}

Den atexit Teil kannst du natürlich weglassen, und stattdessen FreeGlobalCharBuffer selbst aufrufen.

life_drake

Andromeda schrieb:

Hallo,
Dadurch, daß die Variable static ist, wird new nur einmal aufgerufen.
Es reicht also, wenn du ganz am Schluß einmal den Speicher wieder freigibst.

Danke! Ich weiss, was der Befehl static bewirkt ...

@Andromeda
Ich will ja den Speicher ganz zum Schluss freigeben! Aber davor muss ich eben nochmal den Text ins Hauptprogramm schleudern ...

@hustbaer
Koenntest du das vielleicht ein wenig erlaeutern? Waer sehr nett.

finix

Google: atexit?

hustbaer

Was gibts da zu erläutern?

CStoll

Also die Konstruktion sieht übertrieben aus. Normalerweise benutzt man entweder ein static-Array ( static char text[laenge]; ) oder dynamisch angeforderten Speicher ( char* text = new[laenge]; ), um sicherzustellen, daß das Array das Funktionsende überlebt - beide Verfahren gemischt sind mir bislang noch nicht untergekommen.