c++ - 析构函数很懒惰，为什么？

Question

真正销毁对象的是什么？如果您这样做:

class K {
public:
   K (int m) {v = m;}
   int v;
};


Class * x = reinterpret_cast <K*> (:: operator new (sizeof (K)));
new ((void *) x) K (2);


x-> ~ C ();
cout << x-> v; / / result: 2

:: operator delete ((void *) v);

解构器什么也没做! (？)为什么？

Answer 1

您正在处理两组想法:

1. 对象的构建和销毁
2. 分配和释放内存。

了解如何正确组合它们很重要。

假设你有一个函数:

void f1()
{
   // Construct an object.
   // The constructor gets called.
   K k(10);

   // Do something with the object.

   // Done with the function
   // The object k gets destructed.
   // The destructor gets called.
}

在此函数中，您将在堆栈上构造对象。当您从函数返回时，析构函数会自动调用。内存会自动为您从堆栈中分配和释放。

现在，让我们看看另一个函数。

void f2()
{
   // Allocate memory for the object.
   // Use that Construct an object .
   // The constructor gets called.
   K* k = new K(10);

   // Do something with the object.

   // Done with the function
   // Delete the object.
   // The destructor gets called.
   // Deallocate the memory.
   delete k;
}

此函数中的 K* k = new K(10); 行执行两个操作——它从堆中为对象分配内存以及调用构造函数来构造对象。

行 delete k; 也结合了两个操作。它首先调用析构函数，然后从堆中释放内存。如果您没有 delete k;，该函数将泄漏由 new K(10) 分配的内存。

在这里，我们使用了 new 和 delete 运算符。

现在看看如何使用全局 operator new 和 operator delete 函数。

void f3()
{
   // Allocate memory for the object from the heap.
   void* p = ::operator new(sizeof(K));

   // At this point, an object of type K has not been constructed yet.

   K* k1 = reinterpret_cast<K*>(p);
   // Using the reinterpret_cast to treat the `void*` as a `K*` does not
   // change that fact. An object of type K has not yet been constructed still.

   K* k2 = new (p) K(10);
   // Use placement new operator to construct K.
   // At this point, an object of type K has been constructed by calling
   // K's constructor using the memory pointed to by p.


   // Do something with the object.

   // Done with the function.
   // Now it's time to do the necessary things to release resources back to
   // the system.

   // Do not use `delete K` at this point.
   // Whenever you use the placement new operator, call the destructor explicitly.
   // This calls the destructor ~K(), but does not deallocate memory from heap.
   k2->~K();

   // Deallocate the memory heap.
   ::operator delete(p);
}