求解有理数分式方程含代码功能增强.docx

求解有理数分式方程含代码功能增强.docx

《求解有理数分式方程含代码功能增强.docx》由会员分享，可在线阅读，更多相关《求解有理数分式方程含代码功能增强.docx（24页珍藏版）》请在冰点文库上搜索。

求解有理数分式方程含代码功能增强

海南大学

信息科学技术学院

课程设计报告

课程名称：

《C++程序设计》课程设计

课题名称：

求解有理数分式方程

专业：

信息与计算科学

学号：

20151614310002

姓名：

titiedejinse

指导教师：

设计时间：

2016~2017学年第二学期

2017年6月29日

成绩：

1．设计内容

1.1问题描述

一、定义分式类，其中包含分子和分母。

二、实现功能：

求解一元一次有理数分式方程

三、要求：

1、设计菜单实现功能选择

2、输入功能：

输入有理数分式方程

3、计算并输出方程的根，并用最简分式表示

4、使用多文件方式设计：

1）类的说明设计成.h头文件

2）类的实现为一个.cpp文件

3）主函数为另一个.cpp文件

1.2设计思路

1）定义类Fenshi和jisuan，对成员函数进行定义，并运用带默认形参值的构造函数，拷贝构造函数，析构函数，类的组合，运算符的重载等方法。

2）设计多个函数并进行调用实现求解一元一次有理数分式方程。

3）设计一个对象数组存储运算结果。

4）提供查看历史结果功能。

5）提供按照指定规则查询结果功能。

1.3数据结构定义

定义一个类jisuan接受参数，使用类Fenshi类对运算符进行重载计算。

定义一个jisuan类的动态数组p存储结果。

2．总体设计

2.1程序设计函数接口

1.Fenshi类

1）Fenshi（intn=0,intd=1）;//带默认形参值的构造函数

2）Fenshi（Fenshi&fen）;//拷贝构造函数

3）~Fenshi（）;//析构函数

4）voidsimplify（）;//将分式化为最简形式

5）booloperator==（Fenshi&fen）;//运算符重载

6）Fenshioperator+（Fenshi&fen）;

7）Fenshioperator-（Fenshi&fen）;

8）Fenshioperator*（Fenshi&fen）;

9）Fenshioperator/（Fenshi&fen）;

10）voidprint（）;//输出分式

11）intGcd（inta,intb）;//辗转相除法求最大公因子

12）boolIsneg（）;//判断分式是否为正数

2.jisuan类

1）jisuan（）;//默认构造函数

2）jisuan（inta,intb,intc,intd,inte,intf）;//构造函数

3）~jisuan（）;//析构函数

4）voidcal（）;//计算有理分式的结果

5）voidprint（）;//以分数形式输出结果

6）FenshiA;//待求解方程x的系数

3.主函数

1）voidDrawWarn（）；//输出警告界面

2）voidDrawMenu（）；//输出菜单

2.2程序功能说明

1）输入参数：

录入方程的参数并输出结果。

2）历史结果：

查询用户计算过的历史记录。

3）查询结果：

按系数或者次序查询计算过的结果。

4）退出系统。

2.3程序流程图

图2-1程序流程图

3．调试结果

3.1程序运行

1）程序启动输入存储结果个数界面

2）主菜单

3）计算界面

4）历史结果界面

5）查询结果界面

6）警告界面

6.1）未存储数据时查询历史结果

6.2）超过给定的最大存储个数

3.2总结分析

本次设计让我对C++有了更进一步的认识，特别是在类与对象这一块，发现了以前很多的知识漏洞。

这个设计过程最难的便是程序的调试了，有时候程序明明看起来并没有任何的错误，但是结果偏偏不对，实在是恼人，可能只是一个小小的错误比如将“==”写成了“=”，但是结果确实完全错误。

我相信在今后的学习真的我会更加努力，积累经验。

使自己在编程等各方面得到提高。

4.程序清单

头文件（类的定义）：

classFenshi

{

public:

Fenshi（intn=0,intd=1）;

Fenshi（Fenshi&fen）;

~Fenshi（）;

voidsimplify（）;//将分式化为最简形式,并检查分母是否为0

//进行运算符的重载

booloperator==（Fenshi&fen）;

Fenshioperator+（Fenshi&fen）;

Fenshioperator-（Fenshi&fen）;

Fenshioperator*（Fenshi&fen）;

Fenshioperator/（Fenshi&fen）;

voidprint（）;//输出分式

intGcd（inta,intb）;//最大公因子

boolIsneg（）;

private:

intfenmu,fenzi;

};

classjisuan

{

public:

jisuan（）;

jisuan（inta,intb,intc,intd,inte,intf）;

~jisuan（）;

voidcal（）;//计算

voidprint（）;

FenshiA;

private:

FenshiB;

FenshiC;

Fenshians;

};

类的实现：

#include"dingyi.h"

#include

#include

usingnamespacestd;

#include

Fenshi:

:

Fenshi（intn,intd）

{

this->fenzi=n;

this->fenmu=d;

simplify（）;

}

Fenshi:

:

Fenshi（Fenshi&fen）

{

this->fenmu=fen.fenmu;

this->fenzi=fen.fenzi;

simplify（）;

}

Fenshi:

:

~Fenshi（）

{}

boolFenshi:

:

operator==（Fenshi&fen）

{

if（this->fenmu==fen.fenmu&&this->fenzi==fen.fenzi）

returntrue;

else

returnfalse;

}

FenshiFenshi:

:

operator+（Fenshi&fen）

{

Fenshians;

ans.fenmu=this->fenmu*fen.fenmu;

ans.fenzi=this->fenzi*fen.fenmu+this->fenmu*fen.fenzi;

ans.simplify（）;

returnans;

}

FenshiFenshi:

:

operator-（Fenshi&fen）

{

Fenshians;

ans.fenmu=this->fenmu*fen.fenmu;

ans.fenzi=this->fenzi*fen.fenmu-this->fenmu*fen.fenzi;

ans.simplify（）;

returnans;

}

FenshiFenshi:

:

operator*（Fenshi&fen）

{

Fenshians;

ans.fenmu=this->fenmu*fen.fenmu;

ans.fenzi=this->fenzi*fen.fenzi;

ans.simplify（）;

returnans;

}

FenshiFenshi:

:

operator/（Fenshi&fen）

{

Fenshians;

ans.fenmu=this->fenmu*fen.fenzi;

ans.fenzi=this->fenzi*fen.fenmu;

ans.simplify（）;

returnans;

}

voidFenshi:

:

simplify（）

{

if（fenmu<0）

{

fenmu=-fenmu;

fenzi=-fenzi;

}

inta=abs（fenzi）,b=abs（fenmu）;

intk;

if（a

k=Gcd（b,a）;

else

k=Gcd（a,b）;

fenmu=fenmu/k;

fenzi=fenzi/k;

}

intFenshi:

:

Gcd（inta,intb）

{

if（b==0）

returna;

returnGcd（b,a%b）;

}

voidFenshi:

:

print（）

{

if（fenzi==0）

cout<<0;

else

{

if（fenmu==1）

cout<

elseif（fenmu==-1）

cout<<-fenzi;

else

cout<

}

}

boolFenshi:

:

Isneg（）

{

if（fenzi<0）

returnfalse;

else

returntrue;

}

jisuan:

:

jisuan（）:

A（0,1）,B（0,1）,C（0,1）

{

}

jisuan:

:

jisuan（inta,intb,intc,intd,inte,intf）:

A（a,b）,B（c,d）,C（e,f）

{

}

jisuan:

:

~jisuan（）

{}

voidjisuan:

:

cal（）

{

ans=（C-B）/A;

}

voidjisuan:

:

print（）

{

cal（）;

cout<<"\t方程为：

"<

cout<<"\t";

A.print（）;

cout<<'x';

if（B.Isneg（））

cout<<'+';

B.print（）;

cout<<"=";

C.print（）;

cout<

cout<<"\t结果为:

"<

cout<<"\tx=";

ans.print（）;

cout<

}

主函数：

#include"dingyi.h"

#include

#include

usingnamespacestd;

#include

voidDrawWarn（）

{

cout<

<

cout<<"\t┏━━━━━━━━━━━━━━━━━━━━━┓"<

cout<<"\t┃请先输入参数！

┃"<

cout<<"\t┗━━━━━━━━━━━━━━━━━━━━━┛"<

}

voidDrawMenu（）

{

system（"cls"）;

cout<

<

cout<<"\t┏━━━━━━━━━━━━━━━━━━━━━┓"<

cout<<"\t┃请选择操作┃"<

cout<<"\t┣━━━━━━━━━━━━━━━━━━━━━┫"<

cout<<"\t┃1.输入参数┃"<

cout<<"\t┣━━━━━━━━━━━━━━━━━━━━━┫"<

cout<<"\t┃2.历史结果┃"<

cout<<"\t┣━━━━━━━━━━━━━━━━━━━━━┫"<

cout<<"\t┃3.查询结果┃"<

cout<<"\t┣━━━━━━━━━━━━━━━━━━━━━┫"<

cout<<"\t┃0.退出┃"<

cout<<"\t┗━━━━━━━━━━━━━━━━━━━━━┛"<

}

intmain（）

{

inta,b,c,d,e,f,n,count=0;

cout<<"请输入您想要保存的答案个数：

"<

cin>>n;

jisuan*p;

p=newjisuan[n];

charch;

boolbeContinue=true;//表示是否继续，用户选了“退出”，则为false，退出程序

boolbeInited=false;//表示方程是否被初始化，若没有被初始化，则不允许“输出结果”。

while（beContinue）

{

DrawMenu（）;

while

（1）

{

ch=_getch（）;

if（ch<='3'&&ch>='0'）

break;

DrawMenu（）;

}

switch（ch）

{

case'1':

{

system（"cls"）;

if（count==n）

{

cout<<"已经达到最大存储范围"<

cout<<"请按任意键返回";

_getch（）;

DrawMenu（）;

break;

}

cout<

<

<

cout<<"\t方程为：

（a/b）x+c/d=e/f"<

cout<<"\t请依次输入[abcdef]:

"<

a=0;

while（a==0）

{

cout<<"\ta=";

cin>>a;

if（a==0）

cout<<"\t系数不能为0！

请重新输入！

"<

}

b=0;

while（b==0）

{

cout<<"\tb=";

cin>>b;

if（b==0）

cout<<"\t分母不能为0！

请重新输入！

"<

}

cout<<"\tc=";

cin>>c;

d=0;

while（d==0）

{

cout<<"\td=";

cin>>d;

if（d==0）

cout<<"\t分母不能为0！

请重新输入！

"<

}

cout<<"\te=";

cin>>e;

f=0;

while（f==0）

{

cout<<"\tf=";

cin>>f;

if（f==0）

cout<<"\t分母不能为0！

请重新输入！

"<

}

beInited=true;

jisuanfa（a,b,c,d,e,f）;

cout<

<

<

fa.print（）;

p[count]=fa;

count++;

cout<<"请按任意键返回";

_getch（）;

DrawMenu（）;

break;}

case'2':

{

system（"cls"）;

if（beInited）

{

for（inti=0;i

{cout<<"第"<

p[i].print（）;

cout<

cout<<"请按任意键返回";

_getch（）;

DrawMenu（）;

}

else

{

DrawWarn（）;

cout<<"请按任意键返回";

_getch（）;

DrawMenu（）;

}

}

break;

case'3':

{

system（"cls"）;

cout<<"\t┏━━━━━━━━━━━━━━━━━━━━━┓"<

cout<<"\t┃请选择操作┃"<

cout<<"\t┣━━━━━━━━━━━━━━━━━━━━━┫"<

cout<<"\t┃1.以运行顺序查询┃"<

cout<<"\t┣━━━━━━━━━━━━━━━━━━━━━┫"<

cout<<"\t┃2.以x的系数查询┃"<

cout<<"\t┣━━━━━━━━━━━━━━━━━━━━━┫"<

cout<<"\t┃0.退出┃"<

cout<<"\t┗━━━━━━━━━━━━━━━━━━━━━┛"<

boolIsc=true;

while（Isc）

{

charcha;

while

（1）

{

cha=_getch（）;

if（cha<='2'&&ch>='0'）

break;

else

cout<<"输入错误！

请重新输入"<

}

switch（cha）

{

case'1':

{

cout<<"请输入查询第几次的结果"<

intcha;

cin>>cha;

if（cha<=count&&cha>0）

{

cout<<"结果为:

"<

p[cha-1].print（）;

cout<

}

else

cout<<"没有这个结果"<

cout<<"请继续选择查询方法或者返回主菜单"<

break;

}

case'2':

{

intaa,bb;

boolIsexi=true;

cout<<"请输入x的系数的分子分母"<

cin>>aa>>bb;

Fenshichaxun（aa,bb）;

for（inti=0;i

{

if（p[i].A==chaxun）

{p[i].print（）;

cout<

Isexi=false;}

}

if（Isexi）

cout<<"没有这个结果"<

cout<<"请继续选择查询方法或者返回主菜单"<

break;

}

case'0':

Isc=false;

break;

}

}

_getch（）;

DrawMenu（）;

break;

}

case'0':

beContinue=false;

cout<

<<"\t";

break;

}

}

return1;

}