动态内存管理类示例——string专用版vector容器

规划

vector实现原理是预先分配足够的内存来保存元素，然后每添加一个元素都会检查是否有空间容纳更多元素。如果有，成员函数会在下一个可用位置构造一个对象，如果没有，vector就会重新分配空间（获得新的更大的空间，然后将已有元素移动到新的空间中，释放旧空间，然后添加新元素）
我们使用类似的策略：先使用allocator来获得没被构造过的原始内存，添加新元素时都用construct在原始内存上创建对象。当删除元素时使用destroy销毁元素。用三个指针指向三个位置：

• elements指向分配的内存中的首元素
• first_free指向最后一个实际元素之后的位置
• cap指向分配的内存末尾之后的位置

再定义一些常用的工具函数：

• alloc_n_copy分配内存，并拷贝一个给定范围中的元素
• free销毁构造的元素并释放内存
• chk_n_alloc检查是否有足够空间容纳新元素，不够就执行之前说的策略
• reallocate在内存用完时为StrVec分配更多新内存，就是在内存不够时为chk_n_alloc使用

框架

class StrVec
{
	StrVec() : elements(nullptr), first_free(nullptr), cap(nullptr) {}
	StrVec(const StrVec&);
	StrVec &operator=(const StrVec&);
	~StrVec() {}
	void push_back(const string&);
	//一些简单常用函数
	size_t size() const { return first_free - elements; }
	size_t capacity() const { return cap - elements; }
	string *begin() const { return elements; }
	string *end() const { return first_free; }
private:
	//分配空间用
	static allocator<string> alloc;
	//被添加元素的函数使用的工具函数
	void chk_n_alloc() { if (size() == capacity()) reallocate(); }
	//被拷贝构造、赋值运算符和析构使用的工具函数
	pair<string*, string*> alloc_n_copy(const string*, const string*);
	void free();
	void reallocate();
	string *elements;
	string *first_free;
	string *cap;
};

填充

push_back函数

使用push_back之前先检查空间够不够（即调用chk_n_alloc），足够就使用construct在原始内存上构造对象

void StrVec::push_back(const string &s)
{
	chk_n_alloc();
	alloc.construct(first_free++, s);
	//因为first_free指向最后一个已构造元素的后一个位置
	//所以先构造再递增
}

工具函数——alloc_n_copy

用来从原StrVec对象拷贝元素至新对象。

pair<string*, string*>
//b和e表示旧空间的首尾地址
StrVec::alloc_n_copy(const string *b, const string *e)
{
	//data指向新分配的空间的首地址
	auto data = alloc.allocate(e - b);
	return{ data, uninitialized_copy(b, e, data) };
	//这里的uninitialized_copy将be之间的内容拷贝进data
	//同时返回这片空间最后一个构造元素的后面一个地址
}

工具函数——free

free要先destroy掉元素，然后使用deallocate释放StrVec自己分配的内存空间。注意要逆序释放

void StrVec::free()
{
	//因为不能给deallocate传递空指针，所以这里使用elements判断是否为空
	if (elements)
	{
		//逆序destroy
		for (auto p = first_free; p != elements;)
			alloc.destroy(--p);
		alloc.deallocate(elements, cap - elements);
		//deallocate释放elements开始的cap - elements个内存
	}
}

拷贝控制成员

//拷贝构造函数
StrVec::StrVec(const StrVec &s)
{
	auto newdata = alloc_n_copy(s.begin(), s.end());
	elements = newdata.first;
	first_free = newdata.second;
	cap = newdata.second;
	//因为alloc_n_copy分配的空间恰好容纳给定的元素，所以cap也指向这个位置
}
//析构函数
StrVec::~StrVec() { free(); }
//拷贝赋值运算符
StrVec &StrVec::operator=(const StrVec &rhs)
{
	//这句防止自赋值情况
	auto data = alloc_n_copy(rhs.begin(), rhs.end());
	free(); //释放左侧原有内存
	elements = data.first;
	first_free = data.second;
	cap = data.second;
	return *this;
}

工具函数——reallocate

reallocate用来在空间不够时重新分配空间。这里使用allocate分配新的空间，每次要重新分配时都将StrVec的容量加倍。如果StrVec本身是空的，就分配容纳一个元素的空间

void StrVec::reallocate()
{
	auto newcapacity = size() ? size() * 2 : 1;
	auto newdata = alloc.allocate(newcapacity);
	auto dest = newdata; //指向新空间的首元素
	auto elem = elements; //指向旧空间的首元素
	//从头到尾，一个一个对应着构造
	for (size_t i = 0; i != size(); ++i)
		alloc.construct(dest++, std::move(*elem++));
	free(); //移动完后释放旧空间
	//让指针指向新的空间
	elements = elem;
	first_free = dest;
	cap = elements + newcapacity;
}

这里construct的第二个参数是move（注意只能用std::move），调用move会令construct使用string的移动构造函数。使用移动构造函数，string管理的内存不会被拷贝，我们构造的每个string都会从elem指向的string那里接管内存的所有权。这样做能避免拷贝和释放string的额外开销。

结果

class StrVec
{
	StrVec() :
		elements(nullptr), first_free(nullptr), cap(nullptr) {}
	StrVec(const StrVec&);
	StrVec &operator=(const StrVec&);
	~StrVec() { free(); }
	void push_back(const string&);
	size_t size() const { return first_free - elements; }
	size_t capacity() const { return cap - elements; }
	string *begin() const { return elements; }
	string *end() const { return first_free; }
private:
	static allocator<string> alloc;
	void chk_n_alloc() { if (size() == capacity()) reallocate(); }
	pair<string*, string*> alloc_n_copy(const string*, const string*);
	void free();
	void reallocate();
	string *elements;
	string *first_free;
	string *cap;
};
void StrVec::push_back(const string &s)
{
	chk_n_alloc();
	alloc.construct(first_free++, s);
}
pair<string*, string*> StrVec::alloc_n_copy(const string *b, const string *e)
{
	auto data = alloc.allocate(e - b);
	return{ data, uninitialized_copy(b, e, data) };
}
void StrVec::free()
{
	if (elements)
	{
		for (auto p = first_free; p != elements;)
			alloc.destroy(--p);
		alloc.deallocate(elements, cap - elements);
	}
}
StrVec::StrVec(const StrVec &s)
{
	auto newdata = alloc_n_copy(s.begin(), s.end());
	elements = newdata.first;
	first_free = newdata.second;
	cap = newdata.second;
}
StrVec &StrVec::operator=(const StrVec &rhs)
{
	auto data = alloc_n_copy(rhs.begin(), rhs.end());
	free();
	elements = data.first;
	first_free = data.second;
	cap = data.second;
	return *this;
}
void StrVec::reallocate()
{
	auto newcapacity = size() ? size() * 2 : 1;
	auto newdata = alloc.allocate(newcapacity);
	auto dest = newdata;
	auto elem = elements;
	for (size_t i = 0; i != size(); ++i)
		alloc.construct(dest++, std::move(*elem++));
	free();
	elements = elem;
	first_free = dest;
	cap = elements + newcapacity;
}