Item 16：成对使用相同形式的 new 和 delete

猜一猜：把 new Widget[4] 改成 delete，哪一条释放证据会先失真——元素析构次数、array cookie，还是 allocator family？

从“pointer 类型为什么看不出数组”开始

Widget* single = new Widget;
Widget* many = new Widget[10];

两个变量类型都显示 Widget*，但释放协议不同：

delete single;
delete[] many;

Item 16 要求 Use the same form in corresponding uses of new and delete（成对使用相同形式的 new 和 delete）。 简化成审计规则就是 same form in new and delete：单对象、数组、对齐、C heap 与平台 allocator 都必须从创建入口追踪到同家族释放入口。

数组需要知道析构多少元素

delete[] 需要逐个调用非平凡 destructor，典型实现通过 cookie 找到数量。标准不规定具体布局，但程序必须使用匹配表达式。

struct Probe {
    static inline int alive{};
    Probe() { ++alive; }
    ~Probe() { --alive; }
};
 
Probe* probes = new Probe[4];
delete[] probes;
assert(Probe::alive == 0);

错误 delete probes 是未定义行为，可能只析构一个元素、读取错误 cookie 或传错 deallocator。

delete[] 也负责构造失败回滚

class Element {
public:
    Element()
    {
        if (++constructed == failAt)
            throw Failure{};
    }
    ~Element() { --alive; }
};

new[] expression 自己管理回滚。手工 malloc 加 placement new 数组则必须自行记录已构造数量并在异常时逆序清理。

这属于低层容器实现，不能和普通 new[] 混为一谈。

typedef 会隐藏数组性

原书特别警告：

typedef std::string AddressLines[4];
 
std::string* lines = new AddressLines;
delete[] lines; // 必须知道 typedef 是数组

不要对数组类型 typedef 后暴露 raw new/delete。现代写：

using AddressLines = std::array<std::string, 4>;
auto lines = std::make_unique<AddressLines>();

调用方只销毁一个 AddressLines 对象，内部数组由其 destructor 正确处理。

动态序列优先 vector

std::vector<Widget> widgets(10);

比 new Widget[10] 多提供 size、迭代器、异常安全和移动。大多数应用代码无需直接数组 new。

把 Item 16 从运行时纪律变成类型保证。

unique_ptr 单对象与数组特化

auto singleOwner = std::make_unique<Widget>();
auto arrayOwner = std::make_unique<Widget[]>(10);

类型不同，deleter 与 API 不同。不能把 new Widget[10] 放进 unique_ptr<Widget>。

让错误在构造 owner 时暴露，而不是销毁时。

make_unique 避免裸 new 窗口

auto image = std::make_unique<Image>(width, height);
auto pixels = std::make_unique<Pixel[]>(count);

减少重复类型和 raw pointer 暴露；异常路径自动清理。

Item 17 会继续讨论函数实参求值中的这一风险。

malloc/free 是另一分配家族

void* memory = std::malloc(bytes);
if (!memory)
    throw std::bad_alloc{};
std::free(memory);

不能 delete memory，也不能 free(new T)。

不仅是括号匹配，还包括 API/heap/参数。

custom deleter 编码外部协议

struct FreeDeleter {
    void operator()(void* pointer) const noexcept { std::free(pointer); }
};
 
using MallocBuffer = std::unique_ptr<void, FreeDeleter>;

平台资源同理：fopen/fclose、CreateFile/CloseHandle、GPU create/destroy。

factory 应直接返回带 deleter 的 owner。

aligned allocation 还要匹配参数

void* memory = ::operator new(bytes, std::align_val_t{64});::
operator delete(memory, std::align_val_t{64});

编译器生成 delete-expression 会选择正确 overload；手工 operator new/delete 调用必须自己配对。Item 51/52 会深入 custom new/delete。

跨模块 allocator

库导出 raw pointer 并让调用方 delete 可能跨 CRT。安全接口导出配对 destroy：

extern "C" ApiObject* create_object();
extern "C" void destroy_object(ApiObject*) noexcept;

调用方用 custom deleter 回到创建模块。

这是 allocator-family pairing 的模块级形式。

API 不应返回模糊 raw array

Widget* makeWidgets(std::size_t count); // 谁拥有？delete 还是 delete[]？

替代：返回 vector、unique_ptr array 加 count、span borrow，或 caller-provided buffer。

struct WidgetArray {
    std::unique_ptr<Widget[]> data;
    std::size_t size{};
};

通常 vector 更完整；特殊 ABI 才需要自定义。

形式匹配审计

先预测：new Probe[4] 配 delete 时 destructor ledger 会剩多少；不要在主进程依赖 UB 结果，使用 sanitizer 子测试。

• 单对象/数组 Probe constructor/destructor 计数完全匹配。
• new[] 第 N 个构造失败时此前元素逆序析构。
• unique_ptr single/array 类型与 factory 返回一致。
• malloc/custom platform owner 使用正确 deleter，未调用 delete。
• aligned operator delete 收到同 alignment。
• 跨模块创建销毁在真实 allocator 配置下运行。

小结

• new 对应 delete，new[] 对应 delete[]；raw pointer 类型无法显示数组性
• array cookie 是典型实现细节，程序仍必须遵守数组完整生命周期协议
• 避免数组 typedef 配 raw new/delete，优先 array/vector
• unique_ptr single 与 array form 用类型编码正确 deleter
• malloc/free、aligned new/delete、平台 Create/Destroy 和模块 heap 都要按家族配对
• allocation-pair audit 与 destructor ledger 证明构造析构和释放入口一致