c++计算器

最新推荐文章于 2023-11-18 10:27:31 发布
置顶 最新推荐文章于 2023-11-18 10:27:31 发布
阅读量4k 收藏 48
点赞数 15
CC 4.0 BY-SA版权
分类专栏： c/c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_40745534/article/details/80528530

第一个版本：在另一个博客中看到的，那个不是封装在类里边的

#include <iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<stack>
#include<sstream>
using namespace std;
bool isnumber(char c)
{
    if(c>='0'&&c<='9')
    {
        return true;
    }
    else
    {
        return false;
    }
}
class Calculate
{
public:
    int calculate(string s);
private:
    stack<int>number;
    stack<char>operate;
    int priority(char c)
    {
        if(c=='*'||c=='/')
            return 1;
        if(c=='+'||c=='-')
            return 0;
        if(c=='('||c==')')
            return -1;
        if(c=='#')
            return -2;
    }
};
int Calculate::calculate(string s)
{
    stack<int> number;
    stack<char> operate;
    char top;
    int a, b;

    for (unsigned int i = 0; i < s.size(); ++i) {
        if (isnumber(s[i])) {
            int Temp = 0;
            string temp;

            temp += s[i];
            while (isnumber(s[++i]))
                temp += s[i];
            for (unsigned int j = 0; j < temp.size(); ++j) {
                Temp = Temp * 10 + temp[j] - 48;
            }
            number.push(Temp);
            temp.clear();
        }//将字符数字转换成整形数字
        if (!isnumber(s[i])) {
            if (operate.empty()) {
                operate.push(s[i]);
            }//入栈第一个符号'#'
            else {
                top=operate.top();

                if (priority(s[i])>priority(top) || s[i] == '(') {
                    operate.push(s[i]);
                }//入栈高优先级的运算符
                else {
                    while (priority(s[i]) <= priority(top)) {
                        if (top == '#'&&s[i] == '#') {
                            int answer;

                            operate.pop();
                            answer=number.top();
                            cout << "\n答案是：" << answer << endl;
                            number.pop();
                            return 0;
                        }//当运算符实现完全后，只剩下'#'
                        else if (top == '('&&s[i] == ')') {
                            ++i;
                        }//当左右括号相遇时，跳过右括号，删除左括号
                        else {
                            a=number.top();
                            number.pop();
                            b=number.top();
                            number.pop();
                        }
                        if (top == '+') {
                            b += a;
                            number.push(b);
                        }
                        else if (top == '-') {
                            b -= a;
                            number.push(b);
                        }
                        else if (top == '*') {
                            b *= a;
                            number.push(b);
                        }
                        else if (top == '/') {
                            b /= a;
                            number.push(b);
                        }
                        operate.pop();
                        top=operate.top();//取前一个运算符，用于与现在扫描的运算符进行比较
                    }//将优先级高的运算符实现计算
                    operate.push(s[i]);//用于当top=='#'时，将最后一个运算符入栈
                }
            }
        }//扫描运算符，并判断优先级，以及运算
    }//主循环
}
int main()
{
    Calculate c;
    char line[81];
    int result;
    cin.getline(line,80);
    string s(line);
    c.calculate(s);

}

第二个版本：老师写的

#include <iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<stack>
#include<sstream>
using namespace std;
class calculator
{
public:
    int calculate(string expression);
private:
    stack<int>opdstack;
    stack<char>optstack;
    int priority(char opt)
    {
        switch(opt)
        {
            case '+':
            case '-':
                return 1;
            case '*':
            case '/':
                return 2;
        }
    }
    int cal(int opd1,int opd2,char opt)
    {
        switch(opt)
        {
            case '+':
                return opd1+opd2;
            case '-':
                return opd1-opd2;
            case '*':
                return opd1*opd2;
            case '/':
                return opd1/opd2;
        }

    }
};
int calculator::calculate(string expression)
{
    istringstream strin(expression);
    char opt,cur_opt;
    int opd,opd1,opd2,result;
    strin>>opd;
    opdstack.push(opd);
    while(strin>>cur_opt)
    {
        if(optstack.empty())
            optstack.push(cur_opt);
        else
        {
            if(priority(cur_opt)>priority(optstack.top()))
                optstack.push(cur_opt);
            else
            {
                while(!optstack.empty()&&priority(cur_opt)<=priority(optstack.top()))
                {
                    opd2=opdstack.top();
                    opdstack.pop();
                    opd1=opdstack.top();
                    opdstack.pop();
                    opt=optstack.top();
                    optstack.pop();
                    result=cal(opd1,opd2,opt);
                    opdstack.push(result);
                }
                optstack.push(cur_opt);
            }
        }
        strin>>opd;
        opdstack.push(opd);
    }
    while(!optstack.empty())
    {
        opd2=opdstack.top();
        opdstack.pop();
        opd1=opdstack.top();
        opdstack.pop();
        opt=optstack.top();
        optstack.pop();
        result=cal(opd1,opd2,opt);
        opdstack.push(result);
    }
    result=opdstack.top();
    opdstack.pop();
    return result;
}
int main()
{
    calculator cal;
    char line[81];
    int result;
    cin.getline(line,80);
    while(line[0]!='#')
    {
        string expression(line);
        result=cal.calculate(expression);
        cout<<"="<<result<<endl;
        cin.getline(line,80);
    }
}

第三版本：更改第二版本，实现实数计算

#include <iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<stack>
#include<sstream>
using namespace std;
class calculator
{
public:
    double calculate(string expression);
private:
    stack<double>opdstack;
    stack<char>optstack;
    int priority(char opt)
    {
        switch(opt)
        {
            case '+':
            case '-':
                return 1;
            case '*':
            case '/':
                return 2;
        }
    }
    double cal(double opd1,double opd2,char opt)
    {
        switch(opt)
        {
            case '+':
                return opd1+opd2;
            case '-':
                return opd1-opd2;
            case '*':
                return opd1*opd2;
            case '/':
                return opd1/opd2;
        }

    }
};
double calculator::calculate(string expression)
{
    istringstream strin(expression);
    char opt,cur_opt;
    double opd,opd1,opd2,result;
    strin>>opd;
    opdstack.push(opd);
    while(strin>>cur_opt)
    {
        if(optstack.empty())
            optstack.push(cur_opt);
        else
        {
            if(priority(cur_opt)>priority(optstack.top()))
                optstack.push(cur_opt);
            else
            {
                while(!optstack.empty()&&priority(cur_opt)<=priority(optstack.top()))
                {
                    opd2=opdstack.top();
                    opdstack.pop();
                    opd1=opdstack.top();
                    opdstack.pop();
                    opt=optstack.top();
                    optstack.pop();
                    result=cal(opd1,opd2,opt);
                    opdstack.push(result);
                }
                optstack.push(cur_opt);
            }
        }
        strin>>opd;
        opdstack.push(opd);
    }
    while(!optstack.empty())
    {
        opd2=opdstack.top();
        opdstack.pop();
        opd1=opdstack.top();
        opdstack.pop();
        opt=optstack.top();
        optstack.pop();
        result=cal(opd1,opd2,opt);
        opdstack.push(result);
    }
    result=opdstack.top();
    opdstack.pop();
    return result;
}
int main()
{
    calculator cal;
    char line[81];
    double result;
    cin.getline(line,80);
    while(line[0]!='#')
    {
        string expression(line);
        result=cal.calculate(expression);
        cout<<"="<<result<<endl;
        cin.getline(line,80);
    }
}

第四个版本：可实现实数计算，带括号

#include <iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<stack>
#include<sstream>
using namespace std;
bool isnumber(char c)
{
    if(c>='0'&&c<='9'||c=='.')
    {
        return true;
    }
    else
    {
        return false;
    }
}
class Calculate
{
public:
    int calculate(string s);
private:
    stack<int>number;
    stack<char>operate;
    int priority(char c)
    {
        if(c=='*'||c=='/')
            return 1;
        if(c=='+'||c=='-')
            return 0;
        if(c=='('||c==')')
            return -1;
        if(c=='#')
            return -2;
    }
};
int Calculate::calculate(string s)
{
    stack<double> number;
    stack<char> operate;
    char top;
    double a, b;

    for (unsigned int i = 0; i < s.size(); ++i) {
        if (isnumber(s[i])) {
            double Temp = 0,Temp2 = 0;
            string temp="";
            int count=0,flag=0;
            temp += s[i];
            while (isnumber(s[++i]))
                temp += s[i];
            for (unsigned int j = 0; j < temp.size(); ++j) {
                if(flag==0)
                {
                    if(temp[j]!='.')
                    {
                        Temp = Temp * 10 + temp[j] - 48;
                    }
                }
                if(temp[j]=='.')
                {
                    j++;
                    flag=1;
                }
                if(flag)
                {
                    Temp2 = Temp2 * 10 + temp[j] - 48;
                    count++;
                }
            }
            while(count--)
                Temp2 = Temp2 * 0.1;
            Temp=Temp+Temp2;
            number.push(Temp);
            temp.clear();
        }//将字符数字转换成整形数字
        if (!isnumber(s[i])) {
            if (operate.empty()) {
                operate.push(s[i]);
            }//入栈第一个符号'#'
            else {
                top=operate.top();

                if (priority(s[i])>priority(top) || s[i] == '(') {
                    operate.push(s[i]);
                }//入栈高优先级的运算符
                else {
                    while (priority(s[i]) <= priority(top)) {
                        if (top == '#'&&s[i] == '#') {
                            double answer;

                            operate.pop();
                            answer=number.top();
                            cout << "\n答案是：" << answer << endl;
                            number.pop();
                            return 0;
                        }//当运算符实现完全后，只剩下'#'
                        else if (top == '('&&s[i] == ')') {
                            ++i;
                        }//当左右括号相遇时，跳过右括号，删除左括号
                        else {
                            a=number.top();
                            number.pop();
                            b=number.top();
                            number.pop();
                        }
                        if (top == '+') {
                            b += a;
                            number.push(b);
                        }
                        else if (top == '-') {
                            b -= a;
                            number.push(b);
                        }
                        else if (top == '*') {
                            b *= a;
                            number.push(b);
                        }
                        else if (top == '/') {
                            b /= a;
                            number.push(b);
                        }
                        operate.pop();
                        top=operate.top();//取前一个运算符，用于与现在扫描的运算符进行比较
                    }//将优先级高的运算符实现计算
                    operate.push(s[i]);//用于当top=='#'时，将最后一个运算符入栈
                }
            }
        }//扫描运算符，并判断优先级，以及运算
    }//主循环
}
int main()
{
    Calculate c;
    char line[81];
    double result;
    cin.getline(line,80);
    string s(line);
    c.calculate(s);

}

第五个版本：可实现实数计算，带括号，可实现循环输入

#include <iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<stack>
#include<sstream>
using namespace std;
bool isnumber(char c)
{
    if(c>='0'&&c<='9'||c=='.')
    {
        return true;
    }
    else
    {
        return false;
    }
}
class Calculate
{
public:
    int calculate(string s);
private:
    stack<int>number;
    stack<char>operate;
    int priority(char c)
    {
        if(c=='*'||c=='/')
            return 1;
        if(c=='+'||c=='-')
            return 0;
        if(c=='('||c==')')
            return -1;
        if(c=='#')
            return -2;
    }
};
int Calculate::calculate(string s)
{
    stack<double> number;
    stack<char> operate;
    char top;
    double a, b;

    for (unsigned int i = 0; i < s.size(); ++i) {
        if (isnumber(s[i])) {
            double Temp = 0,Temp2 = 0;
            string temp="";
            int count=0,flag=0;
            temp += s[i];
            while (isnumber(s[++i]))
                temp += s[i];
            for (unsigned int j = 0; j < temp.size(); ++j) {
                if(flag==0)
                {
                    if(temp[j]!='.')
                    {
                        Temp = Temp * 10 + temp[j] - 48;
                    }
                }
                if(temp[j]=='.')
                {
                    j++;
                    flag=1;
                }
                if(flag)
                {
                    Temp2 = Temp2 * 10 + temp[j] - 48;
                    count++;
                }
            }
            while(count--)
                Temp2 = Temp2 * 0.1;
            Temp=Temp+Temp2;
            number.push(Temp);
            temp.clear();
        }//将字符数字转换成整形数字
        if (!isnumber(s[i])) {
            if (operate.empty()) {
                operate.push(s[i]);
            }//入栈第一个符号'#'
            else {
                top=operate.top();

                if (priority(s[i])>priority(top) || s[i] == '(') {
                    operate.push(s[i]);
                }//入栈高优先级的运算符
                else {
                    while (priority(s[i]) <= priority(top)) {
                        if (top == '#'&&s[i] == '#') {
                            double answer;

                            operate.pop();
                            answer=number.top();
                            cout << "\n答案是：" << answer << endl;
                            number.pop();
                            return 0;
                        }//当运算符实现完全后，只剩下'#'
                        else if (top == '('&&s[i] == ')') {
                            ++i;
                        }//当左右括号相遇时，跳过右括号，删除左括号
                        else {
                            a=number.top();
                            number.pop();
                            b=number.top();
                            number.pop();
                        }
                        if (top == '+') {
                            b += a;
                            number.push(b);
                        }
                        else if (top == '-') {
                            b -= a;
                            number.push(b);
                        }
                        else if (top == '*') {
                            b *= a;
                            number.push(b);
                        }
                        else if (top == '/') {
                            b /= a;
                            number.push(b);
                        }
                        operate.pop();
                        top=operate.top();//取前一个运算符，用于与现在扫描的运算符进行比较
                    }//将优先级高的运算符实现计算
                    operate.push(s[i]);//用于当top=='#'时，将最后一个运算符入栈
                }
            }
        }//扫描运算符，并判断优先级，以及运算
    }//主循环
}
int main()
{
    Calculate c;
    char line[81];
    double result;
    int i,f=0;
    cout<<"请输入开头和结尾为'#'的表达式"<<endl;
    cin.getline(line,80);
    while(f!=2)
    {
        string s(line);
        for(i=0;i<80;i++)
        {
            if(s[i]=='#')
            {
                f++;
            }
        }
        c.calculate(s);
        cin.getline(line,80);
        f=0;
    }

}

第五个版本：带乘方的

#include <iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<stack>
#include<sstream>
using namespace std;
bool isnumber(char c)
{
    if(c>='0'&&c<='9'||c=='.')
    {
        return true;
    }
    else
    {
        return false;
    }
}
class Calculate
{
public:
    int calculate(string s);
private:
    stack<int>number;
    stack<char>operate;
    int priority(char c)
    {
        if(c=='^')
            return 2;
        if(c=='*'||c=='/')
            return 1;
        if(c=='+'||c=='-')
            return 0;
        if(c=='('||c==')')
            return -1;
        if(c=='#')
            return -2;
    }
};
int Calculate::calculate(string s)
{
    stack<double> number;
    stack<char> operate;
    char top;
    double a, b;

    for (unsigned int i = 0; i < s.size(); ++i) {
        if (isnumber(s[i])) {
            double Temp = 0,Temp2 = 0;
            string temp="";
            int count=0,flag=0;
            temp += s[i];
            while (isnumber(s[++i]))
                temp += s[i];
            for (unsigned int j = 0; j < temp.size(); ++j) {
                if(flag==0)
                {
                    if(temp[j]!='.')
                    {
                        Temp = Temp * 10 + temp[j] - 48;
                    }
                }
                if(temp[j]=='.')
                {
                    j++;
                    flag=1;
                }
                if(flag)
                {
                    Temp2 = Temp2 * 10 + temp[j] - 48;
                    count++;
                }
            }
            while(count--)
                Temp2 = Temp2 * 0.1;
            Temp=Temp+Temp2;
            number.push(Temp);
            temp.clear();
        }//将字符数字转换成整形数字
        if (!isnumber(s[i])) {
            if (operate.empty()) {
                operate.push(s[i]);
            }//入栈第一个符号'#'
            else {
                top=operate.top();

                if (priority(s[i])>priority(top) || s[i] == '(') {
                    operate.push(s[i]);
                }//入栈高优先级的运算符
                else {
                    while (priority(s[i]) <= priority(top)) {
                        if (top == '#'&&s[i] == '#') {
                            double answer;

                            operate.pop();
                            answer=number.top();
                            cout << "\n答案是：" << answer << endl;
                            number.pop();
                            return 0;
                        }//当运算符实现完全后，只剩下'#'
                        else if (top == '('&&s[i] == ')') {
                            ++i;
                        }//当左右括号相遇时，跳过右括号，删除左括号
                        else {
                            a=number.top();
                            number.pop();
                            b=number.top();
                            number.pop();
                        }
                        if (top == '+') {
                            b += a;
                            number.push(b);
                        }
                        else if (top == '-') {
                            b -= a;
                            number.push(b);
                        }
                        else if (top == '*') {
                            b *= a;
                            number.push(b);
                        }
                        else if (top == '/') {
                            b /= a;
                            number.push(b);
                        }
                        else if (top == '^') {
                            b =pow(b,a);
                            number.push(b);
                        }
                        operate.pop();
                        top=operate.top();//取前一个运算符，用于与现在扫描的运算符进行比较
                    }//将优先级高的运算符实现计算
                    operate.push(s[i]);//用于当top=='#'时，将最后一个运算符入栈
                }
            }
        }//扫描运算符，并判断优先级，以及运算
    }//主循环
}
int main()
{
    Calculate c;
    char line[81];
    double result;
    int i,f=0;
    cout<<"请输入开头和结尾为'#'的表达式"<<endl;
    cin.getline(line,80);
    while(f!=2)
    {
        string s(line);
        for(i=0;i<80;i++)
        {
            if(s[i]=='#')
            {
                f++;
            }
        }
        c.calculate(s);
        cin.getline(line,80);
        f=0;
    }

}

第六个版本：加了异常分析

#include <iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<stack>
#include<sstream>
using namespace std;
class Exception
{
public:
    Exception()
    {
        msg="Exception!";
    }
    virtual string Msg()
    {
        return msg;
    }
protected:
    string msg;
};
class OperatorInvalidException:public Exception
{
public:
    OperatorInvalidException()
    {
        msg="Operator invalid exception!";
    }
};
class DivisorIsZero:public Exception
{
public:
    DivisorIsZero()
    {
        msg="Divisor is zero!";
    }
};
bool isnumber(char c)
{
    if(c>='0'&&c<='9'||c=='.')
    {
        return true;
    }
    else
    {
        return false;
    }
}
class Calculate
{
public:
    int calculate(string s);
private:
    stack<int>number;
    stack<char>operate;
    int priority(char c)
    {
        if(c=='^')
            return 2;
        if(c=='*'||c=='/')
            return 1;
        if(c=='+'||c=='-')
            return 0;
        if(c=='('||c==')')
            return -1;
        if(c=='#')
            return -2;
        if(c!='^'&&c!='*'&&c!='/'&&c!='+'&&c!='-'&&c!='('&&c!=')'&&c!='#')
            throw OperatorInvalidException();
    }
};
int Calculate::calculate(string s)
{
    try
    {
    stack<double> number;
    stack<char> operate;
    char top;
    double a, b;

    for (unsigned int i = 0; i < s.size(); ++i) {
        if (isnumber(s[i])) {
            double Temp = 0,Temp2 = 0;
            string temp="";
            int count=0,flag=0;
            temp += s[i];
            while (isnumber(s[++i]))
                temp += s[i];
            for (unsigned int j = 0; j < temp.size(); ++j) {
                if(flag==0)
                {
                    if(temp[j]!='.')
                    {
                        Temp = Temp * 10 + temp[j] - 48;
                    }
                }
                if(temp[j]=='.')
                {
                    j++;
                    flag=1;
                }
                if(flag)
                {
                    Temp2 = Temp2 * 10 + temp[j] - 48;
                    count++;
                }
            }
            while(count--)
                Temp2 = Temp2 * 0.1;
            Temp=Temp+Temp2;
            number.push(Temp);
            temp.clear();
        }//将字符数字转换成整形数字
        if (!isnumber(s[i])) {
            if (operate.empty()) {
                operate.push(s[i]);
            }//入栈第一个符号'#'
            else {
                top=operate.top();

                if (priority(s[i])>priority(top) || s[i] == '(') {
                    operate.push(s[i]);
                }//入栈高优先级的运算符
                else {
                    while (priority(s[i]) <= priority(top)) {
                        if (top == '#'&&s[i] == '#') {
                            double answer;

                            operate.pop();
                            answer=number.top();
                            cout << "\n答案是：" << answer << endl;
                            number.pop();
                            return 0;
                        }//当运算符实现完全后，只剩下'#'
                        else if (top == '('&&s[i] == ')') {
                            ++i;
                        }//当左右括号相遇时，跳过右括号，删除左括号
                        else {
                            a=number.top();
                            number.pop();
                            b=number.top();
                            number.pop();
                        }
                        if (top == '+') {
                            b += a;
                            number.push(b);
                        }
                        else if (top == '-') {
                            b -= a;
                            number.push(b);
                        }
                        else if (top == '*') {
                            b *= a;
                            number.push(b);
                        }
                        else if (top == '/') {
                            if(a==0)
                            {
                                throw DivisorIsZero();
                            }
                            b /= a;
                            number.push(b);
                        }
                        else if (top == '^') {
                            b =pow(b,a);
                            number.push(b);
                        }
                        operate.pop();
                        top=operate.top();//取前一个运算符，用于与现在扫描的运算符进行比较
                    }//将优先级高的运算符实现计算
                    operate.push(s[i]);//用于当top=='#'时，将最后一个运算符入栈
                }
            }
        }//扫描运算符，并判断优先级，以及运算

    }//主循环
    }
    catch(OperatorInvalidException e)
    {
        cout<<e.Msg()<<endl;
        exit(0);
    }
    catch(DivisorIsZero e)
    {
        cout<<e.Msg()<<endl;
        exit(0);
    }
}
int main()
{
    Calculate c;
    char line[81];
    double result;
    int i,f=0;
    cout<<"请输入开头和结尾为'#'的表达式"<<endl;
    cin.getline(line,80);
    while(f!=2)
    {
        string s(line);
        for(i=0;i<80;i++)
        {
            if(s[i]=='#')
            {
                f++;
            }
        }
        c.calculate(s);
        cin.getline(line,80);
        f=0;
    }

}

第七个版本：去了空格

#include <iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<stack>
#include<sstream>
using namespace std;
class Exception
{
public:
    Exception()
    {
        msg="Exception!";
    }
    virtual string Msg()
    {
        return msg;
    }
protected:
    string msg;
};
class OperatorInvalidException:public Exception
{
public:
    OperatorInvalidException()
    {
        msg="Operator invalid exception!";
    }
};
class DivisorIsZero:public Exception
{
public:
    DivisorIsZero()
    {
        msg="Divisor is zero!";
    }
};
bool isnumber(char c)
{
    if(c>='0'&&c<='9'||c=='.')
    {
        return true;
    }
    else
    {
        return false;
    }
}
string delspace(char str[80])
{
    int i=0,j=0;
    for(i=0;i<strlen(str);i++)
    {
        if(str[i]!=' ')
        {
            str[j++]=str[i];
        }
    }
    str[j]='\0';
}
class Calculate
{
public:
    int calculate(string s);
private:
    stack<int>number;
    stack<char>operate;
    int priority(char c)
    {
        if(c=='^')
            return 2;
        if(c=='*'||c=='/')
            return 1;
        if(c=='+'||c=='-')
            return 0;
        if(c=='('||c==')')
            return -1;
        if(c=='#')
            return -2;
        if(c!='^'&&c!='*'&&c!='/'&&c!='+'&&c!='-'&&c!='('&&c!=')'&&c!='#')
            throw OperatorInvalidException();
    }
};
int Calculate::calculate(string s)
{
    try
    {
    stack<double> number;
    stack<char> operate;
    char top;
    double a, b;

    for (unsigned int i = 0; i < s.size(); ++i) {
        if (isnumber(s[i])) {
            double Temp = 0,Temp2 = 0;
            string temp="";
            int count=0,flag=0;
            temp += s[i];
            while (isnumber(s[++i]))
                temp += s[i];
            for (unsigned int j = 0; j < temp.size(); ++j) {
                if(flag==0)
                {
                    if(temp[j]!='.')
                    {
                        Temp = Temp * 10 + temp[j] - 48;
                    }
                }
                if(temp[j]=='.')
                {
                    j++;
                    flag=1;
                }
                if(flag)
                {
                    Temp2 = Temp2 * 10 + temp[j] - 48;
                    count++;
                }
            }
            while(count--)
                Temp2 = Temp2 * 0.1;
            Temp=Temp+Temp2;
            number.push(Temp);
            temp.clear();
        }//将字符数字转换成整形数字
        if (!isnumber(s[i])) {
            if (operate.empty()) {
                operate.push(s[i]);
            }//入栈第一个符号'#'
            else {
                top=operate.top();

                if (priority(s[i])>priority(top) || s[i] == '(') {
                    operate.push(s[i]);
                }//入栈高优先级的运算符
                else {
                    while (priority(s[i]) <= priority(top)) {
                        if (top == '#'&&s[i] == '#') {
                            double answer;

                            operate.pop();
                            answer=number.top();
                            cout << "\n答案是：" << answer << endl;
                            number.pop();
                            return 0;
                        }//当运算符实现完全后，只剩下'#'
                        else if (top == '('&&s[i] == ')') {
                            ++i;
                        }//当左右括号相遇时，跳过右括号，删除左括号
                        else {
                            a=number.top();
                            number.pop();
                            b=number.top();
                            number.pop();
                        }
                        if (top == '+') {
                            b += a;
                            number.push(b);
                        }
                        else if (top == '-') {
                            b -= a;
                            number.push(b);
                        }
                        else if (top == '*') {
                            b *= a;
                            number.push(b);
                        }
                        else if (top == '/') {
                            if(a==0)
                            {
                                throw DivisorIsZero();
                            }
                            b /= a;
                            number.push(b);
                        }
                        else if (top == '^') {
                            b =pow(b,a);
                            number.push(b);
                        }
                        operate.pop();
                        top=operate.top();//取前一个运算符，用于与现在扫描的运算符进行比较
                    }//将优先级高的运算符实现计算
                    operate.push(s[i]);//用于当top=='#'时，将最后一个运算符入栈
                }
            }
        }//扫描运算符，并判断优先级，以及运算

    }//主循环
    }
    catch(OperatorInvalidException e)
    {
        cout<<e.Msg()<<endl;
        exit(0);
    }
    catch(DivisorIsZero e)
    {
        cout<<e.Msg()<<endl;
        exit(0);
    }
}
int main()
{
    Calculate c;
    char line[81];
    double result;
    int i,f=0;
    cout<<"请输入开头和结尾为'#'的表达式"<<endl;
    cin.getline(line,80);
    while(f!=2)
    {
        delspace(line);
        string s(line);
        //s=delspace(s);
        for(i=0;i<80;i++)
        {
            if(s[i]=='#')
            {
                f++;
            }
        }
        c.calculate(s);
        cin.getline(line,80);
        f=0;
    }

}

第八个版本：后缀表达式

#include <iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<stack>
#include<sstream>
#include<vector>
using namespace std;
vector<char> Tmp;

class Exception
{
public:
    Exception()
    {
        msg="Exception!";
    }
    virtual string Msg()
    {
        return msg;
    }
protected:
    string msg;
};
class OperatorInvalidException:public Exception
{
public:
    OperatorInvalidException()
    {
        msg="Operator invalid exception!";
    }
};
class DivisorIsZero:public Exception
{
public:
    DivisorIsZero()
    {
        msg="Divisor is zero!";
    }
};
bool isnumber(char c)
{
    if(c>='0'&&c<='9'||c=='.')
    {
        return true;
    }
    else
    {
        return false;
    }
}
string delspace(char str[80])
{
    int i=0,j=0;
    for(i=0;i<strlen(str);i++)
    {
        if(str[i]!=' ')
        {
            str[j++]=str[i];
        }
    }
    str[j]='\0';
}
class Calculate
{
public:
    double calculate(string s);
private:
    stack<int>number;
    stack<char>operate;
    int priority(char c)
    {
        if(c=='^')
            return 2;
        if(c=='*'||c=='/')
            return 1;
        if(c=='+'||c=='-')
            return 0;
        if(c=='('||c==')')
            return -1;
        if(c!='^'&&c!='*'&&c!='/'&&c!='+'&&c!='-'&&c!='('&&c!=')')
            throw OperatorInvalidException();
    }
};
double Calculate::calculate(string s)
{
    try
    {
        string houzhui="";
        stack<double> number;
        stack<char> operate;
        char top;
        double a, b;
        int len,k=0;
        double answer;
        for (unsigned int i = 0; i < s.size(); ++i)
        {
            if (isnumber(s[i]))
            {
                houzhui+=s[i];
            }
            if (!isnumber(s[i]))
            {
                houzhui+=' ';
                if (operate.empty())
                {
                    operate.push(s[i]);
                }
                else
                {
                    top=operate.top();
                    if (priority(s[i])>priority(top) || s[i] == '(')
                    {
                        operate.push(s[i]);
                    }//入栈高优先级的运算符
                    else
                    {
                        if(s[i]==')')
                        {
                            while(operate.top()!='(')
                            {
                                top=operate.top();
                                houzhui+=top;
                                operate.pop();
                            }
                            operate.pop();
                        }
                        else
                        {
                            while (priority(s[i]) <= priority(top)&&s[i]!='(')
                            {
                                houzhui+=operate.top();
                                operate.pop();
                                if(operate.empty())
                                    break;
                                top=operate.top();
                            }
                            operate.push(s[i]);
                        }
                    }
                }
            }

        }
        while(!operate.empty())
        {
            houzhui+=operate.top();
            operate.pop();
        }
        //return houzhui;
        for (unsigned int i = 0; i < houzhui.size(); ++i)
        {
            if (isnumber(houzhui[i]))
            {
                double Temp = 0,Temp2 = 0;
                string temp="";
                int count=0,flag=0;
                while (isnumber(houzhui[i]))
                {
                    temp += houzhui[i];
                    i++;
                }
                i--;
                //cout<<temp<<endl;
                for (unsigned int j = 0; j < temp.size(); ++j)
                {
                    if(flag==0)
                    {
                        if(temp[j]!='.')
                        {
                            Temp = Temp * 10 + temp[j] - 48;
                        }
                    }
                    if(temp[j]=='.')
                    {
                        j++;
                        flag=1;
                    }
                    if(flag)
                    {
                        Temp2 = Temp2 * 10 + temp[j] - 48;
                        count++;
                    }
                }
                while(count--)
                    Temp2 = Temp2 * 0.1;
                Temp=Temp+Temp2;
                number.push(Temp);
                temp.clear();
            }
            else if(houzhui[i]==' ')
               continue;
            else if (houzhui[i] == '+')
            {
                a=number.top();
                number.pop();
                b=number.top();
                number.pop();
                b += a;
                number.push(b);
            }
            else if (houzhui[i] == '-')
            {
                a=number.top();
                number.pop();
                b=number.top();
                number.pop();
                b -= a;
                number.push(b);
            }
            else if (houzhui[i] == '*')
            {
                a=number.top();
                number.pop();
                b=number.top();
                number.pop();
                b *= a;
                number.push(b);
            }
            else if (houzhui[i] == '/')
            {
                a=number.top();
                number.pop();
                b=number.top();
                number.pop();
                if(a==0)
                {
                    throw DivisorIsZero();
                }
                b /= a;
                number.push(b);
            }
            else if (houzhui[i] == '^')
            {
                a=number.top();
                number.pop();
                b=number.top();
                number.pop();
                b =pow(b,a);
                number.push(b);
            }

        }
        answer=number.top();
        return answer;
        }
        catch(OperatorInvalidException e)
        {
            cout<<e.Msg()<<endl;
            exit(0);
        }
        catch(DivisorIsZero e)
        {
            cout<<e.Msg()<<endl;
            exit(0);
        }
}
int main()
{
    Calculate c;
    double ans;
    char line[81];
    double result;
    int i,f=0;
    cout<<"/*....................计算器....................*/"<<endl;
    while(cin.getline(line,80))
    {
        delspace(line);
        string s(line);
        ans=c.calculate(s);
        cout<<ans<<endl;
    }
}
/*


1.2*2+(2-1)



*/

第九个版本：可以实现负号和减号的区分

#include <iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<stack>
#include<sstream>
#include<vector>
using namespace std;
vector<char> Tmp;

class Exception
{
public:
    Exception()
    {
        msg="Exception!";
    }
    virtual string Msg()
    {
        return msg;
    }
protected:
    string msg;
};
class OperatorInvalidException:public Exception
{
public:
    OperatorInvalidException()
    {
        msg="Operator invalid exception!";
    }
};
class DivisorIsZero:public Exception
{
public:
    DivisorIsZero()
    {
        msg="Divisor is zero!";
    }
};
bool isnumber(char c)
{
    if(c>='0'&&c<='9'||c=='.')
    {
        return true;
    }
    else
    {
        return false;
    }
}
string zero(char *str)
{
    char str2[80];
    int i=0,j=0;
    int len = strlen(str);
    for(i=0; i < len;i++)
    {
        if((i==0&&str[i]=='-')||(str[i-1]=='('&&str[i]=='-'))
        {
            str2[j++]='0';
        }
        str2[j++]=str[i];
    }
    str2[j]='\0';
    //str=str2;
    //return str;
    for(int i = 0, len = strlen(str2); i <= len; ++i) str[i] = str2[i];
    //printf("%s %s\n", str, str2);
}
string delspace(char str[80])
{
    int i=0,j=0;
    for(i=0;i<strlen(str);i++)
    {
        if(str[i]!=' ')
        {
            str[j++]=str[i];
        }
    }
    str[j]='\0';
}
class Calculate
{
public:
    double calculate(string s);
private:
    stack<int>number;
    stack<char>operate;
    int priority(char c)
    {
        if(c=='^')
            return 2;
        if(c=='*'||c=='/')
            return 1;
        if(c=='+'||c=='-')
            return 0;
        if(c=='('||c==')')
            return -1;
        if(c!='^'&&c!='*'&&c!='/'&&c!='+'&&c!='-'&&c!='('&&c!=')')
            throw OperatorInvalidException();
    }
};
double Calculate::calculate(string s)
{
    try
    {
        string houzhui="";
        stack<double> number;
        stack<char> operate;
        char top;
        double a, b;
        int len,k=0;
        double answer;
        for (unsigned int i = 0; i < s.size(); ++i)
        {
            if (isnumber(s[i]))
            {
                houzhui+=s[i];
            }
            if (!isnumber(s[i]))
            {
                houzhui+=' ';
                if (operate.empty())
                {
                    operate.push(s[i]);
                }
                else
                {
                    top=operate.top();
                    if (priority(s[i])>priority(top) || s[i] == '(')
                    {
                        operate.push(s[i]);
                    }//入栈高优先级的运算符
                    else
                    {
                        if(s[i]==')')
                        {
                            while(operate.top()!='(')
                            {
                                top=operate.top();
                                houzhui+=top;
                                operate.pop();
                            }
                            operate.pop();
                        }
                        else
                        {
                            while (priority(s[i]) <= priority(top)&&s[i]!='(')
                            {
                                houzhui+=operate.top();
                                operate.pop();
                                if(operate.empty())
                                    break;
                                top=operate.top();
                            }
                            operate.push(s[i]);
                        }
                    }
                }
            }

        }
        while(!operate.empty())
        {
            houzhui+=operate.top();
            operate.pop();
        }
        //cout<<houzhui<<endl;
        for (unsigned int i = 0; i < houzhui.size(); ++i)
        {
            if (isnumber(houzhui[i]))
            {
                double Temp = 0,Temp2 = 0;
                string temp="";
                int count=0,flag=0;
                while (isnumber(houzhui[i]))
                {
                    temp += houzhui[i];
                    i++;
                }
                i--;
                //cout<<temp<<endl;
                for (unsigned int j = 0; j < temp.size(); ++j)
                {
                    if(flag==0)
                    {
                        if(temp[j]!='.')
                        {
                            Temp = Temp * 10 + temp[j] - 48;
                        }
                    }
                    if(temp[j]=='.')
                    {
                        j++;
                        flag=1;
                    }
                    if(flag)
                    {
                        Temp2 = Temp2 * 10 + temp[j] - 48;
                        count++;
                    }
                }
                while(count--)
                    Temp2 = Temp2 * 0.1;
                Temp=Temp+Temp2;
                number.push(Temp);
                temp.clear();
            }
            else if(houzhui[i]==' ')
               continue;
            else if (houzhui[i] == '+')
            {
                a=number.top();
                number.pop();
                b=number.top();
                number.pop();
                b += a;
                number.push(b);
            }
            else if (houzhui[i] == '-')
            {
                a=number.top();
                number.pop();
                b=number.top();
                number.pop();
                b -= a;
                number.push(b);
            }
            else if (houzhui[i] == '*')
            {
                a=number.top();
                number.pop();
                b=number.top();
                number.pop();
                b *= a;
                number.push(b);
            }
            else if (houzhui[i] == '/')
            {
                a=number.top();
                number.pop();
                b=number.top();
                number.pop();
                if(a==0)
                {
                    throw DivisorIsZero();
                }
                b /= a;
                number.push(b);
            }
            else if (houzhui[i] == '^')
            {
                a=number.top();
                number.pop();
                b=number.top();
                number.pop();
                b =pow(b,a);
                number.push(b);
            }

        }
        answer=number.top();
        return answer;
        }
        catch(OperatorInvalidException e)
        {
            cout<<e.Msg()<<endl;
            exit(0);
        }
        catch(DivisorIsZero e)
        {
            cout<<e.Msg()<<endl;
            exit(0);
        }
}
int main()
{
    //freopen("in.txt", "r", stdin);
    Calculate c;
    double ans;
    char line[81];
    double result;
    int i,f=0;
    cout<<"/*....................计算器....................*/"<<endl;
    while(cin.getline(line,80))
    {
        delspace(line);
        zero(line);
        string s(line);
        ans=c.calculate(s);
        cout<<ans<<endl;
    }
}
/*


-12.5-(-2*3+4^2)



*/
C++计算器
泽皓博客
12-26 706
#include<bits/stdc++.h> #include <Windows.h> using namespace std; int main(){ int lx,ja,jb,jo,jja,jjb,jjo,a; system("title 泽皓计算器V1.0"); cout<<"请输入要运算的类型："<<endl; Sleep(500); cout<<"1 加法计算"<<endl;Sleep(500); cout.
C++计算器（简易版）
jinyanchen的博客
07-27 7799
计算器（简易版） 描述 试编写一个根据用户输入的两个操作数和一个运算符，由计算机输出运算结果的程序。 当操作数是除号("/")时，运算结果是整除的结果，如10/3=3；并且当除数为0时，输出“Error!”。 操作数都是整数。 输入 输入的第一行是两个操作数由一个空格隔开，第二行是一个运算符。 输出 输出一个数，表示运算的结果。 注意除数为0的情况。比如判断字符a是不是加号，可以用 if(a==’+’)来表示，字符要用单个引号括起来。 #include <iostream> using name
计算器 c++
05-28
c++ 版的计算器，不过有bug，但是不影响使用。主要是想描述栈的运用。可以供初学者学习用。functions头文件里是计算的几个重要函数。
C++实现计算器
03-30
C++实现的计算器，你能想到的功能都能实现，绝对良心。
c++实现计算器
12-22
用c++实现一个简单的“计算器”的设计，最基本的要求是能够实现四则运算。
c++计算器源代码
yuhhggyvy的博客
07-19 856
测试过，可行。
C++计算器实现 ——（完整功能实现、设计分析）
热门推荐
demo_yo的博客
01-07 5万+
基于标准C++的计算器实现。 一、需求实现 1、实现功能： 支持运算符：+, - , *, /, %（百分号）, ^（幂次方）, | |（绝对值），！（阶乘）。其他符号：( ) [ ] { } 支持数据类型：正负数、小数。 2、实现方法 符号优先级处理方法：符号等级制 运算表达式处理方法：后缀表达式法 后缀表达式转换及计算辅助方法：符号栈、数字栈
C++计算器（简单）
最新发布
Ryan_201303的博客
11-18 1233
一开始由于输出中文乱码，所以被迫使用英文。后来在网上查到了解决方法，完美解决，于是又全换成了中文，大家就看中文版吧。代码共251行，用的编译软件是Embarcadero Dev-C++ Version 6.3版本；程序肯定有不完善的地方，如果大家发现了可以提出来，我也会改进的。
c++ 计算器c++ 计算器c++ 计算器c++ 计算器
03-29
c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器
c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器
03-29
c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器
计算器（C++控制台界面）
10-22
C++数据结构实习。使用双栈实现计算器计算功能，除基本运算外，支持幂运算，开方运算和三角函数运算。原创，如有问题请联系我
c++计算器程序
04-03
C++计算器的完整程序，可以直接打开，功能齐全，希望对你有帮助。
c++ 计算器
10-24
在本项目中，我们讨论的是一个使用C++编程语言实现的简单计算器，特别地，它基于Microsoft Foundation Classes (MFC) 框架构建。MFC是微软为Windows应用程序开发提供的一套类库，它封装了Windows API，使得开发者...
c++计算器基本代码.zip
03-18
在本压缩包“c++计算器基本代码.zip”中，包含了一个使用C++语言编写的简单计算器的基本代码。这个计算器能够执行基本的算术运算，如加、减、乘、除。接下来，我们将深入探讨C++编程语言以及如何构建一个基础的...
C++ 计算器.zip
09-21
在这个名为"C++ 计算器.zip"的压缩包中，包含了两个关键的工程文件——"My_Calc_Lib"库文件和"Cacl"测试文件，它们共同构成了一个完整的C++计算器应用。 首先，我们来关注"My_Calc_Lib"，这通常是一个静态或动态库...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值