C++20 中 get_temporary_buffer 的演进与替代方案：从弃用到现代实践

在 C++ 标准库的发展历程中，内存管理工具的演进往往折射出语言设计理念的深层变革。std::get_temporary_buffer 作为早期用于请求临时、未初始化原始内存的工具，曾为算法实现（如 std::stable_sort 内部缓冲）提供轻量级支持。然而，随着 C++17 的标准化推进与 C++20 的正式发布，该函数被明确标记为弃用（deprecated），并在 C++20 中完成语义上的终结——它不再推荐使用，标准亦不再保证其存在性。本文将系统梳理 get_temporary_buffer 的设计初衷、运行机制、固有局限，并重点阐述 C++20 及后续标准中更安全、更灵活、更符合 RAII 原则的现代替代方案。

get_temporary_buffer 定义于 <memory> 头文件，其典型声明如下：

template<class T>
std::pair<T*, std::ptrdiff_t> get_temporary_buffer(std::ptrdiff_t n);

该函数尝试分配一块足以容纳 n 个 T 类型对象的未初始化原始内存，返回一个 std::pair：首元素为指向起始地址的裸指针，次元素为实际成功分配的元素数量（可能小于 n）。值得注意的是，它不调用构造函数，也不进行零初始化；使用者需自行调用 std::uninitialized_* 系列算法完成对象构造，并在使用完毕后显式调用 std::return_temporary_buffer 归还内存。这种“手动配对”的资源管理方式，与 C++11 后强调的自动资源管理（RAII）理念明显脱节。

以下是一个典型但已过时的使用示例：

#include <memory>
#include <algorithm>
#include <iostream>

int main() {
    const std::ptrdiff_t count = 1000;

    // 请求临时缓冲区（C++20 中已弃用）
    auto buf = std::get_temporary_buffer<int>(count);
    if (buf.first == nullptr) {
        std::cout << "Failed to allocate temporary buffer.\n";
        return 1;
    }

    // 手动构造对象（此处仅默认初始化）
    std::uninitialized_default_construct(buf.first, buf.first + buf.second);

    // 使用缓冲区...
    for (std::ptrdiff_t i = 0; i < buf.second; ++i) {
        buf.first[i] = static_cast<int>(i * i);
    }

    // 必须显式归还——否则内存泄漏
    std::return_temporary_buffer(buf.first);
}

上述代码存在多重隐患：裸指针易引发悬垂引用；return_temporary_buffer 的调用极易被遗漏或异常绕过；分配失败时缺乏异常安全保证；且无法与智能指针、容器等现代设施协同工作。更重要的是，get_temporary_buffer 的底层实现高度依赖平台与标准库厂商，行为不可移植：某些实现可能直接委托给 malloc，而另一些则复用内部池，导致性能特征难以预测。

C++20 正式将 get_temporary_buffer 和 return_temporary_buffer 标记为 deprecated，其根本原因在于——它们无法满足现代 C++ 对确定性、安全性与组合性的要求。取而代之的，是基于 std::allocator 与 std::unique_ptr 的显式、可控、异常安全的内存管理范式。

首选替代方案是结合 std::allocator 与 std::unique_ptr 构建作用域绑定的临时缓冲：

#include <memory>
#include <algorithm>

template<typename T>
auto make_temporary_buffer(std::size_t n) 
    -> std::unique_ptr<T[], decltype([](T* p) { std::allocator<T>{}.deallocate(p, 0); })> {
    std::allocator<T> alloc;
    T* ptr = alloc.allocate(n);
    // 使用自定义删除器确保析构与释放匹配
    return {ptr, [alloc](T* p) mutable {
        if (p) {
            std::destroy_n(p, n); // C++17 起支持
            alloc.deallocate(p, n);
        }
    }};
}

// 使用示例（C++20 兼容）
int main() {
    constexpr std::size_t N = 1000;
    auto buf = make_temporary_buffer<int>(N);

    // 自动构造（C++17+）
    std::uninitialized_default_construct(buf.get(), buf.get() + N);

    // 使用逻辑...
    for (std::size_t i = 0; i < N; ++i) {
        buf[i] = static_cast<int>(i + 1);
    }

    // 作用域结束时自动析构并释放 —— 无需手动干预
}

此方案优势显著：内存生命周期由 std::unique_ptr 严格管控；构造与析构逻辑内聚；异常安全（若 uninitialized_default_construct 抛异常，删除器仍会被调用）；且完全兼容 C++17 及以上标准。对于需要动态大小且生命周期明确的临时缓冲场景，这是目前最推荐的实践。

此外，若缓冲用途为一次性算法辅助（如排序中间存储），亦可考虑 std::vector 配合 reserve() 与 shrink_to_fit() 控制容量，或直接使用 std::deque 等具备高效分段分配特性的容器——它们虽非“原始”内存，但在绝大多数真实场景中，其抽象开销可忽略，而带来的安全性与可维护性提升远超微小性能差异。

综上所述，std::get_temporary_buffer 的弃用并非功能倒退，而是 C++ 向更高抽象层级演进的必然选择。它提醒开发者：在追求极致性能的同时，不应牺牲程序的健壮性与可演化性。拥抱 std::allocator、std::unique_ptr 与范围化算法，是编写符合 C++20 精神的现代 C++ 代码的关键一步。当临时缓冲的需求浮现，请优先构建具有明确所有权、自动生命周期与异常安全保证的解决方案——这不仅是标准的要求，更是工程实践的成熟标志。