当前位置: 首页 > >

拷贝控制示例??Message和Folder

发布时间:

条件
使用两个类设计,Message??表示电子邮件消息,Folder??表示消息目录。每个Message可以出现在多个Folder中。修改某一条Message,它在它所在的所有Folder中都会被修改。Message使用一个set保存它所在的Folder的Folder指针。Folder也会用set保存它包含的Message的Message指针。Message要有save和remove操作,向一个给定的Folder添加或删除一条Message。Folder也得有类似的操作。拷贝一个Message,将会拷贝其消息内容和保存Folder指针的set。同时每个包含此消息的Folder都添加一个指向新创建的Message的指针;销毁一个Message时,也要从包含此Message的所有Folder中删除指向此Message的指针。将一个Message赋予另一个Message时,左侧的Message会被右侧代替。同时更新Folder,将保存左侧Message的Folder中将它删除,然后添加右侧的Message
实现
框架

class Message
{
friend class Folders;
public:
explicit Message(const string &str = "") : contents(str) {}
Message(const Message&);
Message& operator=(const Message&);
~Message();
void save(Folder&);
void remove(Folder&);
private:
string contents;
set folders;
//将本Message添加到指向参数的Folder中
void add_to_Folders(const Message&);
//从folders中的每个Folder中删除本Message
void remove_from_Folders();
};

save和remove成员

void Message::save(Folder &f)
{
//添加到folders,表示这个Folder保存了本信息
folders.insert(&f);
//将本信息添加到f的Message集合中
f.addMsg(this);
}
void Message::remove(Folder &f)
{
folders.erase(&f);
f.remMsg(this);
}

拷贝控制成员
拷贝构造函数


拷贝一个Message,将会拷贝其消息内容和保存Folder指针的set。同时每个包含此消息的Folder都添加一个指向新创建的Message的指针



包含此消息的Folder们保存在folders中,所以如果拷贝一个Message,就要遍历该Message的folders,对其中每个Folder都要添加一个指向拷贝的新指针。拷贝构造函数和拷贝赋值运算符运算符都要完成这个工作,所以定一个一个函数完成这个公共工作(一般这种公共工作都是private的)


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

拷贝构造函数如下:


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

析构函数

而当一个Message被销毁时,必须从所有指向此Message的Folder中删除它。拷贝赋值运算符也要做这个工作,所以还是定义一个private的函数:


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


tips:拷贝赋值运算符通常执行拷贝构造函数和析构函数中也要做的工作。这种情况下,公共的工作应该作为函数放在private中



同时就能定义析构函数:


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

拷贝赋值运算符

左侧的Message被右侧替代,就相当于左侧的Message被销毁(遍历左侧的folders,删除指向自己的Folder),然后拷贝为右侧的Message(遍历右侧的folders,添加指向拷贝的新指针)


Message& Message::operator=(const Message &rhs)
{
remove_from_Folders();
contents = rhs.contents;
folders = rhs.folders;
add_to_Folders(rhs);
return *this;
}

自己的Message和Folder类
实现了对应的Folder类添加了addFldr()函数和rmvFldr()函数,分别实现向当前Message对象插入/删除一个Folder

class Folder
{
friend class Message;
public:
explicit Folder(const string &str = "") : title(str) {}
Folder(const Folder&);
Folder& operator=(const Folder&);
~Folder() { remove_from_Message(); }
private:
string title;
set msgs;
void add_to_Message(const Folder &f)
{
for (auto m : f.msgs)
m->addFldr(this);
}
void remove_from_Message()
{
for (auto m : msgs)
m->rmvFldr(this);
}
void remMsg(Message *m) { msgs.erase(m); }
void addMsg(Message *m) { msgs.insert(m); }
};
Folder::Folder(const Folder &f) : title(f.title), msgs(f.msgs)
{
//拷贝构造新的Folder
//将老Folder消息集里的消息的set都添加上新Folder的指针
add_to_Message(f);
}
Folder& Folder::operator=(const Folder &f)
{
//拷贝赋值运算符函数,同时执行拷贝构造函数功能和析构函数功能
remove_from_Message();
title = f.title;
msgs = f.msgs;
add_to_Message(f);
return *this;
}
class Message
{
public:
explicit Message(const string &str = "") : contents(str) {}
Message(const Message &m) : contents(m.contents), folders(m.folders) { add_to_Folders(m); }
Message& operator=(const Message&);
~Message() { remove_from_Folders(); }
void saveTo(Folder &f)
{
folders.insert(&f);
f.addMsg(this);
}
void addFldr(Folder *f) { folders.insert(f); }
void removeFrom(Folder &f)
{
folders.erase(&f);
f.remMsg(this);
}
void rmvFldr(Folder *f) { folders.erase(f); }
private:
string contents;
set folders;
void add_to_Folders(const Message &m)
{
for (auto f : m.folders)
f->addMsg(this);
}
void remove_from_Folders()
{
for (auto f : folders)
f->remMsg(this);
}

};
Message& Message::operator=(const Message &rhs)
{
remove_from_Folders();
contents = rhs.contents;
folders = rhs.folders;
add_to_Folders(rhs);
return *this;
}

给Message类加上移动构造函数和移动赋值运算符

Message有string和contents和set的folders,如果用拷贝会比较耗时耗力,利用移动控制能避免产生额外开销。接管了旧Message的资源后就要更新folders,将旧Message换成接管了旧Message的新Message。用一个函数来实现这个操作:


void move_Folders(Message *m)
{
folders = std::move(m->folders); //调用set的移动赋值运算符
for (auto f : folders)
{
f->remMsg(m);
f->addMsg(this);
}
m->folders.clear();
//将老m置于可析构状态
//确保销毁m没有别的影响
}

class Message
{
public:
explicit Message(const string &str = "") : contents(str) {}
Message(const Message &m) : contents(m.contents), folders(m.folders) { add_to_Folders(m); }
//移动构造函数,因为是接管m,所以要从Floder中删除老的m,添加成新的接管了m的左侧对象
Message(Message &&m) : contens(std::move(m.contents)) { move_Folders(&m); }
Message& operator=(const Message &rhs)
{
remove_from_Folders();
contents = rhs.contents;
folders = rhs.folders;
add_to_Folders(rhs);
return *this;
}
//移动赋值运算符
Message& operator=(Message &rhs)
{
if (this != &rhs)
{
remove_from_Folders();
contents = std::move(rhs.contents);
move_Folders(&rhs);
}
return *this;
}
~Message() { remove_from_Folders(); }
void saveTo(Folder &f)
{
folders.insert(&f);
f.addMsg(this);
}
void addFldr(Folder *f) { folders.insert(f); }
void removeFrom(Folder &f)
{
folders.erase(&f);
f.remMsg(this);
}
void rmvFldr(Folder *f) { folders.erase(f); }
private:
string contents;
set folders;
void add_to_Folders(const Message &m)
{
for (auto f : m.folders)
f->addMsg(this);
}
void remove_from_Folders()
{
for (auto f : folders)
f->remMsg(this);
}
void Message::move_Folders(Message *m)
{
folders = std::move(m->folders); //调用set的移动赋值运算符
for (auto f : folders)
{
f->remMsg(m);
f->addMsg(this);
}
m->folders.clear();
//将老m置于可析构状态
}
};
Message& Message::operator=(const Message &rhs)
{
remove_from_Folders();
contents = rhs.contents;
folders = rhs.folders;
add_to_Folders(rhs);
return *this;
}



友情链接: