C++面向对象创建打印算术表达式树

        C++面向对象，实现算术表达式树的创建和打印的案例，来源于《C++沉思录》第八章，涉及数据抽象、继承、多态（动态绑定）、句柄，其中句柄的使用是核心，关于句柄的较为简单的文章链接点击这里，较为复杂的文章链接点击这里

        表达式(-5)*(3+4)对应的树如图，包括常数、一元运算符和二元运算符的结点，结点为图中的圆圈，“边”用箭头表示，一个结点或连接一个子结点、两个子结点或不连接子结点

        结点有三种形式：表示整数表达式，包含一个整数值，无子结点，另外两个分别表示一元表达式和二元表达式包含一个操作符，分别有一个或两个子结点，三种形式对应三个类

        三个类抽象出来一个结点概念，为它们的基类，即结点类，有子结点的类用包装基类指针的句柄表示“边”，使用句柄的作用就是隐藏继承层次，动态绑定，管理内存，避免结点复制

        基类代码

//基类Expr_node
class Expr_node{friend class Expr; //句柄类//因虚函数，重载<<的友元可以不在子类声明friend std::ostream& operator<<(std::ostream&,const Expr&);int use; //计数
protected:Expr_node():use(1) { } //默认构造，计数1virtual void  print(std::ostream&) const =  0;virtual ~Expr_node(){} //虚析构
};

        重载<<操作符函数代码（句柄类对象引用隐藏继承层次）

std::ostream& operator<<(std::ostream& o, const Expr& t)//句柄类对象t.p->print(o);return o;
}

       三个子类代码

//1、包含一个整数，没有子结点的结点类
class Int_node:public Expr_node{friend class Expr; //句柄类int n;Int_node(int k):n(k) { } //构造void print(std::ostream& o) const { o << n; }
};//2、一元运算符结点类
class Unary_node:public Expr_node{friend class Expr; //句柄类std::string op; //操作符Expr t; //句柄对象，表示"边"，指向子结点Unary_node(const std::string& a, Expr t):op(a),t(t) { }void print(std::ostream& o)const{ o << "(" << op << t << ")"; }	
};//3、二元算法符结点类
class Binary_node: public Expr_node{friend class Expr;std::string op;Expr left;Expr right;Binary_node(const std::string&a, Expr b, Expr c):op(a),left(b),right(c) { }void print(std::ostream& o)const{o << "(" << left << op << right << ")";}
};

        句柄类代码（包装基类指针，动态绑定，隐藏继承层次，引用计数避免复制）

class Expr{friend std::ostream& operator<<(std::ostream&,const Expr&);//重载输出操作符<<Expr_node* p; //包装基类指针
public:Expr():p(nullptr){ } //默认构造Expr(int);                            //创建一个Int_nodeExpr(const std::string& op, Expr t);  //创建一个Unary_nodeExpr(const std::string&, Expr, Expr); //创建一个Binary_node//复制管理Expr(const Expr&);              //复制构造Expr& operator=(const Expr&);   //=运算符重载~Expr();                        //析构，释放内存
};
//句柄类构造函数，构造其包装的基类的3个子类对象
Expr::Expr(int n)
{p = new Int_node(n);
}
Expr::Expr(const std::string& op, Expr t)
{p = new Unary_node(op,t);
}
Expr::Expr(const std::string& op, Expr left, Expr right)
{p = new Binary_node(op,left, right);
}
//复制管理
Expr::Expr(const Expr& t){ p = t.p; ++p->use; }; 
Expr& Expr::operator=(const Expr& rhs)
{rhs.p->use++;if(--p->use==0)delete p;p = rhs.p;return *this;
}
Expr::~Expr()
{if(--p->use==0)//计数为0删除delete p; 
} 

        句柄的使用，所有对象只构造一次，句柄的复制只是复制基类指针，对象引用计数，并不复制对象，隐藏了继承层次，管理动态内存 

        主函数测试代码

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

        完整测试代码

#include <iostream>
#include <string>class Expr_node;//前置声明，因为下面的类包装了Expr_node*class Expr{friend std::ostream& operator<<(std::ostream&,const Expr&);//重载输出操作符<<Expr_node* p; //包装基类指针
public:Expr():p(nullptr){ } //默认构造Expr(int);                            //创建一个Int_nodeExpr(const std::string& op, Expr t);  //创建一个Unary_nodeExpr(const std::string&, Expr, Expr); //创建一个Binary_node//复制管理Expr(const Expr&);              //复制构造Expr& operator=(const Expr&);   //=运算符重载~Expr();                        //析构，释放内存
};//基类Expr_node
class Expr_node{friend class Expr; //句柄类//因虚函数，重载<<的友元可以不在子类声明friend std::ostream& operator<<(std::ostream&,const Expr&);int use; //计数
protected:Expr_node():use(1) { } //默认构造，计数1virtual void  print(std::ostream&) const =  0;virtual ~Expr_node(){} //虚析构
};//1、包含一个整数，没有子结点的结点类
class Int_node:public Expr_node{friend class Expr; //句柄类int n;Int_node(int k):n(k) { } //构造void print(std::ostream& o) const { o << n; }
};//2、一元运算符结点类
class Unary_node:public Expr_node{friend class Expr; //句柄类std::string op; //操作符Expr t; //句柄对象，表示"边"，指向子结点Unary_node(const std::string& a, Expr t):op(a),t(t) { }void print(std::ostream& o)const{ o << "(" << op << t << ")"; }	
};//3、二元算法符结点类
class Binary_node: public Expr_node{friend class Expr;std::string op;Expr left;Expr right;Binary_node(const std::string&a, Expr b, Expr c):op(a),left(b),right(c) { }void print(std::ostream& o)const{o << "(" << left << op << right << ")";}
};//句柄类构造函数，构造其包装的基类的3个子类对象
Expr::Expr(int n)
{p = new Int_node(n);
}
Expr::Expr(const std::string& op, Expr t)
{p = new Unary_node(op,t);
}
Expr::Expr(const std::string& op, Expr left, Expr right)
{p = new Binary_node(op,left, right);
}
//复制管理
Expr::Expr(const Expr& t){ p = t.p; ++p->use; }; 
Expr& Expr::operator=(const Expr& rhs)
{rhs.p->use++;if(--p->use==0)delete p;p = rhs.p;return *this;
}
Expr::~Expr()
{if(--p->use==0)delete p; 
} 
//重载运算符<<
std::ostream& operator<<(std::ostream& o,const Expr&t)
{t.p->print(o);return o;
}int main()
{Expr t = Expr("*",Expr("-",5),Expr("+",3,4) );std:: cout << t << std::endl;t = Expr("*",t,t);std:: cout << t <<std:: endl;/* ((-5)*(3+4))(((-5)*(3+4))*((-5)*(3+4))) */return 0;
}