文本查询程序--摘自c++primer-CSDN博客

本文链接：https://blog.csdn.net/wangyanphp/article/details/9265917

本文总结摘录了《c++ primer》中的一个大例子---文本查询程序。主要目的在于学习大师的编程规范。

程序要求：读取用户指定的任意文本文件，然后允许用户从该文件中查找单词。查询的结果是该单词出现的次数，并列出每次出现所在的行。如果某单词在同一行中多次出现，程序将只显示该行一次，行号按升序显示。

分析：

输入为文件名；
必须将一行作为一个整体，由行号输出所在行；
必须每一行都分解为各个单词，并记录单词所在行，对于单词的查询返回所有所在行；
此处主要考察容器的使用；

求解：

使用vector来存储整行，vector中一个元素就是一行；
使用map来以单词为关键字，以所在行的集合为卫星数据；

下面是所包含的的头文件：

#include<utility>
#include<set>
#include<map>
#include<vector>
#include<string>
#include<iostream>
#include<fstream>
#include<sstream>
using namespace std;

下面是主要类TextQuery：

class TextQuery
 {
 public:
	 //typedef to make declarations easier
	 typedef  std::vector<std::string>::size_type  line_no;
	 typedef std::set<line_no>::const_iterator  set_it;

	 /* interface:
	  * read_file() builds internal data structures  for the given file
	  * run_query() finds the given word and returns "set" of lines on which it appears
	  * text_line()  return a requested line from the input file
	  */

	 void read_file(std::ifstream&  is)
	                {  store_file(is);  build_map();}
	  std::pair<set_it,set_it>  run_query(const std::string& )  const;
	  std::string text_line(line_no) const;

 private:
	 //utility functions used by read_file()
	 void store_file(std::ifstream& );  //store input file
	 void build_map();  //associated each word with a set of line numbers;

	 std::vector<std::string> lines_of_text;  //remember the whole input file
	 std::map<std::string, std::set<line_no> > word_map; 
 };

下面是辅助函数make_plural和open_file：

/*此函数提供一个计数器，一个单词word和单词结束符ending，
    当计数器值大于1时，返回单词的复数版本*/
 std::string make_plural(size_t ctr,const std::string& word, const std::string& ending)
 {
	 return (ctr==1)?word :word+ending;
 }

 //打开给定文件
 std::ifstream& open_file(std::ifstream& in,const std::string& file)
 {
	 in.close();//close in case it was already open
	 in.clear();//clear any existing errors;
	 in.open(file.c_str());
	 return in;
 }

下面是类中的各个函数实现，此处run_query的实现采用的是作者的第二种建议，返回一对迭代器：

//第一步：存储输入文件
 void TextQuery::store_file(ifstream&  is)
 {
	 string textline;
	 while( getline(is,textline) )
		 lines_of_text.push_back(textline);
 }

 //第二步：建立单词map容器

 void TextQuery::build_map()
 {
	 for(line_no line_num=0;line_num!=lines_of_text.size();++line_num){
		 istringstream line(lines_of_text[line_num]);
		 string word;
		 while(line>>word){
			 //add this line number to the set;
			 //其中word_map[word]是一个集合，然后insert
			 word_map[word].insert(line_num);
		 }
	 }
 }

 //第三步：支持查询
 //返回set的一对迭代器
  pair<TextQuery::set_it,TextQuery::set_it>  
	  TextQuery::run_query(const string& query_word) const
 {
	 //此处需要注意不能用下标操作直接查询，以防止插入不存在的元素
	 map<string,set<line_no> >::const_iterator loc=word_map.find(query_word);
		 return make_pair((loc->second).begin(),(loc->second).end()); 
 }

//第四步： 输出结果
 void print_results( pair<TextQuery::set_it,TextQuery::set_it>& its,
							 const string& sought,const TextQuery& file)
 {
	 typedef set<TextQuery::line_no> line_nums;
	 line_nums::size_type size=0;
	 for(TextQuery::set_it beg=its.first;beg!=its.second;++beg)
		 ++size;
	 cout<<"\n"<<sought<<" occurs "<<size<<"  "<<make_plural(size,"time","s")<<endl;

	 line_nums::const_iterator it=its.first;
	 for(;it!=its.second;++it){
		 cout<<"\t(line "<<(*it)+1<<")"<<file.text_line(*it)<<endl;
	 }
 }
 string TextQuery::text_line(line_no line) const
 {
	 if(line<lines_of_text.size())
		 return lines_of_text[line];
	 throw std::out_of_range("Line number out of range");
 }

测试程序如下：

int main()
 {
	 ifstream infile;
     string filename;
	 if(!(cin>>filename) || !open_file(infile,filename)){
		 cerr<<"NO input file!"<<endl;
		 return EXIT_FAILURE;
	 }
	 TextQuery tq;
	 tq.read_file(infile);
	 while(true){
		 cout<<"enter word to look for, or q to quit: ";
		 string s;cin>>s;
		 if(!cin || s=="q") break;
		 pair<TextQuery::set_it,TextQuery::set_it> its=tq.run_query(s);
		 print_results(its,s,tq);
	 }
	return 0; 
 }

扩展上面的文本查询程序，要求：

查找单个单词的查询，按升序显示所有包含该单词的行；
“非”查询，使用~操作符，显示所有不匹配行；
“或”查询，使用|操作符，显示与两个查询条件中任意一个匹配的所有行；
“与”查询，使用&操作符，显示与两个查询条件都匹配的所有行；
可以组合这些操作符；

设计类如下：

我们使用时：

Query q=Query（“ ”） & Query（“ ”）|Query（）

这个使用方式告诉我们，用户级代码将不能直接使用我们的继承层次，我们只能定义一个名为Query的句柄类，来隐藏继承层次。用户代码将根据句柄执行，用户代码只能间接操纵Query_base对象。

以Query q=Query("fiery") & Query("bird") |Query("wind")为例：

生成10个对象：5个Query_base对象及其相关联的句柄。

此处直接截取书中代码：

 // private, abstract class acts as a base class for concrete query types
     class Query_base {
         friend class Query;
     protected:
         typedef TextQuery::line_no line_no;
         virtual ~Query_base() { }
     private:
         // eval returns the |set| of lines that this Query matches
         virtual std::set<line_no>
             eval(const TextQuery&) const = 0;
         // display prints the query
         virtual std::ostream&
             display(std::ostream& = std::cout) const = 0;
     };

Query句柄类：

// handle class to manage the Query_base inheritance hierarchy
     class Query {
         // these operators need access to the Query_base* constructor
         friend Query operator~(const Query &);
         friend Query operator|(const Query&, const Query&);
         friend Query operator&(const Query&, const Query&);
     public:
         Query(const std::string&); // builds a new WordQuery
         // copy control to manage pointers and use counting
         Query(const Query &c): q(c.q), use(c.use) { ++*use; }
         ~Query() { decr_use(); }
         Query& operator=(const Query&);
     // interface functions: will call corresponding Query_base operations
     std::set<TextQuery::line_no>
       eval(const TextQuery &t) const { return q->eval(t); }
     std::ostream &display(std::ostream &os) const
                             { return q->display(os); }
     private:
         Query(Query_base *query): q(query),
                                   use(new std::size_t(1)) { }
         Query_base *q;
         std::size_t *use;
         void decr_use()
         { if (--*use == 0) { delete q; delete use; } }
     };

重载操作符：

 inline Query operator&(const Query &lhs, const Query &rhs)
     {
         return new AndQuery(lhs, rhs);
     }
     inline Query operator|(const Query &lhs, const Query &rhs)
     {
          return new OrQuery(lhs, rhs);
     }
     inline Query operator~(const Query &oper)
     {
         return new NotQuery(oper);
     }

输出操作符：

inline std::ostream&
     operator<<(std::ostream &os, const Query &q)
     {
         return q.display(os);
     }

WordQuery类：

class WordQuery: public Query_base {
         friend class Query; // Query uses the WordQuery constructor
         WordQuery(const std::string &s): query_word(s) { }
         // concrete class: WordQuery defines all inherited pure virtual functions
         std::set<line_no> eval(const TextQuery &t) const
                                 { return t.run_query(query_word); }
         std::ostream& display (std::ostream &os) const
                                   { return os << query_word; }
         std::string query_word; // word for which to search
      };

NotQuery类：

class NotQuery: public Query_base {
         friend Query operator~(const Query &);
         NotQuery(Query q): query(q) { }
          // concrete class: NotQuery defines all inherited pure virtual functions
          std::set<line_no> eval(const TextQuery&) const;
          std::ostream& display(std::ostream &os) const
                { return os << "~(" << query << ")"; }
          const Query query;
     };

 set<TextQuery::line_no>
     NotQuery::eval(const TextQuery& file) const
     {
          // virtual call through the Query handle to eval
          set<TextQuery::line_no> has_val = query.eval(file);
          set<line_no> ret_lines;
          // for each line in the input file, check whether that line is in has_val
         // if not, add that line number to ret_lines
         for (TextQuery::line_no n = 0; n != file.size(); ++n)
             if (has_val.find(n) == has_val.end())
                 ret_lines.insert(n);
         return ret_lines;
     }

Binary纯虚类：

 class BinaryQuery: public Query_base {
     protected:
         BinaryQuery(Query left, Query right, std::string op):
               lhs(left), rhs(right), oper(op) { }
         // abstract class: BinaryQuery doesn't define eval
         std::ostream& display(std::ostream &os) const
         { return os << "(" << lhs << " " << oper << " "
                                  << rhs << ")"; }
         const Query lhs, rhs; // right- and left-hand operands
         const std::string oper; // name of the operator
      };

OrQuery类：

class OrQuery: public BinaryQuery 
  {
             friend Query operator|(const Query&, const Query&);
             OrQuery(Query left, Query right):
                         BinaryQuery(left, right, "|") { }
             // concrete class: OrQuery inherits display and defines remaining pure virtual
             std::set<line_no> eval(const TextQuery&) const;
     };

   set<TextQuery::line_no>
     OrQuery::eval(const TextQuery& file) const
     {
             // virtual calls through the Query handle to get result sets for the operands
             set<line_no> right = rhs.eval(file),
                         ret_lines = lhs.eval(file); // destination to hold results
             // inserts the lines from right that aren't already in ret_lines
             ret_lines.insert(right.begin(), right.end());

             return ret_lines;
     }

AndQuery类：

 class AndQuery: public BinaryQuery {
         friend Query operator&(const Query&, const Query&);
         AndQuery (Query left, Query right):
                               BinaryQuery(left, right, "&") { }
         // concrete class: And Query inherits display and defines remaining pure virtual
         std::set<line_no> eval(const TextQuery&) const;
     };


    set<TextQuery::line_no>
     AndQuery::eval(const TextQuery& file) const
     {
          // virtual calls through the Query handle to get result sets for the operands
          set<line_no> left = lhs.eval(file),
                             right = rhs.eval(file);
          set<line_no> ret_lines; // destination to hold results
          // writes intersection of two ranges to a destination iterator
          // destination iterator in this call adds elements to ret
          set_intersection(left.begin(), left.end(),
                        right.begin(), right.end(),
                        inserter(ret_lines, ret_lines.begin()));
          return ret_lines;
     }