写了5年C++才发现：new背后藏着两个函数，placement new让我能控制其中一个

new。

C++程序员每天都在用，int* p = new int(42);这行代码简单直接，分配内存、构造对象一步到位，但你有没有想过，这一行代码背后到底发生了什么？

很多人以为new是一个操作。错了。new是两个操作，第一个操作分配内存，第二个操作调用构造函数，这两个操作可以拆开、可以分别控制，自定义operator new/delete让你控制第一步，而placement new让你跳过第一步、直接在已有内存上执行第二步——搞懂这个，你对C++内存管理的理解会上一个台阶。

new表达式的真相：两步操作

当你写T* p = new T(args);的时候，编译器实际上做了两件事：

// 你写的代码T*p=newT(42);// 编译器实际做的事（伪代码）void*mem=operatornew(sizeof(T));// 第一步：分配内存T*p=new(mem)T(42);// 第二步：在内存上构造对象

第一步调用operator new函数分配一块大小为sizeof(T)的原始内存，这块内存还没有任何对象、就是一块字节；第二步在这块内存上调用构造函数，把字节变成真正的对象——这两步是可以拆开的。

为什么要拆开？场景很多：比如你想用自己的内存池，内存已经分配好了，只需要在上面构造对象；比如你想追踪所有的内存分配，统计程序用了多少内存；比如你想让某个类的对象只能从特定的内存区域分配——这些需求都需要把分配和构造拆开，分别控制。

placement new：在已有内存上构造对象

placement new是new的一种特殊形式，语法是new(ptr) T(args)，它不分配内存，只在ptr指向的内存上构造对象。

#include<new>// placement new需要这个头文件// 先分配一块原始内存（alignas确保对齐）alignas(int)charbuffer[sizeof(int)];// 在这块内存上构造一个int对象int*p=new(buffer)int(42);// 现在buffer这块内存里有一个值为42的int对象

注意对齐问题：上面用了alignas(int)来确保buffer满足int的对齐要求。如果不加alignas，char数组的对齐是1字节，而int通常需要4字节对齐，在某些平台上可能导致未定义行为。对于更复杂的类型（比如包含double或SIMD类型的结构体），对齐问题更严重，务必使用alignas。

注意这里的关键：buffer是一块字节，placement new在上面"放置"了一个int对象，这个int对象占用的就是buffer的内存，不会额外分配，这就是placement new的核心作用——把对象构造和内存分配彻底分离开来。

更常见的用法是配合内存池：

// 简化的内存池示例（生产代码需要更完善的实现）classMemoryPool{char*pool_;size_t offset_=0;size_t size_;public:MemoryPool(size_t size):pool_(newchar[size]),size_(size){}~MemoryPool(){delete[]pool_;}// 别忘了释放void*allocate(size_t bytes){// 生产代码还需要：对齐处理、边界检查、线程安全if(offset_+bytes>size_)returnnullptr;void*ptr=pool_+offset_;offset_+=bytes;returnptr;}};MemoryPoolpool(1024);void*mem=pool.allocate(sizeof(MyClass));MyClass*obj=new(mem)MyClass(args);// 在内存池中构造对象

重要提醒：用placement new构造的对象，不能用delete释放！

为什么？因为delete会调用operator delete去释放内存，但这块内存不是operator new分配的，可能是栈上的buffer、可能是内存池里的一块区域、可能是共享内存，delete去释放这些内存会出大问题——正确的做法是手动调用析构函数：

// 错误！不能用delete// delete obj;// 正确：手动调用析构函数obj->~MyClass();

手动调用析构函数是C++中少数几个需要显式调用析构的场景之一，虽然看起来有点怪，但这是placement new的标准用法。

自定义operator new/delete：全局重载

operator new和operator delete是可以重载的，重载它们，你就控制了new表达式的第一步——内存分配，全局重载会影响所有的new和delete。

#include<cstdlib>#include<iostream>// 全局重载operator newvoid*operatornew(size_t size){std::cout<<"分配 "<<size<<" 字节\n";void*ptr=std::malloc(size);if(!ptr)throwstd::bad_alloc();returnptr;}// 全局重载operator deletevoidoperatordelete(void*ptr)noexcept{std::cout<<"释放内存\n";std::free(ptr);// std::free(nullptr)是安全的，无需额外判空}// 别忘了数组版本void*operatornew[](size_t size){std::cout<<"分配数组 "<<size<<" 字节\n";void*ptr=std::malloc(size);if(!ptr)throwstd::bad_alloc();returnptr;}voidoperatordelete[](void*ptr)noexcept{std::cout<<"释放数组\n";std::free(ptr);}

有了这个，程序中所有的new和delete都会经过你的函数，想做内存追踪、泄漏检测、性能分析都很方便——你可以在这里加计数器、记日志、统计分配大小，所有内存操作尽在掌握。

测试一下：

intmain(){int*p=newint(42);// 输出：分配 4 字节deletep;// 输出：释放内存int*arr=newint[10];// 输出：分配数组 40 字节（或更多）delete[]arr;// 输出：释放数组}

关于new[]的分配大小：上面new int[10]显示分配40字节，但这不是保证的。对于有非平凡析构函数的类型，编译器通常会额外分配几个字节来存储数组元素个数（供delete[]调用正确次数的析构函数）。对于int这种POD类型，某些编译器可能只分配40字节，但换成有析构函数的类，你会看到分配的字节数比sizeof(T) * n更多。

全局重载的注意事项：

operator new分配失败必须抛出std::bad_alloc，不能返回nullptr，因为标准库和很多第三方库都依赖这个行为，如果你返回nullptr而不是抛异常，调用方可能不会检查返回值就直接使用，导致空指针崩溃
operator delete必须能处理nullptr，且不能抛出异常
new和delete、new[]和delete[]必须配对重载，否则可能出现分配用你的函数、释放用标准库函数的情况
全局重载影响整个程序，包括标准库，要小心副作用

自定义operator new/delete：类内重载

更常见的需求是只为某个类自定义内存分配，这时候用类内重载，它只影响这一个类，不会干扰其他代码。

classPooledObject{staticcharpool_[1024];staticsize_t offset_;public:// 类内operator newstaticvoid*operatornew(size_t size){std::cout<<"从内存池分配 "<<size<<" 字节\n";if(offset_+size>sizeof(pool_)){throwstd::bad_alloc();}void*ptr=pool_+offset_;offset_+=size;returnptr;}// 类内operator deletestaticvoidoperatordelete(void*ptr)noexcept{std::cout<<"归还到内存池（实际不释放）\n";// 简单的内存池实现，这里不真正释放}intdata;PooledObject(intd):data(d){}};// 静态成员定义charPooledObject::pool_[1024];size_t PooledObject::offset_=0;

使用起来和普通的new一样：

intmain(){// 自动调用类内的operator newPooledObject*obj=newPooledObject(42);// 自动调用类内的operator deletedeleteobj;}

类内重载特别适合给特定类做内存池优化，比如游戏引擎里的粒子系统，一帧可能创建销毁上万个粒子对象；比如数据库里的B+树节点，查询时需要频繁分配释放节点；比如网络服务器的请求对象，每秒处理几万个请求——这些对象有个共同特点：数量多、大小固定、频繁创建销毁，用标准的malloc/free每次都要走一遍系统分配器，开销太大，用内存池预分配一大块内存、按需分发，能把性能提升好几倍。