C++ Primer09动态内存管理类

动态内存管理类

上一节咱们写了邮件管理类。这一节要写一个动态内存管理类。

前言

如果一个类需要在运行时使用可变大小的内存空间，也就是这个类的数据成员，它不一定需要存储多少个。这样的话，我们一般使用标准库来存储数据。但有的时候，我们需要自己进行内存分配。
还记得之前说的吗？只要需要自己进行内存分配。那必然，这个类会存在析构、拷贝构造、拷贝赋值运算符函数。
跟前面的邮箱管理类一样，这一套函数是存在功能重叠的。因此我们还是，把它重叠的功能定义在private下来作为工具函数。

分析这一套函数来提取工具函数

拷贝赋值运算符一般兼有拷贝构造函数以及析构函数的行为

拷贝构造函数： 这个函数就是将这个对象完全拷贝出新的一模一样的对象来。因此，它的作用包括：分配等大的存储空间，并将原对象存储空间的内容拷贝一份给新分配的存储空间。

析构函数： 它的作用包括：将存储空间存储的对象释放掉，然后释放存储空间。

拷贝赋值运算符： 它需要将运算符左边的对象的数据以及存储空间释放掉，随后将右边对象拷贝一个给左边对象。因此，它的作用包括：将存储空间存储的对象释放掉，然后释放存储空间。然后分配等大的存储空间，并将运算符右边对象存储空间的内容拷贝一份给新分配的存储空间。

这样就发现了重合的功能：

1. 将存储空间存储的对象释放掉，然后释放存储空间。
2. 分配等大的存储空间，并将原对象存储空间的内容拷贝一份给新分配的存储空间。

StrVec.h

#pragma once
#include<string>
#include<memory>
#include<utility>
#include<initializer_list>
using namespace std;
class StrVec
{
public:
	StrVec():elements(nullptr),first_free(nullptr),cap(nullptr){}
	StrVec(initializer_list<string>);
	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:
	string* elements;
	string* first_free;
	string* cap;
	static allocator<string> alloc;
	void alloc_n_copy(const StrVec&); //拷贝给定范围的元素
	void free();//销毁构造的内存
	void chk_n_alloc();//保证有至少容纳一个元素的空间
	void reallocate();//内存用完后重新分配
};

StrVec.cpp

#include "StrVec.h"
allocator<string> StrVec::alloc;
StrVec::StrVec(initializer_list<string> li)//构造函数
{
	string* p = alloc.allocate(li.size());
	elements = p;
	for (auto iter = li.begin(); iter != li.end(); iter++)
	{
		alloc.construct(p++, *iter);
	}
	first_free = p;
	cap = p;
}
StrVec::StrVec(const StrVec& s) //拷贝构造函数
{
	alloc_n_copy(s);
}
StrVec::~StrVec() //析构函数
{
	free();
}
StrVec& StrVec::operator=(const StrVec& s) //拷贝赋值运算符 可以避免自赋值
{
	if (this != &s)
	{
		free();
		alloc_n_copy(s);
	}
	return *this;
}

void StrVec::push_back(const string& s)
{
	chk_n_alloc();
	alloc.construct(first_free++, s);
}
///工具函数//
void StrVec::alloc_n_copy(const StrVec& sv) //分配等大的存储空间，将原来的内容拷贝一份
{
	string* p = alloc.allocate(sv.cap - sv.elements);
	string* q = p;
	string* elem = sv.elements;
	while (elem != sv.first_free)
	{
		alloc.construct(q++, *elem);
		elem++;
	}
	elements = p;
	first_free = q;
	cap = elements + (sv.cap - sv.elements);
}

void StrVec::free()//销毁存储空间
{
	if (elements)
	{
		string* q = first_free;
		while (q != elements)
		{
			alloc.destroy(--q);
		}
		alloc.deallocate(elements, cap - elements);
	}
}

void StrVec::chk_n_alloc()
{

	if (size() == capacity())
	{
		reallocate();
	}
}

void StrVec::reallocate()
{
	size_t n = size() ? size() * 2 : 1;
	string* dest = alloc.allocate(n);
	string* p = dest;
	string* elem = elements;
	for (int i = 0; i != size(); i++)
	{
		alloc.construct(p++, std::move(*elem++));//调用移动构造函数
	}
	free();
	elements = dest;
	first_free = p;
	cap = elements + n;
}

test_StrVec.cpp

#include"StrVec.h"
#include<iostream>

using namespace std;

int main()
{
	StrVec st;
	st.push_back("cuinan");
	st.push_back("dd");
	StrVec st2(st);
	StrVec st3;
	st3 = st;
	st = st;
	StrVec st4({ "lala","cc","dd" });
	for (string* i = st.begin(); i != st.end(); i++)
	{
		cout << *i << " ";
	}
	cout << endl;
	for (string* i = st2.begin(); i != st2.end(); i++)
	{
		cout << *i << " ";
	}
	cout << endl;
	for (string* i = st3.begin(); i != st3.end(); i++)
	{
		cout << *i << " ";
	}
	cout << endl;
	for (string* i = st4.begin(); i != st4.end(); i++)
	{
		cout << *i << " ";
	}
}

运行结果