文章目录

  • ​​allocator​​
  • ​​一个完整的allocator分配内存的过程​​
  • ​​allocator算法​​

allocator

标准库allocator类定义在头文件memory中，他帮助我们把内存分配和对象的构造分离开来，提供一种类型感知的内存分配的方法。

#include < memory >

  • 指明使用allocator可以分配的对象的类型：
allocator<string> alloc;  //表明alloc可以分配string的allocator对象
  • 分配内存空间
constexpr auto n=3; //可以接受常量或者变量
auto p = alloc.allocate(n);   //分配了三个string内存空间给了p

分配之后，p是string* 类型。相当于new string[ 3 ]，但是使用alloc分配的内存是未构造的。

  • 在内存中构造对象

由于 由alloc分配的内存是未构造的，我们无法使用普通的赋值来给它赋予初始值，例如：

string* str = new string[n];
for (int i = 0; i < n; i++)
{
  *str++ = "abc"; //可以赋值
}
for (int i = 0; i < 3; i++)
{
  *p++ = "abc"; //ERROR： 未构造的，无法进行赋值操作
}

因此，在使用alloc分配的内存我们需要使用construct进行构造对象，来完成初始化或者赋值。

正确方式：这样我们就可以完成对分配的内存构造成对象，并且进行赋值。

q=p;  //使用q来记录它的位置，p始终保存着分配的内存的起始位置
for (int i = 0; i < n; i++)
{
  string s;
  cin >> s;
  alloc.construct(q, s);  //构造对象
}

注意：我们的construct第一个参数必须是指向未构造的内存空间，后面的参数为可变参数，表示接受一个构造函数，在这里我们指定它接受默认的string的构造函数。

警告： 使用allocator分配的内存一定要使用construct来进行构造对象，使用未构造的内存其行为是未定义的。

  • 销毁对象

destroy可以销毁每一个构造的对象，相当于对这个对象执行它自己的析构函数。

//销毁构造的对象：q指向的是当前的对象，p指向的是我们的内存的起始位置
while (q != p)
{
  //释放每一个string对象:对string*执行析构操作
  alloc.destroy(--q);
}

从后往前，依次进行string对象的销毁。但是请注意，我们只是析构这个对象，我们开辟的这段空间并未释放。

  • 释放内存空间

使用deallocate来释放开辟的内存空间。

//最后再释放内存块:  deallocate一定要在destroy执行之后再执行
alloc.deallocate(p, n);

一个完整的allocator分配内存的过程

#include <iostream>
#include <memory>
#include <vld.h>
#include <vector>
using namespace std;

int main()
{
  //使用allocator
  constexpr auto n = 3;
  allocator<string> alloc;  //可以分配string的allocator对象
  auto p = alloc.allocate(n);   //分配了三个string内存空间给了p
  string s;
  auto q = p;
  while (q != p + n && cin >> s)
  {
    /*
    在alloc分配的内存是未构造的，必须使用construct来构造对象，使用原始内存
    */
    alloc.construct(q++, s);
  }
  //打印输出构造的对象:保存原始位置，使用一个临时的beg指针
  auto beg = p;
  while (beg != q)
  {
    cout << *beg++ << " ";
  }
  //销毁构造的对象
  while (q != p)
  {
    //释放每一个string对象:对string*执行析构操作
    alloc.destroy(--q);
  }
  //最后再释放内存块:  deallocate一定要在destroy执行之后再执行
  alloc.deallocate(p, n);
  return 0;
}

使用allocator开辟的内存比使用new开辟的内存空间更加安全。

allocator算法

allocator类具有两个伴随算法， 方便进行空间的使用与创建，它们分别是

  • uninitialized_copy：拷贝指定范围的元素到新创建的未构造的内存空间中。
  • uninitialized_fill_n：填充元素到新创建的未构造的内存空间中。

举例： 将一个vector数组扩大一倍，并且把序列中的内从拷贝到我们开辟的动态内存中，多余的未构造的空间进行默认初始化。

/*
拷贝与填充未初始化的内存
*/
vector<int> vec{ 1,2,3,4,5 };
allocator<int> allocInt;
//分配比原始的vector内存空间大两倍的空间
auto vecP =  allocInt.allocate(vec.size() * 2);
//原始的内容拷贝到新的内存空间中
auto vecq =  uninitialized_copy(vec.begin(), vec.end(), vecP);
//剩下的一半内存空间填充
uninitialized_fill_n(vecq++, vec.size(), 6);
//释放内存
allocInt.deallocate(vecP, vec.size() * 2);

uninitialized_copy： 返回值是拷贝完成后剩余未构造的内存空间的起始位置。
uninitialized_fill_n：把前一个函数返回值当作第一个参数，表示从这里开始，填充指定数量的值往剩余的空间中。