字符串公式解析器——使用“逆波兰式算法”及C#实现

从5月中旬到7月中旬，我一直在做焊接工程中接头图的参数化和自动化生成软件。主要是将各种标准接头图分解为一个个的图元，并自定义图元参数和图参数，用户在使用时，只需修改相关参数值，即能生成其所需要的接头图，无须再人工用CAD软件手动绘画。如下图所示。

其中采用了自定义公式来描述参数的变化将导致的图形变化。例如对于厚度的变化，定义的公式为：“dotAll.x=dotAll.x*t1/dot1.y;dotAll.y=dotAll.y*t1/dot1.y;”。这个公式表示对于图形中的所有点，当厚度变化时，点的x坐标变为原x坐标值乘以新的厚度，再除以原来的序号为1的点的y坐标（即原来的厚度），同理对于y坐标的变化也一样。

最终公式将解析成 x=2.0 * 3 / 1.5, 最终结果为 4.0。问题的焦点在于如何将“2.0 * 3 / 1.5”这种字符串的表达式，让计算机能理解，并计算出结果。这里我采用了“逆波兰式算法”来解决这个问题。

关于“逆波兰式算法”的具体内容，请看这里 http://baike.baidu.com/view/2582.htm ，里面解释得很好。

最终程序里面的算法描述如下：

逆波兰式算法

　　　　　 1、从左至右扫描一中缀表达式。
                2、若读取的是操作数，则判断该操作数的类型，并将该操作数存入操作数堆栈
                3、若读取的是运算符
                   (1) 该运算符为左括号"("，则直接存入运算符堆栈。
                   (2) 该运算符为右括号")"，则输出运算符堆栈中的运算符到操作数堆栈，直到遇到左括号为止，此时抛弃该左括号。
                   (3) 该运算符为非括号运算符：
                       (a) 若运算符堆栈栈顶的运算符为左括号，则直接存入运算符堆栈。
                       (b) 若比运算符堆栈栈顶的运算符优先级高，则直接存入运算符堆栈。
                       (c) 若比运算符堆栈栈顶的运算符优先级低或相等，则输出栈顶运算符到操作数堆栈，直至运算符栈栈顶运算符低于（不包括等于）该运算符优先级,或为左括号，
                           并将当前运算符压入运算符堆栈。
                4、当表达式读取完成后运算符堆栈中尚有运算符时，则依序取出运算符到操作数堆栈，直到运算符堆栈为空。

　下面我们来具体实现下这个算法，代码中注释较全，就不详细解说了。

　　首先，我们来定义下操作数类。

定义操作数类型枚举

1     /// <summary>
2     /// 操作数类型
3     /// </summary>
4     public enum OperandType
5     {
6         /// <summary>
7         /// 函数
8         /// </summary>
9         FUNC = 1,
10
11         /// <summary>
12         /// 日期
13         /// </summary>
14         DATE = 2,
15
16         /// <summary>
17         /// 数字
18         /// </summary>
19         NUMBER = 3,
20
21         /// <summary>
22         /// 布尔
23         /// </summary>
24         BOOLEAN = 4,
25
26         /// <summary>
27         /// 字符串
28         /// </summary>
29         STRING = 5
30
31     }

操作数类 Operand

1  public class Operand
2     {
3         #region Constructed Function
4         public Operand(OperandType type, object value)
5         {
6             this.Type = type;
7             this.Value = value;
8         }
9
10         public Operand(string opd, object value)
11         {
12             this.Type = ConvertOperand(opd);
13             this.Value = value;
14         }
15         #endregion
16
17         #region Variable &　Property
18         /// <summary>
19         /// 操作数类型
20         /// </summary>
21         public OperandType Type { get; set; }
22
23         /// <summary>
24         /// 关键字
25         /// </summary>
26         public string Key { get; set; }
27
28         /// <summary>
29         /// 操作数值
30         /// </summary>
31         public object Value { get; set; }
32
33         #endregion
34
35         #region Public Method
36         /// <summary>
37         /// 转换操作数到指定的类型
38         /// </summary>
39         /// <param name="opd">操作数</param>
40         /// <returns>返回对应的操作数类型</returns>
41         public static OperandType ConvertOperand(string opd)
42         {
43             if (opd.IndexOf("(") > -1)
44             {
45                 return OperandType.FUNC;
46             }
47             else if (IsNumber(opd))
48             {
49                 return OperandType.NUMBER;
50             }
51             else if (IsDate(opd))
52             {
53                 return OperandType.DATE;
54             }
55             else
56             {
57                 return OperandType.STRING;
58             }
59         }
60
61         /// <summary>
62         /// 判断对象是否为数字
63         /// </summary>
64         /// <param name="value">对象值</param>
65         /// <returns>是返回真,否返回假</returns>
66         public static bool IsNumber(object value)
67         {
68             double val;
69             return double.TryParse(value.ToString(), out val);
70         }
71
72         /// <summary>
73         /// 判断对象是否为日期
74         /// </summary>
75         /// <param name="value">对象值</param>
76         /// <returns>是返回真,否返回假</returns>
77         public static bool IsDate(object value)
78         {
79             DateTime dt;
80             return DateTime.TryParse(value.ToString(), out dt);
81         }
82         #endregion
83     }

然后，我们来定义下运算符类。

运算符类型枚举

  1 /// <summary>
  2     /// 运算符类型(从上到下优先级依次递减)，数值越大，优先级越低
  3     /// </summary>
  4     public enum OperatorType
  5     {
  6         /// <summary>
  7         /// 左括号:(,left bracket
  8         /// </summary>
  9         LB = 10,
10
11         /// <summary>
12         /// 右括号),right bracket
13         /// </summary>
14         RB = 11,
15
16         /// <summary>
17         /// 逻辑非,!,NOT
18         /// </summary>
19         NOT = 20,
20
21         /// <summary>
22         /// 正号,+,positive sign
23         /// </summary>
24         PS = 21,
25
26         /// <summary>
27         /// 负号,-,negative sign
28         /// </summary>
29         NS = 22,
30
31         /// <summary>
32         /// 正切，tan
33         /// </summary>
34         TAN = 23,
35         /// <summary>
36         /// 反正切，atan
37         /// </summary>
38         ATAN = 24,
39
40
41         /// <summary>
42         /// 乘,*,multiplication
43         /// </summary>
44         MUL = 30,
45
46         /// <summary>
47         /// 除,/,division
48         /// </summary>
49         DIV = 31,
50
51         /// <summary>
52         /// 余,%,modulus
53         /// </summary>
54         MOD = 32,
55
56         /// <summary>
57         /// 加,+,Addition
58         /// </summary>
59         ADD = 40,
60
61         /// <summary>
62         /// 减,-,subtraction
63         /// </summary>
64         SUB = 41,
65
66         /// <summary>
67         /// 小于,less than
68         /// </summary>
69         LT = 50,
70
71         /// <summary>
72         /// 小于或等于,less than or equal to
73         /// </summary>
74         LE = 51,
75
76         /// <summary>
77         /// 大于,>,greater than
78         /// </summary>
79         GT = 52,
80
81         /// <summary>
82         /// 大于或等于,>=,greater than or equal to
83         /// </summary>
84         GE = 53,
85
86         /// <summary>
87         /// 等于,=,equal to
88         /// </summary>
89         ET = 60,
90
91         /// <summary>
92         /// 不等于,unequal to
93         /// </summary>
94         UT = 61,
95
96         /// <summary>
97         /// 逻辑与,&,AND
98         /// </summary>
99         AND = 70,
100
101         /// <summary>
102         /// 逻辑或,|,OR
103         /// </summary>
104         OR = 71,
105
106         /// <summary>
107         /// 逗号,comma
108         /// </summary>
109         CA = 80,
110
111         /// <summary>
112         /// 结束符号 @
113         /// </summary>
114         END = 255,
115
116         /// <summary>
117         /// 错误符号
118         /// </summary>
119         ERR = 256
120
121     }

运算符类

    public class Operator
    {
        public Operator(OperatorType type, string value)
        {
            this.Type = type;
            this.Value = value;
        }

        /// <summary>
        /// 运算符类型
        /// </summary>
        public OperatorType Type { get; set; }

        /// <summary>
        /// 运算符值
        /// </summary>
        public string Value { get; set; }

        /// <summary>
        /// 对于>或者<运算符，判断实际是否为>=,<>、<=，并调整当前运算符位置
        /// </summary>
        /// <param name="currentOpt">当前运算符</param>
        /// <param name="currentExp">当前表达式</param>
        /// <param name="currentOptPos">当前运算符位置</param>
        /// <param name="adjustOptPos">调整后运算符位置</param>
        /// <returns>返回调整后的运算符</returns>
        public static string AdjustOperator(string currentOpt, string currentExp, ref int currentOptPos)
        {
            switch (currentOpt)
            {
                case "<":
                    if (currentExp.Substring(currentOptPos, 2) == "<=")
                    {
                        currentOptPos++;
                        return "<=";
                    }
                    if (currentExp.Substring(currentOptPos, 2) == "<>")
                    {
                        currentOptPos++;
                        return "<>";
                    }
                    return "<";

                case ">":
                    if (currentExp.Substring(currentOptPos, 2) == ">=")
                    {
                        currentOptPos++;
                        return ">=";
                    }
                    return ">";
                case "t":
                    if (currentExp.Substring(currentOptPos, 3) == "tan")
                    {
                        currentOptPos += 2;
                        return "tan";
                    }
                    return "error";
                case "a":
                    if (currentExp.Substring(currentOptPos, 4) == "atan")
                    {
                        currentOptPos += 3;
                        return "atan";
                    }
                    return "error";
                default:
                    return currentOpt;
            }
        }

        /// <summary>
        /// 转换运算符到指定的类型
        /// </summary>
        /// <param name="opt">运算符</param>
        /// <param name="isBinaryOperator">是否为二元运算符</param>
        /// <returns>返回指定的运算符类型</returns>
        public static OperatorType ConvertOperator(string opt, bool isBinaryOperator)
        {
            switch (opt)
            {
                case "!": return OperatorType.NOT;
                case "+": return isBinaryOperator ? OperatorType.ADD : OperatorType.PS;
                case "-": return isBinaryOperator ? OperatorType.SUB : OperatorType.NS;
                case "*": return isBinaryOperator ? OperatorType.MUL : OperatorType.ERR;
                case "/": return isBinaryOperator ? OperatorType.DIV : OperatorType.ERR;
                case "%": return isBinaryOperator ? OperatorType.MOD : OperatorType.ERR;
                case "<": return isBinaryOperator ? OperatorType.LT : OperatorType.ERR;
                case ">": return isBinaryOperator ? OperatorType.GT : OperatorType.ERR;
                case "<=": return isBinaryOperator ? OperatorType.LE : OperatorType.ERR;
                case ">=": return isBinaryOperator ? OperatorType.GE : OperatorType.ERR;
                case "<>": return isBinaryOperator ? OperatorType.UT : OperatorType.ERR;
                case "=": return isBinaryOperator ? OperatorType.ET : OperatorType.ERR;
                case "&": return isBinaryOperator ? OperatorType.AND : OperatorType.ERR;
                case "|": return isBinaryOperator ? OperatorType.OR : OperatorType.ERR;
                case ",": return isBinaryOperator ? OperatorType.CA : OperatorType.ERR;
                case "@": return isBinaryOperator ? OperatorType.END : OperatorType.ERR;
                default: return OperatorType.ERR;
            }
        }

        /// <summary>
        /// 转换运算符到指定的类型
        /// </summary>
        /// <param name="opt">运算符</param>
        /// <returns>返回指定的运算符类型</returns>
        public static OperatorType ConvertOperator(string opt)
        {
            switch (opt)
            {
                case "!": return OperatorType.NOT;
                case "+": return OperatorType.ADD;
                case "-": return OperatorType.SUB;
                case "*": return OperatorType.MUL;
                case "/": return OperatorType.DIV;
                case "%": return OperatorType.MOD;
                case "<": return OperatorType.LT;
                case ">": return OperatorType.GT;
                case "<=": return OperatorType.LE;
                case ">=": return OperatorType.GE;
                case "<>": return OperatorType.UT;
                case "=": return OperatorType.ET;
                case "&": return OperatorType.AND;
                case "|": return OperatorType.OR;
                case ",": return OperatorType.CA;
                case "@": return OperatorType.END;
                case "tan": return OperatorType.TAN;
                case "atan": return OperatorType.ATAN;
                default: return OperatorType.ERR;
            }
        }

        /// <summary>
        /// 运算符是否为二元运算符,该方法有问题，暂不使用
        /// </summary>
        /// <param name="tokens">语法单元堆栈</param>
        /// <param name="operators">运算符堆栈</param>
        /// <param name="currentOpd">当前操作数</param>
        /// <returns>是返回真,否返回假</returns>
        public static bool IsBinaryOperator(ref Stack<object> tokens, ref Stack<Operator> operators, string currentOpd)
        {
            if (currentOpd != "")
            {
                return true;
            }
            else
            {
                object token = tokens.Peek();
                if (token is Operand)
                {
                    if (operators.Peek().Type != OperatorType.LB)
                    {
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                }
                else
                {
                    if (((Operator)token).Type == OperatorType.RB)
                    {
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                }
            }
        }

        /// <summary>
        /// 运算符优先级比较
        /// </summary>
        /// <param name="optA">运算符类型A</param>
        /// <param name="optB">运算符类型B</param>
        /// <returns>A与B相比，-1，低；0,相等；1，高</returns>
        public static int ComparePriority(OperatorType optA, OperatorType optB)
        {
            if (optA == optB)
            {
                //A、B优先级相等
                return 0;
            }

            //乘,除,余(*,/,%)
            if ((optA >= OperatorType.MUL && optA <= OperatorType.MOD) &&
                (optB >= OperatorType.MUL && optB <= OperatorType.MOD))
            {
                return 0;
            }
            //加,减(+,-)
            if ((optA >= OperatorType.ADD && optA <= OperatorType.SUB) &&
                (optB >= OperatorType.ADD && optB <= OperatorType.SUB))
            {
                return 0;
            }
            //小于,小于或等于,大于,大于或等于(<,<=,>,>=)
            if ((optA >= OperatorType.LT && optA <= OperatorType.GE) &&
                (optB >= OperatorType.LT && optB <= OperatorType.GE))
            {
                return 0;
            }
            //等于,不等于(=,<>)
            if ((optA >= OperatorType.ET && optA <= OperatorType.UT) &&
                (optB >= OperatorType.ET && optB <= OperatorType.UT))
            {
                return 0;
            }
            //三角函数
            if ((optA>=OperatorType.TAN && optA<=OperatorType.ATAN)&&
                    (optB >= OperatorType.TAN && optB <= OperatorType.ATAN))
            {
                return 0;
            }

            if (optA < optB)
            {
                //A优先级高于B
                return 1;
            }

            //A优先级低于B
            return -1;

        }
    }

最后，我们来实现算法类RPN，此部分代码较多，因此分成几部分。

1、RPN类中的变量和属性定义

RPN类变量和属性

1 /// <summary>
2     /// Reverse Polish Notation
3     /// 逆波兰式
4     /// </summary>
5     public class RPN
6     {
7         Stack<object> m_tokens = new Stack<object>();            //最终逆波兰式堆栈
8         /// <summary>
9         /// 最终逆波兰式堆栈
10         /// </summary>
11         public Stack<object> Tokens
12         {
13             get { return m_tokens; }
14         }
15
16         private string _RPNExpression;
17         /// <summary>
18         /// 生成的逆波兰式字符串
19         /// </summary>
20         public string RPNExpression
21         {
22             get
23             {
24                 if (_RPNExpression == null)
25                 {
26                     foreach (var item in Tokens)
27                     {
28                         if (item is Operand)
29                         {
30                             _RPNExpression += ((Operand)item).Value + ",";
31                         }
32                         if (item is Operator)
33                         {
34                             _RPNExpression += ((Operator)item).Value + ",";
35                         }
36                     }
37                 }
38                 return _RPNExpression;
39             }
40         }
41
42         List<string> m_Operators = new List<string>(new string[]{
43             "(","tan",")","atan","!","*","/","%","+","-","<",">","=","&","|",",","@"});    //允许使用的运算符
44 }

2、检查特殊符号是否匹配的方法

检查表达式中特殊符号(双引号、单引号、井号、左右括号)是否匹配

1         private bool IsMatching(string exp)
2         {
3             string opt = "";    //临时存储 " ' # (
4
5             for (int i = 0; i < exp.Length; i++)
6             {
7                 string chr = exp.Substring(i, 1);   //读取每个字符
8                 if ("\"'#".Contains(chr))   //当前字符是双引号、单引号、井号的一种
9                 {
10                     if (opt.Contains(chr))  //之前已经读到过该字符
11                     {
12                         opt = opt.Remove(opt.IndexOf(chr), 1);  //移除之前读到的该字符，即匹配的字符
13                     }
14                     else
15                     {
16                         opt += chr;     //第一次读到该字符时，存储
17                     }
18                 }
19                 else if ("()".Contains(chr))    //左右括号
20                 {
21                     if (chr == "(")
22                     {
23                         opt += chr;
24                     }
25                     else if (chr == ")")
26                     {
27                         if (opt.Contains("("))
28                         {
29                             opt = opt.Remove(opt.IndexOf("("), 1);
30                         }
31                         else
32                         {
33                             return false;
34                         }
35                     }
36                 }
37             }
38             return (opt == "");
39         }

3、查找运算符位置

从表达式中查找运算符位置

1  /// <summary>
2         /// 从表达式中查找运算符位置
3         /// </summary>
4         /// <param name="exp">表达式</param>
5         /// <param name="findOpt">要查找的运算符</param>
6         /// <returns>返回运算符位置</returns>
7         private int FindOperator(string exp, string findOpt)
8         {
9             string opt = "";
10             for (int i = 0; i < exp.Length; i++)
11             {
12                 string chr = exp.Substring(i, 1);
13                 if ("\"'#".Contains(chr))//忽略双引号、单引号、井号中的运算符
14                 {
15                     if (opt.Contains(chr))
16                     {
17                         opt = opt.Remove(opt.IndexOf(chr), 1);
18                     }
19                     else
20                     {
21                         opt += chr;
22                     }
23                 }
24                 if (opt == "")
25                 {
26                     if (findOpt != "")
27                     {
28                         if (findOpt == chr)
29                         {
30                             return i;
31                         }
32                     }
33                     else
34                     {
35                         if (m_Operators.Exists(x => x.Contains(chr)))
36                         {
37                             return i;
38                         }
39                     }
40                 }
41             }
42             return -1;
43         }

　 4、解析字符串表达式，算法的关键实现

语法解析,将中缀表达式转换成后缀表达式(即逆波兰表达式)

  1         public bool Parse(string exp)
  2         {
  3             m_tokens.Clear();//清空语法单元堆栈
  4             if (exp.Trim() == "")//表达式不能为空
  5             {
  6                 return false;
  7             }
  8             else if (!this.IsMatching(exp))//括号、引号、单引号等必须配对
  9             {
10                 return false;
11             }
12
13             Stack<object> operands = new Stack<object>();             //操作数堆栈
14             Stack<Operator> operators = new Stack<Operator>();      //运算符堆栈
15             OperatorType optType = OperatorType.ERR;                //运算符类型
16             string curOpd = "";                                 //当前操作数
17             string curOpt = "";                                 //当前运算符
18             int curPos = 0;                                     //当前位置
19             //int funcCount = 0;                                        //函数数量
20
21             curPos = FindOperator(exp, "");
22
23             exp += "@"; //结束操作符
24             while (true)
25             {
26                 curPos = FindOperator(exp, "");
27
28                 curOpd = exp.Substring(0, curPos).Trim();
29                 curOpt = exp.Substring(curPos, 1);
30
31                 //////////////测试代码///////////////////////////////////
32                 //System.Diagnostics.Debug.WriteLine("***************");
33                 //System.Diagnostics.Debug.WriteLine("当前读取的操作数：" + curOpd);
34
35                 //foreach (var item in operands.ToArray())
36                 //{
37                 //    if (item is Operand)
38                 //    {
39                 //        System.Diagnostics.Debug.WriteLine("操作数栈：" + ((Operand)item).Value);
40                 //    }
41                 //    if (item is Operator)
42                 //    {
43                 //        System.Diagnostics.Debug.WriteLine("操作数栈：" + ((Operator)item).Value);
44                 //    }
45                 //}
46
47                 //System.Diagnostics.Debug.WriteLine("当前读取的运算符：" + curOpt);
48                 //foreach (var item in operators.ToArray())
49                 //{
50                 //    System.Diagnostics.Debug.WriteLine("运算符栈：" + item.Value);
51                 //}
52                 ////////////////////////////////////////////////////////
53
54                 //存储当前操作数到操作数堆栈
55                 if (curOpd != "")
56                 {
57                     operands.Push(new Operand(curOpd, curOpd));
58                 }
59
60                 //若当前运算符为结束运算符，则停止循环
61                 if (curOpt == "@")
62                 {
63                     break;
64                 }
65                 //若当前运算符为左括号,则直接存入堆栈。
66                 if (curOpt == "(")
67                 {
68                     operators.Push(new Operator(OperatorType.LB, "("));
69                     exp = exp.Substring(curPos + 1).Trim();
70                     continue;
71                 }
72
73                 //若当前运算符为右括号,则依次弹出运算符堆栈中的运算符并存入到操作数堆栈,直到遇到左括号为止,此时抛弃该左括号.
74                 if (curOpt == ")")
75                 {
76                     while (operators.Count > 0)
77                     {
78                         if (operators.Peek().Type != OperatorType.LB)
79                         {
80                             operands.Push(operators.Pop());
81                         }
82                         else
83                         {
84                             operators.Pop();
85                             break;
86                         }
87                     }
88                     exp = exp.Substring(curPos + 1).Trim();
89                     continue;
90                 }
91
92
93                 //调整运算符
94                 curOpt = Operator.AdjustOperator(curOpt, exp, ref curPos);
95
96                 optType = Operator.ConvertOperator(curOpt);
97
98                 //若运算符堆栈为空,或者若运算符堆栈栈顶为左括号,则将当前运算符直接存入运算符堆栈.
99                 if (operators.Count == 0 || operators.Peek().Type == OperatorType.LB)
100                 {
101                     operators.Push(new Operator(optType, curOpt));
102                     exp = exp.Substring(curPos + 1).Trim();
103                     continue;
104                 }
105
106                 //若当前运算符优先级大于运算符栈顶的运算符,则将当前运算符直接存入运算符堆栈.
107                 if (Operator.ComparePriority(optType, operators.Peek().Type) > 0)
108                 {
109                     operators.Push(new Operator(optType, curOpt));
110                 }
111                 else
112                 {
113                     //若当前运算符若比运算符堆栈栈顶的运算符优先级低或相等，则输出栈顶运算符到操作数堆栈，直至运算符栈栈顶运算符低于（不包括等于）该运算符优先级，
114                     //或运算符栈栈顶运算符为左括号
115                     //并将当前运算符压入运算符堆栈。
116                     while (operators.Count > 0)
117                     {
118                         if (Operator.ComparePriority(optType, operators.Peek().Type) <= 0 && operators.Peek().Type != OperatorType.LB)
119                         {
120                             operands.Push(operators.Pop());
121
122                             if (operators.Count == 0)
123                             {
124                                 operators.Push(new Operator(optType, curOpt));
125                                 break;
126                             }
127                         }
128                         else
129                         {
130                             operators.Push(new Operator(optType, curOpt));
131                             break;
132                         }
133                     }
134
135                 }
136                 exp = exp.Substring(curPos + 1).Trim();
137             }
138             //转换完成,若运算符堆栈中尚有运算符时,
139             //则依序取出运算符到操作数堆栈,直到运算符堆栈为空
140             while (operators.Count > 0)
141             {
142                 operands.Push(operators.Pop());
143             }
144             //调整操作数栈中对象的顺序并输出到最终栈
145             while (operands.Count > 0)
146             {
147                 m_tokens.Push(operands.Pop());
148             }
149
150             return true;
151         }

5、计算

对逆波兰表达式求值

  1         public object Evaluate()
  2         {
  3             /*
  4               逆波兰表达式求值算法：
  5               1、循环扫描语法单元的项目。
  6               2、如果扫描的项目是操作数，则将其压入操作数堆栈，并扫描下一个项目。
  7               3、如果扫描的项目是一个二元运算符，则对栈的顶上两个操作数执行该运算。
  8               4、如果扫描的项目是一个一元运算符，则对栈的最顶上操作数执行该运算。
  9               5、将运算结果重新压入堆栈。
10               6、重复步骤2-5，堆栈中即为结果值。
11             */
12
13             if (m_tokens.Count == 0) return null;
14
15             object value = null;
16             Stack<Operand> opds = new Stack<Operand>();
17             Stack<object> pars = new Stack<object>();
18             Operand opdA, opdB;
19
20             foreach (object item in m_tokens)
21             {
22                 if (item is Operand)
23                 {
24                     //TODO 解析公式，替换参数
25
26                     //如果为操作数则压入操作数堆栈
27                     opds.Push((Operand)item);
28                 }
29                 else
30                 {
31                     switch (((Operator)item).Type)
32                     {
33                         #region 乘,*,multiplication
34                         case OperatorType.MUL:
35                             opdA = opds.Pop();
36                             opdB = opds.Pop();
37                             if (Operand.IsNumber(opdA.Value) && Operand.IsNumber(opdB.Value))
38                             {
39                                 opds.Push(new Operand(OperandType.NUMBER, double.Parse(opdB.Value.ToString()) * double.Parse(opdA.Value.ToString())));
40                             }
41                             else
42                             {
43                                 throw new Exception("乘运算的两个操作数必须均为数字");
44                             }
45                             break;
46                         #endregion
47
48                         #region 除,/,division
49                         case OperatorType.DIV:
50                             opdA = opds.Pop();
51                             opdB = opds.Pop();
52                             if (Operand.IsNumber(opdA.Value) && Operand.IsNumber(opdB.Value))
53                             {
54                                 opds.Push(new Operand(OperandType.NUMBER, double.Parse(opdB.Value.ToString()) / double.Parse(opdA.Value.ToString())));
55                             }
56                             else
57                             {
58                                 throw new Exception("除运算的两个操作数必须均为数字");
59                             }
60                             break;
61                         #endregion
62
63                         #region 余,%,modulus
64                         case OperatorType.MOD:
65                             opdA = opds.Pop();
66                             opdB = opds.Pop();
67                             if (Operand.IsNumber(opdA.Value) && Operand.IsNumber(opdB.Value))
68                             {
69                                 opds.Push(new Operand(OperandType.NUMBER, double.Parse(opdB.Value.ToString()) % double.Parse(opdA.Value.ToString())));
70                             }
71                             else
72                             {
73                                 throw new Exception("余运算的两个操作数必须均为数字");
74                             }
75                             break;
76                         #endregion
77
78                         #region 加,+,Addition
79                         case OperatorType.ADD:
80                             opdA = opds.Pop();
81                             opdB = opds.Pop();
82                             if (Operand.IsNumber(opdA.Value) && Operand.IsNumber(opdB.Value))
83                             {
84                                 opds.Push(new Operand(OperandType.NUMBER, double.Parse(opdB.Value.ToString()) + double.Parse(opdA.Value.ToString())));
85                             }
86                             else
87                             {
88                                 throw new Exception("加运算的两个操作数必须均为数字");
89                             }
90                             break;
91                         #endregion
92
93                         #region 减,-,subtraction
94                         case OperatorType.SUB:
95                             opdA = opds.Pop();
96                             opdB = opds.Pop();
97                             if (Operand.IsNumber(opdA.Value) && Operand.IsNumber(opdB.Value))
98                             {
99                                 opds.Push(new Operand(OperandType.NUMBER, double.Parse(opdB.Value.ToString()) - double.Parse(opdA.Value.ToString())));
100                             }
101                             else
102                             {
103                                 throw new Exception("减运算的两个操作数必须均为数字");
104                             }
105                             break;
106                         #endregion
107
108                         #region 正切,tan,subtraction
109                         case OperatorType.TAN:
110                             opdA = opds.Pop();
111                             if (Operand.IsNumber(opdA.Value))
112                             {
113                                 opds.Push(new Operand(OperandType.NUMBER, Math.Tan(double.Parse(opdA.Value.ToString())*Math.PI/180)));
114                             }
115                             else
116                             {
117                                 throw new Exception("正切运算的1个操作数必须均为角度数字");
118                             }
119                             break;
120                         #endregion
121
122                         #region 反正切,atan,subtraction
123                         case OperatorType.ATAN:
124                             opdA = opds.Pop();
125                             if (Operand.IsNumber(opdA.Value))
126                             {
127                                 opds.Push(new Operand(OperandType.NUMBER, Math.Atan(double.Parse(opdA.Value.ToString()))));
128                             }
129                             else
130                             {
131                                 throw new Exception("反正切运算的1个操作数必须均为数字");
132                             }
133                             break;
134                         #endregion
135
136                     }
137                 }
138             }
139
140             if (opds.Count == 1)
141             {
142                 value = opds.Pop().Value;
143             }
144
145             return value;
146         }

　　至此，算法实现已经完毕，下面我们来看下，如何使用RPN类来计算表达式。

1 private void Test()
2 {
3     string tmpExp="1.0+3/2-tan(45)/(1+1)";
4     RPN rpn = new RPN();
5     if (rpn.Parse(tmpExp))
6     {
7         Console.WriteLine(rpn.Evaluate());
8     }
9 }

posted on 2011-08-02 13:39 Will Lu 阅读(10794) 评论(9) 编辑收藏举报

刷新页面返回顶部

思想

导航

公告

字符串公式解析器——使用“逆波兰式算法”及C#实现