C++ 如何删除模板？

我在删除模板时遇到问题。
我的模板和析构函数：

template<class S, class T>  
class Consortium
{

private :

    map<const S, Node<T>*> m_consortiumMap;
    Heap<T>m_consortiumHeap;

public :

    ~Consortium();
    void Insert(const S key, T toAdd);
    void Update(const S key);
    void Remove(const S key);
    const T Top();
};

template<class S, class T>
Consortium<S,T>::~Consortium()
{
    m_consortiumMap.clear();
    delete &m_consortiumHeap.;
}

template <class T>
class Heap
{
private :

    vector<Node<T>*> m_heapVector;

public :

    ~Heap();

    int parent(int i) const {return i / 2;}
    int left(int i) const {return 2 * i;}
    int right(int i) const {return 2 * i + 1;}
    void heapify(int index);
    Node<T>* extractMin ();
    void heapDecreaseKey (int index, Node<T>* key);
    void MinHeapInsert (Node<T>* key);
    Node<T>* ExtractNode(int index);
    Node<T>* top ()const {return m_heapVector[0];}

};  

template<class T>
Heap<T>::~Heap()
{
    for (int i = 0 ; i < m_heapVector.size() ; i++)
        m_heapVector.erase(m_heapVector.begin() + i);
}

模板
阶级联盟
{
私人：
地图m_财团地图；
Heapm_财团heap；
公众：
~Consortium（）；
无效插入（常数S键，T至添加）；
无效更新（常数S键）；
无效删除（常数S键）；
常数T Top（）；
};
模板
联合体：：~联合体（）
{
m_consortiumMap.clear（）；
删除&m_联合体堆。；
}

我的堆和析构函数：

template<class S, class T>  
class Consortium
{

private :

    map<const S, Node<T>*> m_consortiumMap;
    Heap<T>m_consortiumHeap;

public :

    ~Consortium();
    void Insert(const S key, T toAdd);
    void Update(const S key);
    void Remove(const S key);
    const T Top();
};

template<class S, class T>
Consortium<S,T>::~Consortium()
{
    m_consortiumMap.clear();
    delete &m_consortiumHeap.;
}

template <class T>
class Heap
{
private :

    vector<Node<T>*> m_heapVector;

public :

    ~Heap();

    int parent(int i) const {return i / 2;}
    int left(int i) const {return 2 * i;}
    int right(int i) const {return 2 * i + 1;}
    void heapify(int index);
    Node<T>* extractMin ();
    void heapDecreaseKey (int index, Node<T>* key);
    void MinHeapInsert (Node<T>* key);
    Node<T>* ExtractNode(int index);
    Node<T>* top ()const {return m_heapVector[0];}

};  

template<class T>
Heap<T>::~Heap()
{
    for (int i = 0 ; i < m_heapVector.size() ; i++)
        m_heapVector.erase(m_heapVector.begin() + i);
}

模板
类堆
{
私人：
向量m_heapVector；
公众：
~Heap（）；
int parent（int i）const{return i/2；}
int left（int i）const{return 2*i；}
int right（int i）const{return 2*i+1；}
void heapify（int索引）；
节点*extractMin（）；
void heapDecreaseKey（int索引，节点*键）；
void MinHeapInsert（节点*键）；
节点*ExtractNode（int索引）；
Node*top（）常量{return m_heapVector[0]；}
};  
模板
堆：：~Heap（）
{
对于（int i=0；i

这是保存模板的对象，我也有问题：

class Garage
{
    private :

        Consortium<string, Vehicle*> m_consortium;

    public :

        ~Garage() {delete &m_consortium;}
};

class车库
{
私人：
联合体m_联合体；
公众：
~Garage（）{delete&m_consortium；}
};

---

这里怎么了？

您可能想删除向量中元素指向的对象。Erase方法不会这样做，它只是从向量中删除指针元素，而不会破坏指向的对象。因此，您需要（我猜想）首先删除指向的对象，以避免内存泄漏。你可以这样做：

for( vector<Node<T>*>::iterator iter = m_heapVector.begin(), endI = m_heapVector.end(); iter != endI; ++iter)
{
   delete *iter;
}

// m_heapVector.clean(); // Not necessary in destructor, since the vector will be destroyed anyway.

for（向量：：迭代器iter=m_heapVector.begin（），endI=m_heapVector.end（）；iter！=endI；++iter）
{
删除*国际热核实验堆；
}
//m_heapVector.clean（）；//在析构函数中不需要，因为向量无论如何都会被销毁。

使用C++0x函数：

std::for_each( m_heapVector.begin(), m_heapVector.end(), []( Node<T>* node) { delete node; });

std:：for_each（m_heapVector.begin（），m_heapVector.end（），[]（Node*Node）{delete Node；}）；

---

另外，使用容器的

clear（）。Erase方法不会这样做，它只是从向量中删除指针元素，而不会破坏指向的对象。因此，您需要（我猜想）首先删除指向的对象，以避免内存泄漏。你可以这样做：

for( vector<Node<T>*>::iterator iter = m_heapVector.begin(), endI = m_heapVector.end(); iter != endI; ++iter)
{
   delete *iter;
}

// m_heapVector.clean(); // Not necessary in destructor, since the vector will be destroyed anyway.

for（向量：：迭代器iter=m_heapVector.begin（），endI=m_heapVector.end（）；iter！=endI；++iter）
{
删除*国际热核实验堆；
}
//m_heapVector.clean（）；//在析构函数中不需要，因为向量无论如何都会被销毁。

使用C++0x函数：

std::for_each( m_heapVector.begin(), m_heapVector.end(), []( Node<T>* node) { delete node; });

std:：for_each（m_heapVector.begin（），m_heapVector.end（），[]（Node*Node）{delete Node；}）；

另外，使用容器的
clear（）
方法（在您的例子中是vector）删除所有元素。
因为m_consortiumHeap是类的数据成员（直接，而不是指向它的指针），所以不必显式删除它。当Consortium实例被销毁时，它将自动为您调用m_consortiumHeap的析构函数。
由于m_consortiumHeap是类的数据成员（直接，而不是指向它的指针），您不必显式删除它。当Consortium实例被销毁时，它会自动为您调用m_consortiumHeap的析构函数。
这表面上是错误的：

delete &m_consortiumHeap;

您只能
删除分配给
新建的
内容
m_consortiumHeap
是类的一部分，在类被分配时自动分配，在类被解除分配时自动解除分配。您不能也不能明确地
删除它

这可能有相反的问题：

m_consortiumMap.clear();

m_consortiumMap
的内容是指针。我无法从您显示的代码中分辨出来，但是如果映射中的节点是由
联合体
类使用
new
分配的，则它们必须
delete
ed，否则您将泄漏内存。清除映射只会删除指针，而不会释放指针指向的内存。您必须首先遍历映射并删除每个元素。虽然元素的解除分配很重要，但清除析构函数中的映射是毫无意义的，因为映射本身将立即被销毁

这是令人困惑的：

for (int i = 0 ; i < m_heapVector.size() ; i++)
    m_heapVector.erase(m_heapVector.begin() + i);

另外，
std:：vector
，就像
std:：map
，有一个
clear（）
函数，但是就像我说的，在析构函数中清除向量是没有意义的。您真正想要做的是释放元素（如果需要）。
这表面上是错误的：

delete &m_consortiumHeap;

您只能
删除分配给
新建的
内容
m_consortiumHeap
是类的一部分，在类被分配时自动分配，在类被解除分配时自动解除分配。您不能也不能明确地
删除它

这可能有相反的问题：

m_consortiumMap.clear();

m_consortiumMap
的内容是指针。我无法从您显示的代码中分辨出来，但是如果映射中的节点是由
联合体
类使用
new
分配的，则它们必须
delete
ed，否则您将泄漏内存。清除映射只会删除指针，而不会释放指针指向的内存。您必须首先遍历映射并删除每个元素。虽然元素的解除分配很重要，但清除析构函数中的映射是毫无意义的，因为映射本身将立即被销毁

这是令人困惑的：

for (int i = 0 ; i < m_heapVector.size() ; i++)
    m_heapVector.erase(m_heapVector.begin() + i);

另外，
std:：vector
，就像
std:：map
，有一个
clear（）
函数，但是就像我说的，在析构函数中清除向量是没有意义的。你真正想要的是什么