程序设计之四则运算三

　　这是第三次要对四则运算设计程序实现，这次需要两个人一起编程实现，经过讨论，我们认为最好在两个人的前两次设计中挑选比较适合的一个进行修改。

      这次需要计算生成表达式的值并判断用户输入的值是否正确。

设计思路：

     关键是对结果的计算，可以通过数据结构中的栈实现，计算括号中的内容，首先从第一个字符开始压栈，遇到左括号开始记录位置，继续压栈直到遇到第一个右括号，计算中间式子的值。

程序代码：

 

//赵承圣 2016.3.18
#include<iostream>
#include<ctime>
#include<string>
#include<sstream> 
#include "SqStack.h"
using namespace std;

char ops[7] = { '+', '-', '*', '/', '(', ')', '=' };
char cmp[7][7] = { { '>', '>', '<', '<', '<', '>', '>' },
                    { '>', '>', '<', '<', '<', '>', '>' },
                    { '>', '>', '>', '>', '<', '>', '>' },
                    { '>', '>', '>', '>', '<', '>', '>' },
                    { '<', '<', '<', '<', '<', '=', ' ' },
                    { '>', '>', '>', '>', ' ', '>', '>' },
                    { '<', '<', '<', '<', '<', ' ', '=' } };

bool IsOperator(char ch)
{
    for (int i = 0; i < 7; i++)
        if (ch == ops[i])
            return true;
    return false;
}
char Compare(char ch1, char ch2)
{
    int i, m, n;
    char priority;
    for (i = 0; i < 7; i++) { //找到相比较的两个运算符在比较矩阵里的相对位置
        if (ch1 == ops[i])
            m = i;
        if (ch2 == ops[i])
            n = i;
    }
    priority = cmp[m][n];
    return priority;
}

bool Compute(double x, char op, double y, double &z)
{
    switch (op) {
    case '+':    z = x + y;
        break;
    case '-':    z = x - y;
        break;
    case '*':    z = x * y;
        break;
    case '/':    if (fabs(y) > 1e-7) {
        z = x / y;
        break;
    }
                else
                    cout << "除数为0，出错！" << endl;
        return false;
    }
    return true;
}

bool ExpEvaluation(char *str, double &result)
{
    double a, b, v;
    char ch, op;
    int temp, i = 0;
    SqStack <char> optr(20);     //创建运算符栈optr
    SqStack <double> opnd(20);   //创建运算数栈opnd
    optr.Push('=');
    ch = str[i++];
    while (ch != '=' || optr.Top() != '=') {
        while (ch == ' ')   //跳过空格
            ch = str[i++];
        if (IsOperator(ch)) {  //是7种运算符之一
            switch (Compare(optr.Top(), ch)) {
            case '<':         //栈顶运算符优先级低
                optr.Push(ch);
                ch = str[i++];
                break;
            case '=':         //脱括号并接收下一字符
                optr.Pop();
                ch = str[i++];
                break;
            case '>':         //栈顶运算符优先级高，退栈并将运算结果入栈
                op = optr.Top();
                optr.Pop();
                b = opnd.Top();
                opnd.Pop();
                a = opnd.Top();
                opnd.Pop();
                if (Compute(a, op, b, v)) { //计算v = a <op> b
                    opnd.Push(v);
                    break;
                }
                else {
                    result = 0;
                    return false;
                }
            }
        }
        else {    //是数字
            temp = ch - '0';    //将字符转换为十进制数
            ch = str[i++];
            while (!IsOperator(ch) && ch != ' ') {
                temp = temp * 10 + ch - '0'; //将逐个读入运算数的各位转化为十进制数
                ch = str[i++];
            }
            opnd.Push(temp);    //数值入栈
        }
    }
    result = opnd.Top();
    return true;
}



string IntToString(int & i)
{
    string s;
    stringstream ss(s);
    ss << i;
    return ss.str();
}


void checkcon0(int &num,string chnum)
{
    while(num!=2&&num!=4)
    {
        if(chnum=="否")
        {
            num=2;
        }
        else if(chnum=="是")
        {
            num=4;
        }
        else
        {
            cout<<"输入不合法，请重新输入: ";
            cin>>chnum;
            cout<<endl;
        }
    }
}
void checkcon1(int &num1,string chnum)
{
    while(num1!=1&&num1!=0)
    {
        if(chnum=="否")
        {
            num1=1;
        }
        else if(chnum=="是")
        {
            num1=0;
        }
        else
        {
            cout<<"输入不合法，请重新输入: ";
            cin>>chnum;
            cout<<endl;
        }
    }

}
void check(int &num2,string chnum)
{
    num2 = std::atoi(chnum.c_str() );
    while(num2<=0)
    {
        cout<<"输入不合法，请重新输入: ";
        cin>>chnum;
        cout<<endl;
        num2 = std::atoi(chnum.c_str() );
    }
}

int main()
{
    //数据定义部分
    srand((int)time(NULL));
    int control[2],itemnum, num_max, num_min, num_num, bracket_num;
    string chnum[5];
    string express = "";
    char symbol[4],c[20];;                    //随机计算符号数组
    symbol[0] = '+';
    symbol[1] = '-';
    symbol[2] = '*';
    symbol[3] = '/';

    //输入及判断部分
    cout << "是否有乘除（是/否）：  ";
    cin >> chnum[0];
    checkcon0(control[0],chnum[0]);
    cout << "是否有括号（是/否）：  ";
    cin >> chnum[1];
    checkcon1(control[1],chnum[1]);
    cout << "数字最大取值：  ";
    cin >> chnum[2];
    check(num_max,chnum[2]);
    cout << "数字最小取值：  ";
    cin >> chnum[3];
    check(num_min,chnum[3]);
    cout<<"式子数量： ";
    cin>>chnum[4];
    check(itemnum,chnum[4]);

    string *item=new string[itemnum];
    double *result = new double[itemnum];
    double *uans = new double[itemnum];
    int rightnum = 0;

    //算式生成部分
    for (int count = 0; count<itemnum; count++)
    {
        num_num = rand() % 10;
        string *str = new string[num_num];
        if (num_num == 0 || num_num == 1)
        {
            count--;
            continue;
        }

        //定义并初始化动态数组 num:数字数组  symnum:符号选择数组  sym:符号数组
        int *num = new int[num_num];
        int *symnum = new int[num_num - 1];
        char *sym = new char[num_num - 1];

        int bracket_leftposition, bracket_rightposition;
        int *bracket_left_time = new int[num_num];           //定义左、右括号生成次数数组，下标为数字位置
        int *bracket_right_time = new int[num_num];
        string *bracket_left = new string[num_num]();        //定义左右括号字符串型数组
        string *bracket_right = new string[num_num]();
        for (int rcount = 0; rcount<num_num; rcount++)          //左、右括号生成次数初始化
        {
            bracket_left_time[rcount] = 0;
            bracket_right_time[rcount] = 0;
        }

        //给参与计算的数赋值(指定数值范围)
        for (int cnum = 0; cnum<num_num; cnum++)
        {
            num[cnum] = rand() % (num_max - num_min + 1) + num_min;
        }

        //随机生成式子的各个位置的符号
        for (int snum = 0; snum<num_num - 1; snum++)
        {
            symnum[snum] = rand() % control[0];
            sym[snum] = symbol[symnum[snum]];
        }


        if (control[1] == 0)
        {
            bracket_num = rand() % 7 + 1;
            //生成括号次数
            for (int bcount = 0; bcount<bracket_num; bcount++)
            {
                bracket_leftposition = rand() % num_num;                //随机生成左右括号的位置
                bracket_rightposition = rand() % num_num;
                if ((bracket_leftposition >= bracket_rightposition)||((bracket_leftposition==0)&&(bracket_rightposition==num_num-1)))     //先剔除部分一次性在一个数左右同时生成左右括号和在整个式子前后生成式子的情况
                {
                    continue;
                }
                bracket_left_time[bracket_leftposition]++;            //该位置数左括号生成次数+1
                bracket_right_time[bracket_rightposition]++;
            }
        }
        for (int stnum = 0; stnum < num_num-2; stnum++)
        {
            if ((symbol[symnum[stnum]] == '/') && (symbol[symnum[stnum + 1]] == '/'))
            {
                bracket_left_time[stnum]++;
                bracket_right_time[stnum + 1]++;
            }
        }
        for (int snum = 0; snum < num_num ; snum++)
        {
            
            if (bracket_left_time[snum] == 1)
            {
                bracket_left[snum] = "(";
            }
            if (bracket_left_time[snum] == 2)
            {
                bracket_left[snum] = "((";
            }
            if (bracket_left_time[snum] == 3)
            {
                bracket_left[snum] = "(((";
            }
            if (bracket_right_time[snum] == 1)
            {
                bracket_right[snum] = ")";
            }
            if (bracket_right_time[snum] == 2)
            {
                bracket_right[snum] = "))";
            }
            if (bracket_right_time[snum] == 3)
            {
                bracket_right[snum] = ")))";
            }
            for (int bpcount = 0; bpcount<num_num; bpcount++)            //再次扫描数字左右括号生成次数相等的情况并排除
            {
                if (bracket_left_time[bpcount] == bracket_right_time[bpcount])
                {
                    bracket_right[bpcount] = "";
                    bracket_left[bpcount] = "";
                }
            }
        }

        //输出算式
        for (int ph = 0; ph<num_num - 1; ph++)
        {
            cout << bracket_left[ph] << num[ph] << bracket_right[ph] << sym[ph];
        }
        cout << bracket_left[num_num - 1] << num[num_num - 1] << bracket_right[num_num - 1] << "= ";

        
        for (int i = 0; i < num_num; i++)
        {
            int &temp = num[i];
            str[i] = IntToString(temp);
        }
        for (int ph = 0; ph<num_num - 1; ph++)
        {
            express =express+bracket_left[ph]+str[ph]+bracket_right[ph]+sym[ph];
        }
        express = express + bracket_left[num_num - 1] +str[num_num - 1]+ bracket_right[num_num - 1];
        item[count] = express+"=";
        
        strcpy(c, item[count].c_str());
        ExpEvaluation(c, result[count]); //求表达式的值
        
        cin >> uans[count];
        if (uans[count] == result[count])
        {
            rightnum++;
            cout << "回答正确" << endl;
        }
        else
        {
            cout << "回答错误" << endl;
            cout << "正确答案是  " << result[count] << endl;
        }
        

        express="";

        if (count == 29)
        {
            delete[]num;
            delete[]symnum;
            delete[]sym;
            delete[]bracket_left_time;
            delete[]bracket_right_time;
            delete[]bracket_left;
            delete[]bracket_right;
            delete[]item;
            delete[]str;
            delete[]result;
        }

    }
    cout << "本次测试共答对 "<< rightnum <<" 道题"<< endl;

    system("pause");
    return 0;
}

SqStack.h 

#ifndef _SQSTACK_H_
#define _SQSTACK_H_
//定义顺序栈类
template <class ElemType>//声明一个类模板
class SqStack
{
public://顺序栈类的各成员函数
    SqStack(int m = 100);
    ~SqStack();
    void Clear();
    bool Empty() const;
    int Length() const;
    ElemType & Top() const;
    void Push(const ElemType &e);
    void Pop();
private://顺序栈类的数据成员
    ElemType *m_base;//基地址指针
    int m_top;//栈顶指针
    int m_size; //向量空间大小
};
//构造函数，分配m个结点的顺序空间，构造一个空的顺序栈。
template <class ElemType>
SqStack <ElemType>::SqStack(int m)
{
    m_top = 0;
    m_base = new ElemType[m];
    m_size = m;
}//SqStack
 //析构函数，将栈结构销毁。
template <class ElemType>
SqStack <ElemType>::~SqStack()
{
    if (m_base != NULL) delete[] m_base;
}//~SqStack
 //清空栈。
template <class ElemType>
void SqStack <ElemType>::Clear()
{
    m_top = 0;
}//Clear
 //判栈是否为空，若为空，则返回true，否则返回false。
template <class ElemType>
bool SqStack <ElemType>::Empty() const
{
    return m_top == 0;
}//Empty
 //求栈的长度。
template <class ElemType>
int SqStack <ElemType>::Length() const
{
    return m_top;
}//Length
 //取栈顶元素的值。先决条件是栈不空。
template <class ElemType>
ElemType & SqStack <ElemType>::Top() const
{
    return m_base[m_top - 1];
}//Top
 //入栈，若栈满，则先扩展空间。插入e到栈顶。
template <class ElemType>
void SqStack <ElemType>::Push(const ElemType &e)
{
    if (m_top >= m_size) {            //若栈满，则扩展空间。 
        ElemType *newbase;
        newbase = new ElemType[m_size + 10];
        for (int j = 0; j < m_top; j++)
            newbase[j] = m_base[j];
        delete[] m_base;
        m_base = newbase;
        m_size += 10;
    }
    m_base[m_top++] = e;
}//Push
 //出栈，弹出栈顶元素。先决条件是栈非空。
template <class ElemType>
void SqStack <ElemType>::Pop()
{
    m_top--;
}//Pop
#endif
#pragma once

这次程序还有未完成的地方,对于连续除法未明确优先级，我们将继续努力完成这次程序。

团队成员：赵承圣、罗元浩   http://www.cnblogs.com/lyhao