C++基础的不能再基础的学习笔记——拷贝控制示例（二）

拷贝控制示例

我们在之前的博客上了解到了，需要管理资源的类通常要定义拷贝控制操作、swap操作。http://blog.csdn.net/fancynece/article/details/79346314

但是，①资源管理并不是一个类需要定义自己的拷贝控制成员的唯一原因。

一些类需要拷贝控制成员的帮助来进行②簿记工作或其他操作。

我们通过一个例子来说明，簿记工作需要拷贝控制成员。

定义两个类Message和Folder，分别表示电子邮件消息和消息目录。

一个Message可以出现在多个Folder中

每个Message只有一个副本

我们在每个Message中，用set记录下包含它的Folder的指针；在每个Folder中，用set记录下包含的所有Message的指针。

Message提供save和remove操作，用来将对象保存到Folder中或从Folder删除。

当我们拷贝一个Message时，需要拷贝set，并且在所有包含它的Folder的set中添加该Message的指针

当我们销毁一个Message时，需要在所有包含它的Folder的set中删除该Message的指针

当我们进行赋值操作时，左侧Message的内容被销毁，右侧Message的内容拷贝到左侧。

Folder类提供addMsg和remMsg操作，用来添加或删除Message对象

class Message {

friend class Folder;
friend void swap(Message &lm, Message &rm);

public:

explicit Message(const string &str = "") :contents(str) {}
Message(const Message&);
Message& operator=(const Message&);
~Message();

void save(Folder &f)
{
folders.insert(&f);
f.addMsg(this);
}
void remove(Folder &f)
{
folders.erase(&f);
f.remMsg(this);
}

private:

string contents;        //内容
set<Folder*> folders;

void add_to_Folders(const Message&);
void remove_from_Folders();
};

Message::Message(const Message &m):contents(m.contents),folders(m.folders)
{
add_to_Folders(m);
}

Message & Message::operator=(const Message &m)
{
remove_from_Folders();

contents = m.contents;
folders = m.folders;

add_to_Folders(m);

return *this;
}

Message::~Message()
{
remove_from_Folders();
}

void Message::add_to_Folders(const Message &m)
{
for (auto c : m.folders)
c->addMsg(this);
}

void Message::remove_from_Folders()
{
for (auto c : folders)
c->remMsg(this);
}

void swap(Message & lm, Message & rm)
{
using std::swap;

for (auto c : lm.folders)
c->remMsg(&lm);
for (auto c : rm.folders)
c->remMsg(&rm);

swap(lm.contents, rm.contents);
swap(lm.folders, rm.folders);

for (auto c : lm.folders)
c->addMsg(&lm);
for (auto c : rm.folders)
c->addMsg(&rm);
}

动态内存管理类

某些类需要在运行时分配可变大小的内存空间。

这种类通常可以一般也都会使用标准库容器来保存它们的数据。但是某些类需要自己进行内存分配，这些类一般来说必须定义自己的拷贝控制成员来管理所分配的内存。

我们将实现一个标准库vector类的简化版本StrVec，不适用模板，并且只用于string。

StrVec类的设计

我们已经知道，vector类将元素保存在连续内存中，添加元素时，若有空间则加入，若没有空间则重新分配内存，并将原有元素移动到新内存中，释放旧空间并添加新元素。

因此我们的StrVec类也要如此。

我们将使用一个allocator（一个类模板，将内存分配和对象构造分离开来）来获得原始内存。添加对象时，由于allocator分配的内存是未构造的，我们将用allocator的construct成员在原始内存中创建对象。删除对象时，使用destroy成员来销毁元素。

StrVec有三个指针成员指向其元素所使用的内存，有一个静态成员来分配内存。

elements ： 指向分配的内存中的首元素

first_free ： 指向最后一个实际元素之后的位置

cap ： 指向分配的内存末尾之后的位置

alloc ： 分配内存的静态成员，allocator < string >类型

StrVec还有4个工具函数。

alloc_n_copy ： 分配内存，拷贝指定范围中的元素

free ： 销毁构造的元素并释放内存

chk_n_alloc ： 保证StrVec至少有容纳一个新元素的空间

reallocate ： 在内存用完时为StrVec分配新内存

class StrVec {

public:

StrVec() :elements(nullptr), first_free(nullptr), cap(nullptr) {}
StrVec(const StrVec&);
StrVec& operator = (const StrVec &);
string& operator[](const size_t);
~StrVec();

//插入
void push_back(const string&);
string* insert(string*,const string&);
string* insert(string*,const string*,const string*);

//删除
void pop_back();
string* erase(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:

allocator<string> alloc;  //分配内存
string *elements;
string *first_free;
string *cap;

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

pair<string*, string*> alloc_n_copy(const string *, const string *);
void free();
void reallocate();

};

StrVec::StrVec(const StrVec &s)
{
pair<string*,string*> p;
p = alloc_n_copy(s.begin(), s.end());
elements = p.first;
first_free = p.second;
cap = p.second;

}

StrVec & StrVec::operator=(const StrVec &s)
{
auto p = alloc_n_copy(s.begin(), s.end());

free();

elements = p.first;
first_free = p.second;
cap = p.second;

return *this;

}

string& StrVec::operator[](const size_t loc)
{
return *(elements + loc);
}

StrVec::~StrVec()
{
free();
cout << "析构函数被调用辣" << endl;
}

void StrVec::push_back(const string &s)
{
//添加元素到容器末尾

//确保有位置
chk_n_alloc();
//加入元素
alloc.construct(first_free++,s);

}

string* StrVec::insert(string *p, const string &s)
{

assert(p >= begin() && p <= end());

size_t loc = p - elements;
chk_n_alloc();
auto e = elements + loc;

alloc.construct(end());

for (auto b = end(); b > e; --b)
*b = *(b - 1);

*e = s;

first_free++;

cout << "插入了一个元素" << endl;

return e;
}

string * StrVec::insert(string *, const string *, const string *)
{
return nullptr;
}

void StrVec::pop_back()
{
assert(elements != first_free);
alloc.destroy(--first_free);
}

string * StrVec::erase(string *p)
{
assert(p >= begin() && p < end());

for (auto b = p; b < end() - 1; ++b)
*b = *(b + 1);

alloc.destroy(end() - 1);

return ++p;
}

pair<string*, string*> StrVec::alloc_n_copy(const string *b, const string *e)
{
//分配空间保存给定范围中的元素，返回首元素指针和尾元素下一位置的指针

//分配空间
auto data = alloc.allocate(e - b);

//初始化并返回一个pair，将[b,e)赋值给迭代器data指定的未构造的内存中
return {data,uninitialized_copy(b,e,data)};
}

void StrVec::free()
{
if (elements)
{
//销毁容器中的所有元素
for (auto p = first_free; p != elements;)
alloc.destroy(--p);//析构string
//释放内存空间
alloc.deallocate(elements, cap - elements);
}
}

void StrVec::reallocate()
{
//分配新内存空间
auto newcapacity = size() ? 2 * size() : 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 = newdata;
first_free = dest;
cap = elements + newcapacity;

cout << "重新分配内存辣 当前内存为" << cap - elements << "元素个数为" << first_free - elements << endl;

}

现在，我们只有一个函数reallocate没有实现。这个函数需要完成如下功能。

为容器分配一个更大的内存

在内存的前一部分构造对象，保存现有元素

销毁原内存空间中的元素，释放内存

我们知道，拷贝一个string就必须拷贝数据，它就会有两个用户。但是，如果是reallocate拷贝StrVec中的string，则在拷贝之后，只有一个用户（旧内存被释放了）。

因此，拷贝string是多余的，分配和释放string会造成很多的额外开销，所以我们想要移动它们。

移动构造函数和std::move

通过使用新标准库引入的两种机制，我们就可以避免string库的拷贝。

移动构造函数：移动构造函数通常将对象移动而不是拷贝到正在创建的对象中。对于string，我们可以想象每个string都有一个指向char数组的指针，可以假定string的移动构造函数进行了指针的拷贝。

sd::move ： 定义在utility头文件中。① 当我们希望用string的移动构造函数时，必须调用move来表示这个希望 ② 我们使用move时，直接调用std::move而不是move。

void StrVec::reallocate()
{
//分配新内存空间
auto newcapacity = size() ? 2 * size() : 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 = newdata;
first_free = dest;
cap = elements + newcapacity;
}