Thread: STL Set erase()

I have
vector<set<unsigned short>> theVector
vector<set<unsigned short>>::iterator vecIter
and
set<unsigned short> *theSetP

I use
theSetP = new set<unsigned short>()
to create various sets,
theVector.push_back(*theSetP)
to insert them into the vector,
and when I'm finished with one of them I use
theVector.erase(vecIter)
to delete it.

Does this completely delete the set and free its memory space, or should I be doing this differently?

Originally Posted by laserlight

That is one way, but better yet if it is possible: do not even use a pointer, and simply create the set as you pass it to the vector. If you are inserting n empty sets at the start, then you can just write:

Code:

vector<set<unsigned short> > theVector(n);

I can't do that. The number of sets is only determined at runtime, so I guess I'll just have to do new and delete for each one.

Thanks for clueing me in on what "is known" about what STL containers store. It wasn't known by me.

Besides the fact that you don't have to dynamically allocate each set, laserlight's solution still works even if the number of sets isn't known until runtime. As long as you know how many sets there will be before execution reaches the part of code that initializes the vector, you can construct it or resize it to hold the correct amount of empty sets.

Some examples of options:

Code:

std::vector<std::set<int> > theVector;
while (haveMoreSets)
{
    std::set<int> theSet;
    // fill theSet with data
    theVector.push_back(theSet);
    // Set haveMoreSets to true or false
}

Code:

std::vector<std::set<int> > theVector;
while (haveMoreSets)
{
    theVector.push_back(std::set<int>());
    std::set<int>& theSet = theVector.back(); // notice the reference
    // fill theSet with data
    // Set haveMoreSets to true or false
}

Code:

std::cin >> numberOfSets;
std::vector<std::set<int> > theVector(numberOfSets);
for (size_t i = 0; i < numberOfSets; ++i)
{
    // fill theVector[i] with data
}

Originally Posted by Daved

Besides the fact that you don't have to dynamically allocate each set, laserlight's solution still works even if the number of sets isn't known until runtime. As long as you know how many sets there will be before execution reaches the part of code that initializes the vector, you can construct it or resize it to hold the correct amount of empty sets.

I guess "at runtime" didn't describe my application correctly. The vector is created when the function is called. Then, as the function runs, sets are being created, merged, deleted, additional sets created, and so on, until all the data is processed, and there is no way to determine at the beginning how many sets there will be. I don't know how many sets are used until the function finishes. So it seemed that the most efficient way to handle this was by dynamically allocating them. Isn't this exactly the purpose of dynamic allocation?

Originally Posted by vart

Vector is already a dynamic container, no need to use new/delete directly to dynamicaly change its size

Who said anything about using new/delete to change its size?

The vector may be dynamic, but it's not so dynamic that it gives birth to sets.

Oops, sorry, I guess I wasn't quite awake yet.