如何调用类的析构函数？

Question

我有一个简单的 C++ 代码，但我不知道如何使用析构函数：

class date {

public:
    int day;
    date(int m)
    {
        day =m;
    }

    ~date(){
    cout << "I wish you have entered the year \n" << day;    
    }
};


int main()
{
  date ob2(12);
  ob2.~date();
  cout << ob2.day;
  return 0;
}

我的问题是，我应该在我的析构函数代码中写什么，调用析构函数后，它会删除day变量？

Answer 1

您很少需要显式调用析构函数。而是在对象被销毁时调用析构函数。

对于像ob2这样的局部变量对象，在超出范围时会被销毁：

int main() 
{ 
    date ob2(12); 

} // ob2.~date() is called here, automatically!

如果使用new 动态分配对象，则在使用delete 销毁对象时调用其析构函数。如果你有一个静态对象，它的析构函数会在程序终止时被调用（如果程序正常终止的话）。

除非您使用new 动态创建某些东西，否则您不需要执行任何显式操作来清理它（因此，例如，当ob2 被销毁时，它的所有成员变量，包括day，被破坏）。如果你动态地创建一些东西，你需要确保它在你完成后被销毁；最佳做法是使用所谓的“智能指针”来确保自动处理此清理。

Answer 2

您不需要显式调用析构函数。这是在对象ob2 的范围结束时自动完成的，即在main 函数结束时。

此外，由于对象具有自动存储，因此不必删除其存储。这也是在函数结束时自动完成的。

几乎从不需要手动调用析构函数（仅在低级库代码中），并且仅当先前使用 new 获取内存时（当您使用指针）。

由于手动内存管理容易发生泄漏，现代 C++ 代码尽量不显式使用 new 和 delete。当确实需要使用new时，就会使用所谓的“智能指针”来代替常规指针。

Answer 3

你不应该显式调用你的析构函数。

当您在堆栈上创建对象时（就像您所做的那样），您所需要的只是：

int main()
{
  date ob2(12);
  // ob2.day holds 12
  return 0; // ob2's destructor will get called here, after which it's memory is freed
}

当您在堆上创建对象时，您需要在调用其析构函数并释放内存之前delete您的类：

int main()
{
  date* ob2 = new date(12);
  // ob2->day holds 12
  delete ob2; // ob2's destructor will get called here, after which it's memory is freed
  return 0;   // ob2 is invalid at this point.
}

（未能在最后一个示例中调用 delete 将导致内存丢失。）

这两种方式各有优缺点。堆栈方式非常快地分配对象将占用的内存，您不需要显式删除它，但堆栈空间有限，您无法轻松、快速和干净地移动这些对象。

堆是执行此操作的首选方式，但在性能方面，它的分配速度很慢，您必须处理指针。但是您对对象的操作具有更大的灵活性，进一步使用指针会更快，并且您可以更好地控制对象的生命周期。

Answer 4

只有在非常特殊的情况下才需要直接调用析构函数。默认情况下，当您创建一个自动存储的变量并且它超出范围或使用new 动态分配的对象被delete 销毁时，系统将调用析构函数。

struct test {
   test( int value ) : value( value ) {}
   ~test() { std::cout << "~test: " << value << std::endl; }
   int value;
};
int main()
{
   test t(1);
   test *d = new t(2);
   delete d;           // prints: ~test: 2
}                      // prints: ~test: 1 (t falls out of scope)

为了完整起见，（通常不应使用）调用析构函数的语法类似于方法。析构函数运行后，内存不再是该类型的对象（应该作为原始内存处理）：

int main()
{
   test t( 1 );
   t.~test();            // prints: ~test: 1
                         // after this instruction 't' is no longer a 'test' object
   new (&t) test(2);     // recreate a new test object in place
}                        // test falls out of scope, prints: ~test: 2

注意：在t 上调用析构函数后，该内存位置不再是test，这就是重新创建 对象通过placement new 的原因.

Answer 5

尽管析构函数看起来像是你在使用完对象后需要调用它来摆脱或“销毁”你的对象，但你不应该那样使用它。

析构函数是在您的对象超出范围时自动调用的东西，也就是说，当计算机离开您实例化对象的“花括号”时。在这种情况下，当您离开 main() 时。你不想自己调用它。

Answer 6

您可能会对这里未定义的行为感到困惑。 C++ 标准没有规定如果在对象的析构函数运行后使用对象会发生什么，因为这是未定义的行为，因此实现可以做任何它喜欢的事情。通常，编译器设计者不会为未定义的行为做任何特别的事情，所以发生的事情是其他设计决策的产物。 （这有时会导致非常奇怪的结果。）

因此，一旦您运行了析构函数，编译器就没有关于该对象的进一步义务。如果您不再提及它，那也没关系。如果你确实引用了它，那是未定义的行为，从标准的角度来看，行为并不重要，而且由于标准没有说明，大多数编译器设计者不会担心程序的作用。

在这种情况下，最简单的做法是让对象保持不变，因为它没有占用资源，并且它的存储空间是作为启动函数的一部分分配的，并且在函数退出之前不会被回收.因此，数据成员的值将保持不变。编译器在读取ob2.day 时自然会做的是访问内存位置。

与任何其他未定义行为的示例一样，结果可能会随着环境的任何变化而变化，但在这种情况下可能不会。如果编译器能够捕获更多未定义行为的情况并发出诊断，那就太好了，但是编译器不可能检测到所有未定义的行为（有些发生在运行时），而且他们通常不会检查他们认为不存在的行为可能。

Answer 7

在这种情况下，您的析构函数不需要删除 day 变量。

你只需要在你用 new 分配的内存上调用 delete。

如果您使用 new 和 delete 来触发调用析构函数，您的代码将如下所示

class date {

  public: int* day; 
  date(int m) { 
      day = new int;
      *day = m; 
  }

  ~date(){ 
      delete day;
      cout << "now the destructor get's called explicitly";
  } 
};

int main() { 
  date *ob2 = new date(12); 
  delete ob2;
  return 0; 
}