结对变成项目总结

如下图，为我们做的判卷程序，左侧为出题区，中间为答题去，右侧为结果区

首先点击自动出题按钮，自动生成50道题目，长度随机

然后点击开始测试按钮，即进入如下界面，学生可在题目后方的输入框内答题

全部答完后，点击确认提交按钮，自动判卷

最终结果会显示在右边，例如每道题目的答案和对错数量的信息

之后点击再次测试按钮，可以继续答下10道题，总共有50道题，如果全部答完后，还想继续，可以再次点击自动出题按钮，然后可以继续测试

测试结束后，点击退出测试按钮即可退出程序。

以下为本程序的全部代码

// MFCTest4Dlg.cpp : 实现文件
//

#include "stdafx.h"
#include "MFCTest4.h"
#include "MFCTest4Dlg.h"
#include "afxdialogex.h"
#include "Calculator.h"
#include <string>
#include "Auto_Equation.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

//int EqNum;
MyError temperror;                            //错误缓存
string str_buf[10];                            //算式缓存
int correct;                                //正确题数
int incorrect;                                //错误题数
CString answer[10];                            //结果存在这里
Calculator cal("1+1");                        //创建计算器类
bool last;                                    //是否是最后一组题
ifstream in("equation.txt");                //打开算式所在文件


// CMFCTest4Dlg 对话框



CMFCTest4Dlg::CMFCTest4Dlg(CWnd* pParent /*=NULL*/)
    : CDialogEx(IDD_MFCTEST4_DIALOG, pParent)
{
    m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CMFCTest4Dlg::DoDataExchange(CDataExchange* pDX)
{
    CDialogEx::DoDataExchange(pDX);
    //DDX_Control(pDX, IDC_EQUALITY, Equality);
    DDX_Control(pDX, IDC_EQUALITY1, Equality1);
    DDX_Control(pDX, IDC_EQUALITY2, Equality2);
    DDX_Control(pDX, IDC_EQUALITY3, Equality3);
    DDX_Control(pDX, IDC_EQUALITY4, Equality4);
    DDX_Control(pDX, IDC_EQUALITY5, Equality5);
    DDX_Control(pDX, IDC_EQUALITY6, Equality6);
    DDX_Control(pDX, IDC_EQUALITY7, Equality7);
    DDX_Control(pDX, IDC_EQUALITY8, Equality8);
    DDX_Control(pDX, IDC_EQUALITY9, Equality9);
    DDX_Control(pDX, IDC_EQUALITY10, Equality10);
    DDX_Control(pDX, IDC_A1, Answer1);
    DDX_Control(pDX, IDC_A2, Answer2);
    DDX_Control(pDX, IDC_A3, Answer3);
    DDX_Control(pDX, IDC_A4, Answer4);
    DDX_Control(pDX, IDC_A5, Answer5);
    DDX_Control(pDX, IDC_A6, Answer6);
    DDX_Control(pDX, IDC_A7, Answer7);
    DDX_Control(pDX, IDC_A8, Answer8);
    DDX_Control(pDX, IDC_A9, Answer9);
    DDX_Control(pDX, IDC_A10, Answer10);
}

BEGIN_MESSAGE_MAP(CMFCTest4Dlg, CDialogEx)
    ON_WM_PAINT()
    ON_WM_QUERYDRAGICON()
    ON_BN_CLICKED(IDOK, &CMFCTest4Dlg::OnBnClickedOk)
    ON_EN_CHANGE(IDC_EDIT1, &CMFCTest4Dlg::OnEnChangeEdit1)
    //ON_STN_CLICKED(IDC_STATIC_INT, &CMFCTest4Dlg::OnStnClickedStaticInt)
    //ON_BN_CLICKED(IDC_BUTTON1, &CMFCTest4Dlg::OnBnClickedButton1)
    ON_STN_CLICKED(IDC_STATIC1, &CMFCTest4Dlg::OnStnClickedStatic1)
    ON_STN_CLICKED(IDC_EQUALITY2, &CMFCTest4Dlg::OnStnClickedEquality2)
    ON_BN_CLICKED(IDOK2, &CMFCTest4Dlg::OnBnClickedOk2)
    ON_BN_CLICKED(IDC_BUTTON10, &CMFCTest4Dlg::OnBnClickedButton10)
    ON_EN_CHANGE(IDC_EDIT2, &CMFCTest4Dlg::OnEnChangeEdit2)
    ON_BN_CLICKED(IDC_AUTO, &CMFCTest4Dlg::OnBnClickedAuto)
END_MESSAGE_MAP()


// CMFCTest4Dlg 消息处理程序

BOOL CMFCTest4Dlg::OnInitDialog()
{
    CDialogEx::OnInitDialog();

    // 设置此对话框的图标。  当应用程序主窗口不是对话框时，框架将自动
    //  执行此操作
    SetIcon(m_hIcon, TRUE);            // 设置大图标
    SetIcon(m_hIcon, FALSE);        // 设置小图标

    // TODO: 在此添加额外的初始化代码
    GetDlgItem(IDC_BUTTON10)->EnableWindow(false);

    return TRUE;  // 除非将焦点设置到控件，否则返回 TRUE
}

// 如果向对话框添加最小化按钮，则需要下面的代码
//  来绘制该图标。  对于使用文档/视图模型的 MFC 应用程序，
//  这将由框架自动完成。

void CMFCTest4Dlg::OnPaint()
{
    if (IsIconic())
    {
        CPaintDC dc(this); // 用于绘制的设备上下文

        SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

        // 使图标在工作区矩形中居中
        int cxIcon = GetSystemMetrics(SM_CXICON);
        int cyIcon = GetSystemMetrics(SM_CYICON);
        CRect rect;
        GetClientRect(&rect);
        int x = (rect.Width() - cxIcon + 1) / 2;
        int y = (rect.Height() - cyIcon + 1) / 2;

        // 绘制图标
        dc.DrawIcon(x, y, m_hIcon);
    }
    else
    {
        CDialogEx::OnPaint();
    }
}

//当用户拖动最小化窗口时系统调用此函数取得光标
//显示。
HCURSOR CMFCTest4Dlg::OnQueryDragIcon()
{
    return static_cast<HCURSOR>(m_hIcon);
}

void CMFCTest4Dlg::OnBnClickedOk()                //这个是"开始测试"按钮
{
    // TODO: 在此添加控件通知处理程序代码
    CDialogEx::OnOK();
}

void CMFCTest4Dlg::OnEnChangeEdit1()
{
    // TODO:  如果该控件是 RICHEDIT 控件，它将不
    // 发送此通知，除非重写 CDialogEx::OnInitDialog()
    // 函数并调用 CRichEditCtrl().SetEventMask()，
    // 同时将 ENM_CHANGE 标志“或”运算到掩码中。

    // TODO:  在此添加控件通知处理程序代码
    //SetDlgItemText(IDC_STATIC1, "shit");
    /*CString str;
    GetDlgItemText(IDC_EDIT1, str);
    str.Format("算式%d", ++EqNum);
    SetDlgItemText(IDC_STATIC1, str);*/
}


void CMFCTest4Dlg::OnStnClickedStaticInt()
{
    // TODO: 在此添加控件通知处理程序代码

}


void CMFCTest4Dlg::OnBnClickedButton1()//这个是“确定”按钮
{
    // TODO: 在此添加控件通知处理程序代码
    
    
    
    //EqNum++;
}


void CMFCTest4Dlg::OnStnClickedStatic1()
{
    // TODO: 在此添加控件通知处理程序代码
}


void CMFCTest4Dlg::OnStnClickedEquality2()
{
    // TODO: 在此添加控件通知处理程序代码
}


void CMFCTest4Dlg::OnBnClickedOk2()        //真正的开始按钮
{
    // TODO: 在此添加控件通知处理程序代码
    int e = 0;
    last = false;
    correct = 0;
    incorrect = 0;
    SetDlgItemText(IDC_CORRECT, "0");
    SetDlgItemText(IDC_INCORRECT, "0");
    
    while (e < 10)
    {
        if (in >> str_buf[e])
        {
            switch (e)
            {
            case 0:
                SetDlgItemText(IDC_EDIT1, "");
                SetDlgItemText(IDC_A1, "第一题答案");
                SetDlgItemText(IDC_EQUALITY1, str_buf[e].c_str());
                break;
            case 1:
                SetDlgItemText(IDC_EDIT2, "");
                SetDlgItemText(IDC_A2, "第二题答案");
                SetDlgItemText(IDC_EQUALITY2, str_buf[e].c_str());
                break;
            case 2:
                SetDlgItemText(IDC_EDIT3, "");
                SetDlgItemText(IDC_A3, "第三题答案");
                SetDlgItemText(IDC_EQUALITY3, str_buf[e].c_str());
                break;
            case 3:
                SetDlgItemText(IDC_EDIT4, "");
                SetDlgItemText(IDC_A4, "第四题答案");
                SetDlgItemText(IDC_EQUALITY4, str_buf[e].c_str());
                break;
            case 4:
                SetDlgItemText(IDC_EDIT5, "");
                SetDlgItemText(IDC_A5, "第五题答案");
                SetDlgItemText(IDC_EQUALITY5, str_buf[e].c_str());
                break;
            case 5:
                SetDlgItemText(IDC_EDIT6, "");
                SetDlgItemText(IDC_A6, "第六题答案");
                SetDlgItemText(IDC_EQUALITY6, str_buf[e].c_str());
                break;
            case 6:
                SetDlgItemText(IDC_EDIT7, "");
                SetDlgItemText(IDC_A7, "第七题答案");
                SetDlgItemText(IDC_EQUALITY7, str_buf[e].c_str());
                break;
            case 7:
                SetDlgItemText(IDC_EDIT8, "");
                SetDlgItemText(IDC_A8, "第八题答案");
                SetDlgItemText(IDC_EQUALITY8, str_buf[e].c_str());
                break;
            case 8:
                SetDlgItemText(IDC_EDIT9, "");
                SetDlgItemText(IDC_A9, "第九题答案");
                SetDlgItemText(IDC_EQUALITY9, str_buf[e].c_str());
                break;
            case 9:
                SetDlgItemText(IDC_EDIT10, "");
                SetDlgItemText(IDC_A10, "第十题答案");
                SetDlgItemText(IDC_EQUALITY10, str_buf[e].c_str());
                break;
            }
        }
        else
        {
            last = true;
        }
        e++;
    }
    //按完开始之后就不能再次按下
    SetDlgItemText(IDOK2, "再次测试");
    GetDlgItem(IDOK2)->EnableWindow(false);
    GetDlgItem(IDC_BUTTON10)->EnableWindow(true);
    if (last)
    {
        MessageBox("没有更多的题了！测试结束！", "提示", MB_ICONINFORMATION);
        GetDlgItem(IDC_BUTTON10)->EnableWindow(false);
        in.close();
    }
}


void CMFCTest4Dlg::OnBnClickedButton10()//确认提交按钮
{
    int a = 0;
    //循环存用户答案
    while (a < 10)
    {
        cal.recalculator(str_buf[a]);                    //重启计算器，并传入算式参数
        temperror = cal.run();
        switch (a)
        {
        case 0:
            GetDlgItemText(IDC_EDIT1, answer[a]);
            SetDlgItemText(IDC_A1, cal.getMyResult().c_str());
            break;
        case 1:
            GetDlgItemText(IDC_EDIT2, answer[a]);
            SetDlgItemText(IDC_A2, cal.getMyResult().c_str());
            break;
        case 2:
            GetDlgItemText(IDC_EDIT3, answer[a]);
            SetDlgItemText(IDC_A3, cal.getMyResult().c_str());
            break;
        case 3:
            GetDlgItemText(IDC_EDIT4, answer[a]);
            SetDlgItemText(IDC_A4, cal.getMyResult().c_str());
            break;
        case 4:
            GetDlgItemText(IDC_EDIT5, answer[a]);
            SetDlgItemText(IDC_A5, cal.getMyResult().c_str());
            break;
        case 5:
            GetDlgItemText(IDC_EDIT6, answer[a]);
            SetDlgItemText(IDC_A6, cal.getMyResult().c_str());
            break;
        case 6:
            GetDlgItemText(IDC_EDIT7, answer[a]);
            SetDlgItemText(IDC_A7, cal.getMyResult().c_str());
            break;
        case 7:
            GetDlgItemText(IDC_EDIT8, answer[a]);
            SetDlgItemText(IDC_A8, cal.getMyResult().c_str());
            break;
        case 8:
            GetDlgItemText(IDC_EDIT9, answer[a]);
            SetDlgItemText(IDC_A9, cal.getMyResult().c_str());
            break;
        case 9:
            GetDlgItemText(IDC_EDIT10, answer[a]);
            SetDlgItemText(IDC_A10,cal.getMyResult().c_str());
            break;
        }
        if (answer[a].GetString() == cal.getMyResult())
        {
            correct++;
        }
        else
        {
            incorrect++;
        }
        a++;
    }
    if (temperror != ERROR_NO)                        //显示错误
    {
        MessageBox(printError(temperror).c_str(), "ERROR", MB_ICONHAND);
    }
    char buf[2][3];
    sprintf(buf[0], "%d", correct);
    sprintf(buf[1], "%d", incorrect);
    SetDlgItemText(IDC_CORRECT, buf[0]);
    SetDlgItemText(IDC_INCORRECT, buf[1]);
    // TODO: 在此添加控件通知处理程序代码
    GetDlgItem(IDOK2)->EnableWindow(true);
    GetDlgItem(IDC_BUTTON10)->EnableWindow(false);
}


void CMFCTest4Dlg::OnEnChangeEdit2()
{
    // TODO:  如果该控件是 RICHEDIT 控件，它将不
    // 发送此通知，除非重写 CDialogEx::OnInitDialog()
    // 函数并调用 CRichEditCtrl().SetEventMask()，
    // 同时将 ENM_CHANGE 标志“或”运算到掩码中。

    // TODO:  在此添加控件通知处理程序代码

}


void CMFCTest4Dlg::OnBnClickedAuto()
{
    // TODO: 在此添加控件通知处理程序代码
    srand((int)time(0));
    string equation;
    char temp[100];
    ofstream outf("equation.txt");
    int i = 50;
    //cout << "输入生成算式的数量：";
    //cin >> i;
    while (i--) {
        equation.clear();
        if (i % 2) {                                            //分数运算 
            char lastop = '+';                                //上一个运算符 
            int num = random(5) + 4;                            //算式包含的操作数个数-1 
            sprintf(temp, "%d", random(20) + 1);                 //第一个操作数 
            equation.append(temp);
            while (num--) {
                int b;
                if (lastop == '/')                            //防止连续除法的出现 
                    b = random(2);
                else
                    b = random(12);
                switch (b) {
                case 0:
                case 4:
                case 8:
                    lastop = temp[0] = '+';
                    break;
                case 1:
                case 5:
                case 9:
                    lastop = temp[0] = '-';
                    break;
                case 2:
                case 6:
                case 10:
                    lastop = temp[0] = '*';
                    break;
                case 3:
                case 7:
                case 11:
                    lastop = temp[0] = '/';
                    break;
                }
                temp[1] = 0;
                equation.append(temp);
                sprintf(temp, "%d", random(20) + 1);
                equation.append(temp);
            }
            int k, a = 0;
            for (int j = 0; j<equation.size(); j++) {                    //添加括号 
                if ((equation[j] == '+' || equation[j] == '-') && a == 0) {
                    a++;
                }
                else if ((equation[j] == '+' || equation[j] == '-') && a == 1) {
                    k = j - 1;                                            //添加左括号 
                    while (!isoperator(equation[k - 1]) && k != 0) k--;
                    if (equation[k - 1] == '/') {
                        k--;
                        while (!isoperator(equation[k - 1]) && k != 0) k--;
                    }
                    equation.insert(k, "(");

                    k = j + 2;                                            //添加右括号 
                    while (!isoperator(equation[k + 1]) && k != equation.size() - 1) k++;
                    equation.insert(k + 1, ")");

                    break;
                }
            }
            //cout<<equation<<endl;
        }
        else {                                                        //小数运算 
            char lastop = '+';                                //上一个运算符 
            int num = random(5) + 4;                            //算式包含的操作数个数-1 
            int temp1 = random(200) + 1;
            sprintf(temp, "%g", temp1 / 10.0);                 //第一个操作数 
            equation.append(temp);
            while (num--) {
                int b;
                if (lastop == '/')                            //防止连续除法的出现 
                    b = random(2);
                else
                    b = random(12);
                switch (b) {
                case 0:
                case 4:
                case 8:
                    lastop = temp[0] = '+';
                    break;
                case 1:
                case 5:
                case 9:
                    lastop = temp[0] = '-';
                    break;
                case 2:
                case 6:
                case 10:
                    lastop = temp[0] = '*';
                    break;
                case 3:
                case 7:
                case 11:
                    lastop = temp[0] = '/';
                    break;
                }
                temp[1] = 0;
                equation.append(temp);
                int temp2 = random(200) + 1;
                if (equation[equation.size() - 1] == '/' && (temp1%temp2) != 0) {
                    temp2 = temp1 / 5 + 1;
                    while (temp1%temp2) {
                        temp2++;
                    }
                }
                temp1 = temp2;
                sprintf(temp, "%g", temp2 / 10.0);
                equation.append(temp);
            }
            //cout<<equation<<endl;
        }
        outf << equation << endl;
    }
    //cout << "生成算式成功" << endl;
    MessageBox("生成50道算式成功", "提示", MB_ICONINFORMATION);
    GetDlgItem(IDOK2)->EnableWindow(true);
    in.close();
    in.open("equation.txt");
    outf.close();
}

#pragma once
#include <iostream>
using namespace std;
#include <string.h>
#include <stack>
#include <sstream>
#include <fstream>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>

enum MyError { ERROR_NO = 0, ERROR_SET = 1, ERROR_OPERATOR = 2, ERROR_ZERO = 4, ERROR_STRING = 8, ERROR_RANGE = 16 };

string printError(MyError me) {
    if (me == ERROR_NO) {
        return "没有错误";
    }
    else if (me == ERROR_SET) {
        return "设置参数非法";
    }
    else if (me == ERROR_OPERATOR) {
        return "操作符非法";
    }
    else if (me == ERROR_ZERO) {
        return "除0错误";
    }
    else if (me == ERROR_STRING) {
        return "算式非法";
    }
    else if (me == ERROR_RANGE) {
        return "计算结果超出范围";
    }
    else {
        return "未定义的错误类型";
    }
    //cout<< "    错误代码:" << me << endl << endl;
}

class unit                        //后缀表达式用，单元类 
{
public:
    char op;
    double num;
    int kind;
    unit() {
        kind = 0;
    }
    void set(char c) {
        op = c;
        kind = 1;
    }
    void set(double d) {
        num = d;
        kind = 2;
    }
};

class fenshu                        //分数类 
{
public:
    int fz;
    int fm;
    fenshu(int a, int b) {
        fz = a; fm = b;
        yuefen();
    }
    void yuefen() {
        if (fz == 0)
            return;
        int t;
        int a = fz;
        int b = fm;
        if (a < b) {
            t = a;
            a = b;
            b = t;
        }
        while (t = a % b) {
            a = b;
            b = t;
        }
        if (b != 1) {
            fz /= b;
            fm /= b;
        }
        if (fm<0) {
            fz = -fz;
            fm = -fm;
        }
    }
    void print() {
        cout << fz << "/" << fm;
    }
    string getfenshu() {
        char s[20];
        if (fm == 1) {
            sprintf(s, "%d", fz);
        }
        else {
            sprintf(s, "%d/%d", fz, fm);
        }
        string ss = s;
        return ss;
    }
    fenshu operator +(fenshu &fs) {
        fenshu f(fz*fs.fm + fs.fz*fm, fm*fs.fm);
        f.yuefen();
        return f;
    }
    fenshu operator -(fenshu &fs) {
        fenshu f(fz*fs.fm - fs.fz*fm, fm*fs.fm);
        f.yuefen();
        return f;
    }
    fenshu operator *(fenshu &fs) {
        fenshu f(fz*fs.fz, fs.fm*fm);
        f.yuefen();
        return f;
    }
    fenshu operator /(fenshu &fs) {
        if (fs.fz == 0) {
            fenshu f1(0, 1);
            return f1;
        }
        fenshu f(fz*fs.fm, fm*fs.fz);
        f.yuefen();
        return f;
    }
    void operator =(fenshu &fs) {
        fz = fs.fz;
        fm = fs.fm;
    }
    bool operator ==(fenshu &fs) {
        return fz == fs.fz&&fm == fs.fm;
    }
};

class Calculator                    //核心计算器类 
{
public:
    //辅助计算参数 
    double result;                    //计算结果 
    fenshu fresult;                    //分数计算结果 
    MyError Error;                    //计算过程中是否有错误 
    string str;                        //存放中缀表达式 

    Calculator(string s) :fresult(1, 1) {            //计算器初始化 
        u = new unit();
        str = s;
        accuracy = -1;
        maxunit = 80;
        daterange = 1000;
        clear();
    }

    MyError run() {                        //计算表达式的值，存入result
        MyError temperror = zzh(str);
        if (temperror != ERROR_NO) {
            Error = temperror;
            result = -11111;
            return Error;
        }
        int i;
        bool b = true;
        for (i = 0; i<str.size(); i++) {    //没有小数点，就计算分数结果 
            if (str[i] == '.') {
                b = false;
                break;
            }

        }

        if (b) {
            temperror = getFResult();
            if (temperror != ERROR_NO) {
                fenshu f(-1, -1);
                fresult = f;
                Error = temperror;
                return Error;
            }
            else if (abs(fresult.fz)>daterange || abs(fresult.fm)>daterange) {
                Error = ERROR_RANGE;
                return Error;
            }
        }
        else {
            temperror = getResult();
            if (temperror != ERROR_NO) {
                Error = temperror;
                result = -11111;
                return Error;
            }
            else if (abs(result)>daterange) {
                Error = ERROR_RANGE;
                return Error;
            }
        }
        return ERROR_NO;
    }

    void clear() {                    //清空计算器一切辅助计算参数 
        num = 0;
        Error = ERROR_NO;
        result = 0;
        fenshu f(1, 1);
        fresult = f;
        str = "";
        delete u;
        u = new unit[maxunit];
    }

    void recalculator(string s) {    //重启计算器对象 
        clear();
        str = s;
    }

    string getMyResult() {                                //获得计算结果，小数结果或者分数结果 
        int i = 0;
        char s[20];
        string ss;
        for (; i<str.size(); i++) {
            if (str[i] == '.') {
                if (accuracy != -1)                            //判断精度并输出 
                    sprintf(s, "%.*lf", accuracy, result);
                else
                    sprintf(s, "%g", result);
                ss = s;
                return ss;
            }
        }
        ss = fresult.getfenshu();
        return ss;
    }

    MyError setDateRange(int type) {                //设置数据范围 
        if (0<type) {
            daterange = type;
            return ERROR_NO;
        }
        else
            Error = ERROR_SET;
        return ERROR_SET;
    }

    MyError setMaxUnit(int num) {                //设置最大识别数量 
        if (0<num&&num <= 80) {
            maxunit = num;
            u = new unit[maxunit];             //清空后缀表达式 
            this->num = 0;
            return ERROR_NO;
        }
        else
            Error = ERROR_SET;
        return ERROR_SET;
    }

    MyError setAccuracy(int a) {                    //设置精度 
        if (a >= -1 && a <= 6) {
            accuracy = a;
            return ERROR_NO;
        }
        else
            Error = ERROR_SET;
        return ERROR_SET;
    }

private:
    //非辅助计算参数，设置后，除非重复设置，否则不会被clear之类的清除 
    int daterange;                    //算式参数中数据的范围 
    int maxunit;                    //算式参数最多能识别的字符数量 
    int accuracy;                    //小数精确位数,-1为不精确，即去掉所有末尾的0，其他数字即小数点后保留的位数 

                                    //辅助计算参数 
    unit *u;                        //存储后缀表达式 
    int num;                        //后缀表达式unit数量 

    MyError zzh(string s) {                        //中缀表达式转后缀表达式
        if (s.size()>maxunit) {
            return ERROR_STRING;                //error,传入的算式长度超过设置的最大识别数量
        }
        char c;
        char *temp1 = new char[maxunit];
        double temp;
        string stemp;
        stack<char> st;
        while (!s.empty()) {                    //如果字符串不为空则继续循环 
            c = s[0];
            if (isoperator(c)) {                //是操作符 
                s.erase(0, 1);                //从string中删除操作符  
                if (pushintostack(c, &st) == ERROR_OPERATOR)
                    return ERROR_OPERATOR;
            }
            else if (isnum(c)) {                            //是数字 
                stringstream sst(s);
                sst >> temp;
                sprintf(temp1, "%g", temp);
                stemp = temp1;
                s.erase(0, stemp.size());    //从string中删除数字
                sst.clear();
                u[num++].set(temp);            //存储数字到栈中 
            }
            else {
                return ERROR_STRING;
            }
        }
        if (pushintostack('#', &st) == ERROR_OPERATOR)
            return ERROR_OPERATOR;
        return ERROR_NO;
    }

    bool isoperator(char c) {                //判断是否是操作符 
        if (c == '+')
            return true;
        if (c == '-')
            return true;
        if (c == '*')
            return true;
        if (c == '/')
            return true;
        if (c == '(')
            return true;
        if (c == ')')
            return true;
        return false;
    }

    bool isnum(char c) {
        if (c >= '0'&&c <= '9')
            return true;
        return false;
    }

    int youxian(char c1, char c2) {            //判断两操作符优先级 
        if (c2 == '#')        //结束符 
            return 0;
        if (c2 == '(')
            return 1;
        if (c2 == ')')
            if (c1 == '(')
                return 2;
            else
                return 0;
        if (c1 == '(')
            if (c2 == '+' || c2 == '-' || c2 == '*' || c2 == '/')
                return 1;
        if (c1 == '*' || c1 == '/')
            return 0;
        if (c1 == '+' || c1 == '-')
            if (c2 == '*' || c2 == '/')
                return 1;
            else if (c2 == '+' || c2 == '-')
                return 0;
        return -1;                            //非法运算符 
    }

    MyError pushintostack(char c, stack<char> *st) {        //将操作符执行一系列入栈判断操作 
        char a;
        int y = 0;
        while (!st->empty()) {
            a = st->top();
            y = youxian(a, c);
            if (y == 0) {                //后来的操作符优先级小 
                st->pop();
                u[num++].set(a);
            }
            else if (y == 1) {            //后来的操作符优先级大 
                break;
            }
            else if (y == 2) {            //俩操作符是'('和')'
                st->pop();
                return ERROR_NO;
            }
            else
                return ERROR_OPERATOR;
        }
        st->push(c);
        return ERROR_NO;
    }

    void test() {                                    //输出后缀表达式，测试用（暂留） 
        int i;
        cout << num << endl;
        for (i = 0; i<num; i++) {
            if (u[i].kind == 1)
                cout << u[i].op << " ";
            else if (u[i].kind == 2)
                cout << u[i].num << " ";
        }
    }

    MyError getResult() {                        //由run函数调用，获取小数结果，存入result中 
        int i;
        char op;
        double num1, num2;
        stack<double> st;
        for (i = 0; i<num; i++) {                    //处理后缀表达式 
            if (u[i].kind == 2) {                //如果是数字则入栈 
                st.push(u[i].num);
            }
            else if (u[i].kind == 1) {            //如果是操作符，则出栈两个数字 
                op = u[i].op;
                if (st.empty())
                    return ERROR_STRING;    //算式非法
                num2 = st.top();
                st.pop();
                if (st.empty())
                    return ERROR_STRING;    //算式非法
                num1 = st.top();
                st.pop();
                switch (op) {
                case '+':
                    st.push(num1 + num2);
                    break;
                case '-':
                    st.push(num1 - num2);
                    break;
                case '*':
                    st.push(num1*num2);
                    break;
                case '/':
                    if (num2 == 0)
                        return ERROR_ZERO;    //除0错误
                    st.push(num1 / num2);
                    break;
                }
            }
            else
                return ERROR_STRING;        //算式非法
        }
        result = st.top();
        return ERROR_NO;
    }

    MyError getFResult() {                        //由run函数调用，获取分数结果，存入fresult中 
        int i;
        char op;
        fenshu f1(1, 1), f2(1, 1);
        stack<fenshu> st;
        for (i = 0; i<num; i++) {
            if (u[i].kind == 2) {                //如果是数字则入栈 
                st.push(fenshu(u[i].num, 1));
            }
            else if (u[i].kind == 1) {            //如果是操作符，则出栈两个数字 
                op = u[i].op;
                if (st.empty())
                    return ERROR_STRING;    //算式非法
                f2 = st.top();
                st.pop();
                if (st.empty())
                    return ERROR_STRING;    //算式非法
                f1 = st.top();
                st.pop();
                switch (op) {
                case '+':
                    st.push(f1 + f2);
                    break;
                case '-':
                    st.push(f1 - f2);
                    break;
                case '*':
                    st.push(f1*f2);
                    break;
                case '/':
                    if (f2.fz == 0)
                        return ERROR_ZERO;    //除0错误 
                    st.push(f1 / f2);
                    break;
                }
            }
            else
                return ERROR_STRING;        //算式非法
        }
        fresult = st.top();
        return ERROR_NO;
    }

};

#include<time.h>
#include<stdlib.h>
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
#define random(x) (rand()%x)

bool isoperator(char c) {
    if (c == '+' || c == '-' || c == '*' || c == '/')
        return true;
    return false;
}