一、前言：当 new 和 delete 不够用

标准 C++ 中，new 和 delete 为我们完成了两件事：内存分配/释放 + 对象构造/析构。这套机制在 99% 的场景下工作良好，但如果你正面临以下困境：

• 高频创建/销毁对象导致的内存碎片和分配开销
• 需要在一块已分配的内存上按需构造不同对象
• 嵌入式环境或内核态等不允许动态分配的场景
• 需要精确控制析构顺序的复杂依赖关系

那么，是时候把"内存分配"和"对象构造"拆开，亲手接管对象生命周期了。而这正是placement new与显式析构调用的用武之地。

本文将从底层原理出发，结合开源项目中的实际应用，提供完整的可运行代码示例和性能对比数据。

二、核心机制原理

2.1 operator new 的三层结构

C++ 的 new 表达式实际上由三个独立步骤组成：

标准 placement new 就是跳过步骤①，直接执行步骤②：

void* operator new(size_t, void* ptr) noexcept { return ptr; // 不做任何事，原样返回 }

2.2 显式析构：被忽略的权力

多数开发者都知道不能在同一个对象上调用两次析构函数，但很少有人意识到——你可以显式调用析构函数：

obj.~T(); // 直接调用析构（不释放内存） ptr->~T(); // 通过指针调用析构

这是 C++ 标准明确允许的合法操作（[class.dtor]/14）。它只执行析构逻辑，不触发 operator delete——正如 placement new 的反向操作。

2.3 完整生命周期对照

标准流程： p = new T(args) → operator new + constructor delete p → destructor + operator delete 手动接管： buf = malloc(n) → 仅分配原始内存 new(buf) T(args) → 仅构造函数（placement new） p->~T() → 仅析构函数（显式调用） free(buf) → 仅释放原始内存

三、从零实现对象池

3.1 基础版本：固定大小对象池

#include <cstddef> #include <cstdint> #include <new> #include <utility> template <typename T, size_t BlockSize = 4096> class ObjectPool { // 每个已释放的槽位嵌入一个 free-list 指针 struct Slot { alignas(T) unsigned char data[sizeof(T)]; }; struct Block { Slot slots[BlockSize]; Block* next; }; Block* head_ = nullptr; // 内存块链表头 Slot* free_list_ = nullptr; // 空闲槽位链表头 size_t allocated_ = 0; void allocate_block() { auto* block = static_cast<Block*>( ::operator new(sizeof(Block))); block->next = head_; head_ = block; // 将新块的所有槽位串入 free_list for (size_t i = 0; i < BlockSize; ++i) { auto* slot = &block->slots[i]; *reinterpret_cast<Slot**>(slot) = free_list_; free_list_ = slot; } } public: ~ObjectPool() { // 注意：不调用析构，调用者应保证已显式析构所有对象 while (head_) { auto* next = head_->next; ::operator delete(head_); head_ = next; } } template <typename... Args> T* allocate(Args&&... args) { if (!free_list_) allocate_block(); auto* slot = free_list_; free_list_ = *reinterpret_cast<Slot**>(slot); ++allocated_; return ::new(slot) T(std::forward<Args>(args)...); } void deallocate(T* ptr) { if (!ptr) return; ptr->~T(); // ★ 显式析构 auto* slot = reinterpret_cast<Slot*>(ptr); *reinterpret_cast<Slot**>(slot) = free_list_; free_list_ = slot; --allocated_; } size_t allocated_count() const { return allocated_; } };

3.2 使用示例

#include <iostream> #include <chrono> #include <vector> // 测试用对象 struct Widget { int id; double data[16]; Widget(int i) : id(i) { data[0] = i * 3.14; } ~Widget() { // 模拟一些清理工作 data[0] = -1; } }; int main() { constexpr int N = 100000; // ====== 对象池版本 ====== ObjectPool<Widget> pool; auto t1 = std::chrono::high_resolution_clock::now(); for (int i = 0; i < N; ++i) { auto* w = pool.allocate(i); pool.deallocate(w); } auto t2 = std::chrono::high_resolution_clock::now(); auto pool_time = std::chrono::duration_cast<std::chrono::microseconds>(t2 - t1).count(); // ====== 标准 new/delete 版本 ====== auto t3 = std::chrono::high_resolution_clock::now(); for (int i = 0; i < N; ++i) { auto* w = new Widget(i); delete w; } auto t4 = std::chrono::high_resolution_clock::now(); auto std_time = std::chrono::duration_cast<std::chrono::microseconds>(t4 - t3).count(); std::cout << "对象池: " << pool_time << " μs\n"; std::cout << "标准分配: " << std_time << " μs\n"; std::cout << "加速比: " << (double)std_time / pool_time << "x\n"; }

实测结果（MSVC 2022 /O2，i7-13700H）：

四、变长内存池：支持任意大小分配

对于需要灵活大小的场景，可以使用 slab 分配器扩展：

#include <array> #include <cstddef> #include <cassert> class SlabAllocator { static constexpr size_t kAlignment = alignof(std::max_align_t); static constexpr size_t kChunkSize = 64 * 1024; // 64KB struct Chunk { unsigned char data[kChunkSize]; size_t used = 0; Chunk* next = nullptr; }; Chunk* head_ = nullptr; Chunk* current_ = nullptr; void add_chunk() { auto* c = new Chunk; c->next = head_; head_ = c; current_ = c; } public: ~SlabAllocator() { while (head_) { auto* next = head_->next; delete head_; head_ = next; } } void* allocate(size_t size) { size = (size + kAlignment - 1) & ~(kAlignment - 1); if (!current_ || current_->used + size > kChunkSize) { add_chunk(); } void* ptr = current_->data + current_->used; current_->used += size; return ptr; } void reset() { // 不释放内存，只重置使用标记 current_ = head_; for (auto* c = head_; c; c = c->next) { c->used = 0; } } }; // 搭配 placement new 使用 SlabAllocator g_allocator; template <typename T, typename... Args> T* slab_new(Args&&... args) { return ::new(g_allocator.allocate(sizeof(T))) T(std::forward<Args>(args)...); } template <typename T> void slab_delete(T* ptr) { ptr->~T(); // 仅析构，不释放内存 }

五、C++17 std::launder：不可避免的魔鬼细节

5.1 问题场景

当你在同一块内存上析构旧对象并构造新对象时，编译器可能基于"对象类型不可变"的假设做激进优化，导致未定义行为：

struct X { const int n; }; struct Y { int n; }; alignas(Y) unsigned char storage[sizeof(Y)]; auto* p = new(storage) X{42}; p->~X(); // 销毁 X // 编译器可能认为 storage 上仍然是 X 类型 auto* q = new(storage) Y{99}; // 构造 Y // ❌ 危险！编译器可能用旧的 X::n 做常量折叠 int val = q->n;

5.2 解决方案

auto* q = std::launder(reinterpret_cast<Y*>(storage)); // ✅ std::launder 告诉编译器："这个地址上的对象已经变了，重新读" int val = q->n; // 保证读到 99

5.3 std::launder 的必要条件

只有在以下情况下才需要 std::launder：

• 对象包含 const 成员或引用成员
• 对象有 const 成员函数且编译器可能做常量传播
• 在一个对象的生命周期结束后，在同一地址构造了不同类型的新对象

// 安全模式：在对象池的 deallocate 方法中加防护 template <typename T> void deallocate(T* ptr) { ptr->~T(); // 如果 T 有 const 成员，释放前用 launder 刷掉缓存 if constexpr (has_const_member_v<T>) { ptr = std::launder(ptr); } // ... 归还到 free_list }

六、开源项目中的实践

6.1 Facebook Folly：SysAllocator 与 placement new

Folly 的 IOBuf 大量使用 placement new 管理缓冲区：

// folly/io/IOBuf.h 简化示意 std::unique_ptr<IOBuf> IOBuf::create(size_t capacity) { // 一次分配容纳 IOBuf + 数据缓冲区 size_t size = sizeof(IOBuf) + capacity; void* buf = malloc(size); // placement new 在缓冲区头部构造 IOBuf auto* iobuf = new(buf) IOBuf( TakeOwnership, static_cast<uint8_t*>(buf) + sizeof(IOBuf), capacity ); return std::unique_ptr<IOBuf>(iobuf); }

6.2 EA EASTL：fixed_allocator

EASTL 的固定大小分配器是对象池的工业级实现：

// EASTL 的 fixed_pool 使用 intrusive free-list // 与上文我们的 ObjectPool 设计思想一致， // 但在多线程安全、调试模式下的越界检测方面做了大量增强

6.3 Google Protobuf：Arena 分配器

Protobuf 的 Arena 是一个典型的 slab 分配器，所有对象在 Arena 生命周期内有效，析构时批量释放：

google::protobuf::Arena arena; auto* msg1 = google::protobuf::Arena::CreateMessage<MyMessage>(&arena); auto* msg2 = google::protobuf::Arena::CreateMessage<MyMessage>(&arena); // 无需逐个 delete，arena 析构时统一释放

七、陷阱与最佳实践

7.1 常见陷阱速查

7.2 异常安全处理

template <typename T, typename... Args> T* safe_placement_new(void* storage, Args&&... args) { T* ptr = ::new(storage) T(std::forward<Args>(args)...); return ptr; // 如果 new(storage) T(...) 抛出异常， // storage 指向的内存不会被自动释放—— // 调用者必须自己管理。 // 好在我们已经通过对象池管理了，无需额外处理。 }

7.3 何时使用 vs 何时避免

适合使用 placement new / 显式析构：

• 对象池 / 内存池实现
• 高性能服务端（游戏服务器、交易系统）
• 嵌入式 / 实时系统
• 自定义容器的底层存储（std::vector 内部就在用！）

应该避免：

• 业务逻辑层的普通对象管理
• 涉及复杂继承体系的对象（虚函数指针可能被破坏）
• 代码审查不严格的团队（维护成本高于性能收益）

八、综合可运行示例：轻量级事件循环

将以上技术组合成一个最小化的事件循环框架：

#include <cstddef> #include <cstdint> #include <new> #include <functional> #include <queue> #include <iostream> // ===== 对象池：管理事件对象 ===== template <typename T, size_t N = 1024> class FixedPool { struct alignas(T) Slot { unsigned char data[sizeof(T)]; }; Slot slots_[N]; Slot* free_list_[N]; int free_idx_; public: FixedPool() : free_idx_(N - 1) { for (int i = 0; i < N; ++i) free_list_[i] = &slots_[i]; } template <typename... Args> T* create(Args&&... args) { if (free_idx_ < 0) return nullptr; auto* p = ::new(free_list_[free_idx_--]) T(std::forward<Args>(args)...); return p; } void destroy(T* ptr) { ptr->~T(); free_list_[++free_idx_] = reinterpret_cast<Slot*>(ptr); } }; // ===== 事件定义 ===== struct Event { enum Type { TIMER, IO_READ, IO_WRITE, SHUTDOWN }; Type type; int fd; std::function<void()> callback; uint64_t deadline_us; Event(Type t, int f, std::function<void()> cb, uint64_t dl = 0) : type(t), fd(f), callback(std::move(cb)), deadline_us(dl) {} }; // ===== 事件循环 ===== class EventLoop { FixedPool<Event> pool_; std::priority_queue< std::pair<uint64_t, Event*>, std::vector<std::pair<uint64_t, Event*>>, std::greater<> > timer_queue_; bool running_ = true; public: Event* add_timer(uint64_t delay_us, std::function<void()> cb) { uint64_t deadline = now_us() + delay_us; auto* ev = pool_.create(Event::TIMER, -1, std::move(cb), deadline); timer_queue_.emplace(deadline, ev); return ev; } void cancel_timer(Event* ev) { pool_.destroy(ev); // 简化处理，实际需要从优先队列中移除 } void run() { while (running_) { while (!timer_queue_.empty() && timer_queue_.top().first <= now_us()) { auto* ev = timer_queue_.top().second; timer_queue_.pop(); ev->callback(); pool_.destroy(ev); // ★ 执行后归还 } } } void shutdown() { running_ = false; } private: static uint64_t now_us() { using namespace std::chrono; return duration_cast<microseconds>( steady_clock::now().time_since_epoch()).count(); } }; // ===== 使用 ===== int main() { EventLoop loop; int counter = 0; loop.add_timer(1000, [&] { std::cout << "Timer tick " << ++counter << std::endl; }); loop.add_timer(5000, [&] { std::cout << "Shutting down..." << std::endl; loop.shutdown(); }); loop.run(); return 0; }

九、与 C++20/23 的结合展望

// C++20 风格的写法 #include <memory> void* buf = operator new(sizeof(Widget)); Widget* w = std::construct_at(static_cast<Widget*>(buf), 42); std::destroy_at(w); operator delete(buf);

十、决策速查表

十一、总结

Placement new 与显式析构是 C++ 赋予开发者的两把"手术刀"——它们让你能精确切开"内存管理"和"对象生命周期"这两个在 new/delete 中被捆绑的操作。这不是花哨的技巧，而是标准库（std::vector、std::optional）、工业级开源项目（Folly、EASTL、Protobuf）每天都在用的基础设施。

使用它们的三大理由：

1. 性能：对象池可将分配开销降低一个数量级
2. 控制：精确掌控每个对象的构造和析构时机
3. 灵活性：在同一块内存上按需构造不同类型的对象

但请记住——能力越大，责任越大。显式析构和内存复用引入的复杂性，需要你和你的团队有足够的 C++ 功底来驾驭。在决定"手搓"之前，先问自己：std::pmr 是否已经够用了？