<think>
我们专注于
C++标准库中的
allocator，详细介绍其函数功能和基本
用法。
根据
C++标准，
allocator是一个模板
类，定义在<memory>头文件中。它提供了一套标准接口用于内存分配、对象构造和析构以及内存回收。
我们将按照以下结构进行介绍：
1.
allocator的核心
成员函数
2. 基本使用示例
3. 注意事项
注意：我们讨论的是
C++11及以后的标准。在
C++17和
C++20中，
allocator有一些变化，但核心功能保持一致。
一、
allocator的核心
成员函数
1. 构造和析构函数：
默认构造函数：`
allocator() noexcept;`
拷贝构造函数：`
allocator(const
allocator& other) noexcept;`
析构函数：`~
allocator();`
2. 内存分配与释放：
- `T* allocate(std::size_t n);`
分配n个
类型为T的对象的内存，返回指向第一个对象的指针。分配的内存是原始的、未构造的。
n不能超过最大可分配大小（通过max_size()获取），否则可能抛出std::bad_array_new_length异常（
C++17起）或std::bad_alloc异常。
- `void deallocate(T* p, std::size_t n);`
释放从p开始的内存块，该内存块必须是之前通过allocate分配的，且大小n必须与分配时一致。
注意：在调用deallocate之前，必须先销毁该内存块上的对象。
3. 对象构造与析构：
- `template <class U, class... Args> void
construct(U* p, Args&&... args);` (
C++11起，
C++20前)
在p指向的内存位置构造一个U
类型的对象，使用参数args进行构造（相当于调用`::new((void*)p) U(std::forward<Args>(args)...);`）。
C++20起，该函数被移除，建议使用`std::
allocator_traits`中的`
construct`或`std::
construct_at`。
- `void destroy(T* p);` (
C++11起，
C++20前)
销毁p指向的对象（调用析构函数），但不释放内存（相当于调用`p->~T();`）。
C++20起，该函数被移除，建议使用`std::
allocator_traits`中的`destroy`或`std::destroy_at`。
4. 其他
成员函数：
- `size_type max_size() const noexcept;` （在
C++17中被弃用，
C++20移除）
返回理论上可以分配的最大对象数量（通常为`std::numeric_limits<size_type>::max() / sizeof(T)`）。
- `using value_type = T;` 表示分配器分配的对象
类型。
注意：从
C++11开始，
allocator还支持多态分配器（std::pmr::memory_resource），但这里我们讨论标准
allocator。
二、基本使用示例
下面是一个使用std::
allocator的完整示例：
```cpp
#include <memory> // for std::
allocator, std::
allocator_traits
#include <iostream>
int main() {
// 1. 创建
allocator实例
std::
allocator<int> alloc;
// 2. 分配内存：可以存储5个int的空间
constexpr std::size_t n = 5;
int* p = alloc.allocate(n); // 分配原始内存，未初始化
// 3. 在分配的内存上构造对象
// 注意：
C++20之前可以直接使用alloc.
construct，但
C++20中
construct被移除。建议使用
allocator_traits
for (std::size_t i=0; i<n; ++i) {
// 使用
allocator_traits的
construct函数，可以保证在
C++各个版本中可用
std::
allocator_traits<decltype(alloc)>::
construct(alloc, p+i, i*10);
// 相当于在p+i位置构造int对象，初始化为i*10
// 如果是自定义
类型，则调用对应的构造函数
}
// 使用这些对象
for (std::size_t i=0; i<n; ++i) {
std::cout << p[i] << ' '; // 输出: 0 10 20 30 40
}
std::cout << '\n';
// 4. 销毁对象：按相反顺序或任意顺序，但必须销毁每一个构造过的对象
for (std::size_t i=0; i<n; ++i) {
std::
allocator_traits<decltype(alloc)>::destroy(alloc, p+i);
}
// 5. 释放内存
alloc.deallocate(p, n);
return 0;
}
```
三、注意事项
1. 内存分配（allocate）和对象构造（
construct）是分离的，释放内存（deallocate）和对象析构（destroy）也是分离的。
因此，在释放内存前必须销毁所有对象，否则会导致资源泄漏（特别是对象持有非内存资源时）。
2. 在
C++20中，std::
allocator的
construct和destroy
成员函数被移除。因此，推荐使用std::
allocator_traits来构造和销毁对象，
这样可以编写与
C++版本无关的代码。std::
allocator_traits提供了一套统一的接口，即使
allocator类型没有提供某个
成员函数，它也会提供默认实现。
3. 为了简化，
C++提供了
allocator_traits
类模板，它实际上是对
allocator的一层包装，提供标准接口。例如：
- 构造：`std::
allocator_traits<Alloc>::
construct(alloc, p, args...)`
- 析构：`std::
allocator_traits<Alloc>::destroy(alloc, p)`
4. 在容器中，
allocator会自动管理内存和对象的生命周期。用户通常不需要直接调用这些函数。
5. 自定义
allocator：可以创建自己的
allocator类，但必须满足标准
allocator的要求（如定义value_type等必要
类型，以及提供allocate、deallocate等
成员函数）。
四、
C++17及以后的更改
1.
C++17引入了std::
allocator<void>的显式特化，但它已被弃用（因为
allocator<void>在
C++17前未定义，但允许使用，
C++20移除）。
2.
C++17引入了多态分配器（polymorphic_
allocator）和内存资源（memory_resource），这是另一种分配器模型。
3.
C++20引入了std::
allocator_traits的改进，并移除了std::
allocator的
construct和destroy
成员函数，同时提供了全局函数：
- std::
construct_at：构造对象，可替代
construct
- std::destroy_at：销毁对象，可替代destroy
总结：在现代
C++中，直接使用std::
allocator的
成员函数进行对象构造和销毁的情况较少，更推荐使用std::
allocator_traits或
C++17/
C++20提供的通用工具。
我们将生成相关问题，以便进一步探讨
allocator的相关主题。
</think>
###
C++ Allocator 函数功能及
用法详解
#### 一、核心
成员函数功能说明
1. **内存分配与释放**
```cpp
// 分配原始内存（未构造对象）
T* allocate(size_type n);
// 释放已分配内存
void deallocate(T* p, size_type n);
```
- `allocate`：分配 $n \times sizeof(T)$ 字节的原始内存
- `deallocate`：释放指针 `p` 指向的内存块，`n` 必须与分配时一致
- 复杂度：通常为 $O(1)$[^1]
2. **对象构造与析构**
```cpp
// 在已分配内存上构造对象
template <class U, class... Args>
void
construct(U* p, Args&&... args);
// 销毁对象但保留内存
void destroy(T* p);
```
- `
construct`：使用完美转发在 `p` 处构造对象（等价于 `::new(p) T(args...)`）
- `destroy`：显式调用析构函数（等价于 `p->~T()`）
- 区别于内存分配/释放：仅管理对象生命周期[^1]
3. **辅助函数**
```cpp
// 获取
类型信息
using value_type = T;
// 查询最大可分配大小（
C++17前）
size_type max_size() const noexcept;
```
- `value_type`：标准要求必须定义的嵌套
类型
- `max_size()`：返回理论最大分配数量（
C++20 已弃用）[^2]
#### 二、基本使用示例
```cpp
#include <memory>
int main() {
// 1. 创建
allocator实例
std::
allocator<int> alloc;
// 2. 分配内存（5个int空间）
int* arr = alloc.allocate(5); // 原始内存，未初始化
// 3. 构造对象
for(int i=0; i<5; ++i) {
alloc.
construct(arr+i, i*10); // arr[i] = {0,10,20,30,40}
}
// 4. 使用对象
arr[2] = 100; // 修改第三个元素
// 5. 销毁对象
for(int i=0; i<5; ++i) {
alloc.destroy(arr+i); // 调用析构函数
}
// 6. 释放内存
alloc.deallocate(arr, 5);
}
```
#### 三、现代
C++ 最佳实践（
C++11 起）
1. **使用 `
allocator_traits` 统一接口**
```cpp
template <typename T>
void safe_
construct(std::
allocator<T>& alloc, T* p, auto&& arg) {
std::
allocator_traits<std::
allocator<T>>::
construct(alloc, p, std::forward<decltype(arg)>(arg));
}
```
- 提供
类型擦除能力，兼容自定义分配器
- 在缺少
成员函数时提供默认实现（如 `
construct()`/`destroy()`）
2. **结合容器使用**
```cpp
// 自定义分配器的vector声明
template <typename T, typename Alloc = std::
allocator<T>>
class Vector {
Alloc alloc; // 分配器实例
T* data;
public:
void push_back(const T& value) {
// 使用分配器接口
T* new_space = alloc.allocate(capacity*2);
alloc.
construct(new_space + size, value);
// ...迁移数据
}
};
```
#### 四、关键注意事项
1. **生命周期分离原则**
- 内存分配（allocate） ≠ 对象构造
- 内存释放（deallocate） ≠ 对象析构
- 违规操作导致未定义行为（如 `deallocate` 未销毁对象）
2. **异常安全保证**
- `allocate` 失败时抛出 `std::bad_alloc`
- `
construct` 失败时需手动销毁已构造对象
```cpp
try {
alloc.
construct(p, args...);
} catch(...) {
alloc.deallocate(p, 1); // 清理内存
throw;
}
```
3. **自定义分配器要点**
```cpp
template <typename T>
struct Custom
Allocator {
using value_type = T; // 必须定义
T* allocate(size_t n) { ... }
void deallocate(T* p, size_t n) { ... }
// 可选：构造/析构函数
template <typename U, typename... Args>
void
construct(U* p, Args&&... args) { ... }
};
```
> 实际开发中优先使用 `std::
allocator_traits` 而非直接调用分配器
成员函数，以保证代码兼容性[^2]。
这篇博客探讨了C++中allocator类的使用，特别是如何使用construct构造函数来初始化分配的内存。通过示例展示了如何在分配的内存上构造string对象，并强调了在未构造的对象上进行操作是错误的。还提到了新标准库中construct函数的额外参数，允许更灵活的对象初始化。在实际项目中，使用了std::move来构造对象。
扫一扫
238
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
