表达式求值（二叉树方法/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 1;
    }
    else if (op == '*' || op == '/')
    {
        return 2;
    }
    else
    {
        return 0;
    }
}

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[0];
    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 > 1)
    {
        if (argc == 2)
        {
            calculator.parseExpression(string(argv[1]));
            cout << calculator.calculate() << endl;
        }
        else
        {
            cout << "too many arguments" << endl;
        }
    }
    else
    {
        while (1)
        {
            string expression;
            cout << ">" << flush;
            cin >> expression;
            if (expression == "quit;")
            {
                cout << "Bye." << endl;
                return 0;
            }
            try
            {
                calculator.parseExpression(expression);
                cout << calculator.calculate() << endl;
            }
            catch (string ex)
            {
                cout << ex << endl;
            }
        }
    }
}