运算表达式的抽象

#pragma once
#include<ostream>
#include<string>
class Expr;
class Expr_node
{
    
	friend class Expr;
	friend std::ostream& operator <<(std::ostream& os, const Expr& e);
	int useCount;

protected:
	Expr_node() :useCount(1) {
    }
	virtual void Print(std::ostream& os) const = 0;
	virtual int eval() const = 0;
	virtual ~Expr_node() {
    }
};
class Expr
{
    
	friend std::ostream& operator <<(std::ostream& os, const Expr& e);
	Expr_node* pNode;
public:
	Expr(int num);
	Expr(const std::string& op, const Expr& t);
	Expr(const std::string& op, const Expr& left, const Expr& right);
	Expr(const std::string& op, const Expr& left, const Expr& middle, const Expr& right);
	Expr(const Expr& other) :pNode(other.pNode)
	{
    
		++pNode->useCount;
	}
	Expr& operator=(const Expr& rhs)
	{
    
		++rhs.pNode->useCount;
		if (--pNode->useCount == 0)
			delete pNode;
		pNode = rhs.pNode;
		return *this;
	}
	int eval() const
	{
    
		return pNode->eval();
	}
	~Expr()
	{
    
		if (--pNode->useCount == 0)
			delete pNode;
	}
};
class inc_node :public Expr_node
{
    
	friend Expr;
	int num;
	inc_node(int n) :num(n) {
    }
	virtual void Print(std::ostream& os)const
	{
    
		os << num;
	}

	virtual int eval() const
	{
    
		return num;
	}
};

class Unary_node :public Expr_node
{
    
	friend Expr;
	std::string op;
	Expr opnd;
	Unary_node(const std::string& str, const Expr& t) :op(str), opnd(t) {
    }
	virtual void Print(std::ostream& os)const
	{
    
		os << "("  << op << opnd << ")";
	}
	virtual int eval() const
	{
    
		if (op == "-")
			return -opnd.eval();
			throw("unknown");
			return 0;
	}
};
class Binary_node :public Expr_node
{
    
	friend Expr;
	std::string op;
	Expr left;
	Expr right;
	Binary_node(const std::string& str, const Expr& a,const Expr& b) :op(str), left(a),right(b) {
    	}
	virtual void Print(std::ostream& os)const
	{
    
		os << "(" << left << op << right << ")";
	}
	virtual int eval() const
	{
    
		int lres = left.eval();
		int rres = right.eval();
		if (op == "+")
			return lres + rres;
		if (op == "-")
			return lres - rres;
		if (op == "*")
			return lres * rres;
		if (op == "/"&& rres!=0 )
			return lres / rres;
		throw "unknown";
			return 0;
	}
};

class Ternary_node :public Expr_node
{
    
	friend Expr;
	std::string op;//这个成员也没什么用可以去掉，暂时先这样
	Expr left;
	Expr middle;
	Expr right;
	Ternary_node(const std::string& str, const Expr& a, const Expr& b,const Expr& c) :op(str), left(a),middle(b), right(c) {
    	}
	virtual void Print(std::ostream& os)const
	{
    
		os << "(" << left<<"?" << middle<<":" << right << ")";
	}
	virtual int eval() const
	{
    
		return left.eval() ? middle.eval() : right.eval();
	}
};

inline Expr::Expr(int num) {
    
	pNode = new inc_node(num);
}
inline Expr::Expr(const std::string& op,	const Expr& t)
{
    
	pNode = new Unary_node(op, t);
}
inline Expr::Expr(const std::string& op, const Expr& left, const Expr& right)
{
    
	pNode = new Binary_node(op, left, right);
}
inline Expr::Expr(const std::string& op, const Expr& left, const Expr& middle, const Expr& right)
{
    
	pNode = new Ternary_node(op, left,middle, right);
}

//main.cpp
#include"expr.h"
#include<iostream>
using namespace std;
std::ostream& operator <<(std::ostream& os, const Expr& e)
{
    
	e.pNode->Print(os);//class Expr;前置声明可以避免这里提示错误
	return os;
}
int main()
{
    
	Expr test("*", Expr("-", 7), Expr("+", 4, 5));
	cout << test<<endl;
	test = Expr("*", test, test);
	cout << test<<endl;
	cout << test.eval() << endl;
	Expr three("san", 0, 4, 5);
	cout << three << endl;
	cout << three.eval()<<endl;
	return 0;
}