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

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;
}

Vielen Dank!