C++ 实现整数四则运算

思路：首先利用栈A把四则运算的字符串从中序表达式转换成后序表达式；然后对后序表达式，如果是数字则保存到另一个栈B中，如果是运算符（+,-,*,/）就从栈B中依次获取栈顶两个操作数进行运算，运算成效再压栈B，如此反复，终究栈B中最后的值就是运算成效。

#define MAX_LENGTH  500

class Da ta
{
public:
    double num;
    char op;
};

class FourArithmeticOP
{
private:
    Stack<double> numStack;   //进行四则运算时，保存后序表达式中的操作数
    Stack<char> opStack;         //保存中序表达式转换成后序表达式历程中的操作符
    int InStackPriority(char op);   //进入栈内后的优先级
    int NormalPriority(char op);    //普通表达式中的优先级
public:
    Da ta post[MAX_LENGTH];    //保存后序表达式
    int postLength;                     //后序表达式数组的实际长度
    void InorderToPostorder(char *cExp);  //把中序表达式转换成后序表达式
    double Calculate();                //进行四则运算
};

//对四则运算符，栈内优先级提拔，'('的栈内优先级应该比所有的操作符都小，')'的栈内优先级应该最大
//+-的优先级一致，*/的优先级一致
int FourArithmeticOP::InStackPriority(char op)
{
    int priority;
    switch (op)
    {
    case '+' : priority = 3;
        break;
    case '-' : priority = 3;
        break;
    case '*' : priority = 5;
        break;
    case '/' : priority = 5;
        break;
    case '(' : priority = 1;
        break;
    case ')' : priority = 10;
        break;
    default:  priority = 0;
        break;
    }
    return priority;
}

int FourArithmeticOP::NormalPriority(char op)
{
    int priority;
    switch (op)
    {
    case '+' : priority = 2;
        break;
    case '-' : priority = 2;
        break;
    case '*' : priority = 4;
        break;
    case '/' : priority = 4;
        break;
    case '(' : priority = 10;
        break;
    case ')' : priority = 1;
        break;
    default: priority = 0;
        break;
    }
    return priority;
}

void FourArithmeticOP::InorderToPostorder(char *cExp)
{
    char num[10];

    //把字符串中的数字和操作符（+-*/）放入后序表达式
    opStack.makeEmpty();

    //加入一个优先级最低的特殊字符，使opStack不为空
    opStack.push('&');
   
    int index = 0;
    postLength = 0;
    while (cExp[index] != '\0')
    {
        if (cExp[index] == '+' || cExp[index] == '-' || cExp[index] == '*' || cExp[index] == '/' || cExp[index] == '(')
        {
            //优先级高于当前操作符的栈内操作符出栈
            while (NormalPriority(cExp[index]) < InStackPriority(opStack.getTop()))
            {
                post[postLength++].op = opStack.pop();
            }
            opStack.push(cExp[index]);
        }
        else if (cExp[index] == ')')
        {
            //一直退栈到'('
            while (opStack.getTop() != '(')
            {
                post[postLength++].op = opStack.pop();
            }

            // '(' 出栈
        &n12306bsp;   opStack.pop();
        }
        else if (cExp[index] >= '0' && cExp[index] <= '9')
        {
            //数字
            int j = 0;
            memset(num, 0, 10);
            while (cExp[index] >= '0' && cExp[index] <= '9')
            {
                num[j++] = cExp[index++];
            }
            index--;

            post[postLength].num = atof(num);
            post[postLength].op = '&';
            postLength++;
        }
        else
        {
            //非法字符，不处置惩罚
        }
        index++;
    }

    while (opStack.getTop() != '&')
     {
         post[postLength++].op = opStack.pop();
     }

     // '&' 出栈
     opStack.pop();
}

//根据后序表达式进行四则运算
double FourArithmeticOP::Calculate()
{
    double left, right;

    numStack.makeEmpty();

    for (int i = 0; i < postLength; i++)
    {
        if (post[i].op == '&')
        {
            // 数字
            numStack.push(post[i].num);
        }
        else
        {
            //操作符，取出两个数字进行运算
            right = numStack.pop();
            left = numStack.pop();
            switch (post[i].op)
            {
            case '+' : numStack.push(left + right);
                break;
            case '-' : numStack.push(left - right);
                break;
            case '*' : numStack.push(left * right);
                break;
            case '/' : numStack.push(left / right);
                break;
            }
        }
    }

    return numStack.pop();
}


附： 链表堆栈的实现

//栈节点数据布局
template < typename T>
class Node
{
public:
    Node(T value, Node *p):value(value),next(p){}

    T value;
    Node *next;
};

//栈
template <typename T>
class Stack
{
public:
    Stack():top(NULL){}
    ~Stack();

    void push(T value);
    char pop();
    bool isEmpty(){return top == NULL;}
    T getTop();
    void makeEmpty();
private:
    Node *top;
};

template <typename T>
Stack<T>::~Stack()
{
    Node *p;
    while (NULL != top)
    {
        p = top;
        top = top->next;
        delete p;
    }
}

template <typename T>
void Stack<T>::push(T value)
{
    top = new Node(value,top);
}

template <typename T>
T Stack<T>::pop()
{
    if (!isEmpty())
    {
        T nodeValue = top->value;

        Node *p = top;
        top = top->next;       
        delete p;

        return nodeValue;
    }
}

template <typename T>
T Stack<T>::getTop()
{
   if (!isEmpty())
     return top->value;
}

template <typename T>
void Stack<T>::makeEmpty()
{
    Node *p;
    while (NULL != top)
    {
        p = top;
        top = top->next;
        delete p;
    }
}

貂皮大衣质量鉴别