转化字符串表达式为数学公式并算出结果

曾经终败给现在 2022-06-18 05:58 80阅读 0赞

/\*   
![InBlock.gif][] \* FormulaCalculator.java  
![InBlock.gif][] \*  
![InBlock.gif][] \* Created on 2007年9月18日, 上午11:40  
![InBlock.gif][] \* @title 转化字符串表达式为数学公式并算出结果  
![InBlock.gif][] \* @description 转化字符串表达式为数学公式并算出结果  
![InBlock.gif][] \* 注意:为了区分负号，这边使用\#代替减号  
![InBlock.gif][] \* 使用方法:  
![InBlock.gif][] \* FormulaCalculator calculator=new FormulaCalculator();  
![InBlock.gif][] \* calculator.getResult("10.23\#20.67\*(5.12+7.82)/2",2);  
![InBlock.gif][] \* v1.0.0 created by chenfc  
![InBlock.gif][] \*  
![ExpandedBlockEnd.gif][]\*/  
![None.gif][]  
![None.gif][]package org.jceun;  
![None.gif][]  
![None.gif][]import java.math.BigDecimal;  
![None.gif][]import java.util.LinkedList;  
![None.gif][]import java.util.ArrayList;  
![None.gif][]import java.util.regex.Matcher;  
![None.gif][]import java.util.regex.Pattern;  
![None.gif][]  
![ExpandedBlockStart.gif][]![ContractedBlock.gif][]publicclass FormulaCalculator ...\{  
![InBlock.gif][]privateboolean isRightFormat = true;  
![InBlock.gif][]public String DIVISOR\_EQUALS\_ZERO="0.0" ;//除数为零时的返回值  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][]/\*\* \*//\*\*  
![InBlock.gif][] \* 为了区分负号，这边使用\#代替减号  
![InBlock.gif][] \* @param formula 字符串表达式  
![InBlock.gif][] \* @return 返回公式计算结果  
![ExpandedSubBlockEnd.gif][]\*/  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][]public  double  getResult(String formula)...\{  
![InBlock.gif][]double returnValue =0;  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][]try  ... \{  
![InBlock.gif][] returnValue = doAnalysis(formula);  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][] \}catch  (NumberFormatException nfe)...\{  
![InBlock.gif][] System.out.println("公式格式有误，请检查:"\+ formula);  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][] \}catch  (Exception e)...\{  
![InBlock.gif][] e.printStackTrace();  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][]if  ( ! isRightFormat)...\{  
![InBlock.gif][] System.out.println("公式格式有误，请检查:"\+ formula);  
![ExpandedSubBlockEnd.gif][] \}  
![InBlock.gif][]return returnValue;  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][]/\*\* \*//\*\*  
![InBlock.gif][] \* 采用BigDecimal.ROUND\_HALF\_UP方式返回指定精度的运算结果  
![InBlock.gif][] \* @param formula 公式  
![InBlock.gif][] \* @param decimalPlace 要保留的小数位数  
![InBlock.gif][] \* @return 返回公式计算结果  
![ExpandedSubBlockEnd.gif][]\*/  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][]public  String getResult(String formula,int  decimalPlace)...\{  
![InBlock.gif][]return getResult(formula,decimalPlace,BigDecimal.ROUND\_HALF\_UP);  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][]/\*\* \*//\*\*  
![InBlock.gif][] \* 返回指定精度及舍去尾数的策略的运算结果  
![InBlock.gif][] \* @param formula 公式  
![InBlock.gif][] \* @param decimalPlace 要保留的小数位数  
![InBlock.gif][] \* @param roundMethod 舍去尾数的策略  
![InBlock.gif][] \* 可取值有BigDecimal.ROUND\_HALF\_UP BigDecimal.ROUND\_HALF\_DOWN祥见BigDecimal  
![InBlock.gif][] \* @return 返回公式计算结果  
![ExpandedSubBlockEnd.gif][]\*/  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][]public  String getResult(String formula,int  decimalPlace,int  roundMethod)...\{  
![InBlock.gif][]double result=getResult(formula);  
![InBlock.gif][]if(result==Double.MAX\_VALUE)  
![InBlock.gif][]return DIVISOR\_EQUALS\_ZERO;  
![InBlock.gif][]else  
![InBlock.gif][]return numberAround(result,decimalPlace,roundMethod);  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][]private  double  doAnalysis(String formula)...\{  
![InBlock.gif][]double returnValue =0;  
![InBlock.gif][] LinkedList<Integer> stack  =new LinkedList<Integer> ();  
![InBlock.gif][]  
![InBlock.gif][]int curPos =0 ;  
![InBlock.gif][] String beforePart ="";  
![InBlock.gif][] String afterPart ="";  
![InBlock.gif][] String calculator ="";  
![InBlock.gif][] isRightFormat =true;  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][]while  (isRightFormat&&  (formula.indexOf('  ( ' ) >=0|| formula.indexOf(') ') >=0 ))...\{  
![InBlock.gif][] curPos =0;  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][]for  ( char  s : formula.toCharArray())...\{  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][]if  (s  == '(')  ... \{  
![InBlock.gif][] stack.add(curPos);  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][] \}else if (s ==')')... \{  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][]if  (stack.size() >  0 )...\{  
![InBlock.gif][] beforePart = formula.substring(0, stack.getLast());  
![InBlock.gif][] afterPart = formula.substring(curPos \+1);  
![InBlock.gif][] calculator = formula.substring(stack.getLast() \+1, curPos);  
![InBlock.gif][] formula = beforePart \+ doCalculation(calculator) \+ afterPart;  
![InBlock.gif][] stack.clear();  
![InBlock.gif][]break;  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][] \}else  ... \{  
![InBlock.gif][] System.out.println("有未关闭的右括号！");  
![InBlock.gif][] isRightFormat =false;  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedSubBlockEnd.gif][] \}  
![InBlock.gif][] curPos\++;  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][]if  (stack.size() >  0 )...\{  
![InBlock.gif][] System.out.println("有未关闭的左括号！");  
![InBlock.gif][]break;  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][]if  (isRightFormat)...\{  
![InBlock.gif][] returnValue = doCalculation(formula);  
![ExpandedSubBlockEnd.gif][] \}  
![InBlock.gif][]return returnValue;  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][]/\*\* \*//\*\*  
![InBlock.gif][] \* 为了区分负号，这边使用\#代替减号  
![ExpandedSubBlockEnd.gif][]\*/  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][]private  double  doCalculation(String formula) ...\{  
![InBlock.gif][] ArrayList<Double> values  =   new ArrayList<Double>();  
![InBlock.gif][] ArrayList<String> operators = new ArrayList<String>();  
![InBlock.gif][]int curPos =0 ;  
![InBlock.gif][]int prePos =0 ;  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][]for  ( char  s : formula.toCharArray()) ...\{  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][]if  (s  == '\+' || s ==' \#'||  s  =='\*' || s == '/')   ... \{  
![InBlock.gif][] values.add(Double.parseDouble(formula.substring(prePos, curPos)  
![InBlock.gif][] .trim()));  
![InBlock.gif][] operators.add(""\+ s);  
![InBlock.gif][] prePos = curPos \+ 1;  
![ExpandedSubBlockEnd.gif][] \}  
![InBlock.gif][] curPos\++;  
![ExpandedSubBlockEnd.gif][] \}  
![InBlock.gif][] values.add(Double.parseDouble(formula.substring(prePos).trim()));  
![InBlock.gif][]char op;  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][]for  (curPos =  operators.size() \-  1 ; curPos >=0; curPos\--) ...\{  
![InBlock.gif][] op = operators.get(curPos).charAt(0);  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][]switch  (op) ...\{  
![InBlock.gif][]case'\* ':  
![InBlock.gif][] values.add(curPos, values.get(curPos) \* values.get(curPos \+1));  
![InBlock.gif][] values.remove(curPos \+1);  
![InBlock.gif][] values.remove(curPos \+1);  
![InBlock.gif][] operators.remove(curPos);  
![InBlock.gif][]break;  
![InBlock.gif][]case'/ ':  
![InBlock.gif][]if(values.get(curPos \+1).doubleValue()==0.0 )//除数为零时  
![InBlock.gif][] values.add(curPos, new Double(getDefaultValue()));  
![InBlock.gif][]else  
![InBlock.gif][] values.add(curPos, values.get(curPos) / values.get(curPos \+1));  
![InBlock.gif][] values.remove(curPos \+1);  
![InBlock.gif][] values.remove(curPos \+1);  
![InBlock.gif][] operators.remove(curPos);  
![InBlock.gif][]break;  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][]for  (curPos =  operators.size() \-  1 ; curPos >=0; curPos\--) ...\{  
![InBlock.gif][] op = operators.get(curPos).charAt(0);  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][]switch  (op) ...\{  
![InBlock.gif][]case'\+ ':  
![InBlock.gif][] values.add(curPos, values.get(curPos) \+ values.get(curPos \+1));  
![InBlock.gif][] values.remove(curPos \+1);  
![InBlock.gif][] values.remove(curPos \+1);  
![InBlock.gif][] operators.remove(curPos);  
![InBlock.gif][]break;  
![InBlock.gif][]case'\# ':  
![InBlock.gif][] values.add(curPos, values.get(curPos) \- values.get(curPos \+1));  
![InBlock.gif][] values.remove(curPos \+1);  
![InBlock.gif][] values.remove(curPos \+1);  
![InBlock.gif][] operators.remove(curPos);  
![InBlock.gif][]break;  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedSubBlockEnd.gif][] \}  
![InBlock.gif][]return values.get(0).doubleValue();  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][]/\*\* \*//\*\*  
![InBlock.gif][] \* 对数字进行四舍五入  
![InBlock.gif][] \* @param dN 要四舍五入的数  
![InBlock.gif][] \* @param decimalPlace 精度  
![InBlock.gif][] \* @param roundMethod 舍去尾数的策略  
![InBlock.gif][] \* 可取值有BigDecimal.ROUND\_HALF\_UP BigDecimal.ROUND\_HALF\_DOWN祥见BigDecimal  
![ExpandedSubBlockEnd.gif][]\*/  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][]public  String numberAround(double  dN,int  decimalPlace, int roundMethod)...\{  
![InBlock.gif][] BigDecimal bd =new BigDecimal(String.valueOf(dN));  
![InBlock.gif][] bd = bd.setScale(decimalPlace, roundMethod);  
![InBlock.gif][]return String.valueOf(bd);  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][]/\*\* \*//\*\*  
![InBlock.gif][] \* 对给定的字符串进行模式匹配  
![InBlock.gif][] \* @param str 要匹配的字符串  
![InBlock.gif][] \* @param regix 模式  
![InBlock.gif][] \* @return 返回匹配结果，成功为true,否则为false  
![ExpandedSubBlockEnd.gif][] \*\*/  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][]public  boolean  check(String str,String regix)...\{  
![InBlock.gif][]boolean result=false;  
![InBlock.gif][] Pattern p=Pattern.compile(regix);  
![InBlock.gif][] Matcher m =p.matcher(str);  
![InBlock.gif][] result=m.matches();  
![InBlock.gif][]return result;  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedBlockEnd.gif][] \}

//:表达式解析-两栈算法.txt  
//:Arithmetic.java  
  
package citi;  
import java.util.Iterator;  
import java.util.Stack;  
import java.util.ArrayList;  
  
public class Arithmetic\{  
//定义操作符，为简单起见，只涉及四则运算，可相应扩充之  
static String Operators= "+-\*/()\# ";  
//定义操作符的比较优先级，  
//其中1表示前面的操作符优于后面的操作符  
// -1表示前面的操作符低于后面的操作符  
// 0表示前面的操作符等于后面的操作符  
// 2表示前面的操作符不可能与后面的操作符相比较，如果碰到，则表达式有错  
//PrecedeList\[0\]\[\]表示+和+-\*/()\#这七个操作符相比较的优先级  
//PrecedeList\[1\]\[\]表示-和+-\*/()\#这七个操作符相比较的优先级  
//以此类推  
static byte PrecedeList\[\]\[\]=\{  
\{ 1, 1,-1,-1,-1, 1, 1\},  
\{ 1, 1,-1,-1,-1, 1, 1\},  
\{ 1, 1, 1, 1,-1, 1, 1\},  
\{ 1, 1, 1, 1,-1, 1, 1\},  
\{-1,-1,-1,-1,-1, 0, 2\},  
\{ 1, 1, 1, 1, 2, 1, 1\},  
\{-1,-1,-1,-1,-1, 2, 0\}\};  
//定义数据中可能出现的数字和小数点，可以扩展  
static String Numbers= "0123456789. ";  
private Stack Operator,Operand;  
private ArrayList Expression;  
  
public Arithmetic(String inputStr)\{  
Operator=new Stack();  
Operator.push( "\# ");  
Operand=new Stack();  
Expression=new ArrayList();  
Parse(inputStr);  
\}  
//解析输入的表达式，将操作符和数据分开  
//如输入表达式2+3\*(32-2)则解析成2 + 3 \* ( 32 - 2 )这九个字符串  
private void Parse(String instr)\{  
String single;  
int temp;  
String tempstr= "\# ";  
for(int i=0;i <instr.length();i++)\{  
single=instr.substring(i,i+1);  
//排除非操作符、数字的非法输入，如2+3m  
//Operators.indexOf(single)==6排除\#  
if(Numbers.indexOf(single) <0 && (Operators.indexOf(single) <0 || Operators.indexOf(single)==6))\{  
System.out.println( "Input have wrong char: "+single);  
Expression.clear();  
return;  
\}  
//获得前一个输入字符  
temp=Expression.size()-1;  
if(temp> -1)\{  
tempstr=(String)Expression.get(temp);  
\}  
//排除连续两个操作符的情况，如3\*\*2  
if(Operators.indexOf(single)> -1 && temp> -1 && Operators.indexOf(tempstr)> -1)\{  
System.out.println( "Input have wrong format,two Operators are conjoint ");  
Expression.clear();  
return;  
\}  
//如果当前字符是数字（包括.）而且前一字符也是数字，则将当前字符加到前一字符后面  
//其他情况均新添加一个元素  
if(Operators.indexOf(single) <0 && temp> -1 && Operators.indexOf(tempstr) <0)\{  
Expression.set(temp,tempstr+single);  
\}  
else\{  
Expression.add(single);//其他情况均新添加一个元素  
\}  
\}  
//为了算法处理方便起见，添加特殊字符＃  
Expression.add( "\# ");  
\}  
  
//比较两个操作符的优先级  
private byte Precede(String firstOperator,String secondOperator)\{  
return PrecedeList\[Operators.indexOf(firstOperator)\]\[Operators.indexOf(secondOperator)\];  
\}  
  
//对两个数据字符串进行运算  
private double Operate(String firstOperand,String Operator,String secondOperand)\{  
if(Operator.equals( "+ "))\{  
return (Double.parseDouble(firstOperand)+Double.parseDouble(secondOperand));  
\}  
else if(Operator.equals( "- "))\{  
return (Double.parseDouble(firstOperand)-Double.parseDouble(secondOperand));  
\}  
else if(Operator.equals( "\* "))\{  
return (Double.parseDouble(firstOperand)\*Double.parseDouble(secondOperand));  
\}  
else if(Operator.equals( "/ "))\{  
return (Double.parseDouble(firstOperand)/Double.parseDouble(secondOperand));  
\}  
else\{  
System.out.println( "Operator is wrong!Can throw a Exception ");  
return 0;  
\}  
\}  
//采用两个栈对接解析后的表达式进行运算  
public double Compute()\{  
if(Expression.isEmpty())\{  
System.out.println( "Expresion is empty ");  
return 0;  
\}  
Iterator it = Expression.iterator();  
String single;  
String firstOperand,secondOperand;  
  
single=(String)it.next();  
while(!(single.equals( "\# ") && Operator.peek().equals( "\# ")))\{  
if(Operators.indexOf(single) <0)\{  
Operand.push(single);single=(String)it.next();  
\}  
else\{  
switch(Precede((String)Operator.peek(),single))\{  
case -1:Operator.push(single);single=(String)it.next();break;  
case 0: Operator.pop();single=(String)it.next();break;  
case 1:  
secondOperand=(String)Operand.pop();  
firstOperand=(String)Operand.pop();  
Operand.push(String.valueOf(Operate(firstOperand,(String)Operator.pop(),secondOperand)));break;  
case 2: System.out.println( "Expression is wrong!Can throw a Exception ");break;  
\}  
\}  
\}  
return Double.parseDouble((String)Operand.pop());  
\}  
  
public static void main(String\[\] args)\{  
long t1 = System.currentTimeMillis();  
  
Arithmetic t=new Arithmetic(args\[0\]);  
System.out.println(t.Compute());  
  
long t2 = System.currentTimeMillis();  
System.out.println( "Time needed: " + (t2 - t1));  
\}  
\}

C\# code

using System;
    using System.Text;
    
    namespace Lentro.Edu.Ch02
    {
        public class Expression
        {
            private StackSimple<int> theStack;
            public StringBuilder suffix = new StringBuilder();
    
            /**
             * 检查该字符是否为括号
             */
            private bool isParen(char c)
            {
                if (c == '{' || c == '[' || c == '(' || c == ')' || c == ']' || c == '}')
                    return true;
                else
                    return false;
            }
    
            /**
             * 检查是否为左括号
             */
            private bool isLeftParen(char c)
            {
                if (c == '{' || c == '[' || c == '(')
                    return true;
                else
                    return false;
            }
    
            /**
             * 判断指定的操作符是否为 '+' 或者 '-'
             */
            private bool isAddOrSub(int oper)
            {
                return oper == '+' || oper == '-';
            }
    
            /**
             * 检查是否为数字
             */
            private bool isNumber(int ch)
            {
                return ch >= 48 && ch <= 57;
            }
    
            /**
             * 检查表达式是否合法
             */
            private bool checkExp(String exp)
            {
                char[] ch = exp.ToCharArray();
                StackSimple<int> theStackXInt = new StackSimple<int>(exp.Length / 2);
    
                /**
                 * 遍历表达式,只处理括号部分
                 */
                for (int i = 0; i < ch.Length; i++)
                {
                    char c = ch[i];
                    if (isParen(c))
                    {
                        /**
                         * 左括号进栈
                         */
                        if (isLeftParen(c))
                        {
                            theStackXInt.Push(c);
                        }
                        else
                        {
                            if (theStackXInt.IsEmpty())
                            {
                                return false;
                            }
                            int left = theStackXInt.Pop();
                            switch (c)
                            {
                                case '}':
                                    if (left != '{')
                                        return false;
                                    break;
                                case ']':
                                    if (left != '[')
                                        return false;
                                    break;
                                case ')':
                                    if (left != '(')
                                        return false;
                                    break;
                            }
                        }
                    }
                }
                if (theStackXInt.IsEmpty())
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
    
            /**
             * 根据当前操作符处理之前在栈中的操作符,当前操作符暂不处理,放入栈中
             */
            private void processOper(char oper)
            {
                while (!theStack.IsEmpty())
                {
                    int currTop = theStack.Pop();
                    /**
                     * 如果是左括号,则不予处理,将括号返回进栈
                     * 
                     * 若得到的操作符,则进一步判断
                     */
                    if (currTop == '(')
                    {
                        theStack.Push(currTop);
                        break;
                    }
                    else
                    {
                        if (this.isAddOrSub(currTop))
                        {
                            if (this.isAddOrSub(oper))
                            {
                                this.suffix.Append((char)currTop);
                            }
                            else
                            {
                                this.theStack.Push(currTop);
                                break;
                            }
                        }
                        else
                        {
                            this.suffix.Append((char)currTop);
                            break;
                        }
                    }
                }
                /**
                 * 当前操作符进栈
                 */
                theStack.Push(oper);
            }
    
            /**
             * 处理括弧.
             * 
             * 如果为左括弧,直接进栈;
             * 
             * 否则为右括弧,现将这一对括号中的操作符优先处理完
             */
            private void processParen(char paren)
            {
                if (this.isLeftParen(paren))
                {
                    this.theStack.Push(paren);
                }
                else
                {
                    while (!theStack.IsEmpty())
                    {
                        int chx = theStack.Pop();
                        if (chx == '(')
                            break;
                        else
                            suffix.Append((char)chx);
                    }
                }
            }
    
            /**
             * 将正确的中缀表达式转为后缀表达式
             */
            private void doTrans(String exp)
            {
                theStack = new StackSimple<int>(exp.Length);
                if (this.checkExp(exp))
                {
                    char[] ch = exp.ToCharArray();
                    for (int i = 0; i < ch.Length; i++)
                    {
                        char c = ch[i];
                        switch (c)
                        {
                            case '+':
                            case '-':
                            case '*':
                            case '/':
                                this.processOper(c);
                                break;
                            case '(':
                            case ')':
                                this.processParen(c);
                                break;
    
                            default:
                                this.suffix.Append(c);
                                break;
                        }
                    }
    
                    while (!this.theStack.IsEmpty())
                    {
                        this.suffix.Append((char)this.theStack.Pop());
                    }
                }
            }
    
            /**
             * 计算表达式
             */
            public int clac(String exp)
            {
                this.doTrans(exp);
                String suff = this.suffix.ToString();
                StackSimple<int> stack = new StackSimple<int>(suff.Length);
    
                if (suff == null || suff.Length == 0)
                {
    
                }
                else
                {
                    char[] ch = suff.ToCharArray();
                    for (int i = 0; i < ch.Length; i++)
                    {
                        char c = ch[i];
                        if (this.isNumber(c))
                        {
                            stack.Push(c - 48);
                        }
                        else
                        {
                            int operand2 = stack.Pop();
                            int operand1 = stack.Pop();
                            switch (c)
                            {
                                case '+':
                                    stack.Push(operand1 + operand2);
                                    break;
                                case '-':
                                    stack.Push(operand1 - operand2);
                                    break;
                                case '*':
                                    stack.Push(operand1 * operand2);
                                    break;
                                case '/':
                                    stack.Push(operand1 / operand2);
                                    break;
                            }
                        }
                    }
                }
                return stack.Peep();
            }
        }
    }

其中StackSimple是自己写的一个简单的栈实现

C\# code

using System;
    
    namespace Lentro.Edu.Ch02
    {
        /// <summary>
        /// 用于演示栈（LIFO）的内部实现机制
        ///     
        ///     xfeng/2010-05-07
        /// </summary>
        public class StackSimple<T>
        {
            //栈默认的初始容量大小
            private const int DEFAULT_SIZE = 10;
    
            private T[] array;
    
            private int index;
    
            /// <summary>
            /// 初始化 Stack 类的新实例，该实例为空并且具有默认初始容量。
            /// </summary>
            public StackSimple()
                : this(DEFAULT_SIZE) { }
    
            /// <summary>
            /// 初始化 Stack 类的新实例，该实例为空并且具有指定的初始容量。
            /// </summary>
            /// <param name="size"></param>
            public StackSimple(int size)
            {
                index = -1;
                this.array = new T[size];
            }
    
            private int _count;
            /// <summary>
            /// 获取 Stack 中包含的元素数。
            /// </summary>
            public int Count
            {
                get { return _count; }
            }
    
            /// <summary>
            /// 清空栈
            /// </summary>
            public void Clear()
            {
                for (int i = 0; i < array.Length; i++)
                {
                    array[i] = default(T);
                    this.index = -1;
                    this._count = 0;
                }
            }
    
            public Boolean IsEmpty()
            {
                return this._count == 0;
            }
    
            /// <summary>
            /// 返回位于 Stack 顶部的对象但不将其移除。
            /// </summary>
            /// <returns>位于 Stack 顶部的 Object。</returns>
            public T Peep()
            {
                return this.index < 0 ? default(T) : this.array[this.index];
            }
    
            /// <summary>
            /// 移除并返回位于 Stack 顶部的对象。
            /// </summary>
            /// <returns>从 Stack 的顶部移除的 Object。 </returns>
            public T Pop()
            {
                T obj = this.index < 0 ? default(T) : this.array[this.index];
                if (null != obj)
                {
                    this.index--;
                    this._count--;
                    //this.array[this.index] = default(T);
                }
                return obj;
            }
    
            /// <summary>
            /// 将对象插入 Stack 的顶部。
            /// </summary>
            public void Push(T obj)
            {
                if (null != obj)
                {
                    if (this.index >= this.array.Length - 1)
                    {
                        T[] temp = new T[this.array.Length * 2];
                        int count = 0;
                        foreach (T item in array)
                        {
                            temp[count++] = item;
                        }
                        this.array = temp;
                    }
                    array[++index] = obj;
                    this._count++;
                }
            }
        }
    }

这是那个栈Demo

C\#的动态编译，并返回结果

C\# code

private void btn\_Compute\_Click(object sender, EventArgs e)  
\{  
// 声明要计算C\#代码,要求必须完整的C\#代码  
string strCode = @"  
using System;  
namespace ParseEx  
\{  
public class ParseExC  
\{  
public static double GetValue() //GetValue(int x) //可以带参数  
\{  
return 1+5\*8-(Math.Sin(12)\*2.5);  
\}  
\}  
\}";

Stopwatch sw = new Stopwatch();  
sw.Start();  
string strCode = @"  
using System;  
namespace ParseEx  
\{  
public class ParseExC  
\{  
public static double GetValue()  
\{"  
\+ "return " + this.textBox\_Text.Text.Trim() + ";" +  
@"\}  
\}  
\}";  
  
CodeDomProvider comp = new CSharpCodeProvider();  
CompilerParameters cp = new CompilerParameters();

StringBuilder codeBuilder = new StringBuilder();  
codeBuilder.AppendLine(strCode);

cp.ReferencedAssemblies.Add("System.dll");  
cp.GenerateExecutable = false;  
cp.GenerateInMemory = true;

CompilerResults cr = comp.CompileAssemblyFromSource(cp, codeBuilder.ToString());  
if (cr.Errors.HasErrors)  
\{  
MessageBox.Show("Error!");  
\}  
else  
\{  
Assembly a = cr.CompiledAssembly;  
if (a != null)  
\{  
Type t = a.GetType("ParseEx.ParseExC");  
if (t != null)  
\{  
// 因为是静态调用,不需要创建实例了  
// object mode = a.CreateInstance("Mode");  
MethodInfo mi = t.GetMethod("GetValue", BindingFlags.Static | BindingFlags.Public);  
if (mi != null)  
\{  
double d = (double)mi.Invoke(null, null);

//double d = (double)mi.Invoke(null, new object\[\] \{ 1 \}) \}); //可以带参数

sw.Stop();

this.label\_Result.Text = "Result = " + d.ToString() + "; Time = " + sw.Elapsed.ToString();  
//MessageBox.Show("Result = " + d.ToString());  
\}  
\}  
\}  
\}  
\}  
\}

[InBlock.gif]: /images/20220618/aabff76027c24ac99128e37d1c2a5d1a.png
[ExpandedBlockEnd.gif]: /images/20220618/2751a9a7f0c34bc4bb738cbefbbaf1da.png
[None.gif]: /images/20220618/148e73abb9e64d6facd221405d796363.png
[ExpandedBlockStart.gif]: http://images.csdn.net/syntaxhighlighting/OutliningIndicators/ExpandedBlockStart.gif
[ContractedBlock.gif]: /images/20220618/f7dea27892bd4d84aea41c931c0fd431.png
[ExpandedSubBlockStart.gif]: http://images.csdn.net/syntaxhighlighting/OutliningIndicators/ExpandedSubBlockStart.gif
[ContractedSubBlock.gif]: /images/20220618/e05fdeeab7ed49389e4e70cfc563086c.png
[ExpandedSubBlockEnd.gif]: /images/20220618/89e9d87887f748238d4623d2a6935fa6.png