C++实验报告 2Word格式.docx
《C++实验报告 2Word格式.docx》由会员分享，可在线阅读，更多相关《C++实验报告 2Word格式.docx（22页珍藏版）》请在冰豆网上搜索。
if（*p0++==c）return1;
//后置自增参与后指向下一位
}
return0;
voidSTR:
fun（）
char*p0=s0,*p1=s1;
while（*p1）{
if（isin（s2,*p1）&
&
（!
isin（s0,*p1）））
{
*p0++=*p1;
}
*p0='
p1++;
/*for（char*p1=s1,*p0=s0;
*p1;
p1++）{
if（isin（s2,*p1）&
*p0++=*p1;
*p0='
}*/
print（）
cout<
<
"
字符串1：
s1<
endl;
字符串2：
s2<
两个字符的交集：
s0<
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
classArray{
inta[3][4];
intb[3][4];
Array（intt[][4],intn）;
intnn（intt1,intt2）;
Array:
Array（intt[][4],intn）
for（inti=0;
i<
n;
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:
3;
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
i++）{
cout<
a[i][j]<
'
\t'
cout<
for（i=0;
b[i][j]<
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）私有数据成员。
&
#8226;
inta[5]:
存放需处理的数组。
（2）公有成员函数。
NUM（intt[],intn）:
构造函数,用t初始化a,n为t的元素个数。
voidsort（intt[],intn）:
将数组t的元素从小到大排序。
intconvert（intn）:
去除n中相同的数字并返回新得到的数。
voidfun（）:
将数组a的各元素去除相同的数字后从小到大排列。
要求调用函数
convert（）和sort（）。
voidprint（）:
输出数组a的所有元素。
输入/输出示例（下划线部分为键盘输入）:
输入5个整数:
121365666223131231434435
处理前的数组为:
处理后的数组为:
651232313451234
classNUM
inta[5];
NUM（intt[],intn）;
voidsort（）;
intconvert（intn）;
NUM:
NUM（intt[],intn）//30
a[i]=t[i];
voidNUM:
sort（）
inti,j,k,t;
k=i;
for（j=i+1;
5;
j++）//40
if（a[j]<
a[k]）
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
if（a[i]==[j]）
{
for（k=j;
k<
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;
4-k;
t=j+1;
while（t<
5-k）
if（s[j]==s[t]）{
for（b=t;
b<
b++）
s[b]=s[b+1];
k++;
}
elset++;
5-k;
c=c*10+s[j];
returnc;
a[i]=convert（a[i]）;
sort（）;
a[i]<
ints[5];
请输入5个整数：
cin>
>
s[i];
NUMt（s,5）;
处理前的数组为：
处理后的数组为：
运行结果:
4.试定义一个类STR,统计一个字符串中包含的句子数和单词数,规定单词之间以空格、”,”或”.”分隔,句子以”.”结束,具体要求如下
（1）私有数据成员
char*s:
指向待统计的字符串
intm,n:
分别记录求得的单词数和句子数
（2）公有成员函数
STR（char*t）:
构造函数,用参数t初始化字符串s
按题意统计单词数,结果存放在数据成员m中,再统计句子数,结果存放在数据成员n中
voidprint（）:
按输出示例的格式输出统计结果
~STR（）:
析构函数,实现必要的功能
（3）在主函数中对该类进行测试
输出示例:
字符串:
Iamastudent.Iamtwenty.Icomfromchina.
句子数:
3
单词数:
11
classSTR
char*s;
intm,n;
STR（char*t）;
~STR（）
{delete[]s;
STR（char*t）
s=newchar[strlen（t）+1];
strcpy（s,t）;
char*p=s;
m=0;
n=0;
while（*p）
if（*p=='
.'
）n++;
'
||*p=='
'
）m++;
while（*p=='
）p++;
p++;
字符串:
s<
句子数:
n<
单词数:
m<
chars[100];
cin.getline（s,100）;
STRt（s）;
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项的值。
classpp{
intn;
doublex;
double*p;
pp（intnum,doublex1）;
~pp（）;
doublefun（intn1,doublex）;
voidprocess（）;
voidshow（）;
pp:
pp（intnum,doublex1）
n=num;
x=x1;
p=newdouble[num+1];
~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;
=n;
*（p+i）=fun（i,x）;
show（）
n="
x="
x<
for（inti=0,m=1;
i++,m++）
*（p+i）<
if（m%4==0）cout<
\n'
intnum;
doublex1;
请依次输入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，对该类进行测试。
classSP{
intn,k;
SP（intn1,intk1）;
intpower（intm,intn）;
intfun（）;
SP:
SP（intn1,intm1）
n=n1;
k=m1;
intSP:
power（intm,intn）
if（n==0）return1;
else
for（i=1;
m*=m;
returnm;
inty=0,x;
for（x=1;
x++）
y+=power（x,k）;
returny;
voidSP:
前n项的和为：
fun（）<
intn1,k1;
输入n和k的值"
n1>
k1;
SPs（n1,k1）;
s.fun（）;
s.show（）;
7.建立一个类MOVE，将数组中最大元素的值与最小元素的值互换。
1.int*array：
一维整型数组。
2.intn：
数组中元素的个数。
3.MOVE（intb[],intm）：
构造函数，初始化成员数据。
4.voidexchange（）：
输出平均值，并将数组中的元素按要求重新放置。
5.voidprint（）：
输出一维数组。
6.~MOVE（）：
析构函数。
（3）在主程序中用数据{21,65,43,87,12,84,44,97,32,55}对该类进行测试。
程序源代码：
classMOVE{
int*array;
MOVE（intb[],intm）;
voidexchange（）;
~MOVE（）;
MOVE:
MOVE（intb[],intm）
n=m;
array=newint[n];
for（intx=0;
array[x]=b[x];
voidMOVE:
exchange（）
floata=0;
inti,*p1,*p2;
a+=array[i];
a/=n;
数组的平均数为:
a<
p1=p2=&
array[0];
if（array[i]<
*p1）p1=&
array[i];
if（array[i]>
*p2）p2=&
i=*p1;
*p1=*p2;
*p2=i;
inti,num=1;
array[i]<
if（num%5==0）cout<
num++;
~MOVE（）
{delete[]array;
intb[]={21,65,43,87,12,84,44,97,32,55},n=10;
MOVEff（b,n）;
变化前数组为：
ff.print（）;
ff.exchange（）;
变化后数组为:
8.定义一个类Palindrome，实现绝对回文数。
设计一个算法实现对任意整型数字判断是否为绝对回文数。
所谓绝对回文数，是指十进制数和二进制数均对称的数。
（1）私有数据成员
整型数字。
2.inty：
标记是否为回文数。
1.Palindrome（intx）：
构造函数，根据x参数初始化数据成员n，y初始化为0。
2.voidhuiwen（）：
判断数n是否为绝对回文数。
3.voidshow（）：
若该数为回文数，则在屏幕显示。
（3）在主程序中定义inta，由键盘输入数字。
定义一个Palindrome类对象p，用a初始化p，完成对该类的测试。
classpalindrome{
inty;
palindrome（intx）;
voidhuiwen（）;
palindrome:
palindrome（intx）
n=x;
y=0;
voidpalindrome:
huiwen（）
intb[20],c[50],m,i,p=0,t1=1,t2=1;
m=n;
m>
m/=10）
b[i]=m%10;
i++;
p;
if（b[i]!
=b[p-i-1]）
t1=0;
break;
for（i=0,m=n,p=0;
m/=2）
c[i]=m%2;
if（c[i]!
=c[p-i-1]）
t2=0;
if（t1&
t2）y=1;
if（y==0）cout<
该数不是绝对回文数！
elsecout<
该
升级会员 