• 面向对象的程序范例(一)


    功能:打印表达式

    技术:句柄、继承

    代码 

     1 #include <iostream>
     2 using namespace std;
     3 
     4 class Expr_node;
     5 
     6 // 句柄类
     7 class Expr
     8 {
     9     friend ostream& operator<< (ostream& o, const Expr& t);
    10     Expr_node* p;
    11 public:
    12     Expr():p(0){}
    13     Expr(int n);
    14     Expr(const string& op, const Expr& t);
    15     Expr(const string& op, const Expr& left, const Expr& right);
    16     Expr(const Expr& t);
    17     Expr& operator=(const Expr&);
    18     ~Expr();
    19 };
    20 
    21 // 用于派生实际类型的公共基类,表示“结点”
    22 class Expr_node
    23 {
    24     friend class Expr;
    25     int use;
    26 protected:
    27     Expr_node():use(1){}
    28     virtual ~Expr_node() {};
    29 public:
    30     virtual void print(ostream&)const=0;
    31 };
    32 
    33 // 存放数值的子类
    34 class Int_node:public Expr_node
    35 {
    36     friend class Expr;
    37     int n;
    38     Int_node(int k):n(k){}
    39 public:
    40     void print(ostream& o)const{o<<n;}
    41 };
    42 
    43 // 存放符号数的类
    44 class Unary_node:public Expr_node
    45 {
    46     friend class Expr;
    47     string op;
    48     Expr opnd;
    49     Unary_node(const string& a, const Expr& b):op(a),opnd(b){}
    50 public:
    51     void print(ostream& o)const{o<<"("<<op<<opnd<<")";}
    52 };
    53 
    54 // 存放符号和左右表达式的子类
    55 class Binary_node:public Expr_node
    56 {
    57     friend class Expr;
    58     string op;
    59     Expr left;
    60     Expr right;
    61     Binary_node(const string& a, const Expr& b, const Expr& c):op(a),left(b),right(c){}
    62 public:
    63     void print(ostream& o)const{o<<"("<<left<<op<<right<<")";}
    64 };
    65 
    66 Expr::Expr(int n){p=new Int_node(n);}
    67 Expr::Expr(const string& op, const Expr& t){p = new Unary_node(op,t);}
    68 Expr::Expr(const string& op, const Expr& left, const Expr& right){p = new Binary_node(op,left,right);}
    69 Expr::Expr(const Expr& t):p(t.p){++(p->use);}
    70 Expr& Expr::operator=(const Expr& rhs)
    71 {
    72     rhs.p->use++;
    73     if (p&&--(p->use)==0)
    74         delete p;
    75     p = rhs.p;
    76     return *this;
    77 }
    78 Expr::~Expr() {if (--p->use==0) delete p;}
    79 
    80 ostream& operator<< (ostream& o, const Expr& t)
    81 {
    82     t.p->print(o);
    83     return o;
    84 }
    85 
    86 int main()
    87 {
    88     Expr t("*", Expr("-", 5), Expr("+", 3, 4));
    89     cout<<t<<endl;
    90     t = Expr("*", t, t);
    91     cout<<t<<endl;
    92     Expr u;
    93     u = Expr("*", t, t);
    94     cout<<u<<endl;
    95     return 0;
    96 }

     或:将 '<<' 运算赋予Expr_node的友元属性,并取消print的public、改为private,来隐藏print

     1 #include <iostream>
     2 using namespace std;
     3 
     4 class Expr_node;
     5 
     6 // 句柄类
     7 class Expr
     8 {
     9     friend ostream& operator<< (ostream& o, const Expr& t);
    10     Expr_node* p;
    11 public:
    12     Expr():p(0){}
    13     Expr(int n);
    14     Expr(const string& op, const Expr& t);
    15     Expr(const string& op, const Expr& left, const Expr& right);
    16     Expr(const Expr& t);
    17     Expr& operator=(const Expr&);
    18     ~Expr();
    19 };
    20 
    21 // 用于派生实际类型的公共基类,表示“结点”
    22 class Expr_node
    23 {
    24     friend class Expr;
    25     friend ostream& operator<< (ostream& o, const Expr& t);
    26     int use;
    27 protected:
    28     Expr_node():use(1){}
    29     virtual ~Expr_node() {};
    30     virtual void print(ostream&)const=0;
    31 };
    32 
    33 // 存放数值的子类
    34 class Int_node:public Expr_node
    35 {
    36     friend class Expr;
    37     int n;
    38     Int_node(int k):n(k){}
    39     void print(ostream& o)const{o<<n;}
    40 };
    41 
    42 // 存放符号数的类
    43 class Unary_node:public Expr_node
    44 {
    45     friend class Expr;
    46     string op;
    47     Expr opnd;
    48     Unary_node(const string& a, const Expr& b):op(a),opnd(b){}
    49     void print(ostream& o)const{o<<"("<<op<<opnd<<")";}
    50 };
    51 
    52 // 存放符号和左右表达式的子类
    53 class Binary_node:public Expr_node
    54 {
    55     friend class Expr;
    56     string op;
    57     Expr left;
    58     Expr right;
    59     Binary_node(const string& a, const Expr& b, const Expr& c):op(a),left(b),right(c){}
    60     void print(ostream& o)const{o<<"("<<left<<op<<right<<")";}
    61 };
    62 
    63 Expr::Expr(int n){p=new Int_node(n);}
    64 Expr::Expr(const string& op, const Expr& t){p = new Unary_node(op,t);}
    65 Expr::Expr(const string& op, const Expr& left, const Expr& right){p = new Binary_node(op,left,right);}
    66 Expr::Expr(const Expr& t):p(t.p){++(p->use);}
    67 Expr& Expr::operator=(const Expr& rhs)
    68 {
    69     rhs.p->use++;
    70     if (p&&--(p->use)==0)
    71         delete p;
    72     p = rhs.p;
    73     return *this;
    74 }
    75 Expr::~Expr() {if (--p->use==0) delete p;}
    76 
    77 ostream& operator<< (ostream& o, const Expr& t)
    78 {
    79     t.p->print(o);
    80     return o;
    81 }
    82 
    83 int main()
    84 {
    85     Expr t("*", Expr("-", 5), Expr("+", 3, 4));
    86     cout<<t<<endl;
    87     t = Expr("*", t, t);
    88     cout<<t<<endl;
    89     Expr u;
    90     u = Expr("*", t, t);
    91     cout<<u<<endl;
    92     return 0;
    93 }

     示意图:

      

     结果:

      ((-5)*(3+4))

      ((((-5)*(3+4)))*(((-5)*(3+4))))

       ((((-5)*(3+4))*((-5)*(3+4)))*(((-5)*(3+4))*((-5)*(3+4))))

  • 相关阅读:
    自己动手将整数转换字符串
    自己动手实现字符串倒叙
    欧拉计划第13题题解
    洛谷P1016 旅行家的预算 题解 贪心+单调队列
    欧拉计划第12题题解
    欧拉计划第11题题解
    欧拉计划第10题题解
    欧拉计划第9题题解
    欧拉计划第8题题解
    欧拉计划第7题题解
  • 原文地址:https://www.cnblogs.com/suui90/p/15227949.html
Copyright © 2020-2023  润新知