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:
";

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

";


        for (auto iter = result.lines_->cbegin();
             iter != result.lines_->cend(); iter = (result.lines_->upper_bound(*iter)))
        {
            os << "					(line" << *iter + 1 << "): " << *(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() - 1;


        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 =0;

    virtual std::string rep() const =0;

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 = 0; line != file_line; line++)
        {
            //不在set里
            if (set->find(line + 1) == 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 (1);

    }

    file_.close();

    return 0;
}

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