VC++课程实践报告hwWord文档格式.docx

VC++课程实践报告hwWord文档格式.docx

《VC++课程实践报告hwWord文档格式.docx》由会员分享，可在线阅读，更多相关《VC++课程实践报告hwWord文档格式.docx（20页珍藏版）》请在冰豆网上搜索。

●voidaverage（）：

输出平均值，并将数组中的元素按要求重新放置。

●voidprint（）：

输出一维数组。

（3）在主程序中用数据{1.3，6.2，3，9．1，4．8，7．4，5．6，9．2，2．3}对该类进行测试。

任务三：

建立一个类MOVE，将数组中最大元素的值与最小元素的值互换。

●int*array：

●intn：

数组中的元素的个数。

（2）公有数据成员：

●MOVE（intb[]，intm）：

构造函数，初始化成员数据。

●voidexchange（）：

●voidprint（）：

●~MOVE（）：

析构函数。

（3）在主程序中用数据{21,65,43,87,12,84,44,97,32,55}对该类进行测试。

任务四：

建立一个类MOVE，对数组中元素进行循环换位，即每个元素后移三位，最后三个元素移到最前面。

（1）私有成员数据:

●intarray[20]:

一维数组整型。

（2）公有成员数据：

●voidchange（）：

进行循环换位。

任务五：

定义一个类SIN，求sin（x）=x/1-x3/3!

+x5/5!

-x7/7!

+…+（-1）n+1x（2n-1）/（2n-1）

●intx:

输入公式中x的值，求sin（x）。

输入公式中n的值。

（2）公有成员数据：

●SIN（intx，intn）：

构造函数，用于初始化x和n的值。

●intpower（intq）：

求q！

的值。

●intmi（intm，intn）：

求mn的值。

●intfun（）：

用于求SIN（X）的值。

●voidshow（）：

输出求得结果。

（3）在主程序中定义对象test，对该类进行测试。

任务六：

定义一个方阵累Array，实现对方阵进行顺时针90度旋转，如图所示。

123413951

5678141062

9101112151173

13141516161284

（1）私有成员数据：

●inta[4][4]：

用于存放方阵。

●Arrat（inta1[][4]，intn）：

构造函数，用给定的参数a1初始化数据成员a。

●voidxuanzhuan（）：

实现对方阵a进行顺时针90度的旋转。

在屏幕上显示数组元素。

（3）在主程序中定义数组intb[][4]={1，2，3，4，5，6，7，8，9，10，11，12，13,14，15，16}作为原始数组，定义一个Array类对象test，用b初始化test，完成对该类的测试。

二、系统设计

任务一

1.任务（系统）分析

通过求出数据辅助函数power（）求出mn的值，在成员函数fun（）中计算出所求值类的定义如下：

classSP{

intn,k;

public:

SP（intn1,intk1）；

intpower（intm,intn）；

intfun（）；

voidshow（）；

};

2.算法设计

（1）求mn

利用循环语句，定义整数mul=1,i=0当i<

n时，mul*=mul;

然后返回mul。

（2）求累加和

利用循环语句，定义整数sum=0，j=1,i<

=n时，sum+=power（j,k），然后j自增,然后返回sum。

3.系统测试

在主函数中初始化SP的对象，并调用其成员函数show（）输出测试结果（整数n和k）。

主函数定义如下：

voidmain（）

{

cin>

>

n>

k;

SPtest（n,k）;

test.fun（）;

test.show（）;

}

用以测试的数为：

n:

2,k:

2

预期的输出结果为：

结果为：

5

任务二

通过与数组值平均值比较大小来重新放置各元素，类定义如下：

classMOVE

floatarray[20];

intn;

MOVE（floatb[],intm）;

voidaverage（）;

voidprint（）;

（1）一维数组的赋值：

MOVE:

:

MOVE（floatb[],intm）

{

n=m;

for（inti=0;

i<

n;

i++）

array[i]=b[i];

}

（2）数组的重新排序：

先求出平均值，在将数组元素与该平均值进行比较，进而移位

voidMOVE:

average（）

floatsum=0,c[20],q;

statici=n,p=0;

for（intj=0;

j<

j++）{

sum+=array[j];

q=sum/n;

cout<

<

"

平均数为"

q<

endl;

for（intk=0;

k<

k++）

{c[k]=array[k];

if（c[k]<

q）array[p++]=c[k];

if（c[k]>

q）array[i--]=c[k];

在主函数中定义MOVE的对象test，

定义一维数组{1.3，6.2，3，9．1，4．8，7．4，5．6，9．2，2．3}。

用以测试的整数为：

{1.3,6.2,3,9.1,4.8,7.4,5.6,9.2,2.3}

平均数为：

5.43333

1.334.82.34.89.25.67.49.16.2

任务三

通过成员函数exchange（）定义整数average,通过循环语句，求出平均值average，定义整数i=0，定义最大值x1=array[0],最小值x2=array[0],随着i的递增，一次求出array[i],并将array[i]分别与x1,x2比较，从而实现重新排序。

类的定义如下：

classMOVE{

int*array;

MOVE（intb[],intm）；

voidexchange（）；

voidprint（）；

~MOVE（）；

（1）通过成员函数exchange（）定义的进度实数sum,通过循环语句，求出平均值average，定义整数i=0，定义最大值x1=array[0],最小值x2=array[0],随着i的递增，一次求出array[i],并将array[i]分别与x1,x2比较，从而实现互换。

（2）通过print（）函数输出刚刚求出的array[i];

在主函数中初始化MOVE的对象，并调用其成员函数print（）输出测试结果。

intb[10]={21,65,43,87,12,84,44,97,32,55};

MOVEtest（b，10）;

test.exchange（）;

test.print（）;

21,65,43,87,12,84,44,97,32,55

21,65,43,87,97,84,44,12,32,55

通过类MOVE的构造函数初始化一维数组array[20],通过调用change（）实现元素的换位移动，通过print（）函数实现移动后数组的输出。

intarray[20];

MOVE（intb[],intm）;

voidchange（）;

将前三项数据保存在变量中

定义三个变量a,b,c;

将数组的前三项一一赋值给k1，k2，k3，

将数组中的第最后前三项分别换位到一二三项中

用循环for语句，将最后三项一次赋值到一二三项中

将数组中的第三项以后，最后三项以前的所有数据向后移三个位置，通过循环for语句实现。

将k1，k2，k3中的数据分别保存到数组的四五六项中，这样完整的数组就变换完成了。

在主函数中定义一个数组，a[]={21,65,43,87,12,84,44,97,32,55},定义一个类MOVE的对象t，并用数组a[10]初始化该对象。

通过该对象调用循环换位函数change（）,实现数组中数据的循环换位。

再通过该对象调用输出函数print（）将换位后的函数输出。

主函数的定义如下：

voidmain（）{

inta[]={21,65,43,87,12,84,44,97,32,55};

MOVEtest（a,10）;

test.change（）;

test.print（）;

预期的输出结果为：

97325521654387128444

任务五

通过类SIN的构造函数初始化x和n的值，在数据辅助函数power（）中求出q！

的值，在函数mi（）中求出mn的值，通过成员函数fun（）计算出所求值，通过show（）输出所求值。

#include<

iostream.h>

classSIN{

intx;

SIN（intx1,intn1）;

intpower（intq）;

intmi（intm,intn）;

intfun（）;

voidshow（）;

定义一个整型变量t，用递归函数求出q！

的值，令t=q*power（q-1）。

求mn

利用循环语句，定义整数a,b,定义双精度实数c,b=a*a,c=a,i=0当i<

（2*n-1）时，c*=b;

c*=-1;

求SIN（X）

定义双精度实型变量sum=0，d,e,f，定义整型变量n,x,利用递归语句，d=power（（2n）-1）;

e=mi（m,n）;

f=d/e;

sum=sum+f;

最后返回sum的值。

在主函数中以整数初始化test的对象，通过该对象调用成员函数fun（）得到所求的值，并调用其成员函数show（）输出测试结果。

主函数的定义如下：

intn,x;

SINtest（x,n）;

22

sin（x）=0.6666667

任务六

利用循环语句依次改变每个对象的行下标和列下标，从而实现整个方阵的旋转。

classArray{

inta[4][4];

Array（inta1[][4],intn）;

voidxuanzhuan（）;

（1）在xuanzhuan（）函数中，定义inta2[4][4];

inti=0，intj=0；

intk=0利用循环语句使a[j][3-k]=a2[k][j]，从而实现方阵的顺时针旋转。

（2）通过show（）函数输出结果。

在主函数中初始化Array的对象，并调用其成员函数show（）输出测试结果。

intb[][4]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};

Arraytest（b,16）;

test.xuanzhuan（）;

1，2，3，4，5，6，7，8，9，10，11，12，13，14，15，16

123413951

5678141062

9101112151173

13141516161284

三、实践小结

（说明：

主要写实践心得、实践中遇到的问题，是如何解决的。

）

通过上机实践熟练掌握了一维数组和二维数组的运用，特别是构造函数方面，以及有关函数多态性，明白了它的流程，但是从中也遇到了一些疑问。

析构函数的使用不是很清楚，我主要通过向他人请教，以及翻阅教材中有关章节，还有去图书馆查阅相关资料在多做一些类似的题目（主要是解析实训上的大量习题）去锻炼自己，看自己是否能熟练操作。

构造函数对成员数据初始化有时也不能很精准的掌握，多看看以前做过的题目，从题目中总结经验，得出一些它们的规律，找出相似之处。

对于链表等等这些章节，多是以回归课本，看看书，来了解它的意思。

四、参考文献

[1]齐治昌.软件工程[M].北京：

高等教育出版社出版，2004，35-60

[2]钱雪忠.数据库与SQLServer2005教程[M].北京：

清华大学出版社，2007，194-365

[3]张荣梅，梁晓林等.VisualC++实用教程[M].北京：

中国铁道出版社，2008，31-48

……

五、源程序清单

classSP

SP（intn1,intk1）

n=n1;

k=k1;

intpower（intm,intn）

intmul=1;

for（inti=0;

i++）

mul*=m;

returnmul;

intfun（）

intsum=0;

for（intj=1;

=n;

j++）

sum+=power（j,k）;

returnsum;

voidshow（）

n<

'

\t'

\n'

fun（）<

intk;

voidMOVE:

print（）

cout<

array[i]<

;

floatarray[20]={1.3,6.2,3,9.1,4.8,7.4,5.6,9.2,2.3};

MOVEtest（array,9）;

test.average（）;

intn;

MOVE（intb[],intm）

array=newint[n];

i++）{

array[i]=b[i];

n=m;

voidexchange（）

floatsum=0;

{

sum+=array[i];

sum/=n;

}

intx1=array[0],x2=array[0],s1,s2,s3;

for（intj=0;

{if（x1>

array[j]）{x1=array[j];

s2=j;

if（x2<

array[j]）{x2=array[j];

s3=j;

}

s1=array[s2];

array[s2]=array[s3];

array[s3]=s1;

voidprint（）

cout<

~MOVE（）

if（array）delete[]array;

MOVEtest（b,10）;

test.exchange（）;

string.h>

20;

{

voidchange（）

intk1,k2,k3;

k1=array[n-1];

k2=array[n-2];

k3=array[n-3];

for（inti=n-4;

i>

=0;

i--）

array[i+3]=array[i];

array[0]=k3;

array[1]=k2;

array[2]=k1;

for（intm=0;

m<

m++）

array[m]<

test.change（）;

classSIN

SIN（intx,intn）;

SIN:

SIN（intx,intn）{

intSIN:

power（intq）{

intt;

if（q==1）t=1;

elset=q*power（q-1）;

returnt;

mi（intm,intn）{

inta,b;

doublec;

b=a*a;

c=a;

=（2*n-1）;

i+=2）{

c=c*b;

c=c*（-1）;

returnc;

fun（）{

doublesum=0;

doubled,e,f;

d=power（（2n）-1）;

e=mi（m,n）;

f=d/e;

sum=sum+f;

voidSIN:

show（）{

SIN（X）="

intx,n;

classArray

Array:

Array（inta1[][4],intn）

for（inti=0;

4;

{

for（intj=0;

a[i][j]=a1[i][j];

}

voidArray:

xuanzhuan（）