memory-leak in container c++ - c++

Question

I'm currently writing a container in C++, but I encounter problem with memory leak in it.
For test purpose I created 2 versions of main:
First one created and delete object from list in one loop(everything OK here)
Second one create object in first loop and delete all of them in second one(after end of both loops it's still a lot of memory used by program).
OS: Windows Seven;
IDE: CodeBlock 12.11;
Compiler: GNU GCC
Code
(placed in one code block, sorry if it's unclear for someone, just want to make this post as short as possible)
main.cpp:
#include <iostream>
using namespace std;
#include "planetarySystemContainer.hpp"
int main()
{
PlanetarySystemContainer * container;
container=new PlanetarySystemContainer();
PlanetarySystem *planet;
int i;
cin>>i;
i=0;
for(int i=0; i<10000000; i++)
{
planet=new PlanetarySystem();
planet->name("blabgs4tegser4labnab");
container->AddAtBegining(planet);
}
for(int i=0; i<10000000; i++)
{
container->DeleteFromBegining();
}
cin>>i;
return 0;
}
planetarySystemContainer.hpp:
class PlanetarySystemContainer
{
private:
PlanetarySystem *First;
PlanetarySystem *Last;
int PlanetarySystemQuantity;
public:
PlanetarySystemContainer();
void AddAtBegining(PlanetarySystem *a);
void DeleteFromBegining();
};
planetarySystemContainer.cpp
#include"planetarySystemContainer.hpp"
PlanetarySystemContainer::PlanetarySystemContainer()
:First(NULL)
,Last(NULL)
,PlanetarySystemQuantity(0)
{
}
void PlanetarySystemContainer::AddAtBegining(PlanetarySystem *a)
{
a->SetPrevious(NULL);
a->SetNext(First);
First=a;
if(a->GetNext()==NULL)
Last=a;
PlanetarySystemQuantity++;
}
void PlanetarySystemContainer::DeleteFromBegining()
{
if(First!=NULL )
{
if(First->GetNext()!=NULL)
{
PlanetarySystem* x=First;
First=First->GetNext();
First->SetPrevious(NULL);
delete x;
}
else
{
PlanetarySystem* x=First;
First=NULL;
Last=NULL;
delete x;
}
PlanetarySystemQuantity--;
}
}
planetarySystem.hpp:
#include <iostream>
class PlanetarySystem
{
private:
PlanetarySystem* Next;
PlanetarySystem* Previous;
unsigned int PlanetQuantity; //ilosc obiektow w ukladzie (planet+stacji+asteroid)
public:
PlanetarySystem();
string name;
PlanetarySystem *GetNext();
PlanetarySystem *GetPrevious();
void SetNext(PlanetarySystem *ps);
void SetPrevious(PlanetarySystem *ps);
int GetPlanetQuantity();
};
planetarySystem.cpp:
#include "planetarySystem.hpp"
PlanetarySystem::PlanetarySystem()
:Next(NULL)
,Previous(NULL)
,PlanetQuantity(0)
{
}
PlanetarySystem *PlanetarySystem::GetNext()
{
return Next;
}
PlanetarySystem *PlanetarySystem::GetPrevious()
{
return Previous;
}
void PlanetarySystem::SetNext(PlanetarySystem *ps)
{
Next=ps;
}
void PlanetarySystem::SetPrevious(PlanetarySystem *ps)
{
Previous=ps;
}
int PlanetarySystem::GetPlanetQuantity()
{
return PlanetQuantity;
};

Answer 1

I see no leak on the first look. But you can easily give a planet a unique name based on its insertion loop number and print the name in the destructor.
This way you can test if all Planets get deleted.

Answer 2

I just ran your code on my Linux box with valgrind after fixing some compile-time errors and reducing the loop count to something reasonable. The only leak valgrind detected is the leaked PlanetarySystemContainer. You aren't deleting it before the program exits.
Regardless, and as I mentioned in my comment, why are you reinventing the wheel by creating a custom container? It seems to me the standard containers will meet your needs just as well. Lastly leverage things like std::unique_ptr<> to automate memory management, or simply store PlanetarySystem objects within the container rather than pointers to them to obviate the need to manage memory.