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

转载 2007年09月26日 15:01:00

界面 

四则运算式解释,并计算

语法分析

 

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

    }




}

 

 

复习数据结构,用java栈写了个计算器

为了提高运算效率,计算机采用更易识别的后缀表达式,基于栈进行运算代码前半部分计算后缀表达式,后半部分对后缀表达式进行运算,原理太多了,不解释import java.util.ArrayList; im...
  • weixin_38223828
  • weixin_38223828
  • 2017年09月07日 12:41
  • 512

【学习笔记javascript设计模式与开发实践(职责链模式)----13】

第13章 职责链模式 职责链模式的定义是:使多个对象都有机会处理请求,从而避免请求的发送和接收者之间的耦合关系,将这些对象连成一条链,并沿着这条链传递该请求,直到一个对象处理它为止。 职责链模式的名字...
  • pigpigpig4587
  • pigpigpig4587
  • 2015年12月31日 16:23
  • 719

设计模式之简单工厂模式(以计算器为例)

在了解简单工厂模式之前,首先先来做个小题目:用面向对象语言模拟实现一个简单的计算器,在控制台输入数字A、运算符、数字B,然后在控制台输出相对应的结果。因为我主攻的是java,所以我会选择用java语言...
  • qq_24243127
  • qq_24243127
  • 2017年06月14日 17:30
  • 385

二叉树实现计算器

使用二叉树完成表达式的存储和计算,要求 * 能够含有( )、+、-、*、/等运算符的实数表达式计算功能 * 能够处理小数和负数 * 能够处理求余运算符(%) * 能够处...
  • fangpopopo
  • fangpopopo
  • 2017年04月14日 19:31
  • 1013

用Visual C#动态生成控件

用Visual C#动态生成组件 ·阿虎·  以前在用Delphi写程序的时候,总不喜欢在窗体上排放很多组件,这一方面有点不美观,并且在调试程序时候,也...
  • mydriverc
  • mydriverc
  • 2007年07月05日 10:21
  • 1602

JavaScript设计模式--责任链模式

一、定义责任链模式:使多个对象都有机会处理请求,从而避免请求的发送者和接受者之间的耦合关系,将这些对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它为止。二、示例 假设这么一个场景: ...
  • ligang2585116
  • ligang2585116
  • 2015年12月20日 19:40
  • 1796

用函数指针数组来实现计算器

函数指针:函数指针是指向函数的指针变量。 因而“函数指针”本身首先应是指针变量,只不过该指针变量指向函数。这正如用指针变量可指向整型变量、字符型、数组一样,这里是指向函数。如前所述,C在编译时,每一个...
  • jhcconan614
  • jhcconan614
  • 2016年11月30日 15:46
  • 286

用javascript实现简单计算器

这是一个简单计算器的实现。可以实现简单的加,减,乘,除功能,用户按下“←”按钮,删除当前算术表达式最后一个字符,并更新显示,用户按下“CE”按钮,清除当前算术表达式,如果算术表达式非法,弹出警告框提醒...
  • XHF901
  • XHF901
  • 2016年12月09日 15:49
  • 365

Netbeans设计简易计算器学习

在实训过程中,我有幸学习了Netbean的使用,学习了设计一个简易计算器,然后实现它的部分功能。             1.首先是工程羡慕的创建,然后在包中创建窗体。              2....
  • sky159753zxc
  • sky159753zxc
  • 2015年09月20日 23:20
  • 879

使用unity做的绩点计算器

ps:因为要算一下自己的绩点,便做了一个绩点计算器,为了快捷,没有添加太多功能 代码如下 using UnityEngine; using UnityEngine.UI; using System...
  • w742874584
  • w742874584
  • 2016年01月29日 00:10
  • 758
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:用职责链模式来实现计算器
举报原因:
原因补充:

(最多只允许输入30个字)