今天，看到一个有趣的面试题，问题是：在C++里如何释放内存的时候不调用对象的析构函数？
之所以有趣，是因为这个问题违反了C++中资源管理的RAII（资源获取即初始化），它要求资源的释放应当和对象的生命周期紧密相关。在正常情况下，当对象离开其作用域时，它的析构函数被调用，以释放它所管理的资源，比如内存、文件句柄或网络连接等。
然而，这个问题提出了一种特殊情况，在出于性能优化、特殊的内存管理策略，或是为了与低级操作系统功能或硬件直接交互的需求。在这些情况下，我们可能需要释放对象占用的内存，但又不希望执行其析构函数。
在C++中，如果真的需要这么做，有什么方法呢？我们一起来梳理看看。
placement new方式
可以通过使用 placement new 来在预先分配的内存块上构造对象，然后不显式调用它的析构函数。
#include <new> // 需要包含头文件new
char buffer[sizeof(MyClass)]; // 分配足够的内存来存放MyClass对象
MyClass* obj = new(buffer) MyClass(); // 在buffer上构造对象
// ... 使用obj
// 显式调用析构函数是这样的:
// obj->~MyClass();
// 如果你不调用析构函数，对象的生命周期将结束，
// 但是它的析构函数不会被执行。但是由于对象用的是栈上的内存，内存会正常释放。
使用 placement new 需要你非常明确地知道自己在做什么，因为这样做会绕过正常的构造和析构过程。这可能导致资源泄露、内存未正确释放或其他未定义行为。
MyClass* obj = new MyClass(); // 常规地分配对象
// ... 在这里使用obj
operator delete(obj); // 释放内存但不调用析构函数
placement new的chromium的封装
chromium里面对placement new的设计模式提供了一套模板支持，如下：
template <typename T>
class NoDestructor {
public:
// Not constexpr; just write static constexpr T x = ...; if the value should
// be a constexpr.
template <typename... Args>
explicit NoDestructor(Args&&... args) {
new (storage_) T(std::forward<Args>(args)...);
}
// Allows copy and move construction of the contained type, to allow
// construction from an initializer list, e.g. for std::vector.
explicit NoDestructor(const T& x) { new (storage_) T(x); }
explicit NoDestructor(T&& x) { new (storage_) T(std::move(x)); }
NoDestructor(const NoDestructor&) = delete;
NoDestructor& operator=(const NoDestructor&) = delete;
~NoDestructor() = default;
const T& operator*() const { return *get(); }
T& operator*() { return *get(); }
const T* operator->() const { return get(); }
T* operator->() { return get(); }
const T* get() const { return reinterpret_cast<const T*>(storage_); }
T* get() { return reinterpret_cast<T*>(storage_); }
private:
alignas(T) char storage_[sizeof(T)];
};
//使用方法：
void foo() {
// std::string析构函数不会被调用，即便出了foo的scope
NoDestructor<std::string> s("Hello world!");
}
上述代码的细节说明：
-
new (storage_) T(x)使用了 placement new 操作符。这个操作符的语法是new (address) Type(arguments)，它允许你在一个已经分配好的内存地址address上直接构造一个Type类型的对象。这个操作不会分配新的内存，而是使用你提供的内存地址。在这个例子中，storage_是一个足够大的字符数组，能够存放T类型的对象，而alignas(T)确保了这个数组的对齐方式与T类型相同。 -
T(x)是调用T类型对象的复制构造函数，以x为参数来构造一个新的T实例。
在 NoDestructor 类的 storage_ 成员中直接构造一个 T 类型的对象。因为它使用了 placement new，所以不会为这个 T 对象分配新的堆内存，而是利用 storage_ 这块已经预留的栈内存。这也意味着 T 对象的析构函数不会在 NoDestructor 对象被销毁时自动调用，这正是 NoDestructor 的设计目的。
union方式
union类型的析构函数在执行body之后不会调用variant member对象的析构函数
#include <iostream>
template<class T>
union NoDestructor{
T value;
~Forget(){}
};
struct A{
~A(){
std::cout<<"destroy A\n";
}
};
int main(){
auto f = NoDestructor<A>{A{}}; // 不会执行A的析构
// f.value.~A(); // 需要手动调用析构, 否则不会析构
}
union 是一种特殊的类类型，它允许你在同一个内存地址存储不同的数据类型，但是一次只能使用其中一个成员。这意味着 union 的所有成员都共享同一块内存空间，所以其大小等于其最大成员的大小。
union 有一些限制，其中之一就是所有的成员函数必须是非虚（non-virtual）的。理解这一点需要知道虚函数和虚函数表（vtable）的工作原理。在C++中，当类有一个或多个虚函数时，编译器会为该类创建一个虚函数表。这个虚函数表是一个函数指针数组，用于支持动态绑定，也就是在运行时决定调用哪个函数。每个有虚函数的对象都会含有一个指向虚函数表的指针，通常称为vptr。在 union 的情况下，由于所有成员共享同一块内存空间，如果 union 允许虚函数存在，那么vptr的存储位置就会和 union 的其他成员发生冲突，导致不确定的行为。此外，由于 union 的成员可以是不同的数据类型，编译器也无法确定应该使用哪个成员的虚函数表。
正因为这些原因，C++标准规定 union 不能包含虚函数。所有的成员函数，包括构造函数和析构函数，都必须是非虚的。这样就保证了 union 成员之间不会发生内存覆盖，同时也避免了动态绑定相关的复杂性。
在C++11及以后的版本中，union 可以包含非静态数据成员的构造函数和析构函数，但是仍然不能包含虚函数。如果 union 包含一个或多个非平凡的成员（比如包含自己的构造函数或析构函数的类类型成员），那么你需要负责正确地构造和析构这些成员，因为 union 不会自动为你做这些事情。
利用union的这个特性，就能轻松实现“释放内存的时候不调用对象的析构函数”。
但是，在使用union的时候，这个特性反而是一个坑，需要小心处理。一般来说，需要手动判断哪个成员是有效的，并显式地调用该成员的析构函数。类似这样：
union U {
Type1 member1;
Type2 member2;
// ...
~U() {
switch (active_member) {
case Member1:
member1.~Type1(); // 显式调用析构函数
break;
case Member2:
member2.~Type2(); // 显式调用析构函数
break;
// ...
}
}
};
jmp 方式
直接通过longjmp，跳出作用域，避免析构函数调用：
#include <setjmp.h>
int main()
{
jmp_buf buf {};
if (setjmp(buf) == 0) {
string s(p); // 对象s不会析构
longjmp(buf, 1);
}
}
不过通过longjmp没有很好的封装形式，语义上也过于隐晦，因此不常用于这个场景。
结语
这个面试题既有趣也有深度，它提供了一个探讨C++语言内存和资源管理机制的机会，同时考察面试者对C++底层细节的了解程度。然而，在实际的软件开发中，绝大多数情况下都应该遵循RAII原则，让析构函数自动管理资源的释放。
