程序设计，C++ 与面向对象

class Expr_node {
    friend std::ostream& operator<< (std::ostream&, const Expr_node&);
protected:
    virtual std::ostream& print(std::ostream&) const = 0;
    virtual ~Expr_node(){}
};

class Expr_node {
    friend std::ostream& operator<< (std::ostream& o, const Expr_node& e){
        return e.print(o);
    }
protected:
    virtual std::ostream& print(std::ostream&) const = 0;
    virtual ~Expr_node() = 0;
};

Expr_node::~Expr_node(){}

class Int_node : public Expr_node {
    int n;
    std::ostream& print(std::ostream& o) const {
        return o << n;
    }
public:
    Int_node(int k) : n(k) {}
};

class Unary_node : public Expr_node {
    std::string op;
    const Expr_node* opnd;
    std::ostream& print(std::ostream& o) const {
        return o << "(" << op << *opnd << ")";
    }
public:
    Unary_node(const std::string a, const Expr_node* b) : op(a), opnd(b) {}
};

class Binary_node : public Expr_node {
    std::string op;
    const Expr_node* left;
    const Expr_node* right;
    std::ostream& print(std::ostream& o) const {
        return o << "(" << *left << op << *right << ")";
    }
public:
    Binary_node(const std::string& a, const Expr_node* b, const Expr_node* c) : op(a), left(b), right(c) {}
};

Binary_node *e = new Binary_node("*", new Unary_node("-", new Int_node(5)), new Binary_node("+", new Int_node(3), new Int_node(4)));

std::cout << *e << std::endl; // 打印((-5)*(3+4))

class Expr {
    friend std::ostream& operator<<(std::ostream&, const Expr&);
    Expr_node *node;
public:
    Expr(int n) {
        node = new Int_node(n);
    }
    Expr(const std::string& op, Expr t){
        node = new Unary_node(op, t);
    }
    Expr(const std::string& op, Expr left, Expr right){
        node = new Binary_node(op, left, right);
    }
    Expr(const Expr& t);
    ~Expr();
    Expr& operator=(const expr& rhs);
};

#include <iostream>
#include <string>


class Expr_node;

class Expr {
    friend std::ostream& operator<<(std::ostream& o, const Expr& e);
    Expr_node* node;
public:
    Expr(int data);
    Expr(const std::string& op, Expr e);
    Expr(const std::string& op, Expr a, Expr b);
    Expr(const Expr& e);
    Expr& operator=(const Expr& rhs);
    std::ostream& print(std::ostream&) const;
    ~Expr();
};

class Expr_node {
    friend class Expr;
    friend std::ostream& operator<<(std::ostream& o, const Expr_node& e);
    friend std::ostream& operator<<(std::ostream& o, const Expr& e);
protected:
    Expr_node() : count(0) {}
    virtual ~Expr_node() = default;
private:
    unsigned int count;
    virtual std::ostream& print(std::ostream&) const = 0;
};

class Int_node final: public Expr_node {
    friend class Expr;
    int num;
    Int_node(int k) :Expr_node(), num(k) {}
    std::ostream& print(std::ostream& o) const override { return o << num; }
};

class Unary_node final: public Expr_node {
    friend class Expr;
    std::string op;
    Expr opend;
    Unary_node(const std::string& a, Expr b)
        :Expr_node(), op(a), opend(b) {}
    std::ostream& print(std::ostream& o) const override {
        return o << "(" << op << opend << ")";
    }
};

class Binary_node final: public Expr_node {
    friend class Expr;
    std::string op;
    Expr left;
    Expr right;
    Binary_node(const std::string a, Expr b, Expr c)
        :Expr_node(), op(a), left(b), right(c) {}
    std::ostream& print(std::ostream& o) const override {
        return o << "(" << left << op << right << ")";
    }
};

Expr::Expr(int data) {
    node = new Int_node(data);
}

Expr::Expr(const std::string& op, Expr e) {
    node = new Unary_node(op, e);
}

Expr::Expr(const std::string& op, Expr a, Expr b) {
    node = new Binary_node(op, a, b);
}

Expr::Expr(const Expr& e) {
    node = e.node; // 由于表达式是使用指针形成的树状结构，若不提供完整的结构化复制，则必须采用引用计数
    ++node->count; // 由于该函数是利用已有表达式构造新的表达式，且已有表达式内含节点指针，则该指针被两个表达式共享
}

Expr::~Expr() {
    if (node->count == 0)
    {
        delete node;
    }
}

Expr& Expr::operator=(const Expr& rhs) {
    rhs.node->count++; // 此处也是使用已有表达式构造新表达式
    if (node->count == 0) // 此处判断子节点是否有意义，若无意义则回收内存
    {
        delete node;
    }
    node = rhs.node;
    return *this;
}

std::ostream& Expr::print(std::ostream& o) const {
    return node->print(o); // 转发器
}

std::ostream& operator<<(std::ostream& o, const Expr& e) {
    return e.node->print(o); // 必须同时为 Expr 和 Expr_node 的友元才能通过通过 node 访问 print
    // return e.print(o); // 或者使用转发器
}

int main() {
    Expr t = Expr("*", Expr("-", Expr(5)), Expr("+", Expr(3), Expr(4)));
    std::cout << t << std::endl;
    t = Expr("*", t, t);
    std::cout << t << std::endl;
    return 0;
}

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

namespace {
    using vsize_t = std::vector<std::string>::size_type;
    using std::map;
    using std::string;
    using std::vector;
    using std::set;
    using std::shared_ptr;
    using std::make_shared;
    using std::ostream;
    using std::cout;
    using std::endl;
    using std::istream;
    using std::istringstream;
}

class TextQuery;
class Query;
class WordQuery;

class QueryResult {
    friend ostream& operator<<(ostream&, const QueryResult&);
public:
    QueryResult(const string& s, shared_ptr<set<vsize_t>> set,
        shared_ptr<vector<string>> v)
        : expect(s), lines(set), text(v) {}
    auto begin() { return lines->begin(); }
    auto end() { return lines->end(); }
    auto get_text() { return text; } // 保存文本的每行
private:
    string expect;
    shared_ptr<set<vsize_t>> lines; // 用 set 保存行号，自动排序
    shared_ptr<vector<string>> text; // 保存文本的每行
};

class TextQuery {
public:
    TextQuery(istream&);
    QueryResult query(const string&) const;

private:
    shared_ptr<vector<string>> text; // 保存输入的 vector 的智能指针
    map<string, shared_ptr<set<vsize_t>>> result; // 单词及其对应的行号
};

class Query;
class Query_base {
    friend class Query;
protected:
    virtual ~Query_base() = default;
private:
    virtual QueryResult eval(const TextQuery&) const = 0; // 返回查询结果
    virtual string rep() const = 0; // 生成要查询的内容
};

class WordQuery : public Query_base {
    friend class Query;
    WordQuery(const string& s) :expect(s) {}
    QueryResult eval(const TextQuery& t) const {
        return t.query(expect);
    }
    string rep() const { return expect; }
    string expect;
};

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& s) : q(new WordQuery(s)) {}
    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) {} // And,Or,Not
    shared_ptr<Query_base> q;
};

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

class BinaryQuery : public Query_base
{
protected:
    BinaryQuery(const Query& left, const Query& right, string s) :
        lhs(left), rhs(right), 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;
};

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;
};

ostream& operator<<(ostream& os, const Query& query) {
    return os << query.rep(); // 输出要查询的字符串
}

TextQuery::TextQuery(istream& is) : text(new vector<string>) { // 以行存放字符串的 vector
    string line; // 一行
    while (getline(is, line)) // <fstream>
    {
        text->push_back(line); // 当前行全部存入 vector
        vsize_t n = text->size() - 1; // 当前行号
        istringstream lines(line); // 分解行文本为单词
        string word;
        while (lines >> word)
        {
            auto& lines = result[word];// 根据当前 word 返回存放行号的 shared_ptr<set<vsize_t>>
            if (!lines) // 如果之前没有出现过该关键字则为空
            {
                lines.reset(new set<vsize_t>); // 分配一个新的 set
            }
            lines->insert(n); // 将当前行号 n 插入到 set
        }
    }
}

QueryResult TextQuery::query(const string& expect) const {
    static shared_ptr<set<vsize_t>> nodata(new set<vsize_t>);
    auto loc = result.find(expect); // 查找关键字，返回迭代器

    if (loc == result.end())
        return QueryResult(expect, nodata, text);
    else
        return QueryResult(expect, loc->second, text); // loc->second 根据当前 word 返回存放行号的 shared_ptr<set<vsize_t>>
}

Query operator~(const Query& operand) {
    return shared_ptr<Query_base>(new NotQuery(operand)); // 返回一个新建的 Query_base 指针，指向 NotQuery，调用 Query 构造函数
}
QueryResult NotQuery::eval(const TextQuery& text) const {
    auto result = query.eval(text); // 查询结果，得到行号
    auto lines = make_shared<set<vsize_t>>(); // 行号集合
    auto beg = result.begin(), end = result.end();
    auto sz = result.get_text()->size(); // 总行数       
    for (vsize_t n = 0; n != sz; ++n)
    {
        if (beg == end || *beg != n)
            lines->insert(n); // 如果不在查询结果中，则放入结果
        else if (beg != end)
            ++beg;
    }
    return QueryResult(rep(), lines, result.get_text());
}

Query operator&(const Query& lhs, const Query& rhs) {
    return shared_ptr<Query_base>(new AndQuery(lhs, rhs));
}
QueryResult AndQuery::eval(const TextQuery& text) const {
    auto right = rhs.eval(text), left = lhs.eval(text);
    auto lines = make_shared<set<vsize_t>>();
    set_intersection(left.begin(), left.end(), right.begin(), right.end(),
        inserter(*lines, lines->begin())); // 交集放入 lines
    return QueryResult(rep(), lines, left.get_text());
}

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 lines = make_shared<set<vsize_t>>(left.begin(), left.end()); // 复制左侧运算结果
    lines->insert(right.begin(), right.end()); // 加上右侧运算结果，并集
    return QueryResult(rep(), lines, left.get_text());
}

ostream& operator<<(ostream& o, const QueryResult& qr) {
    o << qr.expect << " occors " << qr.lines->size() << " times " << endl; // 关键字和出现次数
    for (auto num : *qr.lines)
    {
        o << " \t(line " << num + 1 << ")" << *(qr.text->begin() + num) << endl; // 关键字所在行
    }
    return o;
}

int main() {
    istringstream str;
    str.str("Alice Emma has long flowing red hair.\nHer Daddy says when the wind blows\nthrough her hair, it looks almost alive,\nlike a fiery bird in flight.\nA beautiful fiery bird, he tells her,\nmagical but untamed.\n“Daddy, shush, there is no such thing,”\nshe tells him, at the same time wanting\nhim to tell her more.\nShyly, she asks, “I mean, Daddy, is there?”");
    TextQuery file = str;
    Query q = Query("fiery") & Query("bird") | Query("wind");
    cout << "Executing Query for: " << q << endl;
    auto result = q.eval(file);
    cout << result << endl;
    return 0;
}