stl + memory management question

For example, i have next code:

#include <set>
using namespace std;

struct SomeStruct 
{
    int a;
};

int main ()
{
    set<SomeStruct *> *some_cont = new set<SomeStruct *>;
    set<SomeStruct *>::iterator it;
    SomeStruct *tmp;

    for (int i = 0 ; i < 1000; i ++)
    {
        tmp = new SomeStruct;
        tmp->a = i;
        some_cont->insert(tmp);
    }

    for (it = some_cont->begin(); it != some_cont->end(); it ++)
    {
        delete (*it);
    }

    some_cont-&开发者_Go百科gt;clear(); // <<<<THIS LINE
    delete some_cont;
    return 0;
}

Does "THIS LINE" need to be called before deleting some_cont for avoiding memory leaks or destructor will be called automatically?

You don't need to call it, destructor will be called for sure.

No, there is no need to clear the set before destroying it.

Note that there is very rarely a need to allocate an std::set (or any standard container) manually. You'd be much better off just putting it in automatic storage and letting C++ handle the cleanup for you:

So instead of

set<SomeStruct *> *some_cont = new set<SomeStruct *>;

use

set<SomeStruct *> some_cont;

then change all some_cont-> to some_cont. and remove the delete some_cont (the container will be destroyed when main exits automatically.

The advantage to do things this way are:

1. You don't need to remember to delete the container, and
2. You don't need to do an expensive memory allocation up front.

It's also far more idomatic C++ to put things in automatic storage.

No, you don't need to explicitly clear a set before destroying the set.

OTOH, you do have a number of other problems ranging from lousy (Java-like) design, to incorrect syntax, to a missing operator to lots of potential memory leaks. While some of the design might make sense in Java or C#, it's a really poor idea in C++. Once we get rid of the most egregious problems, what we have left is something like this:

#include <set>

struct SomeStruct 
{
    int a;
    SomeStruct(int i) : a(i) {}
    bool operator<(SomeStruct const &other) const { return a < other.a; }
};

int main ()
{
    std::set<SomeStruct> some_cont;

    for (int i = 0 ; i < 1000; i ++)
    {
        SomeStruct tmp(i);
        some_cont.insert(tmp);
    }
    return 0;
}

No it is not, this will be done automatically in the set's destructor.

The STL containers automatically free any memory they own. So in your case the place allocated to store your SomeStruct* will be freed by the destructor of set. Note that the destructor of set does not call any destructors of SomeStruct, so it's good you iterate over them to delete them yourself.