C++课程设计报告小型特殊计算器Word格式文档下载.docx

C++课程设计报告小型特殊计算器Word格式文档下载.docx

《C++课程设计报告小型特殊计算器Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《C++课程设计报告小型特殊计算器Word格式文档下载.docx（44页珍藏版）》请在冰豆网上搜索。

2.设计目的与要求：

2.1设计目的

达到熟练掌握C++语言的基本知识和技能；

基本掌握面向对象程序设计的基本思路和方法；

能够利用所学的基本知识和技能，解决简单的面向对象程序设计问题。

2.2设计要求

要求利用面向对象的方法以及C++的编程思想来完成系统的设计；

要求在设计的过程中，建立清晰的类层次；

在系统的设计中，至少要用到面向对象的一种机制。

3.系统分析与设计

3.1主要知识点

运算符重载增加了C++语言的可扩充性。

运算符的重载实际上就是一种函数调用的形式，可以用成员函数重载运算符，就是将运算符重载定义为一个类的成员函数的形式；

也可以用友元函数重载。

用友元重载运算符的友元函数是独立于类以外的一般函数。

3.2关键技术

程序中每一种数据类型用一个类来实现，共设计了4个类。

复数类complex，矩阵类matrix，有理数类rational以及集合类set。

每一种类都定义了相应的运算符重载函数。

具体定义如下所示：

（1）类complex

类complex中，成员变量image表示虚部，real表示实部。

成员函数print（）用来显示数据。

运算符重载函数都是用友元函数来实现的。

分别重载+、-、*、/运算符。

（2）类matrix

类matrix中，成员变量elems用来存放矩阵的所有元素，rows表示矩阵的行，cols表示矩阵的列。

成员函数SetElems（）用来给矩阵中的每一个元素赋值，Disp（）用来显示矩阵中的所有元素。

其它友元函数分别重载+、-、*、/运算符。

（3）类rational

类rational中，有两个成员变量：

denominator用来表示有理数的分母，numerator表示有理数的分子。

有理数成员函数print（）用来显示有理数，optimization（）用来优化有理数函数。

友元函数real（）用来将有理数转换为实数，其它友元函数分别重载+、-、*、/运算符。

（4）类set

类set中，有两个成员变量：

elems用来存储集合中的元素，card表示集合中元素的个数。

成员函数print（）用来输出集合中的元素，additem（）用来给集合增加元素。

友元函数分别重载了&

、==、!

=、+、*、<

、<

=运算符。

程序中的运算符重载函数都用友元函数来实现。

① 

类complex的友元函数

复数的表达形式为a+bi，对复数进行运算符重载不像对一般书进行运算那样简单，它的运输方法如下：

加法：

（a+bi）+（c+di）=（a+c）+（b+d）i

减法：

（a+bi）-（c+di）=（a-c）+（b-d）i

乘法：

（a+bi）*（c-di）=（ac-bd）+（ad+bc）i

除法：

（a+bi）/（c+di）=（（a+bi）*（c-di））/（c2+d2）

重载函数将以上算法用在了函数中。

② 

类matrix的友元函数

矩阵类的赋值，实质上是给二维数组赋值；

矩阵相加减就是两个行数列数相同的二维数组相加减；

二维数组相乘，其实就是两个二维数组，其中一个的行数等于另一个的列数，按矩阵相乘的法则进行计算。

③ 

类rational的友元函数

对有理数类进行的操作有下面几种：

有理数相加：

当两个有理数a/b和c/d相加时，可得到这样的算式：

a/b+c/d=（a*d+b*c）/（b*d）

有理数相减：

当两个有理数a/b和c/d相减时，得到的结果是：

分子：

a*d-b*c

分母：

b*d

有理数相乘：

当两个有理数a/b和c/d相乘时，得到的结果是：

a*c

有理数相除：

当两个有理数a/b和c/d相除时，得到的结果是：

a*d

b*c

每次得到结果时，都需要对有理数进行优化。

④ 

类set的友元函数

集合类的运算符重载操作主要有以下几种：

判定某一元素是否属于集合：

此操作用重载运算符函数&

实现，返回值只有两种情况true或者false，取bool类型。

判断两个集合是否相等：

判定两个集合是否相等，需要看两个集合中所包含的元素是否相同，并且不管顺序如何。

用重载运算符==来实现。

判断两个集合是否不等：

是相等操作的取反，用!

=来实现

两个集合的交集：

即求出两个集合中的公共元素，用运算符*实现。

两个个集合的并集：

即两个集合相合并，合并以后去掉重复的元素，用运算符+来实现。

判定一个集合是否是另一个集合的子集：

用运算符<

判定一个集合是否是另一个集合的纯子集：

实现

3.3基本功能要求

（1）功能选择可以用菜单来实现

例如：

请选择您的计算内容：

1. 

复数计算

2. 

有理数计算

3. 

矩阵计算

4. 

集合计算

0. 

退出

用户通过输入不同的数字进入不同的菜单。

次级菜单主要显示本程序的功能，主要的功能有加法、减法、乘法和除法以及集合的求交集、求并集、求子集。

（2）运行时给出明确的提示信息。

比如，输入一个什么类型的数据。

根据用户的输入计算输出结果。

由于数据类型比较多，可以一次输入第一个复数的实部，第一个复数的虚部，再输入第二个复数的实部、虚部。

矩阵运算需要先输入矩阵的行数和列数，然后依次输出矩阵的第一行第一列的元素、第一行第二列的元素等等，依次类推。

有理数运算需要一次输入有理数的分子、分母。

集合运算需要输入集合的元素个数，然后依次输入集合中的每一个元素。

4.系统总体设计（确定程序功能模块）

本程序的功能结构如1所示：

图1程序功能结构图

5.源程序代码

/*****************************************************************************/

//complex.h:

interfaceforthecomplexclass.

#include<

stdlib.h>

classcomplex

{

public:

voidprint（）;

complex（）;

complex（floatr,floati）

{

real=r;

image=i;

}

virtual~complex（）;

friendcomplexoperator+（complexa,complexb）;

friendcomplexoperator-（complexa,complexb）;

friendcomplexoperator*（complexa,complexb）;

friendcomplexoperator/（complexa,complexb）;

private:

floatimage;

floatreal;

};

//rational.h:

interfacefortherationalclass.

classrational

//输出函数

rational（intx=0,inty=0）;

virtual~rational（）;

friendrationaloperator+（rationalnum1,rationalnum2）;

//重载运算符+

friendrationaloperator-（rationalnum1,rationalnum2）;

//重载运算符-

friendrationaloperator*（rationalnum1,rationalnum2）;

//重载运算符*

friendrationaloperator/（rationalnum1,rationalnum2）;

//重载运算符/

friendbooloperator==（rationalnum1,rationalnum2）;

//重载运算符==

frienddoublereal（rationalx）;

//声明转换函数

voidoptimization（）;

//优化有理数函数

intdenominator;

//分母

intnumerator;

//分子

//matrix.h:

interfaceforthematrixclass.

classmatrix

voidDisp（）;

//显示矩阵所有元素

intmatrix:

:

operator（）（shortrow,shortcol）;

//重载运算符成员函数（）

voidSetElem（shortrow,shortcol,intval）;

//将元素（row,col）设置为val

matrix（）;

matrix（shortr,shortc）

rows=r;

cols=c;

elems=newint[rows*cols];

virtual~matrix（）;

friendmatrixoperator+（matrixp,matrixq）;

//重载运算符＋

friendmatrixoperator-（matrixp,matrixq）;

//重载运算符－

friendmatrixoperator*（matrixp,matrixq）;

//重载运算符×

int*elems;

//存放矩阵的所有元素

shortcols;

//矩阵的列

shortrows;

//矩阵的行

//set.h:

interfaceforthesetclass.

#include<

iostream.h>

//enumbool{false,true};

enumerrcode{noerr,overflow};

//定义集合类

classset

//显示输出集合元素

set（）{card=0;

}

virtual~set（）;

errcodeadditem（int）;

//增加集合元素

friendbooloperator&

（int,set）;

//声明重载运算符&

，判断某一整数是否属于某一集合

friendbooloperator==（set,set）;

//声明重载运算符==,判断两个集合是否相等

friendbooloperator!

=（set,set）;

//声明重载运算符!

=，判断两个集合是否不等

friendsetoperator*（set,set）;

//声明重载运算符*，求两个集合的交

friendsetoperator+（set,set）;

//声明重载运算符+,求两个集合的并

friendbooloperator<

（set,set）;

//声明重载运算符<

判断某一集合是否为另一集合的纯子集

＝,判断某一集合是否为另一集合的子集

intelems[16];

intcard;

//complex.cpp:

implementationofthecomplexclass.

#include"

complex.h"

complex:

complex（）

~complex（）

/*

函数名称：

print

功能描述：

显示复数

修改记录：

*/

voidcomplex:

print（）

cout<

<

real;

if（image>

0）

cout<

"

+"

;

if（image!

=0）

image<

i\n"

operator+

*/

complexoperator+（complexa,complexb）

complextemp;

temp.real=a.real+b.real;

temp.image=a.image+b.image;

returntemp;

operator－

complexoperator-（complexa,complexb）

temp.real=a.real-b.real;

temp.image=a.image-b.image;

operator*

complexoperator*（complexa,complexb）

temp.real=a.real*b.real-a.image*b.image;

temp.image=a.real*b.image+a.image*b.real;

operator/

complexoperator/（complexa,complexb）

floattt;

tt=1/（b.real*b.real+b.image*b.image）;

temp.real=（a.real*b.real+a.image*b.image）*tt;

temp.image=（b.real*a.image-a.real*b.image）*tt;

//rational.cpp:

implementationoftherationalclass.

math.h>

rational.h"

rational:

rational（intx,inty）

numerator=x;

denominator=y;

optimization（）;

//有理数优化

~rational（）

optimization

定义有理数优化函数

voidrational:

optimization（）

intgcd;

if（numerator==0）//如果分子为零，则分母为1后返回

denominator=1;

return;

//取分子分母中较小的数作为公约数极限

gcd=（abs（numerator）>

abs（denominator））?

abs（numerator）:

abs（denominator）;

if（gcd==0）

//若为0，则返回

for（inti=gcd;

i>

1;

i--）//用循环找最大公约数

if（（numerator%i==0）&

&

（denominator%i==0））

break;

numerator/=i;

//i为最大公约数，将分子分母整除它，重新赋值

denominator/=i;

//若分子分母均为负数，则结果为正

if（numerator<

0&

denominator<

numerator=-numerator;

denominator=-denominator;

//若分子分母只有一个为负数，则调整为分子取负，分母取正

elseif（numerator<

0||denominator<

numerator=-abs（numerator）;

denominator=abs（denominator）;

numerator;

if（numerator!

=0&

denominator!

=1）

/"

denominator<

\n"

else

operator+

重载运算符+

rationaloperator+（rationalnum1,rationalnum2）

rationaltemp;

temp.denominator=num1.denominator*num2.denominator;

temp.numerator=num1.numerator*num2.denominator+num1.denominator*num2.numerator;

temp.optimization（）;

operator-

重载运算符-

rationaloperator-（rationalnum1,rationalnum2）

temp.numerator=num1.numerator*num2.denominator-num1.denominator*num2.numerator;

}

重载运算符*

rationaloperator*（rationalnum1,rationalnum2）

temp.numerator=num1.numerator*num2.numerator;

重载运算符/

rationa