C++实验报告 2.docx

C++实验报告 2.docx

《C++实验报告 2.docx》由会员分享，可在线阅读，更多相关《C++实验报告 2.docx（22页珍藏版）》请在冰豆网上搜索。

C++实验报告2

C++课程实验报告

1340601119林子扬

1.试定义一个类STR，实现求两个字符串的交集。

两个字符串的交集是指同时属于两个字符串的字符的集合，且该集合中的字符各不相同。

具体要求如下：

（1）私有数据成员:

chars1[50],s2[50],s0[50];字符串s0用于存放字符串s1和字符串s2的交集。

（2）公有成员函数:

●STR（char*p1,char*p2）;构造函数，分别用参数p1和p2初始化成员数组s1和s2。

●intisin（char*p,charc）;判断字符c是否出现在字符串p中，如果是，则返回值为1，否则返回0。

●voidfun（）;求成员数组s1和s2的交集，并将结果存放在成员数组s0中。

提示：

利用函数isin（char*,char）依次判断一个字符串中的每个字符是否包含于另一个字符串中，如果包含，且该字符不包含于成员数组s0中，则将该字符加入到成员数组s0中。

●voidprint（）;按输出示例的格式输出所有数据成员。

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

输出示例：

字符串1：

abcdef123abc12

字符串2：

acef123ace124

两个字符串的交集：

acef123

源程序代码：

#include

#include

classSTR{

chars0[50],s1[50],s2[50];

public:

STR（char*p1,char*p2）;

intisin（char*p,charc）;

voidfun（）;

voidprint（）;

};

STR:

:

STR（char*p1,char*p2）

{

strcpy（s1,p1）;

strcpy（s2,p2）;

s0[0]='\0';

}

intSTR:

:

isin（char*p,charc）

{

char*p0=p;

while（*p0）

{

if（*p0++==c）return1;//后置自增参与后指向下一位

}

return0;

}

voidSTR:

:

fun（）

{

char*p0=s0,*p1=s1;

while（*p1）{

if（isin（s2,*p1）&&（!

isin（s0,*p1）））

{

*p0++=*p1;

}

*p0='\0';

p1++;

}

/*for（char*p1=s1,*p0=s0;*p1;p1++）{

if（isin（s2,*p1）&&（!

isin（s0,*p1）））

*p0++=*p1;

*p0='\0';

}*/

}

voidSTR:

:

print（）

{

cout<<"字符串1：

"<

cout<<"字符串2：

"<

cout<<"两个字符的交集：

"<

}

voidmain（）

{

charstr1[]="abcdef123abc12";

charstr2[]="acef123ace124";

STRt（str1,str2）;

t.fun（）;

t.print（）;

}

运行结果：

2.试定义一个类Array，实现由一个数组派生出另一个数组。

派生规则如下：

新数组的元素取值为原数组中相同位置元素的左、右两个相邻元素前后拼接后形成的整数（左邻元素在前，右邻元素在后）。

规定最左（右）列元素的左（右）邻元素为该元素所在行的最右（左）侧的元素。

具体要求如下：

（1）私有数据成员:

●inta[3][4];原数组。

●intb[3][4];派生数组。

（2）公有成员函数

●Array（intt[][4],intn）；构造函数，利用参数t的前n行元素初始化数据成员a。

●intnn（intt1，intt2）；返回t1，t2拼接后形成的整数（t1在前，t2在后）。

●voidfun（）；按题意生成新数组，并将结果存放到数据成员b中。

●voidprint（）；按矩阵形式输出成员数组。

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

输出示例：

原数组：

4167340

69247858

6264545

派生数组：

6741346703441

5824697824587869

45646256445562

源程序代码：

#include

#include

classArray{

inta[3][4];

intb[3][4];

public:

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

intnn（intt1,intt2）;

voidfun（）;

voidprint（）;

};

Array:

:

Array（intt[][4],intn）

{

for（inti=0;i

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

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

}

intArray:

:

nn（intt1,intt2）

{

intt=t2;

while（t）

{

t1*=10;

t/=10;

}

returnt1+t2;

}

voidArray:

:

fun（）

{

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

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

intc=j-1;

intd=j+1;

c=c<0?

3:

c;

d=d>3?

0:

d;

b[i][j]=nn（a[i][c],a[i][d]）;//56

}

}

voidArray:

:

print（）

{

cout<<"原数组：

"<

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

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

cout<

cout<

}

cout<<"派生数组：

"<

for（i=0;i<3;i++）{

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

cout<

}

cout<

}

}

voidmain（）

{

intt[3][4]={41,67,34,0,69,24,78,58,62,64,5,45};

Arraysz（t,4）;

sz.fun（）;

sz.print（）;

}运行结果：

3.试定义一个类NUM,实现将一维数组中各整数元素去掉其中相同数字后再对数组从小

到大排序。

将一个整数去掉相同数字是指:

如果一个整数中有相同的数字,则保留从左数起

第一次看到的那个数字,而将其他相同的数字去掉。

例如:

数字12324151中有三个1、两个2,则去掉相同的数字后变为12345。

具体要求如下:

（1）私有数据成员。

•inta[5]:

存放需处理的数组。

（2）公有成员函数。

•NUM（intt[],intn）:

构造函数,用t初始化a,n为t的元素个数。

•voidsort（intt[],intn）:

将数组t的元素从小到大排序。

•intconvert（intn）:

去除n中相同的数字并返回新得到的数。

•voidfun（）:

将数组a的各元素去除相同的数字后从小到大排列。

要求调用函数

convert（）和sort（）。

•voidprint（）:

输出数组a的所有元素。

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

输入/输出示例（下划线部分为键盘输入）:

输入5个整数:

121365666223131231434435

处理前的数组为:

121365666223131231434435

处理后的数组为:

651232313451234

源程序代码：

#include

classNUM

{

inta[5];

public:

NUM（intt[],intn）;

voidsort（）;

intconvert（intn）;

voidfun（）;

voidprint（）;

};

NUM:

:

NUM（intt[],intn）//30

{

for（inti=0;i

a[i]=t[i];

}

voidNUM:

:

sort（）

{

inti,j,k,t;

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

{

k=i;

for（j=i+1;j<5;j++）//40

if（a[j]

k=j;

if（k!

=i）

{t=a[k];a[k]=a[i];a[i]=t;}

}

}

intNUM:

:

convert（intn）

{

/*ints[5],i,j,k;

for（i=4;i>0;i--）

{

k=n;

s[i]=k%10;

n/=10

}

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

for（j=i+1;j<5;j++）

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

{

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

a[k]=a[k+1];

}*/

ints[5],i=4,j,k=0,t,b,c=0;

while（n）{

s[i--]=n%10;

n/=10;

}

for（j=i+1;j<4-k;j++）

{

t=j+1;

while（t<5-k）

if（s[j]==s[t]）{

for（b=t;b<4-k;b++）

s[b]=s[b+1];

k++;

}

elset++;

}

for（j=i+1;j<5-k;j++）{

c=c*10+s[j];}

returnc;

}

voidNUM:

:

fun（）

{

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

a[i]=convert（a[i]）;

sort（）;

}

voidNUM:

:

print（）

{

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

cout<

cout<

}

voidmain（）

{

ints[5];

cout<<"请输入5个整数：

";

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

cin>>s[i];

NUMt（s,5）;

cout<<"处理前的数组为：

";

t.print（）;

t.fun（）;

cout<<"处理后的数组为：

";

t.print（）;

}

运行结果:

4.试定义一个类STR,统计一个字符串中包含的句子数和单词数,规定单词之间以空格、”,”或”.”分隔,句子以”.”结束,具体要求如下

（1）私有数据成员

char*s:

指向待统计的字符串

intm,n:

分别记录求得的单词数和句子数

（2）公有成员函数

STR（char*t）:

构造函数,用参数t初始化字符串s

voidfun（）:

按题意统计单词数,结果存放在数据成员m中,再统计句子数,结果存放在数据成员n中

voidprint（）:

按输出示例的格式输出统计结果

~STR（）:

析构函数,实现必要的功能

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

输出示例:

字符串:

Iamastudent.Iamtwenty.Icomfromchina.

句子数:

3

单词数:

11

源程序代码：

#include

#include

classSTR

{

char*s;

intm,n;

public:

STR（char*t）;

voidfun（）;

voidprint（）;

~STR（）

{delete[]s;}

};

STR:

:

STR（char*t）

{

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

strcpy（s,t）;

}

voidSTR:

:

fun（）

{

char*p=s;

m=0;n=0;

while（*p）

{

if（*p=='.'）n++;

if（*p==''||*p==';'||*p==','||*p=='.'）m++;

while（*p==''）p++;

p++;

}

}

voidSTR:

:

print（）

{

cout<<"字符串:

"<

cout<<"句子数:

"<

cout<<"单词数:

"<

}

voidmain（）

{

chars[100];

cin.getline（s,100）;

STRt（s）;

t.fun（）;

t.print（）;

}

运行结果：

5.试建立一个类PP，求出下列多项式的前n项的值。

具体要求如下：

（1）私有数据成员

1.intn：

前若干项的项数。

2.doublex：

存放x的值。

3.double*p：

根据n的大小动态申请存放Pn（x）前n项的数组空间。

（2）公有成员函数

1.PP（intnum,doublex1）：

构造函数，初始化数据成员n和x，使p指向动态申请的数组空间。

2.～PP（）：

析构函数，释放p指向的动态内存空间。

3.doublefun（intn1,doublex）：

递归函数，用于求多项式的第n1项。

注意：

将递归公式中的n用作函数参数。

本函数供process函数调用。

4.voidprocess（）：

完成求前n项的工作，并将它们存放到p指向的动态数组中。

5.voidshow（）：

输出n和x，并将前n项以每行4个数的形式输出到屏幕上。

（3）在主函数中完成对该类的测试。

先输入num和x1，并定义一个PP类的对象items，用num和x1初始化items的成员n和x，调用items的成员函数，求出并输出多项式前num项的值。

源程序代码：

#include

classpp{

intn;

doublex;

double*p;

public:

pp（intnum,doublex1）;

~pp（）;

doublefun（intn1,doublex）;

voidprocess（）;

voidshow（）;

};

pp:

:

pp（intnum,doublex1）

{

n=num;

x=x1;

p=newdouble[num+1];

}

pp:

:

~pp（）

{

delete[]p;

}

doublepp:

:

fun（intn1,doublex）

{

if（n1==0）return1;

if（n1==1）returnx;

if（n1>1）return（（2*n1-1）*x*fun（n1-1,x）-（n1-1）*fun（n1-2,x））/n1;

}

voidpp:

:

process（）

{

inti;

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

{

*（p+i）=fun（i,x）;

}

}

voidpp:

:

show（）

{

cout<<"n="<

for（inti=0,m=1;i

{

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

if（m%4==0）cout<<'\n';

}

}

voidmain（）

{

intnum;

doublex1;

cout<<"请依次输入num和x1的值"<

cin>>num>>x1;

ppitems（num,x1）;

items.process（）;

items.show（）;

}

运行结果：

6.试建立一个类SP，求，另有辅助函数power（m,n）用于求。

具体要求如下：

（1）私有成员数据。

1.intn，k：

存放公式中n和k的值；

（2）公有成员函数。

1.SP（intn1,intk1）：

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

2.intpower（intm,intn）：

求mn。

3.intfun（）：

求公式的累加和。

4.voidshow（）：

输出求得的结果。

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

源程序代码：

#include

classSP{

intn,k;

public:

SP（intn1,intk1）;

intpower（intm,intn）;

intfun（）;

voidshow（）;

};

SP:

:

SP（intn1,intm1）

{

n=n1;

k=m1;

}

intSP:

:

power（intm,intn）

{

inti;

if（n==0）return1;

else

for（i=1;i

m*=m;

returnm;

}

intSP:

:

fun（）

{

inty=0,x;

for（x=1;x<=n;x++）

y+=power（x,k）;

returny;

}

voidSP:

:

show（）

{

cout<<"前n项的和为：

"<

}

voidmain（）

{

intn1,k1;

cout<<"输入n和k的值"<

cin>>n1>>k1;

SPs（n1,k1）;

s.fun（）;

s.show（）;

}

运行结果：

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

具体要求如下：

（1）私有数据成员

1.int*array：

一维整型数组。

2.intn：

数组中元素的个数。

（2）公有成员函数

3.MOVE（intb[],intm）：

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

4.voidexchange（）：

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

5.voidprint（）：

输出一维数组。

6.~MOVE（）：

析构函数。

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

程序源代码：

#include

classMOVE{

int*array;

intn;

public:

MOVE（intb[],intm）;

voidexchange（）;

voidprint（）;

~MOVE（）;

};

MOVE:

:

MOVE（intb[],intm）

{

n=m;

array=newint[n];

for（intx=0;x

array[x]=b[x];

}

voidMOVE:

:

exchange（）

{

floata=0;

inti,*p1,*p2;

for（i=0;i

a+=array[i];

a/=n;

cout<<"数组的平均数为:

"<

p1=p2=&array[0];

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（）

{

inti,num=1;

for（i=0;i

{

cout<

if（num%5==0）cout<<'\n';

num++;

}

}

MOVE:

:

~MOVE（）

{delete[]array;}

voidmain（）

{

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

MOVEff（b,n）;

cout<<"变化前数组为：

"<

ff.print（）;

ff.exchange（）;

cout<<"变化后数组为:

"<

ff.print（）;

}

运行结果：

8.定义一个类Palindrome，实现绝对回文数。

设计一个算法实现对任意整型数字判断是否为绝对回文数。

所谓绝对回文数，是指十进制数和二进制数均对称的数。

具体要求如下：

（1）私有数据成员

1.intn：

整型数字。

2.inty：

标记是否为回文数。

（2）公有成员函数

1.Palindrome（intx）：

构造函数，根据x参数初始化数据成员n，y初始化为0。

2.voidhuiwen（）：

判断数n是否为绝对回文数。

3.voidshow（）：

若该数为回文数，则在屏幕显示。

（3）在主程序中定义inta，由键盘输入数字。

定义一个Palindrome类对象p，用a初始化p，完成对该类的测试。

源程序代码：

#include

classpalindrome{

intn;

inty;

public:

palindrome（intx）;

voidhuiwen（）;

voidshow（）;

};

palindrome:

:

palindrome（intx）

{

n=x;

y=0;

}

voidpalindrome:

:

huiwen（）

{

intb[20],c[50],m,i,p=0,t1=1,t2=1;

m=n;

for（i=0;m>0;m/=10）

{

p++;

b[i]=m%10;

i++;

}

for（i=0;i

if（b[i]!

=b[p-i-1]）

{

t1=0;

break;

}

for（i=0,m=n,p=0;m>0;m/=2）

{

p++;

c[i]=m%2;

i++;

}

for（i=0;i

if（c[i]!

=c[p-i-1]）

{

t2=0;

break;

}

if（t1&&t2）y=1;

}

voidpalindrome:

:

show（）

{

if（y==0）cout<<"该数不是绝对回文数！

"<

elsecout<<"该