How to delete elements in a vector. (erase won't work )

Question

When I delete elements in a vector with “erase”, then there is no memory cleared. For example I make a vector of the size 2000. After the creation the program use 1,5 MB memory. When I do the erase call nothing will be cleared. All the elements are gone. But they are still in memory.

For example:

#include <iostream>
#include <vector>

using namespace std;


int main()
{
    //Makes a vector of 2000 items
    vector<int> test(200000);

    //Pause for test purpose
    system("pause");

    //erase all elements
    test.erase(test.begin(),test.end());

    //Pause for test purpose
    system("pause");

    return false;
}

Size returns 0. But the process still uses 1,5MB of memory.

Maybe you should read this: http://stackoverflow.com/questions/586634/shrinking-a-vector Hope it helps. — Gang YIN, Feb 15 '12 at 07:54

Mike Seymour · Answer 1 · 2012-02-15T08:21:55.050

There are two reasons why the process keeps the memory:

std::vector will only reallocate memory when it grows, not when it shrinks.
Freed memory is often retained by the process to be reused.

In C++11, vectors have a shrink_to_fit member function, which will ask the vector to reduce the amount of allocated memory if possible. There's no guarantee that it will do that, though. In C++03, or if you want to guarantee that the excess memory is freed, you can use the trick of swapping the vector with a newly allocated one:

std::vector<int>(test).swap(test);

or if you want to clear it completely:

std::vector<int>().swap(test);

This trick moves the ownership of the allocated memory to a temporary vector; at the end of the expression, that vector is destroyed, freeing the memory.

Whether or not the memory is released from the process is entirely up to how your library manages the free store. Often, small allocations (up to a few megabytes, perhaps) are handled by a heap - the process requests large blocks of memory from the system, and splits them up into small pieces. The blocks can't be released unless all the small pieces have been freed, and many implementations won't release them even then.

Larger allocations may be requested directly from the system, in which case they will be released once they are freed.

So you may get the effect you expect with code like this:

// A few gigabytes will probably be allocated directly.
// You'll have to reduce this on a 32-bit system, or if there's not enough memory
std::vector<int> test(1000000000)

// Use the "swap trick" to ensure the memory is deallocated.
std::vector<int>().swap(test);

But there is no guarantee that even this will release the memory from the process; the details of memory allocation aren't specified by the standard, and are up to the compiler/library implementation.

score 8 · Accepted Answer · answered Feb 15 '12 at 07:54

8

erase doesn't free the memory. After the code in question test.capacity() >= 200000 is required by standard. Use

test.shrink_to_fit(); // in C++11
vector<int>(test).swap(test); // in C++03

to reduce vector's capacity. Please note that this still doesn't guarantee that the memory use as seen by the rest of the system will drop. The heap of the process cannot be reduced in size in general.

answered Feb 15 '12 at 07:54

Yakov Galka

70,775
16
139
220

What's the point is passing `test` into constructor? Why not just swap `temp` with an empty vector? – sharptooth Feb 15 '12 at 07:56
@sharptooth: the code posted is more general-will work even if you want to erase only *some* of the elements. – Yakov Galka Feb 15 '12 at 07:58

score 0 · Answer 3 · answered Feb 15 '12 at 08:00

You may like to test it this way:

int main() 
{ 
    //Makes a vector of 2000 items 
    {
        vector<int> test(200000); 

       //Pause for test purpose 
       system("pause"); 

       //erase all elements 
       test.erase(test.begin(),test.end()); 

       // Call erase or not, but destructor will be called here - freeing all memory
    } 

    //Pause for test purpose 
    system("pause"); 

    return false; 
}

vector.erase deons't deallocate memory for simple purpose - probably reusability of memory it has allocated, rather than re-allocating for future requests.

The vector is used in the whole process. So I can't use this in my case. — Laurence, Feb 15 '12 at 08:05

score 0 · Answer 4 · answered Feb 15 '12 at 08:00

0

When the process terminates, memory is reclaimed in your case. So, there is no need to erase the vector.
If you want to keep using the vector in a loop, then consider using clear() which clears the contents of the vector.
If the vector is used in an object, then once the object is destroyed, then vector is also destroyed.
But, if the vector contains pointers then you have to explicitly delete them.

answered Feb 15 '12 at 08:00

Jagannath

3,995
26
30

I want to clean the vector when it is alive. It is used in the whole process. So I can't use this in my case. – Laurence Feb 15 '12 at 08:06
As others have said swap() trick or shrink_to_fit() will clean the vector. The memory will be reclaimed or not is dependant on the implementation of library or compiler. For optmization reasons they don't normally do it. – Jagannath Feb 15 '12 at 09:38

How to delete elements in a vector. (erase won't work )

4 Answers4