1--allocator类的使用背景
new 在分配内存时具有一定的局限性,其将内存分配和对象构造组合在一起;当分配一大块内存时,一般希望可以在内存上按需构造对象,这时需要将内存分配和对象构造分离,而定义在头文件 memory 的 allocator 类可以帮助我们将内存分配和对象构造分离开来;
2--allocator类的基本用法
① allocator<T> a 用于定义一个名为 a 的 allocator 对象,其可以为类型为T的对象分配内存;
② a.allocate(n) 用于分配一段原始的、未构造的内存,保存 n 个类型为 T 的对象;
③ a.deallocate(p, n) 用于释放从 T* 指针 p 中地址开始的内存,该内存保存了 n 个类型为 T 的对象;n 必须是 p 创建时所要求的大小,在调用 deallocate 之前必须对创建的对象调用 destroy();
④ a.construct(p, args) 用于在 p 指向的内存中构造一个对象;
⑤ a.destroy(p) 用于对 p 指向的对象执行析构函数;
#include <iostream>
#include <string>
#include <memory>
int main(int arc, char *argv[]){
std::allocator<std::string> alloc; // 定义对象
int n = 20;
auto const p = alloc.allocate(n); // 分配n个string的内存
auto q = p;
alloc.construct(q++); // *q 为空字符串
alloc.construct(q++, 10, 'c'); // *q 为cccccccccc
alloc.construct(q++, "hi"); // *q 为hi
auto i = p;
while(i != q){
std::cout << *i << std::endl;
alloc.destroy(i);
i++;
}
alloc.deallocate(p, n);
return 0;
}
// 输出结果
//
// cccccccccc
// hi
3--allocator类的拷贝填充
① uninitialized_copy(b, e, b2) 用于将迭代器 b 到 e 范围内元素拷贝到迭代器 b2 指定的未构造的原始内存中;
② uninitialized_copy_n(b, n, b2) 用于从迭代器 b 开始,拷贝 n 个元素到 b2 开始的内存中;
③ uninitialized_fill(b, e, t) 用于在迭代器 b 和 e 指定的范围内创建对象,对象的值均为 t 的拷贝;
④ uninitialized_fill_n(b, n, t) 用于从迭代器 b 开始创建 n 个对象,对象的值均为 t 的拷贝;
#include <iostream>
#include <string>
#include <memory>
int main(int arc, char *argv[]){
std::allocator<std::string> alloc1;
int n = 20;
auto const p = alloc1.allocate(n);
auto q = p;
alloc1.construct(q++); // *q 为空字符串
alloc1.construct(q++, 10, 'c'); // *q 为cccccccccc
alloc1.construct(q++, "hi"); // *q 为hi
std::allocator<std::string> alloc2;
auto const p2 = alloc2.allocate(2 * n);
std::uninitialized_copy(p, q, p2);
std::uninitialized_fill_n(q, 7, "aaa");
auto i = p;
while(i != p + 10){
std::cout << *i << std::endl;
i++;
}
return 0;
}
// 输出结果
//
// cccccccccc
// hi
// aaa
// aaa
// aaa
// aaa
// aaa
// aaa
// aaa