C++ 文本查询2.0(逻辑查询)

代码实例实现了继承和友元之间的关系,以及为了隐藏实际继承实现，而实现的接口类,代码偏乱，楼主- -自看的(提醒作用)

TextQuery.h

 //
 // Created by 徐爱东 on 17/7/19.
 //

 #ifndef TEXTQUERY_2_0_TEXTQUERY_H
 #define TEXTQUERY_2_0_TEXTQUERY_H

 #include <iostream>
 #include <map>
 #include <set>
 #include <vector>
 #include <string>
 #include <memory>
 #include <sstream>
 #include <fstream>

 class QueryResult
 {
     friend std::ostream &operator<<(std::ostream &os, const QueryResult &result);

     typedef std::vector<std::string>::size_type line_no;
 public:
     QueryResult(const std::string &word, std::shared_ptr<std::set<line_no> > lines,
                 std::shared_ptr<std::vector<std::string>> files);

     std::set<line_no>::iterator begin()
     {
         return lines_->begin();
     }

     std::set<line_no>::iterator end()
     {
         return lines_->end();
     }

     std::shared_ptr<std::vector<std::string> > get_file()
     {
         return files_;
     }

 private:
     std::string word_;    //查询单词
     std::shared_ptr<std::set<line_no>> lines_;    //单词出现行数集合
     std::shared_ptr<std::vector<std::string>> files_;          //根据的文件

 };

 class TextQuery
 {
 public:
     // using line_no=std::vector<std::string>::size_type ;
     typedef std::vector<std::string>::size_type line_no;    //C++11

     TextQuery(std::fstream &in);

     QueryResult query(const std::string &word) const;

 private:
     std::shared_ptr<std::vector<std::string> > filecontext_;      //文件内容
     std::map<std::string, std::shared_ptr<std::set<line_no> > > wordlinesset_;      //单词集合
 };

 #endif //TEXTQUERY_2_0_TEXTQUERY_H

TextQuery.cpp

 //
 // Created by 徐爱东 on 17/7/19.
 //

 #include "TextQuery.h"

 QueryResult::QueryResult(const std::string &word, std::shared_ptr<std::set<line_no> > lines,
                          std::shared_ptr<std::vector<std::string>> files)
         : word_(word), lines_(lines), files_(files)
 {

 }

 std::ostream &operator<<(std::ostream &os, const QueryResult &result)
 {
     if (!result.lines_)
     {
         return os << result.word_ << " apprear 0 time:\n";

     } else
     {
         os <<"\n"<< result.word_ << " appear " << result.lines_->size()
            << (result.lines_->size() >  ? " times:" : " time:") << "\n\n";

         for (auto iter = result.lines_->cbegin();
              iter != result.lines_->cend(); iter = (result.lines_->upper_bound(*iter)))
         {
             os << "\t\t\t\t\t(line" << *iter +  << "): " << *(result.files_->begin() + *iter) << std::endl<<std::endl;
         }

         return os;
     }
 }

 TextQuery::TextQuery(std::fstream &in)
         : filecontext_(new std::vector<std::string>{})
 {
     std::string line;
     std::stringstream stream;

     //每次获得一行
     while (std::getline(in, line))
     {
         stream.clear();
         filecontext_->push_back(line);
         auto linenumber = filecontext_->size() - ;

         stream << line;
         while (stream >> line)
         {
             //没有则创建,有则返回只能指针;
             auto& lineset = wordlinesset_[line];

             if (!lineset)
                 lineset.reset(new std::set<line_no>);

             //记录行号
             lineset->insert(linenumber);
         }

     }

 }

 QueryResult TextQuery::query(const std::string &word) const
 {
     if (wordlinesset_.find(word) == wordlinesset_.end())
     {
         std::shared_ptr<std::set<line_no> > null_sharedptr(new std::set<line_no>);
         return QueryResult(word, null_sharedptr, filecontext_);

     } else
     {
         return QueryResult(word, wordlinesset_.find(word)->second, filecontext_);
     }

 }

Query.h & QueryBase{WordQuery,NotQuery,BinaryQuery{AndQuery,OrQUery}};

基本关系:Query是接口类,QueryBase是抽象类,WordQUery,NotQuery实现类,BinaryQuery抽象类(重构),AndQuery,OrQUery实际类

 //
 // Created by 徐爱东 on 17/7/19.
 //

 #ifndef TEXTQUERY_2_0_QUERY_BASE_H
 #define TEXTQUERY_2_0_QUERY_BASE_H

 #include "TextQuery.h"

 class Query;

 class WordQuery;

 class NotQuery;

 class AndQuery;

 class OrQuery;

 //抽象类
 class Query_base
 {
     //接口类,用于隐藏继承结构
     friend class Query;;
 private:
     virtual QueryResult eval(const TextQuery &) const =;

     virtual std::string rep() const =;

 protected:
     using line_no=TextQuery::line_no;

     virtual ~Query_base() = default;

 };

 class Query
 {
     friend class Query_base;

     friend class WordQuery;

     friend class NotQuery;

     friend class AndQuery;

     friend class OrQuery;

     //运算符操作需要访问私有shared_ptr，所以声明为友元
     friend Query operator~(const Query &);

     friend Query operator&(const Query &lhs, const Query &rhs);

     friend Query operator|(const Query &l, const Query &r);

     friend std::ostream &operator<<(std::ostream &os, const Query query)
     {
         return os << query.rep();
     }

 public:
     Query(const std::string &word);    //普通单单词查询，WordQuery;

     //接口函数,因为不是继承Query_base
     QueryResult eval(const TextQuery &text) const
     {
         return q->eval(text);
     }

     std::string rep() const
     {
         return q->rep();
     }

 private:
     //shared_ptr构造,为了使用动态虚调用
     //private 不允许外部调用
     Query(std::shared_ptr<Query_base> query) : q(query)
     {};
     std::shared_ptr<Query_base> q;
 };

 //唯一实际查询的类
 class WordQuery : public Query_base
 {
     //所有成员皆为private
     friend class Query;     //Query 需要使用构造函数

     std::string word_;

     WordQuery(const std::string &word) : word_(word)
     {}

     QueryResult eval(const TextQuery &Tq) const override
     {
         return Tq.query(word_);
     }

     std::string rep() const override
     {
         return word_;
     }

 };

 //取反的Query
 class NotQuery : public Query_base
 {

     friend Query operator~(const Query &);

     NotQuery(const Query &q) : query_(q)
     {

     }

     Query query_;

     //"~单词"返回的结果
     QueryResult eval(const TextQuery &Tq) const override
     {
         auto result = query_.eval(Tq);

         auto ret_line = std::make_shared<std::set<std::vector<std::string>::size_type>>();
         auto set = std::make_shared<std::set<std::vector<std::string>::size_type> >(result.begin(), result.end());

         auto file_line = result.get_file()->size();

         for (auto line = ; line != file_line; line++)
         {
             //不在set里
             if (set->find(line + ) == set->end())
             {
                 //添加
                 ret_line->insert(line);
             }
         }

         return QueryResult(query_.rep(), ret_line, result.get_file());

     }

     std::string rep() const override
     {
         return "~(" + query_.rep() + ")";//表示不需要查询的单词
     }
 };

 //BinaryQuery类，一个抽象基类，因为继承了基类的纯虚函数eval()
 //重构
 class BinaryQuery : public Query_base
 {
     friend class Query;;
 protected:
     BinaryQuery(const Query &l, const Query &r, const std::string &operaname)
             : lhs_(l),
               rhs_(r),
               operaname_(operaname)
     {

     }

     Query lhs_, rhs_;
     std::string operaname_;

 //    QueryResult eval(const TextQuery &) const
 //    {
 //
 //    }

     std::string rep() const
     {
         return "(" + lhs_.rep() + " " + operaname_ + " " + rhs_.rep() + ")";
     }
 };

 class AndQuery : public BinaryQuery
 {
     friend class Query;;
 protected:
     friend Query operator&(const Query &, const Query &);

     AndQuery(const Query &l, const Query &r) : BinaryQuery(l, r, "&")
     {}

     QueryResult eval(const TextQuery &text) const
     {
         //通过Query成员进行虚调用
         //调用eval返回每个QueryResult结果
         auto right = lhs_.eval(text), left = rhs_.eval(text);
         //空的目标容器
         auto ret_lines = std::make_shared<std::set<std::vector<std::string>::size_type>>();

         //取交集放入re_lines;
         std::set_intersection(right.begin(), right.end(),
                               left.begin(), left.end(),
                               std::inserter(*ret_lines, ret_lines->begin()));

         return QueryResult(rep(), ret_lines, right.get_file());
     }

 };

 class OrQuery : public BinaryQuery
 {
     friend class Query;;
 protected:
     friend Query operator|(const Query &, const Query &);

     OrQuery(const Query &l, const Query &r) : BinaryQuery(l, r, "|")
     {}

     QueryResult eval(const TextQuery &text) const
     {
         //通过Query成员lhs和rhs进行虚调用
         //调用eval返回每个运算对象的QueryResult
         auto right = lhs_.eval(text), left = rhs_.eval(text);
         auto ret_lines = std::make_shared<std::set<std::vector<std::string>::size_type> >(right.begin(), right.end());
         //进行并集操作y
         ret_lines->insert(left.begin(), left.end());
         return QueryResult(rep(), ret_lines, right.get_file());
     }
 };

 //每个Query都先生成基本WordQuery基础
 inline Query::Query(const std::string &word) : q(new WordQuery(word))
 { std::cout << "Query" << std::endl; }

 inline Query operator~(const Query &q)
 {
     return std::shared_ptr<Query_base>(new NotQuery(q));
 }

 inline Query operator&(const Query &lhs, const Query &rhs)
 {
     return std::shared_ptr<Query_base>(new AndQuery(lhs, rhs));
 }

 inline Query operator|(const Query &l, const Query &r)
 {
     return std::shared_ptr<Query_base>(new OrQuery(l, r));
 }

 #endif //TEXTQUERY_2_0_QUERY_BASE_H

main.cpp

 #include <iostream>
 #include "Query_base.h"

 int main()
 {
     std::fstream file_("Text.txt", std::ios::in);
     std::vector<std::string> str_vec;
     std::vector<Query> que_vec;

     if (file_.is_open())
     {
         TextQuery file(file_);

         std::string word1, word2;
         do
         {
             std::cout << "Input word you want('quit to exit'): ";
             std::cin >> word1 >> word2;

             if (word1 == "quit")
             {
                 break;
             }

             Query query1(word1), query2(word2);
             auto q = query1 & query2;
             std::cout << q.rep() << std::endl;
             std::cout << q.eval(file) << std::endl;
             word1.clear();
         } while ();

     }

     file_.close();

     return ;
 }

缺点:本来想实现字符串读取分隔实现动态逻辑Query联合,太麻烦- -就没写