江苏科技大学c++实验报告.docx

江苏科技大学c++实验报告.docx

《江苏科技大学c++实验报告.docx》由会员分享，可在线阅读，更多相关《江苏科技大学c++实验报告.docx（25页珍藏版）》请在冰豆网上搜索。

江苏科技大学c++实验报告

江苏科技大学-c++实验报告

江苏科技大学

课程实践报告

设计题目：

计算机程序设计实验（C++）

设计时间：

2016年10月3日至2016年10月4日

学院：

计算机科学与工程学院

专业班级：

通信工程1522107041

学生姓名：

周祯楠学号：

152********0

指导老师：

於跃成

一、第三题

（一）题目：

3．建立一个类MOVE，不进行排序，将数组中小于平均值的元素放到数组的左边，大于平均值的元素放到数组的右边。

 具体要求如下：

（1）私有数据成员。

float array[20]：

一维整型数组。

int n：

数组中元素的个数。

（2）公有成员函数 

MOVE（float b[],int m）：

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

void average（）：

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

void print（）：

输出一维数组。

（3）在主程序中用数据{1.3,6.2,3,9.1,4.8,7.4,5.6,9.2,2.3}对该类进行测试。

（二）源程序：

#include

classMOVE

{

floatarray[20];

intn;

public:

MOVE（floatb[],intm）;

voidaverage（）;

voidprint（）;

};

MOVE:

:

MOVE（floatb[],intm）

{

inti;

n=m;

for（i=0;i

array[i]=b[i];

}

voidMOVE:

:

average（）

{

inti,x;

floata=0;

for（i=0;i

a+=array[i];

a/=n;

cout<<"平均值为:

"<

floatf[20];

for（i=0,x=0;i

if（array[i]

{

f[x]=array[i];

x++;

}

for（i=0;i

if（array[i]>a）

{

f[x]=array[i];

x++;

}//

for（i=0;i

array[i]=f[i];//

}

voidMOVE:

:

print（）

{

inti;

for（i=0;i

{

cout<

if（（i+1）%5==0）cout<

}

cout<

}

voidmain（）

{

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

intm=9;

MOVEff（b,m）;

ff.average（）;

ff.print（）;

}

（三）运行结果：

（四）基本分析：

1.就结构而言，定义类以及成员函数按照题目要求写即可，注意类作用域符：

：

不可缺失。

2.就算法而言:

求数组中的数的平均值，就是先求和，再除总个数。

 “小于平均值的放左边，大于平均值的放右边。

”先新建一个数组f[20]用于存放排列后的数组，通过if条件判断语句进行排序，这里大于平均值和小于平均值是有先后顺序的，因为是依次放入f[20]中，所以要等小于平均值的放完，再放大于平均值的。

再把f[20]赋值给array[20],这样array[20]就是排序后的符合题目要求的新数组。

每行5个输出，i的初始值是0，所以if条件判断中应该是if（（i+1）%5==0），直接用i，无需定义其他变量。

二、第四题

（一）题目：

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

 具体要求如下：

（1）私有数据成员 

int *array：

一维整型数组。

int n：

数组中元素的个数。

（2）公有成员函数 

MOVE（int b[],int m）：

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

void exchange（）：

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

void print（）：

输出一维数组。

~MOVE（）：

析构函数。

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

（2）源程序

#include

classMOVE

{

int*array;

intn;

public:

MOVE（intb[],intm）;

voidexchange（）;

voidprint（）;

~MOVE（）;

};

MOVE:

:

MOVE（intb[],intm）

{

n=m;

array=newint[n];//

for（inti=0;i

array[i]=b[i];

}

voidMOVE:

:

exchange（）

{

floata=0;

inti,*p1,*p2;

for（i=0;i

a+=array[i];

a/=n;

cout<<"Theaverageofthenumberis:

"<

p1=p2=array;//

for（i=0;i

{

if（array[i]<*p1）p1=&array[i];

if（array[i]>*p2）p2=&array[i];

}//

i=*p1;

*p1=*p2;

*p2=i;//

}

voidMOVE:

:

print（）

{

for（inti=0;i

{

cout<

if（（i+1）%5==0）cout<<'\n';

}

}

MOVE:

:

~MOVE（）

{

delete[]array;//

}

voidmain（）

{

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

MOVEf（b,n）;

f.exchange（）;

f.print（）;

}

（3）运行结果

（4）基本分析

1.要注意的函数：

构造函数中：

当要用到指针来操作数组时，要通过new运算符动态申请空间。

格式：

指针变量=new数据类型[数组大小]，指针变量保存该空间的首地址

析构函数：

释放new分配的而动态内存，格式：

delete[]指针变量

2.相关算法：

定义指针变量p1、p2指向数组的首地址，这句话等价于p1=p2=&array[0];

遍历数组，p1指向最小值，p2指向最大值

交换*p1、*p2的值

3、第17题

（1）题目：

定义一个类SIN。

求sin（x）=x/1-x^3/3!

+x^5/5!

-x^7/7!

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

具体要求如下：

（1）私有成员数据。

①doublex：

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

②intn：

输入公式中n的值。

（2）公有成员函数。

①SIN（intx,intn）：

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

②double power（intq）：

求q!

的值。

③int mi（intm,intn）：

求m^n的值。

fun（）：

用于求sin（x）的值。

void show（）：

输出求得的结果。

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

（二）源程序：

#include

classSIN

{

doublex;

intn;

public:

SIN（doublex,intn）;

doublepower（intq）;

doublemi（intm,intn）;

doublefun（）;

voidshow（）;

};

SIN:

:

SIN（doublex,intn）

{

this->x=x;

this->n=n;//

}

doubleSIN:

:

power（intq）

{

for（intm=1;m

q*=m;//

returnq;

}

doubleSIN:

:

mi（intm,intn）

{

for（inti=1;i

m*=m;//

returnm;

}

doubleSIN:

:

fun（）

{

doublesinx=0;

for（inti=1;i<=n;i++）

sinx+=mi（-1,i+1）*mi（x,2*i-1）/power（2*i-1）;//

returnsinx;

}

voidSIN:

:

show（）

{

cout<<"请输入x:

"<

cout<<"sin（"<

}

voidmain（）

{

doublex,n;

cout<<"请输入x和n的值:

"<

cin>>x>>n;

SINtest（x,n）;

test.show（）;

}

（3）运行结果：

（四）基本分析：

1.需要注意：

this指针指向本身对象的数据成员，避免因数据名相同而造成的混乱。

按题目要求，这一题只能用this指针加以区分。

2.相关算法：

求阶乘

求m^n。

i

这个公式看起来比较繁琐，对应着公式调用相关函数写，不要弄错

4、第18题

（1）题目：

18．试建立一个类VAR，用于求n（n<=100）个数的均方差。

均方差的计算公式为 

，其中平均值为

具体要求如下：

（1）私有成员数据。

double a[100]：

用于存放输入的n个数。

int n：

实际输入数的个数n。

（2）公有成员函数。

VAR（double x[], int n1）：

构造函数，初始化成员数据a和个数n。

double average（double x[], int n）：

求平均值，数组x具有n个元素。

void variance（double x[],int n）：

求均方差，数组x具有n个元素。

void show（）：

输出求得的均方差。

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

（2）源程序：

#include

classVAR

{

doublea[100];

intn;

public:

VAR（doublex[],intn1）;

doubleaverage（doublex[],intn）;

voidvariance（doublex[],intn）;

voidshow（）;

};

VAR:

:

VAR（doublex[],intn1）

{

for（inti=0;i

a[i]=x[i];

n=n1;

}

doubleVAR:

:

average（doublex[],intn）

{

doublea=0;

for（inti=0;i

a+=x[i];

a/=n;

returna;

}

voidVAR:

:

variance（doublex[],intn）

{

doubled=0;//

for（inti=0;i

d=（x[i]-average（x,n））*（x[i]-average（x,n））;

d/=n;

cout<<"方差为:

"<

}

voidVAR:

:

show（）

{

cout<<"平均值为:

"<

variance（a,n）;

}

voidmain（）

{

doublex[100]={16,18,25,23,56,14};

intn1=6;

VARtest（x,n1）;

test.show（）;

}

（3）运行结果：

（4）基本分析：

1.需要注意：

方差d最好定义成double型

2.此题不难，按照题目要求“堆”程序即可，没有复杂的算法，也没有特殊的结构。

5、第二十题

（1）题目：

4

8

12

16

3

7

11

15

2

6

10

14

1

5

9

13

20．定义一个方阵类Array，实现对方阵进行逆时针90度旋转。

如图所示。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

具体要求如下：

（1）私有数据成员  

int a[4][4]：

用于存放方阵。

（2）公有成员函数 

Array （int a1[][4],int n） ：

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

void xuanzhuan （） ：

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

void show（） ：

在屏幕上显示数组元素。

（3）在主程序中定义数组

intb[ ][4]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}作为原始数组。

定义一个Array类对象test，用b初始化test，完成对该类的测试。

（2）源程序：

#include

classArray

{

inta[4][4];

public:

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

voidxuanzhuan（）;

voidshow（）;

};

Array:

:

Array（inta1[][4],intn）

{

for（inti=0;i

for（intj=0;j

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

}

voidArray:

:

xuanzhuan（）

{

inti;

inta2[4][4];

for（i=0;i<4;i++）

{

for（intj=0;j<4;j++）

a2[i][j]=a[j][3-i];//

}

for（i=0;i<4;i++）

for（intj=0;j<4;j++）

a[i][j]=a2[i][j];//

}

voidArray:

:

show（）

{

cout<<"输出的数组为:

"<

for（inti=0;i<4;i++）

{

for（intj=0;j<4;j++）

cout<

cout<

}

}

voidmain（）

{

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

intn=4;

Arraytest（b,n）;

test.xuanzhuan（）;

test.show（）;

}

（3）运行结果：

（4）基本分析：

新建一个数组a2[4][4]，用来存放旋转后的a1[4][4]，逆时针旋转90度，其实就是列变成行，行变成列的同时左移三个。

把a2[4][4]赋值给a1[4][4],这样a1[4][4]就是旋转后的矩阵。

六、第三十题

（一）题目：

30．建立一个矩阵类Array，对二维数组中左下三角的全部元素（包括对角线上的元素）作如下变换。

（1）若该数不是素数则保持不变；

（2）若该数是素数，则用大于它的最小素数替换该数。

并统计二维数组中左下三角的全部元素（包括对角线上的元素）中的素数个数。

具体要求如下：

（1）私有数据成员 

int x[4][4]：

存储需要处理的二维数组的各元素值。

int count：

存储左下三角元素中素数的个数。

（2）公有成员函数 

构造函数：

进行初始化x数组和count的值。

intfun（int）；判断一个数是否为素数的函数。

voidencode（）：

对x数组中左下三角的全部元素（包括对角线上的元素）逐一进行判断，若该数不是素数则保持不变，若该数是素数，则用大于它的最小素数替换该数。

void print（）：

按行输出矩阵的值。

（3）编写一个程序测试该类，说明（声明）Array对象A，将一个矩阵存入对象A中，并输出矩阵的值，使用以下测试数据。

3

6

4

17

8

5

9

10

12

19

7

20

4

14

21

23

5

6

4

17

8

7

9

10

12

23

11

20

4

14

21

29

（2）源程序：

#include

classarray

{

intx[4][4];

intcount;

public:

array（inta[4][4]）;

intfun（int）;

voidencode（）;

voidprint（）;

};

array:

:

array（inta[4][4]）

{

for（inti=0;i<4;i++）

for（intj=0;j<4;j++）

x[i][j]=a[i][j];

count=0;

}

intarray:

:

fun（intnum）

{

intflag;

for（inti=2;i

if（num%i==0）return0;

elsereturn1;//

}

voidarray:

:

encode（）

{

inti,j,n;

for（i=0;i<4;i++）

{

for（j=0;j<=i;j++）//

{

if（fun（x[i][j]））//

{

for（intm=x[i][j]+1;;m++）

if（fun（m））//

{

x[i][j]=m;

break;//

}

count+=1;//

}

}

}

}

voidarray:

:

print（）

{

inti,j;

cout<<"变换后的矩阵为:

"<

for（i=0;i<4;i++）

{

for（j=0;j<4;j++）

cout<

cout<

}

cout<<"左下角素数个数为:

"<

}

voidmain（）

{

inta[4][4]={3,6,4,17,8,5,9,10,12,19,7,20,4,14,21,23};

arraytest（a）;

test.encode（）;

test.print（）;

}

（3）运行结果：

（4）基本分析：

判断是否为素数，运用条件语句，是就return1，否就return0，是很巧妙地方法。

如何表示一个方阵的左下角（包括对角线上）的数?

通过双循环，列不大于行数即可表示。

逐个判断左下角（包括对角线上）的数是否为素数，利用了上面定义的fun（）函数实现，是就进入下面的循环。

如果是素数，就寻找下一个用来代替它的素数。

一旦找到就跳出循环，count计数

count加一计数