指针的释放

Question

我有一个 A 类型的列表指针（称为 ListA），容器是指针 B 的向量。（每个 A 对象都是一个具有私有属性的容器类：std*B）。然后，我声明一个指针（称为C，与A的类型相同），通过ListA进行for循环以获取所有指针B并将它们放入C中。当我退出程序时，我首先释放ListA，ListA依次释放他们自己的指针向量 B。然后我释放了指针 C，但程序崩溃了。

我对此进行了一些调试，知道释放时指针 C 没有指向任何内容，因此它不知道要释放什么。

我做错了吗？或者我的问题有什么解决方案？

抱歉，我将把我的代码放在下面

//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();
}

我执行以下操作： 1. 初始化一个列表A对象：MyContainer *pListOfA； 2.将B数据插入到pListOfA中的每个A对象中 3. 初始C对象 4. 调用C对象操作getListOfB从pListOfA中获取B数据。 5.退出程序

程序首先dealloc pListOfA，每个A然后dealloc自己的pListOfB。之后，程序释放 C 对象，然后释放 C 的 pListOfB 属性。但是 pListOfB 指向任何内容，因为 pListOfA 释放了所有数据。所以我的程序崩溃了。 我通过 rem 修复了 C 类 dtor 中的删除 pListOfB 行，但我在该行收到了警告内存泄漏。 这就是我的问题。请告诉我正确的方法。提前致谢。

Answer 1

• 首先，您分配，
• 然后您“取出并放置”某处（不分配，只是复制指针），
• 然后您取消分配
• ，然后您取消分配。 ...等待

Answer 2

正确的方法是不要使用普通指针。

当你开始编写deletepointer;时，你必须重新考虑是否真的需要该指针，如果确实需要它，是否没有一些预先打包的智能指针类可以接受内存管理的负担由您承担。

您发布的示例代码完全可以在不使用指针的情况下编写：

//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();
}

如果 B 实例需要在类 A 和类 C 之间共享（A 和 C 中的列表都引用相同的 B 对象），那么您可以存储 <列表中的 href="http://www.boost.org/doc/libs/1_36_0/libs/smart_ptr/shared_ptr.htm" rel="nofollow">共享指针。