Chapter15：程序实例

购物篮程序：模拟虚拷贝

class Basket
{
public:
    //使用合成的默认构造函数和拷贝控制
    void add_item(const shared_ptr<Quote> &sale)
    {
        items.insert(sale);
    }
    double total_recipt(ostream& os) const
    {
        double sum = 0.0;
        for (auto iter = items.cbegin(); iter != items.cend(); iter = items.upper_bound(*iter))
        {
            sum += print_total(os, **iter, items.count(*iter));
        }
    }
private:
    static bool compare(shared_ptr<Quote> &lhs, shared_ptr<Quote> &rhs)
    {
        return lhs->isbn() < rhs.isbn();
    }
    multiset<shared_ptr<Quote>, decltype(compare)*> items{ compare };

};

//使用方法
Basket bsk;
bsk.add_item(make_shared<Quote>("123", 45));
bsk.add_item(make_shared<Bulk_quote>("345", 45,3,15));

//我们想这么使用,即：add_item负责内存的分配与管理
bsk.add_item(Quote("123", 45));
bsk.add_item(Bulk_quote("345", 45, 3, 15));

//问题是，我们无法通过参数的类型Quote，来得知应该分配什么样的内存，Quote or Bulk_quote？
//解决方法：模拟虚拷贝
class Quote
{
public:
    virtual Quote* clone() const & { return new Quote(*this); }
    virtual Quote* clone() && {return new Quote(std::move(*this)); }
};
class Bulk_quote:public Quote
{
public:
    virtual Bulk_quote* clone() const & { return new Bulk_quote(*this); }
    virtual Bulk_quote* clone() && {return new Bulk_quote(std::move(*this)); }
};

void add_item(const Quote &sale)
{
    items.insert(shared_ptr<Quote>(sale.clone()));
}
void add_item(Quote &&sale)
{
    items.insert(shared_ptr<Quote>(std::move(sale).clone()));
}

 

文本查询程序（2）：允许单词的逻辑组合查询如：fiery&bird|wind

分析：

我们只需要对于TextQuery，定义operator~()，operator|(TextQuery1,TextQuery2)，operator&(TextQuery1,TextQuery2)即可完成任务。

我们这样使用：TextQuery（fiery）&TextQuery（brid）|TextQuery（wind），会出现三个TextQuery对象。

逻辑上来讲，文本文档对象TextQuery只需要一个。其实，真正需要多个操作的是查询这一操作。我们现在有必要将查询这一操作分离出来。

 

之前的查询是一个函数[参见 Chapter12&Chapter13程序实例]：

47 //如果没有找到string，应该返回什么？
48 //我们定义一个局部static对象，它指向一个空行号set的shared_ptr，未找到单词，则返回此对象的一个拷贝
49 QueryResult TextQuery::query(const string &sought) const
50 {
51     static shared_ptr<set<line_no>> nodata(new set<line_no>);
52     //不使用下标运算符来查找，避免将单词添加到wm中
53     auto loc = wm.find(sought);
54     if (loc == wm.end())
55         return { sought, nodata, file };
56     else
57         return { sought, loc->second, file };
58 }

现在我们把它分离出来，重新写作一个类Query，然后定义operator~，operator|，operator&即可。

但是书中为了演示继承，所以把操作设计成继承体系。

每个查询类只包含两个操作：

eval，接受一个TextQuery对象，返回一个QueryResult；

rep，返回基础查询的string表示形式。

具体的类设计细节参见书本。

然后使用Query类隐藏继承体系。

所以Query_base的所有函数都是私有的。（私有虚函数竟然可以被派生基类访问？Query不是NotQuery的友元，亦可以调用私有虚函数？？）

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 string rep() const = 0;
};

class Query
{
    friend Query operator~(const Query&);
    friend Query operator|(const Query&, const Query&);
    friend Query operator&(const Query&, const Query&);
public:
    Query(const string&);//要生成WordQuery，WordQuery定义之后再定义；
    QueryResult eval(const TextQuery &t) const { return q->eval(t); }
    string rep() const { return q->rep(); }
private:
    Query(shared_ptr<Query_base> query) :q(query) {}
    shared_ptr<Query_base> q;
};

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


//Query_base的继承体系
class WordQuery :public Query_base
{
    friend class Query;
    WordQuery(const string& s) :query_word(s) {}
    QueryResult eval(const TextQuery &t) const { return t.query(query_word); }
    string rep() const { return query_word; }
    string query_word;
};
//注意，Query只是Query_base和WordQuery的友元
inline Query::Query(const string &s)
    :q(new WordQuery(s)) {}


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

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

class BinaryQuery :public Query_base
{
    //抽象基类，Query不访问，故不用friend
protected:
    BinaryQuery(const Query &l, const Query &r, string s)
        :lhs(l), rhs(r), opSym(s) {}
    string rep() const { return "(" + lhs.rep() + " " + opSym + " " + rhs.rep() + ")"; }
    Query lhs, rhs;
    string opSym;
};

class AndQuery :public BinaryQuery
{
    friend Query operator&(const Query&, const Query&);
    AndQuery(const Query &left, const Query &right)
        :BinaryQuery(left, right, "&") {}
    QueryResult eval(const TextQuery&) const;
};

inline Query operator&(const Query &lhs, const Query &rhs)
{
    return 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, "|") {}
    QueryResult eval(const TextQuery&) const;
};

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

QueryResult OrQuery::eval(const TextQuery &text) const
{
    auto right = rhs.eval(text), left = lhs.eval(text);

    auto ret_lines = make_shared<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 right = rhs.eval(text), left = lhs.eval(text);

    auto ret_lines = make_shared<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 = make_shared<set<line_no>>();
    auto beg = result.begin(), end = result, end();
    auto sz = result.get_file()->size();
    for (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());
}