Wie dynamischen Speicher einer statischen Variablen freigeben?

_paul_

Moin zusammen,

ich habe eine Funktion die etwa folgendermaßen aussieht:

std::set<std::string> const & f()
{
    static std::set<std::string> *p = 0;

    if (p == 0)
    {
        p = new std::set<std::string>;
        *p.insert(...);
        .
        .
        .
    }

    return *p;
}

Wie kann ich nun den mit new allokierten Speicher wieder freigeben? Ein Ansatz wäre, eine Klasse um die Funktion herumzubauen, so das der Destruktor den Speicherplatz wieder freigeben kann.

class C
{
    private:
    static std::set<std::string> *p = 0;

    public:
    C()
    {
        if (p == 0)
        {
            p = new std::set<std::string>;
            *p.insert(...);
            .
            .
            .
        } 
    }

    ~C()
    {
        if (p != 0)
            delete p;
    }

    std::set<std::string> const & f()
    {
        if (p == 0)
        {
            p = new std::set<std::string>;
            *p.insert(...);
            .
            .
            .
        }

        return *p;
    }
};

Was mir an der Lösung jedoch nicht gefällt ist, dass ich stets eine Instanz der Klasse brauche. Dabei würde es mir im Grunde reichen, wenn C::f statisch wäre. Wenn ich aber C::f nur statisch verwende, dann wird wieder kein Destruktor aufgerufen, der mir den Speicher freigeben würde.

Was ist also des Rätselts Lösung? Freue mich auf Antworten.

Gruß
Paul

Michael E.

Warum benutzt du überhaupt new? Machs doch so:

std::set<std::string> initFunction()
{
    std::set<std::string> p;    // Ist wegen NRVO nicht teuer
    p.insert(...);
    ...
    return p;
}

const std::set<std::string>& f()
{
    static std::set<std::string> p = initFunction();
    return p;
}

_paul_

Das war jetzt zu einfach.

Vielen Dank!