C++ 中的析构函数调用

Question

我研究过，每当对象超出范围或使用delete 运算符取消分配给它的内存时，就会调用Destructor。

#include  <iostream>

using namespace std;

class point
{
   private:
      int x_coord;
      int y_coord;

   public:
      point()
      {
         x_coord = 0;
         y_coord = 0;
      }

      point(int x, int y)
      {
         x_coord = (x > 79 ? 79 : (x < 0 ? 0 : x));
         y_coord = (y > 79 ? 79 : (y < 0 ? 0 : y));
      }

      ~point()
      {
         cout << "Destructor invoked\n";
      }

      int getx(void)
      {
         return x_coord;
      }

      int gety(void)
      {
         return y_coord;
      }
};

int main()
{
   point p1;
   point p2(20, 80);

   point *p3 = new point;

   cout << "p1.x =  " << p1.getx() << ": p1.y = " << p1.gety()<< "\n";
   cout << "p2.x =  " << p2.getx() << ": p2.y = " << p2.gety()<< "\n";
   cout << "p3->x =  " << p3->getx() << ": p3->y = " << p3->gety()<< "\n";

   point * p4 = &p1;
   delete p4;
   delete p3;

   return 0;

}

1. 使用delete p4 取消分配给p1 的内存。因此析构函数被调用
2. delete p3 调用下一个析构函数。
3. p2 超出范围并调用下一个析构函数。

我预计析构函数只会被调用 3 次。但我看到析构函数被调用了 4 次。这是什么原因呢？我对析构函数的理解是否有一些错误

Answer 1

代码中有错误。您无法删除 p1（p4 指向 p1），因为它不是使用 new 创建的。因此，程序正在调用未定义的行为。

在这种特殊情况下，p1 的析构函数被调用两次：第一次是 delete，第二次是 p1 超出范围。也可能是其他任何结果（另一个可能的结果是崩溃）。

Answer 2

您将销毁 p1 两次，一次是当 p1 超出范围时，一次是当您调用 delete p4 时，它只是一个指向 p4 的指针。 code>p1，而不是单独的对象。顺便说一句，两次销毁一个对象是未定义的行为（就像删除堆栈对象一样（参见注释））。

Answer 3

p1 已在堆栈上分配，因此即使您在 p4 上调用了 delete，delete 也会在现在未分配的 p1 上调用。

请注意，释放内存并不（必然）将其清零。因此析构函数有可能被再次调用并打印消息。或者它可能会爆炸。这就是为什么确保在上次使用之前不释放内存至关重要。

Answer 4

如果您使用调试 CRT 进行编译，通过指针 p4 对 p1 的破坏是无效的，并且会引发运行时错误。