我想理解当一个对象在栈上销毁时会发生什么。 以下是我的示例代码：
#include <stdio.h>
struct B {
~B() {puts("BBBB");}
};
int main()
{
B b;
b.~B();
}
输出结果为
BBBB
BBBB
#include <iostream>
struct B {
B() { std::cout << "B()" << std::endl; }
~B() { std::cout << "~B()" << std::endl; }
};
int main()
{
std::cout << "start main" << std::endl;
{ // scope
std::cout << "start scope" << std::endl;
B b;
std::cout << "end scope" << std::endl;
} // <-- b gets destroyed here.
std::cout << "end main" << std::endl;
}
#include <iostream>
#include <memory.h>
struct B {
B() { std::cout << "B()" << std::endl; }
~B() { std::cout << "~B()" << std::endl; }
};
int main()
{
std::cout << "start main" << std::endl;
{ // scope
std::cout << "start scope" << std::endl;
void* stackStorage = alloca(sizeof(B));
std::cout << "alloca'd" << std::endl;
// use "in-place new" to construct an instance of B
// at the address pointed to by stackStorage.
B* b = new (stackStorage) B();
std::cout << "ctord" << std::endl;
b->~B(); // <-- we're responsible for dtoring this object.
std::cout << "end scope" << std::endl;
} // <-- b gets destroyed here, but it's just a pointer.
std::cout << "end main" << std::endl;
}
然而，请记住，这是一个栈。当它超出范围时，它就消失了 - 如果你不销毁它，它就只剩下消失的痕迹。
{
void* stackStorage = alloca(sizeof(B));
B* b = new (stackStorage) B(); // "in-place new"
} // (*b)s memory is released but (*b) was not dtord.
std::aligned_storage -- 例如，声明一个类型为std::aligned_storage<sizeof(B)>::type的对象，然后使用放置new在其地址处构造您的对象。 - Benjamin Lindley请记住，析构函数与其他函数一样。唯一的区别是它在对象被释放时自动调用。你可以将其看作一个事件。你有机会在对象被销毁之前清理一切。手动调用析构函数不会释放对象。
C++中的对象构造/析构遵循这个简单的规则：
任何自动分配（和构造）的内容都会自动销毁。
任何使用new显式分配的内容都需要通过delete显式调用析构函数进行销毁。
任何使用new()显式构造的内容都必须通过调用析构函数显式销毁。
在所有三种情况下都必须调用析构函数，区别在于对象内存的分配方式：
对象在堆栈上，其分配由编译器管理。
对象在堆上，其分配由程序员管理。
对象可以存在于任何地方，构造和析构与分配无关。
在前两种情况下，我们有一个分配和构造的组合，因此也需要一个析构和解除分配的组合。第三种情况完全不同，但是语言完全支持它，并且您被允许显式调用析构函数的原因就在于这种情况下对象是在没有为其分配内存的情况下构造的。因此，它必须能够在不解除分配内存的情况下被销毁。可以像这样使用此案例：
void* buffer = (void*)new char[sizeof(Foo)]; //allocation
Foo* myFoo = new(buffer) Foo(); //construction
myFoo->~Foo(); //destruction
Foo* anotherFoo = new(buffer) Foo(); //reuse the buffer to construct another object in it
anotherFoo->~Foo(); //destruction of the second object
delete buffer; //deallocation
std::vector<> 就是这样工作的。new(buffer) B()构造了对象，那么您必须显式调用b->~B()。不幸的是，语言无法阻止您犯错，因此您有责任不让已析构的对象超出范围或调用delete。 - cmaster - reinstate monica你所做的是一个变量超出作用域的很好的例子。
int main()
{
//Main is started
B b;
/* What happens is that `b` is constructed as a local
variable and put on the runtime stack.*/
b.~B();
/*You then invoke the destructor manually which is bad practice.
But it is possible and it will execute the code.
However, the state of the resulting instance is undefined.*/
}
/*Main ends and local variables defined in the
current scope get destroyed. Which also means that B's destructor
is called the second time */
请注意 - 您唯一应该手动销毁对象的时候，是当它被放在堆上时，像这样：
// create an instance of B on the heap
B* b = new B();
// remove instance and implicitly call b's destructor.
delete b;
1. destructor doesnt destroy it's object. the object stays at stack
until out of scope.
2. nothing can destroy a stack object.
3. the destructor did destroy RESOURCE inside the object.
示例代码：
struct B {
B() {happy="today is a good day"; hour = 7;}
~B() {puts("BBBB");}
std::string happy;
int hour;
};
int main()
{
B b;
std::cout << b.happy << b.hour <<std::endl;
b.~B();
std::cout << b.happy << b.hour <<std::endl;
}
输出：
today is a good day7
BBBB
7
BBBB
我们可以看到，在调用 b.~B() 后，资源 b.happy 不再存在。这证明了我的第3点观点。
你可以看到 b.hour（int类型不是资源）仍然存在。这证明了我的第1点观点。