实例：加减法小测验-面向对象

项目设计题目及要求

题目：加减法小测验。面向小学1~2年级学生，随机选择两个整数和加减法形成算式要求学生解答。

功能要求：电脑随机出10道题，每题10分，程序结束时显示学生得分；确保算式没有超出1~2年级的水平，只允许进行100以内的加减法，不允许两数之和或之差超出0~100的范围，负数更是不允许的；每道题学生有三次机会输入答案，当学生输入错误答案时，提醒学生重新输入，如果三次机会结束则输出正确答案；对于每道题，学生第一次输入正确答案得10分，第二次输入正确答案得7分，第三次输入正确答案得5分，否则不得分；总成绩90以上显示“SMART”，80-90显示“GOOD”，70-80显示“OK”，60-70显示“PASS”，60以下“TRYAGAIN”

变化扩展：

1）允许用户初始选择题目类型：加法，减法，还是加减法都有。

2）评判完成后，显示答错的题，并给出正确答案。

3）若是一组题，可以重复使用，怎样处理？

4）界面与应用逻辑分离

5）可以设置参数

项目的面向对象设计

2.1需求分析

1）分析系统的功能需求：

出题：随机出题。每题要求：确保算式没有超出1~2年级的水平，只允许进行100以内的加减法，不允许两数之和或之差超出0~100的范围，负数更是不允许的。

答题：每道题学生有三次机会输入答案，每输入一次答案，进行评价，若正确显示正确，若错误，显示错误，并提醒学生重新输入答案。若是第三次错误，则不再给机会输入答案。

答题评分：每道题，学生一次做对得10分，二次做对得7分，三次做对得5分，其余不得分；

总评分：每个测试出10题，10题做完过后给出总评分。总成绩90以上显示“SMART”,80-90显示“GOOD”,70-80显示“OK”,60-70显示“PASS”,60以下“TRYAGAIN”

2）系统流程：

先出完10题然后按顺序做题。

首先显示一个题目用户给出答案进行评判。若做题结束进入下一题若没有结束用户继续给出答案进行评判。

做完10题计算总评分并分等级给出评价。

流程如图1所示。

图1系统流程图

2.2总体设计

方案一：

1）识别类

问题中出现了题目，解答，测试等事物。将题目和解答的数据及功能合并，作为题目类将测试作为一个类。

题目类：表示一个题目，及相关的解答状况。

测试类：对一次测试做一个包装，其中包括10个题目，以及测试的总分评价。

测试类和题目类之间是个1对多的包含关系。

2）详细设计

Question类设计数据成员：两个操作数，运算符，运算结果；本题得分，答题次数，是否答对。功能：负责出一道题并让用户做题，并评价。

接口：

生成题目。

答题（显示题目，支持做题，支持得分）。

返回成绩。

私有成员函数

生成题目数据。（私有）

判断题目是否符合要求。（私有）

Test类设计

数据成员：多个Question类对象（用数组组织数据，用vector组织数据），题目数目,总分，等级，评价。

功能：创建测试题目，启动测试，总评价。

接口为：

创建题目（或放在构造函数中）

启动测试

返回总分

返回评判结果（获得评判）

方案一：实现

#include〈iostream〉

#include〈cstdlib〉

#include<ctime〉

#include〈conio.h〉usingnamespacestd;

chartype[2]={，+，,，_，};

intgrade[3]={10,7,5};

char*evaluation[5]={"SMART","GOOD","OK","PASS","TRYAGAIN"};constintMAX_TIMES=3;

intgetACount(inta,intb)

{

returnrand()%(b_a)+a;

}

classQuestion

{

private:

inta;

intb;

charc;

intresult;

//

intscore;

inttimes;

intstate;

intresults[MAX_TIMES];

voidAQuestion()

{

a=getACount(0,100);

b=getACount(0,100);

c=type[getACount(0,2)];

if(c=='+')

result=a+b;

else

result=a—b;

}

booltestAQuestion()

{

if((result〈0)||(result〉100))

returnfalse;

else

returntrue;

}

booldoOnceTest()

{

cout＜〈a〈〈c〈〈b〈〈"=";

cin〉〉results[times];

if(results[times]==result)

state—1;

else

state—0;

times++;

returnstate;

}

public:

Question():a(0),b(0),c('+'),result(0),times(0),state(0),score(0)

{

}

voidcreateQuestion()

{

while(true)

{

AQuestion();

if(testAQuestion())

break;

}

}

voiddoATest()

{

for(inti=O;i〈MAX_TIMES;i++)

{

if(doOnceTest())

{

score=grade[timesT];

break;

}

else

{

if(i<2)

cout〈〈"答错了，请继续回答："；

else

cout〈〈"答错了，你没有机会了〃〈〈endl;

}

}

}

intgetScore()

{

returnscore;

}

};

classTest

{

private:

Question*q;

intcount;

intscore;

intlevel()

{

intlevel=4;

switch(score/10)

{

{

case10:

case9:

level=0;

break;

case8:

level=1;

break;

case7:

level=2;

break;

case6:

level=3;

break;

case5:

level=4;

}

returnlevel;

}

public:

Test(intc=10):count(c),score(0)

{

q=newQuestion[c];

}

intgetScore()

{

returnscore;

}

char*getEvaluation()

{

returnevaluation[level()];

}

voidrunTest()

{

for(inti=0;i〈count;i++)

{

q[i].createQuestion();q[i].doATest();score=score+q[i].getScore();

}

}

};

intmain()

srand((unsigned)time(NULL));

TestaTest;

aTest.runTest();

cout〈〈"你的成绩为"〈〈aTest.getScore()〈〈"，"〈〈aTest.getEvaluation()〈〈endl;getch();

}

方案二：

1）识别类将题目独立出来。从概念上来说题目是独立于解答存在的，将其独立出来作为题目类

Question。将一个题目的测试作为一个独立的类Answer,记录做题的相关数据，支持相关功能。将一个学生的完整测试作为一个类Test，包装整个测试，以对外界提供更高层的抽象。类结构如图所示。

Answer类与Question类是单向关联关系（使用关系）。Test类与Question类是一对多的关联关系，与Answer类是一对多关联关系。

2）详细设计设计时考虑1）可以设置测试题目类型（加法、减法、加减混合），可以设置其它参数

（总题目数，每个题目的最大答题次数，总分，每个题目的每次解答的分数）；2）界面与应用分离。

Question类：

数据成员：两个操作数，运算符，运算结果。定义一个静态成员type表示测试的类型，来决定出题的算法。

功能：出题。

接口为：

出题

获得结果：为Answer提供服务，获得结果。

获得题目（字符串）：为了做到与界面分离，只负责业务逻辑，不负责输入输出，因此需要返回题目。

Answer类：数据成员：本题得分，答题次数，是否答对，各次的答题结果。指向当前题目的指针。定义静态数据成员作为答题参数：最大答题次数，每次答题的分数。

功能：提供答题判断，并给分。

接口为：

setQuestion:关联题目。

setResult：得到学生的答案并评价：通过与question的关联获得正确结果，并判断是否作对。设置相关参数（答题次数，答题状态，得分）

返回本次答题评价

返回获得分数

Test类

数据成员：本次测试的一组Question（用数组或vector组织），本次测试的解答一组Answer（用数组或vector组织）。为类描述测试的进行状态，增加两个数据成员：当前题目，是否进入下个题目。以及测试的所有相关参数。

功能：对全部测试提供对外包装，描述测试状态。

接口为：

设置参数

出题

返回题目信息

学生给出一个结果

是否还有题

方案二：实现

#include"stdafx.h"

#include〈iostream〉

#include<strstream〉

#include<cstdlib〉

#include<ctime〉

#include<string〉

#include<vector〉

#include〈conio.h〉

usingnamespacestd;

chartype[2]={，+，,，_，};

intgrade[3]={10,7,5};

char*evaluation[5]={"SMART","GOOD","OK","PASS","TRYAGAIN"};

intgetANumber(inta,intb)

{

returnrand()%(b_a)+a;

}

classQuestion

{

private:

inta;

intb;

charc;

intresult;

staticintstyle;

public:

staticvoidsetParam(ints)

{

style=s;

}

Question():a(0),b(0),c(type[O]),result(0)

{

}

~Question(){}

voidcreate()

{

while(true)

{

createQuestion();

if(testQuestion())break;

}

}

intgetResult()

{

returnresult;

}

stringgetQuestion()

{

charstr[100];

sprintf_s(str,"%d%c%d=",a,c,b);returnstring(str);

}

private:

voidcreateQuestion()

{

a=getANumber(0,100);

b=getANumber(0,100);

c=getType();

if(c=='+')

result=a+b;

elseresult=a—b;

}

chargetType()//返回题目的运算符(根据要求的测试类型，产生不同的运算符){

switch(style)

{

case1:

return'+';

break;

case2:

return'-';

break;

case0:

returntype[getANumber(0,1)];break;

}

}

booltestQuestion()

{

if((result〈0)||(result〉100))

returnfalse;

else

returntrue;

}

};

intQuestion::style=0;

classAnswer

{

private:

inttimes;//做题次数

vector〈int〉result;

boolstate;//是否作对

intscore;//本题得分

Question*que;

staticintmaxTimes;//最大做题次数

staticint*grade;//不同次数得分

public:

staticvoidsetParam(intmT,int*g)

{

maxTimes=mT;

grade=g;

}

Answer():times(O),state(0),score(0),que(NULL)

{

result.reserve(IO);

}

~Answer(){}

voidsetQuestion(Question*q)

{

que=q;

}

boolsetResult(intr)//返回值表示本题答题是否结束

{

result.push_back();

if(r==que-〉getResult())

{

state=true;score=grade[times];

}

times++;

if((state==true)||(times==3))

returntrue;//本题结束

else

returnfalse;//本题还有机会

}

stringgetString()

{

strings1="答对了"；

strings2=〃答错了，请继续回答〃；

strings3="答错了，你没有机会了";

if(state)

returns1;

if(times<3)

returns2;

else

returns3;

}

intgetScore()

{

returnscore;

}

};

intAnswer::maxTimes=O;int*Answer::grade=NULL;

classTest

{

private:

Question*q;

Answer*ans;

intcount;//本次测试的题目数

intstyle;//本次测试的题目类型，0:混合，1：加，2减

intmaxA;//本次测试的每题答题次数

int*sDistribution;//不同次数的成绩分配

inttotalScore;//最后得分

intcurrentQ;//当前题

boolnextQ;//是否进入下一题

public:

Test():q(NULL),ans(NULL),totalScore(0),currentQ(0),nextQ(false),count(0),maxA(0),style(0)

{

}

~Test()

{

delete]]q;

delete]]ans;

delete[]sDistribution;

}

voidsetParam(intc,intmA,intt,int*sd)//设置参数

{

count=c;

style=t;

maxA=mA;

sDistribution=newint[maxA];

for(inti=0;i〈maxA;i++)

sDistribution[i]=sd[i];

Question::setParam(style);

Answer::setParam(maxA,sDistribution);

if(q!=NULL)delete]]q;

if(ans!=NULL)

delete]]ans;

q=newQuestion[count];

ans=newAnswer[count];

for(inti=0;i〈count;i++)

{

}

ans[i].setQuestion(&q[i]);

}

voidsetTest()//出题

{

for(inti=0;i〈count;i++)

q[i].create();

}

inthasQuestion()//当前测试，还有题吗？

{

returncurrentQ〈countT;

}

stringgetCurrentQ()//返回当前题目字符串

{

if(nextQ)

currentQ++;

returnq[currentQ].getQuestion();

}

booldoCurrentQ(intre)//当前题目，设置一次结果，返回是否正确{

if(ans[currentQ].setResult(re))

{

nextQ=true;

returntrue;

}

else

returnfalse;

}

stringgetCurrentAS()

{

returnans[currentQ].getString();

}

voidcomputeScore()

{

for(inti=0;i〈count;i++)

totalScore