A small example of c/c + + inheritance and polymorphic text query (smart pointer version)

In order to better understand inheritance and polymorphism, make a small example of text query.

Interface class: Query has two methods.

  • eval: query, return query result class QueryResult
  • rep: get the text to query

How to use the client program:

//Query the row containing the text of Daddy
Query q("Daddy");
//Query the row of text without Alice
Query q = ~Query("Alice");
//Query, line with fiery or bird
Query q = Query("fiery") | Query("bird");
//Query, with lines of fiery, bird or wind
Query q = Query("fiery") & Query("bird") | Query("wind");

Interface class: Query, which has a private smart pointer of the parent class Query base.

  • The parent query base has children WordQuery, NotQuery and BinaryQuery (AndQuery, OrQuery).

  • Subclass is responsible for processing individual query results. For example, do And processing Or processing.

Query.h

#ifndef __QUERY_H__
#define __QUERY_H__

#include <string>
#include <memory>
#include <iostream>
#include "TextQuery.h"

class QueryResult;
class Query;

class Query_base{
  friend class Query;
 protected:
  using line_no = TextQuery::line_no;
  virtual ~Query_base() = default;
 private:
  virtual QueryResult eval(const TextQuery&) const = 0;
  virtual std::string rep() const = 0;
};

class Query{
  friend Query operator~(const Query&);//Need to access private constructor
  friend Query operator|(const Query&, const Query&);//Need to access private constructor
  friend Query operator&(const Query&, const Query&);//Need to access private constructor
 public:
  Query(const std::string&);//Build a new WordQuery
  // Interface function: call the corresponding query base operation
  QueryResult eval(const TextQuery& t) const{
    return q->eval(t);
  }
  std::string rep()const{
    return q->rep();
  }

 private:
  Query(std::shared_ptr<Query_base> query)
    :q(query){
    std::cout << "Query pri:" << std::endl;
  }
  std::shared_ptr<Query_base> q;
  
};

class WordQuery : public Query_base{
  friend class Query;//Query uses WordQuery's private constructor
  WordQuery(const std::string& s)
    : query_word(s){
    std::cout << "WordQuery:" << s << std::endl;
  }
  QueryResult eval(const TextQuery& t)const{
    return t.query(query_word);
  }
  std::string rep()const{
    return query_word;
  }

  std::string query_word;
};

class NotQuery : public Query_base{
  friend Query operator~(const Query&);
  NotQuery(const Query& q)
    :query(q){
    std::cout << "NotQuery" << std::endl;
  }
  std::string rep() const {
    return "~(" + query.rep() + ")";
  }
  QueryResult eval(const TextQuery&)const;
  Query query;
};

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


class BinaryQuery : public Query_base{
 protected:
  BinaryQuery(const Query& l, const Query& r,
          std::string s)
    : lhs(l), rhs(r), opSym(s){
    std::cout << "BinaryQuery" << std::endl;
  }
  std::string rep() const {
    return "(" + lhs.rep() + " "
      + opSym + " "
      + rhs.rep() + ")";
  }
  Query lhs, rhs;
  std::string opSym;
};

class AndQuery : public BinaryQuery{
  friend Query operator&(const Query&, const Query&);
  AndQuery(const Query& l, const Query& r)
    : BinaryQuery(l, r, "&"){
    std::cout << "AndQuery" << std::endl;
  }
  QueryResult eval(const TextQuery&) const;
};

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

class OrQuery : public BinaryQuery{
  friend Query operator|(const Query&, const Query&);
  OrQuery(const Query& l, const Query& r)
    : BinaryQuery(l, r, "|"){
    std::cout << "OrQuery" << std::endl;
  }
  QueryResult eval(const TextQuery&) const;
};

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

#endif

Query.cpp

#include "Query.h"
#include <algorithm>

/*
std::ostream& operator<<(std::ostream& os, const Query& q){
  //Query::rep Make a virtual call to rep() through its query base pointer
  return os << q.rep();
}
*/
Query::Query(const std::string& s) : q(new WordQuery(s)){
    std::cout << "Query pub" << std::endl;
}

QueryResult NotQuery::eval(const TextQuery& text)const{
  //Virtual call to eval through Query operation object
  auto result = query.eval(text);
  //The result set is empty at the beginning
  auto ret_lines = std::make_shared<std::set<line_no>>();
  auto beg = result.begin();
  auto end = result.end();
  //For each line of the input file, if the line is not in the result, it will be added to ret [lines]
  auto sz = result.get_file()->size();
  for(size_t n = 0; n != sz; ++n){
    //If you haven't finished processing all the lines of the result
    //Check if the current row exists
    if(beg == end || *beg != n){
      ret_lines->insert(n);
    }
    else if(beg != end){
      ++beg;//Continue to get the next line of reslut
    }
  }

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

QueryResult AndQuery::eval(const TextQuery& text)const{
  //Virtual call through Query member lhs,rhs
  //Call eval to return QueryResult of each object
  auto right = rhs.eval(text);
  auto left  = lhs.eval(text);
  //Save the set of left and right intersection
  auto ret_lines =
    std::make_shared<std::set<line_no>>();
  //Writes the intersection of two ranges into a destination iteration.
  std::set_intersection(left.begin(), left.end(),
            right.begin(), right.end(),
            inserter(*ret_lines, ret_lines->begin()));
  return QueryResult(rep(), ret_lines, left.get_file());
}

QueryResult OrQuery::eval(const TextQuery& text)const{
  //Virtual call through Query member lhs,rhs
  //Call eval to return QueryResult of each object
  auto right = rhs.eval(text);
  auto left  = lhs.eval(text);
  //Copy the row number of the left operand to the result set
  auto ret_lines =
    std::make_shared<std::set<line_no>>(left.begin(), left.end());
  //Line number from insert right operand
  ret_lines->insert(right.begin(), right.end());
  //Returns a new QueryResult representing the union of lhs and rhs
  return QueryResult(rep(), ret_lines, right.get_file());
}

QueryResult.h

#ifndef __QUERYRESULT_H__
#define __QUERYRESULT_H__

#include <iostream>
#include <set>
#include <vector>
#include <string>
#include <memory>

class QueryResult{
  friend std::ostream& print(std::ostream&, const QueryResult&);
public:
  using line_no = std::vector<std::string>::size_type;
  using Iter = std::set<line_no>::iterator;
  QueryResult(std::string s, std::shared_ptr<std::set<line_no>> p,
              std::shared_ptr<std::vector<std::string>> f):
    sought(s), lines(p), file(f){}
    Iter begin() const {return lines->begin();}
    Iter end() const {return lines->end();}
    std::shared_ptr<std::vector<std::string>> get_file() const{
      return file;
    }
private:
  std::string sought;//Query words                                                    
  std::shared_ptr<std::set<line_no>> lines;//Line number that appears                                   
  std::shared_ptr<std::vector<std::string>> file;
};
//Friend declaration of QueryResult class
std::ostream& print(std::ostream&, const QueryResult&);

#endif

TextQuery.h

#ifndef __TEXTQUERY_H__
#define __TEXTQUERY_H__

#include "QueryResult.h"
#include <map>
#include <iostream>
#include <fstream>
#include <sstream>
#include <set>
#include <vector>
#include <string>
#include <memory>

using namespace std;
class TextQuery{
 public:
  using line_no = std::vector<std::string>::size_type;

  TextQuery(ifstream& is);  
  QueryResult query(const std::string &sought) const;
 private:
  std::shared_ptr<std::vector<std::string>> file;
  std::map<std::string, std::shared_ptr<std::set<line_no>>> wm;
};

#endif

TextQuery.cpp

#include "TextQuery.h"

using namespace std;

TextQuery::TextQuery(ifstream& is) : file(new vector<string>){
  string text;
  while(getline(is, text)){//Read every line of the file                                   
    file->push_back(text);
    int n = file->size() - 1;//Current line number                                       
    istringstream line(text);//Break line text into words                             
    string word;
    while(line >> word){
      //It's very important to use references, otherwise a new set will be copied to lines instead of the original one    
      auto &lines = wm[word];//lines is shared? PTR                              
      if(!lines)
    lines.reset(new set<line_no>);
      lines->insert(n);
    }
  }
}

QueryResult TextQuery::query(const string &sought) const{
  //If no fault is found, a smart pointer to this set is returned                           
  static shared_ptr<set<line_no>> nodata(new set<line_no>);
  auto ret = wm.find(sought);
  if(ret == wm.end()){
    return QueryResult(sought, nodata, file);//Can't find                       
  }
  else{
    return QueryResult(sought, ret->second, file);
  }
}

main.cpp

#include "Query.h"

//Friend function of QueryResult                                                         
ostream& print(ostream& os, const QueryResult& qr){
  os << qr.sought << " There are:" << qr.lines->size() << "second" << endl;
  for(auto num : *qr.lines){
    os << "\t(Line number " << num + 1 << ")"
       << *(qr.file->cbegin() + num) << endl;
  }
  return os;
}

int main(){
  ifstream infile("/home/ys/cpp/thread/oop/TextQuery/search_text");
  TextQuery tq(infile);
  //Query q = Query("fiery") & Query("bird") | Query("wind");//OK
  //Query q = Query("fiery") | Query("bird");//OK
  //Query q("Daddy");//OK
  Query q = ~Query("Alice");//OK
  print(std::cout, q.eval(tq)) << std::endl;
}

Compilation method:

g++ -g Query.cpp TextQuery.cpp main.cpp -std=c++11

Text file for query

Alice Emma has long flowing red hair.
Her Daddy says when the wind blows
through her hair, it looks almost alive,
like a fiery bird in flight.
A beautiful fiery bird, he tells her,
magical but untamed.
" Daddy , shush, there is no such thing,"
she tells him, at the same time wanting
him to tell her more.
Shyly, she asks, "I mean, Daddy , is there?"

Query q = query ("fiery") & Query ("bird") | query ("wind"); execution result:

(fiery & bird) | wind) appeared: twice
    (line 2)Her Daddy says when the wind blows
    (line 4)like a fiery bird in flight

QQ group of mutual learning in c/c + +: 877684253

My wechat: xiaoshitou5854

Tags: C++

Posted on Wed, 04 Dec 2019 01:10:19 -0800 by shortcircuit