关闭

用职责链模式来实现计算器

464人阅读 评论(0) 收藏 举报

界面 

四则运算式解释,并计算

语法分析

 

using System;
using System.Collections;

namespace myChain
{
    
/// <summary>
    
/// 自定义的CxyStack。
    
/// </summary>

    public class cxyStack
    
{
        
private Stack mystack;
        
public cxyStack()
        

            mystack
=new Stack();
        }


        
public void Push(object o)
        
{
            mystack.Push(o);
        }


        
public object Pop()
        
{
            
return mystack.Pop();
        }


        
public bool IsEmpty()
        
{
            
return mystack.Count==0;
        }


        
public int Count
        
{
            
get{return mystack.Count;}
        }


        
public object TopItem()
        
{
            
return mystack.Peek();
        }

    }



    
/// <summary>
    
/// 处理四则表达式中Token的基础类
    
/// </summary>

    public abstract class TreateToken
    
{
        
//用来处理Token的临时堆栈
        protected cxyStack st;
        
//用来保存结果的堆栈
        protected cxyStack stOutput;
        
//Next构成职责链
        protected TreateToken next;

        
public TreateToken Next
        
{
            
get{return next;}
            
set{next=value;}
        }


        
public TreateToken(cxyStack tst,cxyStack tstOut)
        
{
            
this.st=tst;
            
this.stOutput=tstOut;
        }


        
public abstract void Treat(string s);

    }


    
/// <summary>
    
/// 处理数字
    
/// </summary>

    public class NumberToToken:TreateToken
    
{
        
public NumberToToken(cxyStack tst,cxyStack tstOut):base(tst,tstOut)
        
{

        }


        
public override void Treat(string s)
        
{
            
if(Char.IsNumber(s,0))
            
{
                stOutput.Push(s);
            }

            
else
            
{
                next.Treat(s);
            }

        }
 
    }


    
/// <summary>
    
/// 处理字符串+-*/()
    
/// </summary>

    public class OperatorToken:TreateToken
    
{
        
private myOperator ope;

        
public OperatorToken(cxyStack tst,cxyStack tstOut,myOperator op):base(tst,tstOut)
        
{
            
this.ope=op;
        }


        
public override void Treat(string s)
        
{
            
if(s==ope.Op)
            
{
                
if(st.IsEmpty()||s=="(")
                
{
                    st.Push(ope);
                }

                
else
                
{
                    myOperator o
=(myOperator) st.TopItem();
                    
while(o.Level>=ope.Level||ope.Op==")")
                    
{
                        myOperator ol
=(myOperator)st.Pop();
                        
if(ol.Op=="("break;

                        
this.stOutput.Push(ol);
                        
if(st.IsEmpty()) break;
                        o
=(myOperator)st.TopItem();
                    }

                    
if(ope.Op!=")")
                        st.Push(ope);
                }

            }

            
else
                next.Treat(s);
        }


    }


    
/// <summary>
    
/// 操作符与优先级
    
/// </summary>

    public class myOperator
    
{
        
private string ope;
        
private int level;

        
public myOperator(string o,int l)
        
{
            ope
=o;level=l;
        }


        
public string Op
        
{
            
get{return ope;}
            
set{ope=value;}
        }


        
public int Level
        
{
            
get{return level;}             
        }


        
public override string ToString()
        
{
            
return ope;
        }


    }


    
/// <summary>
    
/// 处理除字符串和操作符之外的字符
    
/// </summary>

    public class OtherToken:TreateToken
    
{
        
public OtherToken():base(null,null)
        
{
        }


        
public override void Treat(string s)
        
{
            
if(s!="")
                
throw new ArgumentException("无法识别的操作符"+s);
        }
 
    }







}

 

计算机

 

using System;
using System.Collections;

namespace myChain

    
public abstract class CompToken:TreateToken
    
{
        
protected string token=" ";
        
public CompToken(cxyStack sstemp,cxyStack soutput):base(sstemp,soutput)
        
{

        }

        
public override void Treat(string s)
        
{
            
if(s==token) {
                
double b=Convert.ToDouble(stOutput.Pop().ToString());
                
double a=Convert.ToDouble(stOutput.Pop().ToString());
                
double c=Comp(a,b);
                
this.stOutput.Push(c.ToString());
            }

            
else {
                
this.next.Treat(s);
            }

        }

 

        
public abstract double Comp(double a,double b);

    }



    
public class AddToken:CompToken 
    
{

        
public AddToken(cxyStack sstemp,cxyStack stout):base(sstemp,stout) 
        
{
            token
="+";

        }


        
public override double Comp(double a, double b)
        
{
            
return a+b;
        }
 

    }


    
public class MinusToken:CompToken
    
{
        
public MinusToken(cxyStack sstemp,cxyStack stout):base(sstemp,stout)
        
{
            token
="-";
        }


        
public override double Comp(double a, double b)
        
{
            
return a-b;
        }


    }


    
public class ByToken:CompToken
    
{
        
public ByToken(cxyStack sstemp,cxyStack stout):base(sstemp,stout)
        
{
            token
="*";
        }


        
public override double Comp(double a, double b)
        
{
            
return a*b;
        }


    }


    
public class DivideToken:CompToken
    
{
        
public DivideToken(cxyStack sstemp,cxyStack stout):base(sstemp,stout)
        
{
            token
="/"
        }


        
public override double Comp(double a, double b)
        
{
            
return a/b;
        }


    }


    
public class ChangFange:CompToken
    
{
        
public ChangFange(cxyStack sstemp,cxyStack stout):base(sstemp,stout)
        
{
            token
="^";
        }


        
public override double Comp(double a, double b)
        
{
            
return Math.Pow(a,b);
        }



    }


    
public class Computer
    
{
        
private cxyStack InStack;
        
private cxyStack OutStack=new cxyStack();

        
private TreateToken tk;

        
public Computer(cxyStack inStk)
        
{
            InStack
=inStk;

            tk
=new NumberToToken(InStack,OutStack); 

            ArrayList configFile
=new ArrayList();
            MyConstruct addcon
=new MyConstruct();
            addcon.TypeStr
= "myChain.AddToken";

            MyConstruct minuscon
=new MyConstruct();
            minuscon.TypeStr
="myChain.MinusToken";
            

            MyConstruct bycon
=new MyConstruct();
            bycon.TypeStr
="myChain.ByToken";

            MyConstruct divecon
=new MyConstruct();
            divecon.TypeStr
="myChain.DivideToken";

            MyConstruct changfange
=new MyConstruct();
            changfange.TypeStr
="myChain.ChangFange";

            configFile.Add(addcon);
            configFile.Add(minuscon);
            configFile.Add(bycon);
            configFile.Add(divecon);
            configFile.Add(changfange);
            

            ArrayList comar
=ComputChainFactory.GetChain(InStack,OutStack,configFile);

            tk.Next
=(CompToken)comar[0];


        }


        
public string Do()
        
{
            
while(InStack.Count>0)
            
{
                
string s=InStack.Pop().ToString();
                tk.Treat(s);
            }

            
return OutStack.Pop().ToString();
        }

    }




}

 

 

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:413604次
    • 积分:5873
    • 等级:
    • 排名:第4313名
    • 原创:178篇
    • 转载:40篇
    • 译文:1篇
    • 评论:28条
    最新评论