C++第七章课程设计.docx

C++第七章课程设计.docx

《C++第七章课程设计.docx》由会员分享，可在线阅读，更多相关《C++第七章课程设计.docx（14页珍藏版）》请在冰豆网上搜索。

C++第七章课程设计

第七章

实

验

报

告

（类和对象）

指导老师束鑫

1140501218彭祥

1.定义一个数组类ARRAY，实现对数组a中的N（0

例如，设a={5,3,4,7,3,5,6}，元素3,4,5,6,7的编号分别为1,2,3,4,5，为此输出编号为：

（3,1,2,5,1,3,4）。

具体要求如下：

（1）私有成员

int*a：

存放数组a

int*b：

存放数组a中各元素的编号，其中b[i]为a[i]的编号

intlen：

数组a和b中实际元素的个数

（2）公有成员

ARRAY（int*x,intn）：

构造函数。

为数组a和b动态分配存储空间：

分别利用x和n初始化数组a和整数len。

voidnumber（）：

对数组a的元素从小到大进行连续编号并保存在数组b中。

voidshowdata（）：

输出数组a的元素值。

voidshownumber（）：

输出数组a的元素对应的编号值。

~ARRAY（）：

释放相应的动态储存空间。

（3）在主函数中定义一个整型数组，用该整型数组初始化一个ARRAY对象，调用相关成员

函数完成对类ARRAY的测试。

源程序代码：

#include

classARRAY{

int*a,*b;

intlen;

public:

ARRAY（int*x,intn）;

voidnumber（）;

voidshowdata（）;

voidshownumber（）;

~ARRAY（）

{delete[]a;

delete[]b;

}

};

ARRAY:

:

ARRAY（int*x,intn）{

a=newint[n];

b=newint[n];

for（inti=0;i

a[i]=x[i];

len=n;

}

voidARRAY:

:

showdata（）

{cout<<"数组a=（";

for（inti=0;i

cout<

cout<

}

voidARRAY:

:

shownumber（）

{cout<<"编号:

b=（";

for（inti=0;i

cout<

cout<

}

voidARRAY:

:

number（）

{inti,j,k,t,*x;

if（len>0）

x=newint[len];

elsereturn;

for（i=0;i

x[i]=a[i];

for（i=0;i

k=i;

for（j=i+1;j

if（x[k]>x[j]）k=j;

t=x[k];x[k]=x[i];x[i]=t;

}

for（k=i=0;i

if（i>0&&x[i]==x[i-1]）

continue;

k++;

for（j=0;j

if（a[j]==x[i]）

b[j]=k;

}

delete[]x;

}

voidmain（）

{inta[7]={5,3,4,7,3,5,6};

ARRAYc（a,7）;

c.number（）;

c.showdata（）;

c.shownumber（）;

}

运行结果是：

2.试定义一个类STR，将字符串中的数字字符依次全部移到字符串的后半部分。

具体要求如

下：

（1）私有数据成员

char*p;p为待处理的字符串。

（2）公有成员函数

STR（char*s）；构造函数，用s初始化数据成员p。

voidmove（char&t1,char&t2）；辅助函数，交换两个字符的位置。

voidfun（）；根据题意处理字符串p。

~STR（）；析构函数，撤销所占用的动态储存空间。

voidprint（）；输出数组中的所有元素。

（3）在主函数中对类STR进行测试。

源程序代码：

#include

#include

classSTR{

char*p;

public:

STR（char*s）

{p=newchar[strlen（s）+1];

strcpy（p,s）;

}

voidfun（）

{

for（char*p1=p;*p1;p1++）{

if（*p1>'9'&&*p1<'0'）continue;

for（char*p2=p1;*p2>='0'&&*p2<='9';p2++）;

if（!

（*p2））break;

while（*p2&&p2>p1）{

move（*p2,*（p2-1））;

p2--;

}

}

}

voidmove（char&t1,char&t2）

{chart=t1;t1=t2;t2=t;}

voidprint（）

{cout<

~STR（）

{delete[]p;}

};

voidmain（）

{

cout<<"请输入一个包含数字字符的字符串:

"<<'\n';

chars[100];

cin.getline（s,100）;

STRtest（s）;

cout<<"原字符串:

";

test.print（）;

test.fun（）;

cout<<"转换后的字符串:

";

test.print（）;

}

运行结果是：

3.定义一个字符串类，其成员数据为一个指向字符串的指针变量。

成员函数至少实现设定字符串的值、将一个字符串拼接到成员字符串上、将成员字符串逆序以及输出字符串等功能。

要求编写一个完整的程序对类进行测试。

源程序代码：

#include

#include

classSTR{

char*p;

public:

STR（char*s=0）

{if（s）{

p=newchar[strlen（s）+1];

strcpy（p,s）;

}

}

voidset（char*s=0）

{if（p）delete[]p;

if（s）{

p=newchar[strlen（s）+1];

strcpy（p,s）;

}

else

p=0;

}

voidjoin（char*s）

{intn1,n2;

n1=strlen（p）;

n2=strlen（s）;

char*p0=newchar[n1+n2+1],*p1=p0,*p2=p;

while（*p1++=*p2++）;

p1--;p2=s;

while（*p1++=*p2++）;

delete[]p;

p=newchar[n1+n2+1];

p1=p;p2=p0;

while（*p1++=*p2++）;

delete[]p0;

}

voidbackward（）

{char*p1=p,*p2=p;

while（*p2++）;

p2-=2;

while（p1

chart=*p1;

*p1=*p2;*p2=t;

p1++;p2--;

}

}

~STR（）

{if（p）delete[]p;}

voidprint（）

{if（p）

cout<

}

};

voidmain（）

{STRst1（"12345"）;

st1.print（）;

st1.set（"abcde"）;

st1.print（）;

st1.join（"12345"）;

st1.print（）;

st1.backward（）;

st1.print（）;

}

运行结果是：

4.试定义一个类Array，实现由一个二维数组派生出一个新的二维数组，新数组的行数和列数分别为原数组的列数和行数，且新数组的元素值为原数组中与该元素同序的元素的所有相邻元素的平均值。

所谓同序元素，是指两个数组中存储顺序相同的两个元素。

例如，假设定义两个数组inta[4][5],b[5][4];b[1][2]为数组b的第6个元素，则a的第6个元素a[1][0]是b[1][2]的同序元素；所谓相邻元素，是指该元素的上、下、左、右四个元素，其中最左（右）列元素的左（右）邻元素为最右（左）列，最上（下）行元素的上（下）邻元素为最下（上）行。

例如，对于上述的b[1][2]，其值应该为（a[0][0]+a[2][0]+a[1][4]+a[1][1]）/4。

源程序代码：

#include

classArray{

floata[4][5],b[5][4];

public:

Array（floatt[4][5]）

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

for（intj=0;j<5;j++）{

a[i][j]=t[i][j];

b[j][i]=0;

}

}

voidfun（）

{for（inti=0;i<5;i++）

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

intn,i0,j0;

n=i*4+j;i0=n/5;j0=n-i0*5;

b[i][j]=（a[（i0+3）%4][j0]+a[（i0+1）%4][j0]+a[i0][（j0+4）%5]+a[i0][（j0+1）%5]）/4;

}

}

voidprint（）

{cout<<"数组a:

\n";

for（inti=0;i<4*5;i++）{

cout<<*（*a+i）<<'\t';

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

}

cout<<"数组b:

\n";

for（i=0;i<5*4;i++）{

cout<<*（*b+i）<<'\t';

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

}

}

};

voidmain（）

{floatt[4][5]={{1,2,3,4,5},{6,7,8,9,10},{11,12,13,14,15},{16,17,18,19,20}};

Arraytest（t）;

test.fun（）;

test.print（）;

}

运行结果是：

5.对一个5位数的任意整数，求出其降序数。

例如，整数是82319，则其降序数是98321。

算法提示：

将整数的各位数分解到一维整型数组a中，再将a数组中的元素按降序排列，最后输出a数组元素值。

试建立一个类NUM，用于完成该功能。

具体要求如下：

（1）似有数据成员

intn；存放5位数的整数

inta[]；存放其元素的降序排列值

（2）公有成员函数

NUM（intx=0）；构造函数，用参数x初始化数据成员n

voiddecrease（）；将n的各位数值分解到a数组中，并将a数组排成降序

voidshow（）；屏幕显示原数及其降序数

（3）在主函数中输入一个5位数的任意整数，然后定义一个NUM类对象num，用上述输入的数初始化num，然后完成对该类的测试。

源程序代码：

#include

intc[5];

classNUM{

intn;

inta[5];

public:

NUM（intx=0）;

voiddecrease（）{

inti=0,b=n,j=4;

while（b）{

c[j]=a[i]=b%10;

b=b/10;

i++;

j--;

}

for（intm=0;m<4;m++）

for（intj=m+1;j<5;j++）

if（a[m]

intt=a[m];

a[m]=a[j];

a[j]=t;

}

};

voidshow（）{

cout<<"原数为:

";

for（intd=0;d<5;d++）cout<

cout<<'\n';

cout<<"变换后为:

";

for（intj=0;j<5;j++）{

cout<

}

cout<

}

};

NUM:

:

NUM（intx）{

n=x;

};

voidmain（）

{

cout<<"请输入一个5位整数"<<'\n';

inta;cin>>a;

NUMs（a）;

s.decrease（）;

s.show（）;

}

运行结果是：

实验结论：

如果对类成员的访问特性不加说明，则说明该成员是私有的访问特性。

可以用关键字static将数据成员说明为静态类型的，其意义为该成员属于类的所有对象所共有。

任何一个类均有构造函数，任何一个对象生成时必要调用相应的构造函数来初始化其成员。

如果类中没有定义构造函数，系统编译时会自动产生一个空的构造函数，从而保证生成对象时有合适的构造可调用。