C++ 我可以显式地调用对象'；在另一个类的实例中使用析构函数？

作为练习，我正在使用两个队列实现一个堆栈。我在堆栈类的每个实例中都有两个队列对象。我希望堆栈的析构函数调用队列的析构函数。从网上看，显式使用析构函数似乎并不常见，因为它们倾向于自动调用。我的代码：

template<class T>
class Stack {
// LIFO objects
   public:
      Stack(int MaxStackSize = 10);
      ~Stack();

      bool IsEmpty() const {return addS.IsEmpty();}
      bool IsFull() const {return addS.getSize()==maxSize;}

      Stack<T>& Add(const T& x);
      Stack<T>& Delete(T& x);
      void Print() const;
   private:
      LinkedQueue<T> addS;
      LinkedQueue<T> delS;
      int maxSize;
};

template<class T>
Stack<T>::Stack(int MaxStackSize)
{
   maxSize = MaxStackSize;
}

template<class T>
Stack<T>::~Stack()
{
   ~addS();
   ~delS();
}

template<class T>
class LinkedQueue {
// FIFO objects
    public:
        LinkedQueue() {front = rear = 0;} // constructor
        ~LinkedQueue(); // destructor
        bool IsEmpty() const
           {return ((front) ? false : true);}
        bool IsFull() const;
        T First() const; // return first element
        T Last() const; // return last element
        LinkedQueue<T>& Add(const T& x);
        LinkedQueue<T>& Delete(T& x);
      void Print() const;  // print the queue in order
      int getSize() const;

   private:
      Node<T> *front;  // pointer to first node
      Node<T> *rear;   // pointer to last node
};

template<class T>
LinkedQueue<T>::~LinkedQueue()
{// Queue destructor.  Delete all nodes.
   Node<T> *next;
   while (front) {
      next = front->link; 
      delete front; 
      front = next;
      }
}

模板
类堆栈{
//后进先出对象
公众：
堆栈（int-MaxStackSize=10）；
~Stack（）；
bool IsEmpty（）常量{return addS.IsEmpty（）；}
bool IsFull（）const{return addS.getSize（）==maxSize；}
堆叠和添加（常量T&x）；
堆叠和删除（T&x）；
无效打印（）常量；
私人：
LinkedQueue添加；
链接队列delS；
int-maxSize；
};
模板
堆栈：：堆栈（int-MaxStackSize）
{
maxSize=MaxStackSize；
}
模板
堆栈：：~Stack（）
{
~addS（）；
~delS（）；
}
模板
类链接队列{
//先进先出对象
公众：
LinkedQueue（）{front=rear=0；}//构造函数
~LinkedQueue（）；//析构函数
bool IsEmpty（）常量
{返回（（前面）？假：真）；}
bool IsFull（）常量；
T First（）const；//返回第一个元素
T Last（）const；//返回最后一个元素
链接队列和添加（常量T&x）；
链接队列与删除（T&x）；
void Print（）const；//按顺序打印队列
int getSize（）常量；
私人：
Node*front；//指向第一个节点的指针
Node*rear；//指向最后一个节点的指针
};
模板
LinkedQueue:：~LinkedQueue（）
{//队列析构函数。删除所有节点。
节点*下一步；
while（前面）{
下一步=前->链接；
删除前端；
前=下；
}
}

运行上述代码会导致以下错误：

stack.h:在析构函数“stack：~stack（）[with T=int]”中： stackrunner.cc:9:从此堆栈实例化。h:37:错误：不匹配 用于调用“（LinkedQueue）（）”

---

我给析构函数打错电话了吗？我应该不给析构函数打电话吗？调用类析构函数时是否自动调用对象析构函数？

会自动为您调用析构函数

对已销毁的对象调用析构函数是未定义的行为。它可能会崩溃，或导致任意结果，或造成实际损害

---

通常，不要显式调用析构函数（除非您一直在使用placement new在现有存储中构造对象）。

析构函数会自动为您调用

对已销毁的对象调用析构函数是未定义的行为。它可能会崩溃，或导致任意结果，或造成实际损害

---

通常，永远不要显式调用析构函数（除非您一直在使用placement new在现有存储中构造对象）.

将为您调用析构函数。将为您调用析构函数。类对象的析构函数是否在类析构函数中调用？类对象的析构函数是否在类析构函数中调用？