Chapter12&Chapter13：程序实例

文本查询程序

要求：程序允许用户在一个给定文件中查询单词。查询结果是单词在文件中出现的次数及所在行的列表。如果一个单词在一行中出现多次，此行只列出一次。

对要求的分析：

1.读入文件，必须记住单词出现在每一行。因此，程序需要逐行读取文件，并将每一行分解成独立的单词；

2. 程序生成输出时，它必须能提取每个单词所关联的行号；行号必须按升序出现且无重复；必须能打印给定行号的文本。

数据结构分析：

使用vector<string>来保存整个文件的拷贝；使用set来保存每个单词出现的行号；使用map将单词与行号关联起来。

我们在此基础上，再抽象一层：

定义一个保存文本输入的类，叫TextQuery。有两个操作：一是读取文件构造对象；二是执行查询操作。

查询操作：返回单词所在行及其文本。此结果定义一个类：QueryResult。

TextQuery与QueryResult的关系

由于QueryResult所需要的数据都保存在一个QTextQuery对象中，我们必须确定如何访问它们。我们可以拷贝行号的set，但这样很耗时。而且我们不希望拷贝vector。

所以两个类共享了数据。

 class QueryResult;

 class TextQuery
 {
 public:
     using line_no = vector<string>::size_type;
     TextQuery(ifstream&);
     QueryResult query(const string&) const;//不完全类型可以声明（但不能定义）为参数类型和返回类型
 private:
     shared_ptr<vector<string>> file;
     map<string, shared_ptr<set<line_no>>> wm;
 };

 TextQuery::TextQuery(ifstream& is)
     :file(new vector<string>)
 {
     string text;
     while (getline(is, text))
     {
         file->push_back(text);
         int n = file->size() - ;
         istringstream line(text);
         string word;
         while (line >> word)
         {
             auto &lines = wm[word];
             if (!lines)
                 lines.reset(new set<line_no>);
             lines->insert(n);
         }
     }
 }

 class QueryResult
 {
     friend ostream& print(ostream&, const QueryResult&);
 public:
     using line_no = vector<string>::size_type;
     QueryResult(string s, shared_ptr<set<line_no>> p, shared_ptr<vector<string>> f)
         :sought(s), lines(p), file(f) {}
 private:
     string sought;
     shared_ptr<set<line_no>> lines;
     shared_ptr<vector<string>> file;
 };

 //如果没有找到string，应该返回什么？
 //我们定义一个局部static对象，它指向一个空行号set的shared_ptr，未找到单词，则返回此对象的一个拷贝
 QueryResult TextQuery::query(const string &sought) const
 {
     static shared_ptr<set<line_no>> nodata(new set<line_no>);
     //不使用下标运算符来查找，避免将单词添加到wm中
     auto loc = wm.find(sought);
     if (loc == wm.end())
         return { sought, nodata, file };
     else
         return { sought, loc->second, file };
 }

 ostream& print(ostream &os, const QueryResult &qr)
 {
     os << qr.sought << " occurs " << qr.lines->size() << " time(s)" << endl;
     for (auto num : *qr.lines)
         os << "\t(line " << num +  << ") " << *(qr.file->begin() + num) << endl;
     return os;
 }

 void runQueries(ifstream& infile)
 {
     TextQuery tq(infile);
     while (true)
     {
         cout << "enter word to look for, or q to quit: ";
         string s;
         if (!(cin >> s) || s == "q")
             break;
         print(cout, tq.query(s)) << endl;
     }
 }

邮件与目录

资源管理并不是类需要定义自己的拷贝控制成员的唯一原因。一些类也需要拷贝控制成员的帮助来进行簿记工作或其他操作。

要求：有两个类Message和Folder，分别表示电子邮件消息和目录。每个Message可以出现在多个Folder中，Message内容只有一个副本——>如果一条Message的内容被改变，则我们从它所在的任何Folder来浏览此Message。

设计思路如下：

Message保存一个它所在Folder的指针的set；Folder保存一个它包含Message的指针的set。

当我们拷贝一个Message时，副本和原对象是不同的Message对象。因此，拷贝Message的操作包括消息内容和Folder指针set的拷贝；而且，我们必须在每个包含此消息的Folder中都添加一个指向新创建的Message的指针；

当我们销毁一个Message时，它将不复存在。因此，我们必须从包含此消息的所有Folder中删除指向此Message的指针；

当我们将一个Message对象赋予另一个Message对象时，左侧Message的内容会被右侧Message的内容所替代。同时，还必须更新Folder集合。

我们可以看到：

析构函数和拷贝赋值运算符都必须从包含一条Message的所有Folder中删除它。

拷贝构造函数和拷贝赋值运算符都要将一个Message添加到给定的一组Folder中。

我们定义两个private工具函数来完成这些工作。

 class Message
 {
     friend class Folder;
     friend void swap(Message&, Message&);
 public:
     explicit Message(const string &str = "")
         :contents(str) {}
     Message(const Message&);
     Message& operator=(const Message&);
     Message(Message &&m);
     Message& Message::operator=(Message &&rhs);
     ~Message();
     void save(Folder&);
     void remove(Folder&);
 private:
     string contents;
     set<Folder*> folders;
     void addToFolders(const Message&);
     void removeFromFolders();
     void moveFolders(Message *m);
 };

 void Message::save(Folder &f)
 {
     folders.insert(&f);
     f.addMsg(this);
 }

 void Message::remove(Folder &f)
 {
     folders.erase(&f);
     f.remMsg(this);
 }
 //拷贝控制：
 void Message::addToFolders(const Message &m)
 {
     for (auto f : m.folders)
         f->addMsg(this);
 }
 void Message::removeFromFolders()
 {
     for (auto f : folders)
         f->remMsg(this);
 }

 Message::Message(const Message &m)
     :contents(m.contents),folders(m.folders)
 {
     addToFolders(m);
 }
 Message::~Message()
 {
     removeFromFolders();
 }
 Message& Message::operator=(const Message &rhs)
 {
     //先从左侧对象的folders中删除此Message指针，然后再添加到右侧运算对象的folders中，从而实现自赋值的正确处理
     removeFromFolders();
     contents = rhs.contents;
     folders = rhs.folders;
     addToFolders(rhs);
     return *this;
 }
 //定义自己的swap版本
 void swap(Message &lhs, Message &rhs)
 {
     using std::swap;
     for (auto f : lhs.folders)
         f->remMsg(&lhs);
     for (auto f : rhs.folders)
         f->remMsg(&rhs);

     swap(lhs.folders, rhs.folders);
     swap(lhs.contents, rhs.contents);
     for (auto f : lhs.folders)
         f->addMsg(&lhs);
     for (auto f : rhs.folders)
         f->addMsg(&rhs);
 }

 //移动操作
 void Message::moveFolders(Message *m)
 {
     folders = std::move(m->folders);//使用set的移动赋值运算符
     for (auto f : folders)
     {
         f->remMsg(m);
         f->addMsg(this);
     }
     m->folders.clear();
 }

 Message::Message(Message &&m)
     :contents(std::move(m.contents))
 {
     moveFolders(&m);
 }

 Message& Message::operator=(Message &&rhs)
 {
     if (this != &rhs)
     {
         removeFromFolders();
         contents = std::move(rhs.contents);
         moveFolders(&rhs);
     }
     return *this;
 }

上述代码以Message类为例。