C++ Not Freeing Memory

[MaxterTheTurtle]

Hello,

I am confused on why my program will not release its memory back to the OS. Here is my code:

#include <iostream>
#include <vector>

template <class C>
void delVector(std::vector<C> &vec)
{
	/* an empty vector */
	std::vector<C> empty;

	/* call the destructor of the vector elements */
	for (int a = 0; a < vec.size(); a++)
	{
		delete vec[a];
	}

	/* swap the contents for an empty vector */
	vec.swap(empty);
}

int main(void)
{
	/* memory test location one */
	std::cin.get();

	/* our test vector */
	std::vector<float*> test;

	/* give our vector some elements */
	for (int a = 0; a < 8192; a++)
	{
		test.push_back(new float(a));
	}

	/* memory test location two */
	std::cin.get();

	/* release our vector */
	delVector(test);

	/* memory test location three */
	std::cin.get();

	return 0;
}

I'm using one of the various methods that I found online, because it seemed to have the best results. I'm measuring the memory usage at those certain points in the program that the program uses in Task Manager. These are the results that I am getting:

At Location One: 720kb (roughly) 
At Location Two: 912kb (roughly)
At Location Three: 812kb (roughly)

Shouldn't the memory usage at location one and three be the same since I cleaned up the vector? Any help would be appreciated!

With even worse results, I've also tried:

test.clear();
test.shrink_to_fit();

Thanks,
MaxterTheTurtle

[Ispil]

Well, the issue has nothing to do with your code. The issue is that your vector still exists. Even an empty vector still allocates memory for the potential to fill- it is a dynamic array, after all. So there is still some memory dedicated for the first spot, even though there is none. It is just prepared to fill it, in case you decide to. After all, you are simply emptying it- you aren't deleting it outright.

[MaxterTheTurtle]

Thanks for the reply. I tried what you said and I have re-written my code to also delete the test vector as well, but I'm still ending up with some used memory. Though, when I test with crtDumpMemoryLeaks it returns 0. Is it possible that I am not deleting things properly?

#include <crtdbg.h>
#include <iostream>
#include <vector>

template <class C>
void delVector(std::vector<C> *vec)
{
	/* an empty vector */
	std::vector<C> empty;

	/* call the destructor of the vector elements */
	for (int a = 0; a < vec->size(); a++)
	{
		delete (*vec)[a];
	}

	/* swap the contents for an empty vector */
	vec->swap(empty);
	
	vec->clear();
	vec->shrink_to_fit();
}

int main(void)
{
	_CrtSetReportMode( _CRT_WARN, _CRTDBG_MODE_DEBUG );
	_CrtSetReportFile( _CRT_WARN, _CRTDBG_FILE_STDOUT );

	/* memory test location one */
	std::cin.get();

	/* our test vector */
	std::vector<float*> *test = new std::vector<float*>;

	/* give our vector some elements */
	for (int a = 0; a < 8192; a++)
	{
		test->push_back(new float(a));
	}

	/* memory test location two */
	std::cin.get();
	
	delVector(test); delete test;
	
	/* check for memory leaks */
	std::cout << _CrtDumpMemoryLeaks();

	/* memory test location three */
	std::cin.get();
	
	return 0;
}

[rmxhaha]

I try your code and seems to have the same problem
I experimented with raw array
then back to malloc
and still experiencing the same problem
I play with the size

#include <iostream>
#include <vector>
#include <cstdlib>

using namespace std;

int main(void)
{
cin.get();

    const int size = 200000;
    float* p[size];


cin.get();
    for( int x = 5; x--; ){

    cout << "Allocating " << size * sizeof( float ) << " after pause "<< endl;
    cin.get();

        for( int i = 0; i < size; ++ i ){
            p[i] = (float*) malloc( sizeof( float ) );
        }

    cout << "freeing it after pause\n";
    cin.get();

        for( int i = 0; i < size; ++ i ){
            free( p[i] );
        }
    }

cin.get();
	return 0;
}

I try to loop like the code above
allocate then deallocate
the allocate again and so forth
there is increase in memory everytime but it's just as much as 4KB or more

I found that the size of your allocation matters
and my conclusion
it's seems that C++ compiler or the OS is so smart that it left behind some memory just in case the next allocation to be a big one too...