13-36.md

#include <iostream>
using std::cin; using std::cout; using std::endl; using std::cerr;
#include <string>
using std::string;
#include <set>
using std::set;

class Folder;
class Message {
    friend class Folder;
    friend void swap(Message &, Message &);
public:
    //folders被隐式初始化为空set
    explicit Message(const string &str = "") :
        contents(str) {};
    //拷贝控制成员，用来管理指向本Message的指针
    Message(const Message &);       //拷贝构造函数
    Message &operator=(const Message &);    //拷贝赋值运算符
    ~Message();     //析构函数
    //从给定Folder集合中添加/删除本Message
    void save(Folder&);
    void remove(Folder&);
private:
    string contents;        //实际消息文本
    set<Folder *> folders;  //包含本Message的Folder
    //拷贝构造函数、拷贝赋值运算符和析构函数所使用的工具函数
    //将本Message添加到指向参数的Folder中
    void add_to_Folders(const Message &);
    //从folders中的每个Folder中删除本Message
    void remove_from_Folders();
};

class Folder{
    friend class Message;
    friend void swap(Message &, Message &);
    friend void swap(Folder &, Folder &);
public:
    Folder() = default;
    //拷贝控制成员，用来管理指向本Folder的指针
    Folder(const Folder &);     //拷贝构造函数
    Folder &operator=(const Folder &);      //拷贝赋值运算符
    ~Folder();      //析构函数
    void save(Message *);
    void remove(Message *);
private:
    set<Message *> messages;
    //在给定Folder对象的消息集合中添加/删除元素
    void addMsg(Message *);
    void remMsg(Message *);
};

void Message::save(Folder &f) {
    folders.insert(&f);     //将给定Folder添加到我们的Folder列表中
    f.addMsg(this);         //将本Message添加到f的Message集合中
}

void Message::remove(Folder &f) {
    folders.erase(&f);      //将给定Folder从我们的Folder列表中删除
    f.remMsg(this);         //将本Message从f的Message集合中删除
}

//将本Message添加到指向m的Folder中
void Message::add_to_Folders(const Message &m) {
    for (auto f : m.folders)    //对每个包含m的Folder
        f->addMsg(this);        //向该Folder添加一个指向本Message的指针
}

Message::Message(const Message &m) :
    contents(m.contents), folders(m.folders){
    add_to_Folders(m);          //将本消息添加到指向m的Folder中
}

//从对应的Folder中删除本Message
void Message::remove_from_Folders() {
    for (auto f : folders)      //对folders中每个指针
        f->remMsg(this);        //从该Folder中删除本Message
}

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

Message &
Message::operator=(const Message &rhs) {
    //通过先删除指针再插入他们来处理自赋值情况
    remove_from_Folders();  //更新已有Folder
    contents = rhs.contents;    //从rhs拷贝消息内容
    folders = rhs.folders;      //从rhs拷贝Folder指针
    add_to_Folders(rhs);        //将本Message添加到那些Folder中
    return *this;
}

void swap(Message &lhs, Message &rhs){
    using std::swap;
    //将每个消息的指针从它（原来）所在Folder中删除
    for (auto f : lhs.folders)
        f->remMsg(&lhs);
    for (auto f : rhs.folders)
        f->remMsg(&rhs);
    //交换contents和Folder指针set
    swap(lhs.folders, rhs.folders);     //使用swap(set&, set&)
    swap(lhs.contents, rhs.contents);   //使用swap(string&, string&)
    //将每个Message的指针添加到它的（新）Folder中
    for (auto f : lhs.folders)
        f->addMsg(&lhs);
    for (auto f : rhs.folders)
        f->addMsg(&rhs);
}

//Folder的拷贝控制函数，不仅需要将该folder下所含的消息拷贝
//还需要更新每条消息的set<Folder *>，将新Folder对象添加到每一条消息，
Folder::Folder(const Folder &f) : messages(f.messages){
    for (auto &mm : messages)   //对包含的每条消息
        mm->folders.insert(this);   //
}

//Folder的拷贝赋值运算符
Folder &
Folder::operator=(const Folder &rhs) {
    //通过先删除指针再插入处理自赋值情况
    for (auto &mm : messages)   //对messages中的每个指针
        mm->folders.erase(this);    //从该Message的folders中删除本Folder
    messages = rhs.messages;    //从rhs中拷贝Message *指针（即所有条的消息）
    for (auto &mm : messages)   //对messages中的每个指针
        mm->folders.insert(this);   //将本Folder添加到所有的Message的folders中
    return *this;
}

//Folder的析构函数
Folder::~Folder() {
    for (auto &mm : messages)   //对messages中的每个指针
        mm->folders.erase(this);    //从该Message的folders中删除本Folder
}

void Folder::addMsg(Message *m) {
    m->folders.insert(this);
}

void Folder::remMsg(Message *m) {
    m->folders.erase(this);
}

void Folder::save(Message *m) {
    messages.insert(m);
    m->folders.insert(this);
}

void Folder::remove(Message *m) {
    messages.erase(m);
    m->folders.erase(this);
}

void swap(Folder &lhs, Folder &rhs) {
    using std::swap;
    //将每个目录的指针从它（原来）所包含的Message中删除
    for (auto &mm : lhs.messages)
        mm->remove(lhs);
    for (auto &mm : rhs.messages)
        mm->remove(rhs);
    swap(lhs.messages, rhs.messages);
    //将每个目录添加到每一条新的Message中
    for (auto &mm : lhs.messages)
        mm->save(lhs);
    for (auto &mm : rhs.messages)
        mm->save(rhs);
}

int main(){}