deallocation of pointers - c++

Question

I have a list pointer in type of A (called ListA) container a vector of pointers B. (Each A object is a container class that has a private attribute: std<vector> *B). Then, I declare a pointer (called C having the same type as A), make a for-loop through ListA to get all pointers B and put them in C. When I quit my program, I deallocate ListA first, ListA in turn deallocates their own vector of pointers B. Then I deallocate pointer C, but the program crashes.
I have debugged this a bit and know that pointer C at the time of deallocation points to nothing, so it doesn't know what to deallocate.
Am I doing wrong? Or what is the solution for my problems?
Sorry, I'll put my code below
//Class A
#pragma once
#include "MyContainer.h"
class B;
class A
{
public:
A();
~A();
MyContainer<B> *pListOfB;
}
A::A()
{
pListOfB = new MyContainer<B>;
}
A::~A()
{
if(pListOfB)
{
delete pListOfB;
pListOfB = NULL;
}
}
//Class C
#pragma once
#include "MyContainer.h"
class B;
class C
{
public:
C();
~C();
MyContainer<B> *pListOfB;
void getListOfB(MyContainer<A> *pListOfA);
}
C::C()
{
pListOfB = new MyContainer<B>;
}
C::~C()
{
if(pListOfB)
{
delete pListOfB;
pListOfB = NULL;
}
}
void C::getListOfB(MyContainer<A> *pListOfA)
{
for(pListOfA->isBegin(); !pListOfA->isEnd();)
{
A *pA = pListOfA->getNext();
for(pA->isBegin(); !pA->isEnd();)
{
B* pB = pA->*pListOfB->getNext();
pListOfB->add(pB);
}
}
}
//Class MyContainer
#pragma once
#include <vector>
template <class T>
class MyContainer
{
public:
MyContainer(void);
~MyContainer(void);
T* getNext();
void removeAll();
void add(T* t);
void isBegin();
bool isEnd();
private:
std::vector<T*> items;
typename std::vector<T*>::iterator it;
};
template <class T> MyContainer<T>::~MyContainer()
{
removeAll();
}
template <class T> void MyContainer<T>::add(T *t)
{
items.push_back(t);
}
template <class T> void MyContainer<T>::removeAll()
{
while(!isEmpty())
{
std::vector<T*>::iterator tempIt =items.begin();
T* t = (*tempIt);
items.erase(tempIt);
delete t;
t=NULL;
}
}
template <class T>
T* MyContainer<T>::getNext()
{
if(isEnd() || isEmpty())
return NULL;
return (T*)(*(it++));
}
template <class T>
void MyContainer<T>::isBegin()
{
it = items.begin();
}
template <class T>
bool MyContainer<T>::isEnd()
{
return it==items.end();
}
I do the following action:
1. Initial a list A object : MyContainer *pListOfA;
2. Insert B data to each A object in pListOfA
3. Initial C object
4. Call C object operation getListOfB to get B data from pListOfA.
5. Quit program
Program first dealloc pListOfA, each A then dealloc their own pListOfB. After that program dealloc C object in turn dealloc pListOfB attribute of C. But pListOfB point to nothing because pListOfA deallocs every data. So my program crash.
I fix by rem the line delete pListOfB in the dtor of class C but I got a warning memory leak at that line.
That's all my problem. Please show me the right way. Thanks in advance.

Answer 1

first, you allocate
then you "take and put" somewhere (not allocating, just copying pointers)
then you deallocate
then you deallocate. ...wait

Answer 2

The right way is not to use plain pointers.
The moment you start to write delete pointer;, you have to reconsider if you really need that pointer and if you do need it, if there is not some pre-packaged smart-pointer class that can take the burden of memory management from you.
The example code you posted can be written entirely without the use of pointers:
//Class A
#pragma once
#include "MyContainer.h"
#include "B.h"
class A
{
public:
A() { };
~A() { };
MyContainer<B> ListOfB;
};
//Class C
#pragma once
#include "MyContainer.h"
#include "B.h"
class C
{
public:
C() { };
~C() { };
MyContainer<B> ListOfB;
void getListOfB(MyContainer<A>& ListOfA);
};
void C::getListOfB(MyContainer<A>& ListOfA)
{
for(ListOfA.isBegin(); !ListOfA.isEnd();)
{
A& anA = ListOfA.getNext();
for(anA.ListOfB.isBegin(); !anA.ListOfB.isEnd();)
{
B aB = anA.ListOfB.getNext();
ListOfB.add(aB);
}
}
}
//Class MyContainer
#pragma once
#include <vector>
template <class T>
class MyContainer
{
public:
MyContainer(void);
~MyContainer(void) { };
T& getNext();
void removeAll();
void add(const T& t);
void isBegin();
bool isEnd();
private:
std::vector<T> items;
typename std::vector<T>::iterator it;
};
template <class T> void MyContainer<T>::add(const T& t)
{
items.push_back(t);
}
template <class T> void MyContainer<T>::removeAll()
{
items.clear();
}
template <class T>
T& MyContainer<T>::getNext()
{
if(isEnd() || isEmpty())
return throw std::out_of_range("");
return *it++;
}
template <class T>
void MyContainer<T>::isBegin()
{
it = items.begin();
}
template <class T>
bool MyContainer<T>::isEnd()
{
return it==items.end();
}
If the B instances need to be shared between class A and class C (the lists in A and C refer both to the same B objects), then you could store shared pointers in the lists.