先附上前面的basket类的例子，里面很多思想也是我需要学的

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

//买书的类
class quote
{
    friend double print_total(std::ostream &os, quote &q, std::size_t sz);
    public:
        quote() = default;
        quote(const std::string &book, double p):
            bookNo(book), price(p) { }
        quote(const quote &q):
            bookNo(q.bookNo), price(q.price) { }
        quote(quote &&q):             //一个右值拷贝
            bookNo(q.bookNo), price(q.price) { }
        quote& operator=(const quote &q)
        {
            bookNo = q.bookNo;
            price = q.price;
            return *this;
        }
        virtual double net_price(std::size_t sz)const
        {
            return price * sz;
        }
        const std::string& isbn()const
        {
            return bookNo;
        }
        //注意动态内存分配问题，基类和派生类的内存大小不同
        //所以我们写了个分配函数，且必须定义为虚函数。为了实现后面的动态分配
        //后面跟着成员限定符说明是用作左值还是右值
        virtual quote* clone()const&
        { return new quote(*this); }
        virtual quote* clone() &&
        { return new quote(std::move(*this)); }

    protected:
        double price;

    private:
        std::string bookNo;
};

double print_total(std::ostream &os, quote &q, std::size_t sz)
{
    double ret = q.net_price(sz);
    os << q.isbn() << " " << q.price << " " << ret << "\n";
    return ret;
}

//抽象基类，因为打折有许多不同的措施，但都基于discount和disc_num
//简单来说抽象出来一个标准，discount和disc_num 就可以说是一个标准。
class disc_quote : public quote
{
    public:
        disc_quote() = default;
        disc_quote(const std::string &book, double p, double disc, std::size_t num):
            quote(book, p), discount(disc), disc_num(num) { }
        double net_price(std::size_t sz)const = 0;   //纯虚函数

    protected:
        double discount;
        std::size_t disc_num;

    private:
};


//第一种打折方式
class one_bulk_quote : public disc_quote
{
    public:
        using disc_quote::disc_quote;
        double net_price(std::size_t sz)const override
        {
            if(sz > disc_num)
            {
                return sz * price * discount;
            }
            else
            {
                return sz * price;
            }
        }
        //对第一种打折类实现动态分配
        one_bulk_quote* clone()const &
        {
            return new one_bulk_quote(*this);
        }
        one_bulk_quote* clone() && 
        {
            return new one_bulk_quote(std::move(*this));
        }

    protected:

    private:
};

class two_bulk_quote : public disc_quote
{
    public:
        using disc_quote::disc_quote;
        double net_price(std::size_t sz)
        {
            if(sz > disc_num)
            {
                return (sz-disc_num) * price * discount + disc_num * price;
            }
            else
            {
                return sz * price;
            }
        }

    protected:

    private:
};

class basket
{
    public:
        //void add_item(const std::shared_ptr<quote>&sale)
        //{
        //    items.insert(sale);
        //}
        //如果像上面那样写分配内存不会是动态决定的，参数传递是quote，那么无论传参是什么分配都是quote,如果是派生类就会被砍掉一部分。
        
        void add_item(const quote &sale)
        {
            items.insert(std::shared_ptr<quote>(sale.clone()));
        }
        void add_item(quote && sale)
        {
            items.insert(std::shared_ptr<quote>(std::move(sale).clone()));
        }
        double total_receipt(std::ostream &os)const;

    protected:

    private:
        //自定义比较函数
        static bool compare(const std::shared_ptr<quote> &lhs, const std::shared_ptr<quote> &rhs)
        {
            return lhs->isbn() < rhs->isbn();
        }
        std::multiset<std::shared_ptr<quote>, decltype(compare)*> items{compare};//decltype不能推断出指针和引用
};

double basket::total_receipt(std::ostream &os)const
{
    double sum = 0.0;
    //注意下upper_bound的作用
    for(auto iter = items.cbegin(); iter != items.cend(); iter = items.upper_bound(*iter))
    {
        sum += print_total(std::cout, **iter, items.count(*iter));
    }
    os << "total Sale: " << sum << std::endl;
    return sum;
}

int main()
{

}

文本程序

#ifndef _TEXTQUERY_H_
#define _TEXTQUERY_H_

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

class QueryResult;
class TextQuery;

using line_no = std::vector<std::string>::size_type;

class QueryResult
{
    friend class TextQuery;
    friend std::ostream& operator<<(std::ostream &os, const QueryResult &q);
    public:
        QueryResult() = default;
        QueryResult(std::string s, std::shared_ptr<std::set<line_no>>li, std::shared_ptr<std::vector<std::string>>wf):
            q_word(s), lines(li), wordfile(wf) { }
        std::set<line_no>::iterator begin();
        std::set<line_no>::iterator end();
        std::shared_ptr<std::vector<std::string>> get_file();

    private:
        std::string q_word;                                 //要查询单词
        std::shared_ptr<std::set<line_no>>lines;            //出现行号
        std::shared_ptr<std::vector<std::string>>wordfile;  //单词文件
};

class TextQuery
{
    friend class QueryResult;
    public:
        TextQuery() = default;
        TextQuery(std::ifstream &is);
        QueryResult query(const std::string &s)const;

    private:
        std::shared_ptr<std::vector<std::string>>m_file;
        std::map<std::string, std::shared_ptr<std::set<line_no>>>m_word_line;     //考虑共享数据的需求
    
};

  
//Query_base 抽象基类，制定一个标准
class Query_base
{
    friend class Query;
    protected:
        virtual ~Query_base() = default;

    private:
        //
        virtual QueryResult eval(const TextQuery &)const = 0;
        virtual std::string rep()const = 0;
};

//接口类,基类包括派生类都可以通过Query来使用，隐藏实现
class Query
{
    friend Query operator~(const Query &);
    friend Query operator&(const Query &, const Query &);
    friend Query operator|(const Query &, const Query &);
    friend std::ostream& operator<<(std::ostream &os, const Query &query);
    public:
        Query(const std::string&);//wait WordQuery
        //Query是Query_base的唯一接口，所以必须定义纯虚函数
        //且Query就可以通过指针来调用派生类各自Query_base虚函数
        QueryResult eval(const TextQuery &t)const
        { return q->eval(t); }
        std::string rep()const
        { return q->rep(); }
    private:
        //构造函数定义为private,不希望一般用户随便定义Query_base对象。
        Query(std::shared_ptr<Query_base> query):q(query) { }
        //通过智能指针实现动态绑定
        std::shared_ptr<Query_base> q;
};

//派生类
class WordQuery: public Query_base
{
    friend class Query;
    WordQuery(const std::string &s):query_word(s) { }
    //具体的类
    QueryResult eval(const TextQuery &t)const
    { return t.query(query_word); }
    std::string rep()const { return query_word; }
    std::string query_word;        //要查找的单词
};

//无论哪种查询都是建立在WordQuery的根本上，So Query的构造函数用一个WordQuery来初始化
inline Query::Query(const std::string &s):
    q(new WordQuery(s)) { }

class NotQuery: public Query_base
{
    friend Query operator~(const Query &);
    NotQuery(const Query &q):query(q) { }
    //具体的类，覆盖掉纯虚函数
    std::string rep()const { return "~(" + query.rep() + ")"; }
    QueryResult eval(const TextQuery &)const;
    Query query;
};

inline Query operator~(const Query &operand)
{
    //注意返回值
    return std::shared_ptr<Query_base>(new NotQuery(operand));
}

//两个运算符的抽象基类
class BinaryQuery: public Query_base
{
    protected:
    BinaryQuery(const Query &l, const Query &r, std::string s):
        lhs(l), rhs(r), opSym(s) { }
    std::string rep()const 
    { return "(" + lhs.rep() + " " + opSym + " " + rhs.rep() + ")"; }
    //eval函数没有定义，继承了纯虚函数，还是抽象基类

    Query lhs, rhs;
    std::string opSym;
};

class AndQuery: public BinaryQuery
{
    friend Query operator&(const Query&, const Query&);
    AndQuery(const Query &left, const Query &right):
        BinaryQuery(left, right, "&") { }
    //具体的类，覆盖了eval并且继承了rep
    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 &left, const Query &right):
        BinaryQuery(left, right, "|") { }
    //具体的类，覆盖了eval并且继承了rep
    QueryResult eval(const TextQuery&)const;
};

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

#include "textquery.h"

std::ostream& operator<<(std::ostream &os, const QueryResult &q)
{
    os << "element occurs:" << q.lines->size() << " times\n";
    for(line_no i : *q.lines)
    {
        os << "   " << "line(" << i+1 << ") ";
        os << *(q.wordfile->begin()+i) << "\n";
        //os << (*(q.wordfile))[i] << "\n";   //注意运算符优先级
    }
    return os;
}

TextQuery::TextQuery(std::ifstream &is):m_file(new std::vector<std::string>)
{
    std::string word;
    std::string line;
    static int i = 0;
    while(std::getline(is, line))
    {
            //行号
        m_file->push_back(line);
        i = m_file->size()-1;
        std::istringstream ist(line);
        while(ist >> word)
        {
            auto &li = m_word_line[word];  //返回set的shared_ptr
            if(!li)
                li.reset(new std::set<line_no>);
            li->insert(i);
        }
    }
}

QueryResult TextQuery::query(const std::string &s)const
{
    static std::shared_ptr<std::set<line_no>> nodata(new std::set<line_no>);
    auto ret = m_word_line.find(s);
    if(ret == m_word_line.end())
        return QueryResult(s, nodata, m_file);
    else
        return QueryResult(s, ret->second, m_file);
}

std::ostream& operator<<(std::ostream &os, const Query &query)
{
    //query.rep()内部还是通过指针来调用的，是需调用
    return os << query.rep();
}

//QueryResult
std::set<line_no>::iterator QueryResult::begin()
{
    return lines->begin();
}

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

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


//eval

QueryResult
OrQuery::eval(const TextQuery &text)const
{
    auto right = rhs.eval(text), left = lhs.eval(text);
    auto ret_lines = std::make_shared<std::set<line_no>>(left.begin(), left.end());
    ret_lines->insert(right.begin(), right.end());

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

QueryResult
AndQuery::eval(const TextQuery &text)const
{
    auto left = lhs.eval(text), right = rhs.eval(text);
    auto ret_lines = std::make_shared<std::set<line_no>>();
    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
NotQuery::eval(const TextQuery &text)const
{
    auto result = query.eval(text);
    auto ret_lines = std::make_shared<std::set<line_no>>();
    auto beg = result.begin(), end = result.end();
    auto sz = result.get_file()->size();
    //相当于两个集合两个指针一起走。
    for(std::size_t n = 0; n != sz; ++n)
    {
        if(beg == end || *beg != n)
            ret_lines->insert(n);
        else if(beg != end)
            ++beg;
    }

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

#include "textquery.h"

int main(int argc, char *argv[])
{
    std::ifstream is(argv[1]);
    TextQuery t1(is);
    std::string word;
    Query q = Query("fiery") & Query("bird") | Query("wind");
    //Query q = Query("fiery");
    //Query q = Query("A");
    std::cout << q << std::endl;
    std::cout << q.eval(t1) << std::endl;
}

运行结果：

这个例子自己也看了挺久，感觉还是有点复杂，可能是自己写的这种面向对象的不多吧，还要多加联系。

这个例子中的很多思想非常好，值得我们去学习。

总结：

1.好好体会抽象基类纯虚函数这个概念，在c++面向对象编程是非常重要的。