C++ allocator设计内存管理器

时间：2021-05-02 00:55:12


文章目录

  • ​​allocator内存管理器​​
  • ​​基本属性​​
  • ​​类的设计​​
  • ​​关键功能的实现​​
  • ​​完整的内存管理器​​
  • ​​内存管理器的测试：设计自定义的String类。​​

前情回顾：
​allocator内存管理类​​

allocator内存管理器

某些类需要在运行时分配可变大小的内存空间，一般来说我们使用容器如vector来管理我们的数据，但是对于某些类，在有些时候我们需要自己进行内存的分配。这些类必须定义自己的拷贝控制成员来管理所分配的内存。

我们将实现一个vector，这个vector保存的是sring类型的数据，而且使用我们自己创建的内存分配的方式。我们的这个类叫做 vecStr

基本属性

我们在自己创建的vecStr中需要有三个属性，分别是：

  • element： 指向分配的内存的起始位置。
  • first_free：指向已经构造完成的对象的下一个位置，即未构造的内存的起始位置。
  • cap：总的内存空间的尾后位置。

如图所示：

C++ allocator设计内存管理器

类的设计

基本构造函数：

strVec();
strVec(std::initializer_list<std::string> initList);
~strVec();
strVec(const strVec& other);      //拷贝构造函数
strVec& operator=(const strVec& other); //拷贝赋值运算符

以下几个具有关键功能的函数：

  • alloc_n_copy：分配内存，并且拷贝给定范围的元素到一个新的内存中。
std::pair<std::string*, std::string*> alloc_n_copy(const std::string* beg, const std::string* end);
  • reallocate： 当内存不够时，重新分配一块新的内存，并且拷贝原始内容，释放旧的内存
void reallocate();
  • free：释放内存空间
//释放内存
void free();
  • check_n_alloc：检查当前内存空间是否足够，不够的话调用reallocate重新分配一块内存。
//检查内存是否足够，不够的话就重新分配
void check_n_alloc();

其他功能性函数：

//获取总容量
size_t capacity()const { return cap - element; }
//获取已分配的容量大小
size_t size()const { return first_free - element; }
void push_back(const std::string& str);

关键功能的实现

  • alloc_n_copy：接受一个开始位置和结束的位置的指针，开辟一块新的内存空间，并且把开始位置到结束位置中的内容拷贝到这块新的内存空间，并且返回这块内存空间的初始位置和尾后位置。

我们使用pair来保存这两个位置。

std::pair<std::string*, std::string*> strVec::alloc_n_copy(const std::string* beg, const std::string* end)
{
  auto p = allocStr.allocate(end - beg);    //分配end - beg个大小的内存空间,返回未构造的初始的位置
  //拷贝内存到新的内存空间，uninitialized_copy返回拷贝结束后的位置，这个位置就是first_free的位置，p就是element的位置
  return { p,std::uninitialized_copy(beg, end, p) };
}

使用uninitialized_copy来拷贝beg到end的内存空间的内容到新的内存空间p中。

  • reallocate：旧内存空间不够时，我们重新开辟一块内存，并且把原始内容拷贝到新内存中，注意我们的新内存一般是原始内存的两倍大小。
  1. 使用move的进行移动构造，从而避免拷贝构造（拷贝后销毁）的繁琐操作，直接进行指针所有权的转移即可，这就是移动构造函数。
  2. 使用construct构造对象。
  3. 注意属性的更新，element first_free cap此时都指向了新的内存空间的对应位置。
void strVec::reallocate()
{
  /*
  在重新分配空间的时候，移动而不是拷贝构造
  */
  //申请两倍的空间
  auto NewSpace = (size() == 0) ? 1 : 2 * size();
  //分配新内存
  auto pNew = allocStr.allocate(NewSpace);
  auto dest = pNew;
  auto old = element;
  for (size_t i = 0; i != size(); i++)
  {
    //移动构造旧的内存里的数据，移动到新的内存空间里
    allocStr.construct(dest++, std::move(*old++));
  }
  free(); //释放旧内存

  //更新数据
  element = pNew;
  first_free = dest;
  cap = element + NewSpace;
}
  • free：释放旧的内存空间，我们使用三种方法来释放旧的内存空间，for_each函数式，正序销毁和逆序销毁，注意，销毁只是调用了他们的析构函数，我们一定最后使用deallocate来彻底释放这块内存。 
void strVec::free()
{
  if (element)
  {
#if 0
    //for_each销毁
    std::for_each(begin(), end(), [&](std::string& str)
      {
        allocStr.destroy(&str);
      });
#elif 0
    //逆序销毁旧元素
    /*for (auto eleBeg = first_free; eleBeg != element;)
    {
      allocStr.destroy(--eleBeg);
    }*/
#else
    //正序销毁旧元素
    for (auto elebeg = element; elebeg != first_free;)
    {
      allocStr.destroy(elebeg++);
    }
#endif
    allocStr.deallocate(element, cap - element);
  }
}

完整的内存管理器

#pragma once
#include <iostream>
#include <vector>
#include <memory>
#include <vld.h>
#include <algorithm>

/*
内存管理器
*/
class strVec
{
public:
  strVec();
  strVec(std::initializer_list<std::string> initList);
  ~strVec();
  strVec(const strVec& other);      //拷贝构造函数
  strVec& operator=(const strVec& other); //拷贝赋值运算符
  //总容量
  size_t capacity()const { return cap - element; }
  //已分配的容量
  size_t size()const { return first_free - element; }
  void push_back(const std::string& str);
  //分配至少能容纳n个元素的内存空间
  void reserve(const int& n);
  //重新调整大小
  void resize(const int& n, const std::string& str = "None");
public:
  std::string* begin()const { return element; }
  std::string* end()const { return first_free; }
private:
  //分配内存，并且拷贝元素到这个范围里
  std::pair<std::string*, std::string*> alloc_n_copy(const std::string* beg, const std::string* end);
  //释放内存
  void free();
  //检查内存是否足够，不够的话就重新分配
  void check_n_alloc();
  //内存不够，分配新的内存空间:需要拷贝原来的元素并且释放原来的内存
  void reallocate();
  void reallocate(int n);
private:
  std::allocator<std::string> allocStr; //内存分配器
  std::string* element;   //内存空间的起始元素
  std::string* first_free;  //已分配的实际元素之后的位置
  std::string* cap;     //总的分配空间之后的位置
};



strVec::strVec()
  :element(nullptr), first_free(nullptr), cap(nullptr)
{
}

strVec::strVec(std::initializer_list<std::string> initList)
{
  //分配合适的内存大小
  int n = initList.size();
  auto p = allocStr.allocate(n);
  element = first_free = p;
  cap = p + n;
  for (auto& xStr : initList)
  {
    allocStr.construct(first_free++, xStr);
  }
}

strVec::~strVec()
{
  free();
}

strVec::strVec(const strVec& other)
{
  //拷贝构造,other的内存拷贝到新的对象中
  auto pPair = alloc_n_copy(other.element, other.first_free);
  element = pPair.first;
  first_free = pPair.second;
  cap = pPair.second;     //alloc_n_copy分配的空间恰好容纳给定的元素
}

strVec& strVec::operator=(const strVec& other)
{
  //赋值运算符，直接对自身操作，返回自身，记得销毁原来的内存
  auto pPair = alloc_n_copy(other.element, other.first_free);
  free();
  element = pPair.first;
  first_free = cap = pPair.second;
  // TODO: 在此处插入 return 语句
  return *this;
}

void strVec::push_back(const std::string& str)
{
  //插入元素
  check_n_alloc();  //检查空间大小
  //构造对象
  allocStr.construct(first_free++, str);
}

void strVec::reserve(const int& n)
{
  //如果n小于等于当前容量，则什么也不做
  if (n > capacity())
  {
    //重新分配
    reallocate(n);
  }
}

void strVec::resize(const int& n, const std::string& str)
{
  if (n < capacity())
  {
    //如果说缩小容量，则删除后面的元素
    int m = capacity() - n;   //容量差值 15-10=5 则删除后五个元素
    for (int i = 0; i < m; i++)
    {
      allocStr.destroy(--first_free);
    }
    cap = first_free;
  }
  else
  {
    //否则增大容量，末尾填充str
    reallocate(n);
    while (first_free != cap)
    {
      allocStr.construct(first_free++, str);
    }
  }
}

std::pair<std::string*, std::string*> strVec::alloc_n_copy(const std::string* beg, const std::string* end)
{
  auto p = allocStr.allocate(end - beg);    //分配end - beg个大小的内存空间,返回未构造的初始的位置
  //拷贝内存到新的内存空间，uninitialized_copy返回拷贝结束后的位置，这个位置就是first_free的位置，p就是element的位置
  return { p,std::uninitialized_copy(beg, end, p) };
}

void strVec::free()
{
  if (element)
  {
#if 0
    //for_each销毁
    std::for_each(begin(), end(), [&](std::string& str)
      {
        allocStr.destroy(&str);
      });
#elif 0
    //逆序销毁旧元素
    /*for (auto eleBeg = first_free; eleBeg != element;)
    {
      allocStr.destroy(--eleBeg);
    }*/
#else
    //正序销毁旧元素
    for (auto elebeg = element; elebeg != first_free;)
    {
      allocStr.destroy(elebeg++);
    }
#endif
    allocStr.deallocate(element, cap - element);
  }
}

void strVec::check_n_alloc()
{
  //内存不够
  if (size() == capacity())
  {
    reallocate();
  }
}

void strVec::reallocate()
{
  /*
  在重新分配空间的时候，移动而不是拷贝构造
  */
  //申请两倍的空间
  auto NewSpace = (size() == 0) ? 1 : 2 * size();
  //分配新内存
  auto pNew = allocStr.allocate(NewSpace);
  auto dest = pNew;
  auto old = element;
  for (size_t i = 0; i != size(); i++)
  {
    //移动构造旧的内存里的数据，移动到新的内存空间里
    allocStr.construct(dest++, std::move(*old++));
  }
  free(); //释放旧内存

  //更新数据
  element = pNew;
  first_free = dest;
  cap = element + NewSpace;
}

void strVec::reallocate(int n)
{
  auto NewSpace = n;
  //分配新内存
  auto pNew = allocStr.allocate(NewSpace);
  auto dest = pNew;
  auto old = element;
  for (size_t i = 0; i != size(); i++)
  {
    //移动构造旧的内存里的数据，移动到新的内存空间里
    allocStr.construct(dest++, std::move(*old++));
  }
  free(); //释放旧内存

  //更新数据
  element = pNew;
  first_free = dest;
  cap = element + NewSpace;
}

内存管理器的测试：设计自定义的String类。

/*
char* 类型的内存分配器
*/

class String
{
public:
  String();
  String(const char* str);
  String(const String& other);
  String& operator=(const String& other);
  ~String();
  size_t size() const { return end - element; }
  //重新分配内存
public:

private:
  void free();
  std::pair<char*, char*> alloc_n_copy(const char* beg,const char* end);
  //void reallocapacity();
  char* element;
  char* end;
  std::allocator<char> alloCh;  //内存分配器
};

int main()
{
  String s{"woaini"};
  String s1{ s };
  String s2;
  s2 = s1;
  return 0;
}

String::String()
  :element(nullptr),end(nullptr)
{
}

String::String(const char* str)
{
  //分配内存
  int len = strlen(str);
  auto pStr =  alloc_n_copy(str, str + len);
  element = pStr.first;
  end = pStr.second;
}

String::String(const String& other)
{
  auto pNew = alloc_n_copy(other.element, other.end);
  element = pNew.first;
  end = pNew.second;
}

String& String::operator=(const String& other)
{
  auto pNew = alloc_n_copy(other.element, other.end);
  free();
  element = pNew.first;
  end = pNew.second;
  return *this;
}

String::~String()
{
  free();
}

void String::free()
{
  if (element)
  {
    std::for_each(element, end, [&](char& str)
      {
        alloCh.destroy(&str);
      });
    alloCh.deallocate(element, end - element);
  }
}

std::pair<char*, char*> String::alloc_n_copy(const char* beg, const char* end)
{
  auto p =  alloCh.allocate(end - beg);
  return { p,std::uninitialized_copy(beg,end,p) };
}


标签：

相关文章