CODEWITHSUNDEEP
c++memory-managementvectormemory-leaks
JBRPG
JBRPG

Reputation: 141

How to really delete vectors

I am quite new to C++ memory management because unlike C, there are more hurdles to freeing all memory.

I am trying to successfully delete a pointer to vector of any type (i.e. vector * data)

/** 
 * We test the program in accessing vectors
 * with dynamic storage
**/
#include <iostream>
#include <vector> // you must include this to use vectors

using namespace std;

int main (void){
    // Now let's test the program with new and delete
    // for no memory leaks with vectors (type safe)
    // however, just calling delete is not enough to free all memory
    // at runtime
    vector <int> * test_vect = new vector <int> (10,5);

    // Print out its size
    cout << "The size of the vector is " << test_vect->size()
         << " elements" << endl;

    // run through vector and display each element within boundary
    for (long i = 0; i < (long)test_vect->size(); ++i){
        cout << "Element " << i << ": " << test_vect->at(i) << endl;
    }

    delete test_vect;
    return EXIT_SUCCESS;
}

However, I get a memory leak after using valgrind

==2301== HEAP SUMMARY:
==2301==     in use at exit: 4,184 bytes in 2 blocks
==2301==   total heap usage: 4 allocs, 2 frees, 4,248 bytes allocated
==2301== 
==2301== LEAK SUMMARY:
==2301==    definitely lost: 0 bytes in 0 blocks
==2301==    indirectly lost: 0 bytes in 0 blocks
==2301==      possibly lost: 0 bytes in 0 blocks
==2301==    still reachable: 4,096 bytes in 1 blocks
==2301==         suppressed: 88 bytes in 1 blocks

How can I be able to get rid of all traces of memory leaks with pointer to vector (i.e. at runtime)?

Upvotes: 8

Views: 19450

Answers (4)

user1357649
user1357649

Reputation:

For starters, I don't believe there is a leak. Did you properly read the Leak Summary you posted for the program?:

==2301== LEAK SUMMARY:
==2301==    definitely lost: 0 bytes in 0 blocks
==2301==    indirectly lost: 0 bytes in 0 blocks
==2301==      possibly lost: 0 bytes in 0 blocks
==2301==    still reachable: 4,096 bytes in 1 blocks
==2301==         suppressed: 88 bytes in 1 blocks

You've lost 0 bytes in 0 blocks. valgrind can't find any definite, indirect, or possible leaks. Your program is just fine.

As an aside: You... really shouldn't be using new or delete in this situation with that vector. C++, exactly like C, has things that come into and go out of scope on the stack if you declare them as regular variables. The following code achieves exactly what you did in your question, without the use of new and delete:

int main (void){
    // Now let's test the program with new and delete
    // for no memory leaks with vectors (type safe)
    // however, just calling delete is not enough to free all memory
    // at runtime (ThePhD: it is, actually!)
    vector <int>  test_vect(10,5);

    // Print out its size
    cout << "The size of the vector is " << test_vect.size() 
         << " elements" << endl;

    // run through vector and display each element within boundary
    for (long i = 0; i < (long)test_vect.size(); ++i){
        cout << "Element " << i << ": " << test_vect.at(i) << endl;
    }

    // ( ThePhD: Look ma, no deletions! )
    return EXIT_SUCCESS;
}

The stack will clean itself up magically, because std::vector has a destructor that cleans up its resources when it goes out of scope. You don't need to make it dynamic and put it on the heap / free-store area of program memory, when the stack will do it just fine.

Also, it sounds like you come from C, so I'll take the time to say: Welcome to C++. :D

Upvotes: 22

dtech
dtech

Reputation: 49329

The whole purpose of those container classes is to do memory management for you, allocation, reallocation and deallocation. You put the container on the stack, it internally keeps its contents dynamically allocated, and when the container instance is deleted, it automatically deletes the dynamically allocated data.

Dynamic instantiation of the container itself defeats the purpose and is almost always entirely pointless.

And yes, in your case, the vector is really deleted.

Upvotes: 3

Ryan Santos
Ryan Santos

Reputation: 9

I think you need to call

if(test_vect != 0)
{
   if(!test_vect->empty())
      test_vect->clear();
}

before deleting it

Upvotes: -3

stardust
stardust

Reputation: 5998

I think this can be the answer. As far as C++ is concerned there is no leak here.

Upvotes: 6

Related Questions