C++实验报告0623052253.docx

C++实验报告0623052253.docx

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

C++实验报告0623052253

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*pO=sO,*p1=s1;

while（*p1）{

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

isin（s0,*p1）））

{

*pO++=*p1;

}

*p0='\0：

p1++;

}

/*for（char*p1=s1,*pO=sO;*p1;p1++）{

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

isin（:

sO,*p1）））

*pO++=*p1;

*p0='\0：

}*/

}

voidSTR:

:

print（）

{

cout<<"字符串1：

"<

cout<<"字符串2:

"<

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

"<

}

voidmain（）

{

charstr1[]="abcdef123abc12";

charstr2[]="acef123ace124";

STRt（str1,str2）;

t.fun（）;

t.print（）;

}

运行结果：

贰"F:

\lirtc4-Debug\0001.exe"

字符abcdefl23ahcl2字特禹2：

aceF123acel24商个学符的acefl23

Pressanytocontinue

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）在主函数中对该类进行测试。

输出示例：

原数组：

41

67

34

0

69

24

78

58

62

64

5

45

派生数组：

67

4134

670

3441

5824

6978

2458

7869

4564

625

6445

562

源程序代码:

#includeviostream.h>#includeclassArray{inta[3][4];intb[3][4];

public:

Array（intt[][4],intn）;intnn（intt1,intt2）;voidfun（）;

voidprint（）;

};

Array:

:

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

for（inti=0;ivn;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（）

{

coutvv"原数组：

"vvendl;

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

for（intj=0;j<4;j++）{coutvva[i][j]vv'\t';}coutvvendl;

}

coutvv"派生数组：

"vvendl;

for（i=0;iv3;i++）{

for（intj=0;jv4;j++）{coutvvb[i][j]vv'\t';

}coutvvendl;

}

}

voidmain（）

{

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

Arraysz（t,4）;

sz.fun（）;

sz.print（）;

}运行结果：

•F:

\lin数袒派生盈DebugVJOOZexh

11

6?

34

Q

24

78

58

>2

64

5

45

底生数组=

>7

4134

67

3441

>824

6?

78

2458

7869

625

644B

562

*res£

NnyMy

tocontinue

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++）//40if（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（）;

运行结果：

-*F：

\lin"十\1泊0去除丐同数字再升序排歹蛇§\。

訪旳\000玮姑・

1213&566223131231434435

34435

1234

址理前的薮殂为：

丄2d65662231312314

抄理后的数组为’65123231345

Pressanykep七

4•试定义一个类STR,统计一个字符串中包含的句子数和单词数，规定单词之间以空格、”

或”•”分隔，句子以”•”结束，具体要求如下

（1）私有数据成员

char*s:

指向待统计的字符串

intm,n:

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

（2）公有成员函数

STR（char*t）:

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

voidfun（）:

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

员n中

voidprint（）:

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

~STR（）:

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

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

输出示例：

字符串：

lamastudent.Iamtwenty.Icomfromchina.

句子数:

3

单词数:

11

源程序代码：

#includeviostream.h>

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

{

coutvv"字符串:

"vvsvvendl;

coutvv"句子数:

"vvnvvendl;

coutvv"单词数:

"vvmvvendl;

}

voidmain（）

{

chars[100];

cin.getline（s,100）;

STRt（s）;

t.fun（）;

t.print（）;

}

运行结果:

l'Fi\linc++\li诜计句子数单词Debug\0004-exe"

|Ian&student.IamtwentyconFromchina.

字符串amastudentIamtuontyIconfromchina.

词数江1

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="<

{

cout<<*（p+i）<<'\t';if（m%4==0）cout<<'\n：

}

}voidmain（）

{

intnum;

doublex1;

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

ppitems（num,x1）;

items.process（）;

items.show（）;

}

运行结果：

'F;\lint++\lin\5,建立PP求雾项式\D亡心孑•

p青依次输入n吓和5的值

32

n=3x=2

125_5Pressanvtocontinuje

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==O）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的值"<>k1;

SPs（n1,k1）;

s.fun（）;

s.show（）;

}

运行结果:

*F:

\linc++\lrn\6.建立类SP求打n.k）\Debi

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

}

voidMOVE:

:

exchange（）

{

floata=0;

inti,*p1,*p2;

for（i=0;i

a/=n;

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

"<

p1=p2=&array[0];

for（i=0;i

{

if（array[i]<*p1）p仁&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（）;

4

s

为匕

54勺目5

平数

且匕

1

12

55

43

7

on

4441232

^'esske9tocontinue

97

55

运行结果:

14

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