表达式求值（二叉树方法/C++语言描述）（四）

代码清单

 // binarytree.h
 #ifndef BINARYTREE_H
 #define BINARYTREE_H

 template <typename T> class BinaryTree;

 template <typename T>
 class BinaryTreeNode
 {
 public:
     friend class BinaryTree<T>;
     friend class Calculator;
     T _data;

 private:
     BinaryTreeNode<T> * _leftChild;
     BinaryTreeNode<T> * _rightChild;
 };

 template <typename T>
 class BinaryTree
 {
 public:
     BinaryTree()
     {
         _root = nullptr;
     }

     ~BinaryTree()
     {
         destory();
     }

     void preOrder()
     {
         preOrder(_root);
     }

     void inOrder()
     {
         inOrder(_root);
     }

     void postOrder()
     {
         postOrder(_root);
     }

 protected:
     BinaryTreeNode<T> * _root;

     void destory()
     {
         if (_root)
         {
             destory(_root);
             delete _root;
         }
     }

     void destory(BinaryTreeNode<T> * node)
     {
         if (node)
         {
             destory(node->_leftChild);
             destory(node->_rightChild);
             // visit binary tree data
             if (node->_leftChild)
             {
                 delete node->_leftChild;
             }
             if (node->_rightChild)
             {
                 delete node->_rightChild;
             }
         }
     }

     virtual void preOrder(BinaryTreeNode<T> * node)
     {
         if (node)
         {
             // visit binary tree data
             preOrder(node->_leftChild);
             preOrder(node->_rightChild);
         }
     }

     virtual void inOrder(BinaryTreeNode<T> * node)
     {
         if (node)
         {
             inOrder(node->_leftChild);
             // visit binary tree data
             inOrder(node->_rightChild);
         }
     }

     virtual void postOrder(BinaryTreeNode<T> * node)
     {
         if (node)
         {
             postOrder(node->_leftChild);
             postOrder(node->_rightChild);
             // visit binary tree data
         }
     }
 };

 #endif // BINARYTREE_H

 // calculator.h
 #ifndef CALCULATOR_H
 #define CALCULATOR_H

 #include <cassert>
 #include <string>
 #include <stack>
 #include <iostream>
 #include "binarytree.h"

 using namespace std;

 typedef enum
 {
     BEGIN,
     NUMBER,
     OPERATOR,
     LEFT_BRAC,
     RIGHT_BRAC
 } TokenType;

 class Token
 {
 public:
     TokenType _type;
     union
     {
         char op;
         double num;
     } _data;
 };

 class Calculator : public BinaryTree<Token>
 {
 public:
     void parseExpression(string expression) throw(string);
     double calculate();

 private:
     stack<char> _stkOperators;
     stack<BinaryTreeNode<Token> *> _stkNodes;
     stack<double> _stkNumbers;

     static int priority(char op);
     static double calculate(double d1, char op, double d2) throw(string);

     void postOrder(BinaryTreeNode<Token> * node);
     void calculateStack() throw(string);
     void dealWithNumber(char *&pToken) throw(string);
     void dealWithOperator(char *&pToken) throw(string);
     void dealWithLeftBrac(char *&pToken) throw(string);
     void dealWithRightBrac(char *&pToken) throw(string);
 };

 #endif // CALCULATOR_H

 // calculator.cpp
 #include "calculator.h"

 int Calculator::priority(char op)
 {
     assert(op == '+' || op == '-' || op == '*' || op == '/' || op == '(');

     if (op == '+' || op == '-')
     {
         return ;
     }
     else if (op == '*' || op == '/')
     {
         return ;
     }
     else
     {
         return ;
     }
 }

 double Calculator::calculate(double d1, char op, double d2) throw(string)
 {
     assert(op == '+' || op == '-' || op == '*' || op =='/');

     cout << d1 << op << d2 << endl;

     if (op == '+')
     {
         return d1 + d2;
     }
     else if (op == '-')
     {
         return d1 - d2;
     }
     else if (op == '*')
     {
         return d1 * d2;
     }
     else
     {
         if (!d2)
         {
             throw string("divided by 0");
         }
         return d1 / d2;
     }
 }

 void Calculator::calculateStack() throw(string)
 {
     BinaryTreeNode<Token> * node = new BinaryTreeNode<Token>();
     assert(node);
     node->_data._type = OPERATOR;
     node->_data._data.op = _stkOperators.top();
     _stkOperators.pop();
     assert(!_stkNodes.empty());
     node->_rightChild = _stkNodes.top();
     _stkNodes.pop();
     assert(!_stkNodes.empty());
     node->_leftChild = _stkNodes.top();
     _stkNodes.pop();
     _stkNodes.push(node);
 }

 void Calculator::parseExpression(string expression) throw(string)
 {
     destory();
     while (!_stkNodes.empty())
     {
         _stkNodes.pop();
     }
     while (!_stkOperators.empty())
     {
         _stkOperators.pop();
     }
     TokenType lastToken = BEGIN;

     char * pToken = &expression[];
     while (*pToken)
     {
         switch (lastToken)
         {
         case BEGIN:
             if (*pToken == '(')
             {
                 // an expression begin with a left bracket
                 dealWithLeftBrac(pToken);;
                 lastToken = LEFT_BRAC;
             }
             else
             {
                 // or a number
                 dealWithNumber(pToken);
                 lastToken = NUMBER;
             }
             break;
         case NUMBER:
             // after a number
             if (*pToken == ')')
             {
                 // it may be a right bracket
                 dealWithRightBrac(pToken);
                 lastToken = RIGHT_BRAC;
             }
             else
             {
                 // it may be an operator
                 dealWithOperator(pToken);
                 lastToken = OPERATOR;
             }
             break;
         case OPERATOR:
         case LEFT_BRAC:
             // after an operator or a left bracket
             if (*pToken == '(')
             {
                 // it may be a left bracket
                 dealWithLeftBrac(pToken);
                 lastToken = LEFT_BRAC;
             }
             else
             {
                 // it may be a number
                 dealWithNumber(pToken);
                 lastToken = NUMBER;
             }
             break;
         case RIGHT_BRAC:
             // after a right bracket
             if (*pToken == ')')
             {
                 // it may be another right bracket
                 dealWithRightBrac(pToken);
                 lastToken = RIGHT_BRAC;
             }
             else
             {
                 // it may be an perator
                 dealWithOperator(pToken);
                 lastToken = OPERATOR;
             }
             break;
         }
     }

     while (!_stkOperators.empty())
     {
         if (_stkOperators.top() == '(')
         {
             throw string("bad token '('");
         }
         calculateStack();
     }

     assert(!_stkNodes.empty());
     _root = _stkNodes.top();
 }

 void Calculator::postOrder(BinaryTreeNode<Token> *node)
 {
     if (node)
     {
         postOrder(node->_leftChild);
         postOrder(node->_rightChild);
         // visit binary tree data
         if (node->_data._type == NUMBER)
         {
             _stkNumbers.push(node->_data._data.num);
         }
         else
         {
             assert(!_stkNumbers.empty());
             double d2 = _stkNumbers.top();
             _stkNumbers.pop();
             assert(!_stkNumbers.empty());
             double d1 = _stkNumbers.top();
             _stkNumbers.pop();
             char op = node->_data._data.op;
             _stkNumbers.push(calculate(d1, op, d2));
         }
     }
 }

 double Calculator::calculate()
 {
     while (!_stkNumbers.empty())
     {
         _stkNumbers.pop();
     }

     BinaryTree::postOrder();

     assert(!_stkNumbers.empty());
     return _stkNumbers.top();
 }

 void Calculator::dealWithNumber(char *&pToken) throw(string)
 {
     if (!isdigit(*pToken) && *pToken != '-')
     {
         throw string("bad token '") + *pToken + "'";
     }

     BinaryTreeNode<Token> * node = new BinaryTreeNode<Token>();
     assert(node);
     node->_data._type = NUMBER;
     node->_data._data.num = strtod(pToken, &pToken);
     node->_leftChild = node->_rightChild = nullptr;
     _stkNodes.push(node);
 }

 void Calculator::dealWithOperator(char *&pToken) throw(string)
 {
     if (*pToken != '+' && *pToken != '-' && *pToken != '*' && *pToken != '/')
     {
         throw string("bad token '") + *pToken + "'";
     }

     if (!_stkOperators.empty()
             && priority(_stkOperators.top()) >= priority(*pToken))
     {
         calculateStack();
     }
     _stkOperators.push(*pToken++);
 }

 void Calculator::dealWithLeftBrac(char *&pToken) throw(string)
 {
     if (*pToken != '(')
     {
         throw string("bad token '") + *pToken + "'";
     }

     _stkOperators.push(*pToken++);
 }

 void Calculator::dealWithRightBrac(char *&pToken) throw(string)
 {
     if (*pToken != ')')
     {
         throw string("bad token '") + *pToken + "'";
     }

     while (!_stkOperators.empty() && _stkOperators.top() != '(')
     {
         calculateStack();
         if (_stkOperators.empty())
         {
             throw string("bad token ')'");
         }
     }
     _stkOperators.pop();
     pToken++;
 }

 // main.cpp
 #include "calculator.h"

 int main(int argc, char *argv[])
 {
     Calculator calculator;

     if (argc > )
     {
         if (argc == )
         {
             calculator.parseExpression(string(argv[]));
             cout << calculator.calculate() << endl;
         }
         else
         {
             cout << "too many arguments" << endl;
         }
     }
     else
     {
         while ()
         {
             string expression;
             cout << ">" << flush;
             cin >> expression;
             if (expression == "quit;")
             {
                 cout << "Bye." << endl;
                 return ;
             }
             try
             {
                 calculator.parseExpression(expression);
                 cout << calculator.calculate() << endl;
             }
             catch (string ex)
             {
                 cout << ex << endl;
             }
         }
     }
 }