C++，用栈的方式实现中缀表达式(四则运算)的运算，包含小数，不包含负数。

---

大致思路

用栈的方式实现中缀表达式的运算，因为其中涉及到小数(未涉及到负数)，所以采用常规思路之前首先要对给出的中缀表达式做出一些处理。首先把给出的中缀表达式(字符串)转换成好处理的double数组，再将double数组转换为前缀的形式，最后再利用栈来计算前缀表达式

---

一、将字符串转换为double数组

这里需要运用到一个函数atof，但需要注意此函数的运用方法，他会把字符串中的数字转换为double型，但仅仅转换到下一个非数字字符。这么说可能不好理解，例如，给出一个字符串"1.2+2.3",如果我们把这个字符串传入这个函数，那么我们只能得到1.2这一个数字，后面的2.3是得不到的，atof函数在遇到+号的时候就已经退出了。下面是我的实现方法：

char b;
char c[20] = { '\0' };
double num[100] = { 0 };
int k = 0, len = 0;
int flag = 0;
while (true) {     //第一步，将表达式字符串转为double型的数组
        scanf("%c", &b);
        if (b == '\n') {
            if (flag == 1) {
                num[len++] = atof(c);
            }
            break;
        }
        if (b >= '0' && b <= '9' || b == '.') {
            c[k++] = b;
            flag = 1;
        }
        else if (b < '0' && flag == 1) {
            num[len++] = atof(c);
            flag = 0;
            for (int i = 0; i < k; i++) {         //清空字符串c
                c[i] = 0;
            }
            k = 0;
        }
        if (b < '0' && flag == 0) {
            num[len++] = b - '0';
        }
    }

字符b和字符串c都是中间操作，num数组才是我们需要的。注意此时运算符由于被减去了一个‘0’，所以此时是以负数形式储存在num里面，例如我们输入1.2+2.3，那么num数组里面储存的便是1.2，-5，2.3，这三个数据。

二、将中缀表达的double数组转换为前缀表达

a数组是上面得到的num数组，n是上面的num数组长度len，栈是自己写的，不是直接调用的头文件，所以函数名和头文件里面不太一样，pop是获取栈顶元素，getTop是出栈，push是入栈。此处需要准备两个栈，一个数据栈，一个符号栈。

int len;
double num1[100] = { 0 };
int len1 = 0;

void change(double a[], int n) {     //中缀换前缀
    Stack idx(n);                     //放数据的栈
    Stack symbol(n);                  //放符号的栈
    for (int i = n - 1; i >= 0; i--) {
        if (a[i] < 0) {                 //小于0说明遇到了符号
            int flag = 0;
            char temp = a[i] + '0';
            if (temp == '+' || temp == '-') {
                flag = 1;
                while (flag == 1) {
                    if ((symbol.pop() + '0') == '*' || (symbol.pop() + '0') == '/') {  //比较符号优先级
                        idx.push(symbol.getTop());
                    }
                    else {
                        flag = 0;
                        symbol.push(a[i]);
                    }
                }
            }
            else if (temp == '(') {
                while (symbol.pop() != (')' - '0')) {        //当遇到右括号时，将symbol栈里面的元素放到idx栈
                    idx.push(symbol.getTop());               //此步骤一直持续到遇到symbol栈内的下一个左括号为止
                }                                            //或者持续到栈内空
                symbol.getTop();                             //将左括号出栈
            }
            else {
                symbol.push(a[i]);                           //入栈
            }
        }
        else {
            idx.push(a[i]);
        }
    }
    while (symbol.isEmpty() == false) {
        idx.push(symbol.getTop());
    }
    while (idx.isEmpty() == false) {
        num1[len1] = idx.getTop();
        len1++;
    }
}

---

三、对前缀表达式进行计算

a是上面得到的num1数组，n是上面的num1数组长度len1。

double calculate(double a[], int n) {                   //波兰表达式计算，n为数据和符号的个数
    Stack s(n);
    for (int i = n - 1; i >= 0; i--) {
        if (a[i] < 0) {
            char flag = a[i] + '0';
            double b = s.getTop();
            double c = s.getTop();
            double m = 0;
            if (flag == '+') {
                m = b + c;
            }
            else if (flag == '-') {
                m = b - c;
            }
            else if (flag == '*') {
                m = b * c;
            }

            else if (flag == '/') {
                m = b / c;
            }
            s.push(m);
        }
        else {
            s.push(a[i]);
        }
    }
    return s.getTop();
}

完整代码如下：

因为是大一学C++，所以栈是老师要求我们自己写的。

#define _CRT_SECURE_NO_WARNINGS 1
#include <cstddef>
#include <iostream>
#include<iomanip>
#include<string.h>

using namespace std;

class Stack {
private:
    int top;
    double* data;
    int msize;
public:

    Stack(int n);
    ~Stack();
    void push(double e);
    double pop();
    double getTop();
    bool isEmpty();
};

Stack::Stack(int n) {               //构建实例
    msize = n;
    data = new double[msize];
    top = 0;
}

Stack::~Stack() {                   //消除实例
    delete[]data;
}

void Stack::push(double e) {       //push入栈
    if (top >= msize) {
        return;
    }
    data[top++] = e;
}

double Stack::pop() {              //pop获取栈顶元素
    if (isEmpty() == false) {
        return data[top - 1];
    }
}

double Stack::getTop() {          //getTop出栈
    if (isEmpty() == false) {
        return data[--top];
    }
}

bool Stack::isEmpty() {           //判断栈内是否为空
    if (top == 0) {
        return true;
    }
    else {
        return false;
    }
}

int len;
double num1[100] = { 0 };
int len1 = 0;

void change(double a[], int n) {     //中缀换前缀
    Stack idx(n);                     //放数据的栈
    Stack symbol(n);                  //放符号的栈
    for (int i = n - 1; i >= 0; i--) {
        if (a[i] < 0) {                 //小于0说明遇到了符号
            int flag = 0;
            char temp = a[i] + '0';
            if (temp == '+' || temp == '-') {
                flag = 1;
                while (flag == 1) {
                    if ((symbol.pop() + '0') == '*' || (symbol.pop() + '0') == '/') {  //比较符号优先级
                        idx.push(symbol.getTop());
                    }
                    else {
                        flag = 0;
                        symbol.push(a[i]);
                    }
                }
            }
            else if (temp == '(') {
                while (symbol.pop() != (')' - '0')) {        //当遇到右括号时，将symbol栈里面的元素放到idx栈
                    idx.push(symbol.getTop());               //此步骤一直持续到遇到symbol栈内的下一个左括号为止
                }                                            //或者持续到栈内空
                symbol.getTop();                             //将左括号出栈
            }
            else {
                symbol.push(a[i]);                           //入栈
            }
        }
        else {
            idx.push(a[i]);
        }
    }
    while (symbol.isEmpty() == false) {
        idx.push(symbol.getTop());
    }
    while (idx.isEmpty() == false) {
        num1[len1] = idx.getTop();
        len1++;
    }
}

double calculate(double a[], int n) {                   //波兰表达式计算，n为数据和符号的个数
    Stack s(n);
    for (int i = n - 1; i >= 0; i--) {
        if (a[i] < 0) {
            char flag = a[i] + '0';
            double b = s.getTop();
            double c = s.getTop();
            double m = 0;
            if (flag == '+') {
                m = b + c;
            }
            else if (flag == '-') {
                m = b - c;
            }
            else if (flag == '*') {
                m = b * c;
            }

            else if (flag == '/') {
                m = b / c;
            }
            s.push(m);
        }
        else {
            s.push(a[i]);
        }
    }
    return s.getTop();
}

int main()
{
    char b;
    char c[20] = { '\0' };
    double num[100] = { 0 };
    int k = 0, len = 0;
    int flag;
    cout << "请输入要计算的中缀表达式(四则混合运算式):";
    while (true) {     //第一步，将表达式字符串转为double型的数组
        scanf("%c", &b);
        if (b == '\n') {
            if (flag == 1) {
                num[len++] = atof(c);
            }
            break;
        }
        if (b >= '0' && b <= '9' || b == '.') {
            c[k++] = b;
            flag = 1;
        }
        else if (b < '0' && flag == 1) {
            num[len++] = atof(c);
            flag = 0;
            for (int i = 0; i < k; i++) {         //清空字符串c
                c[i] = 0;
            }
            k = 0;
        }
        if (b < '0' && flag == 0) {
            num[len++] = b - '0';
        }
    }
    cout << "将中缀表达式转为double数组，便于储存、计算:";
    for (int i = 0;i < len;i++) {
        cout << num[i] << ' ';
    }
    cout << endl;
    change(num, len);       //第二步，中缀表达式转为前缀表达式
    cout << "将中缀表达式转为前缀表达式:";
    for (int i = 0;i < len1;i++) {
        cout << num1[i] << ' ';
    }
    cout << endl;
    cout << "计算结果为:";
    cout << calculate(num1, len1) << endl;  //第三步，计算前缀表达式
    return 0;
}

这是代码运行的结果，正数，小数都可以运算。

在此分享出自己的学习经历，希望大家能指出上文代码的不足，也希望可以帮助到后面学习的人。