完整版江苏科技大学VC++程序实践答案.docx
《完整版江苏科技大学VC++程序实践答案.docx》由会员分享，可在线阅读，更多相关《完整版江苏科技大学VC++程序实践答案.docx（22页珍藏版）》请在冰点文库上搜索。
完整版江苏科技大学VC++程序实践答案
江苏科技大学
VC++实践报告
一、实践任务
任务一（第2题）：
试建立一个类SP,求f（n,k）=1^k+2^k+3^k+…+n^K,另有辅助函数power（m,n），用于求m^n。
具体要求如下：
（1）私有成员数据：
intn,k:
存放公式中n和k得值。
（2）公有成员函数：
SP（intn1,intk1）:
构造函数，初始化成员数据n和k。
intpower（intm,intn）:
求m^n。
intfun（）:
求公式的累加和。
voidshow（）:
输出求的结果。
（3）在主程序中定义对象s，对该类进行测试。
任务一分析
1、任务分析
通过SP的成员函数power（）可求出m^n的值，再通过累加函数fun（），可求出累加和。
类的定义如下：
#include
classSP
{
intn,k;
public:
SP（）
intpower（）
intfun（）
voidshow（）
};
2、算法设计
求m^n：
定义变量P=1，循环n次，每次循环P乘以m
求累加和：
定义变量S=0,通过for循环，将power（）函数计算的结果累加。
3、系统测试
在主函数中用整数初始化SP的对象，并调用成员函数show（）输出结果。
主函数定义如下：
voidmain（）
{
SPa（2,3）;
a.power（2,3）;
a.fun（）;
a.show（）;
}
用以测试的数据为：
n=2,k=3;
预期的输出结果为：
当n=2,k=3时，f（n,k）=9
任务一程序
#include
classSP
{
intn,k;
public:
SP（intn1,intk1）
{
n=n1;k=k1;
}
intpower（intm,intn）
{
intp=1;
for（inti=1;i<=n;i++）
p*=m;
returnp;
}
intfun（）
{
ints=0;
for（inti=1;i<=n;i++）
s+=power（i,k）;
returns;
}
voidshow（）
{
cout<<"当n="<}
};
voidmain（）
{
SPa（2,3）;
a.power（2,3）;
a.fun（）;
a.show（）;
}
任务二（第24题）：
建立一个NUM，并统计特定序列中相同的字符的个数。
具体要求如下：
（1）、私有数据成员
●chardata[25]:
随机生成25个字符。
●intnum[128]：
储存每个字符出现的个数。
（1）公有成员函数
●NUM（intdata）：
构造函数，同时初始化数组data。
●voidprocess（）：
统计data中没得字符出现的个数，并保存到数组num中。
●voidprint（）：
输出每个出现过的额字符及其出现的个数，每行输出5个，没有出现过的字符不显示
（3）在主程序中定义一个对象，对该类进行测试。
1、任务（系统）分析
由利用头文件#include，程序会自动产生随机的整数，在主函数中将整数转化为字符，用字符初始化类的对象，用循环语句遍历真个字符数组，用这些字符的ASCII字判断它们所出现的次数，然后输出。
类的定义如下:
classNUM
{
chardata[25];
intnum[128];
public:
NUM（chara[25]）
voidprocess（）
voidprint（）
};
任务二分析
（1）将程序随机产生的整数利用循环语句转换为字符，保存在数组a中
（2）将num数组中的每一个元素初始化为0，然后利用这些字符的ASCII字判断它们所出现的次数，保存在num中；
3.系统测试
在主函数中用数组a初始化Move的对象，并调用其成员函数，print（）输出测试结果。
主函数定义如下：
voidmain（）
{
chara[25];
for（inti=0;i<24;i++）
a[i]=rand（）%128;
a[24]=0;
NUMt（a）;
t.process（）;
t.print（）;
}
输出结果为：
任务二程序
#include
classNUM{
chardata[25];
intnum[128];
public:
NUM（intdata）
{
for（inti=0;i<25;i++）
this->data[i]=rand（）%128;
}
voidprocess（）
{
for（inti=0;i<128;i++）
num[i]=0;
for（i=0;i<25;i++）
num[data[i]]++;
}
voidprint（）
{
for（inti=0;i<25;i++）
{
cout<if（（i+1）%5==0）cout<intk=0;
for（i=0;i<128;i++）
{if（num[i]!
=0）
{chartemp=i;
cout<k++;}
if（k%5==0）cout<}
}
};
voidmain（）
{
NUMtest
（1）;
test.process（）;
test.print（）;
}
任务三（第13题）：
建立一个类MOVE，对数组中的元素进行循环换位，即每个元素后移三位，最后三个元素移到最前面。
具体要求如下：
（1）私有数据成员
intarray[20]:
一维整型数组。
intn:
数组中元素的个数。
（2）公有成员函数
MOVE（intb[],intm）:
构造函数，初始化成员数据。
voidchange（）:
进行循环换位。
voidprint（）:
输出一维数组。
（3）在主程序中用数据{21，65，43，87，12，84，44，97，32，55}对该类进行测试。
任务三分析
1、任务分析
初始化对象数组，定义3个变量依次存放对象数组的最后3个元素。
通过循环语句将前面的元素依次后移3个单位。
最后再把3个变量中的元素值赋给最前的三个数。
类的定义如下：
#include
classMOVE
{
intarray[20];
intn;
public:
MOVE（intb[],intm）
voidchange（）
voidprint（）
};
2、算法设计
初始化对象数组，定义3个变量a,b,c,依次将array数组的最后三个元素赋给它们。
再通过for循环语句，依次把前面的元素后移3位。
最后再把3个变量中的元素值赋给最前的三个数。
3、系统测试
在主函数中初始化对象数组，并调用其成员函数print（）输出结果。
主函数的定义如下：
voidmain（）
{
inta[]={21,65,43,87,12,84,44,97,32,55};
MOVEs（a,10）;
s.change（）;
s.print（）;
}
用以测试的数据为：
{21,65,43,87,12,84,44,97,32,55}
预期的结果为：
97,32,55,21,65,43,87,12,84,44
任务三程序
#include
classMOVE
{
intarray[20];
intn;
public:
MOVE（intb[],intm）
{
n=m;
for（inti=0;iarray[i]=b[i];
}
voidchange（）
{
inta,b,c,t=n;
a=array[t-1];b=array[t-2];c=array[t-3];
for（1;t-4>=0;t--）
array[t-1]=array[t-4];
array[0]=c;array[1]=b;array[2]=a;
}
voidprint（）
{
for（inti=0;icout<cout<}
};
voidmain（）
{
inta[]={21,65,43,87,12,84,44,97,32,55};
MOVEs（a,10）;
s.change（）;
s.print（）;
}
任务四（第4题）：
建立一个类MOVE，将数组中最大元素的值与最小元素的值进行互换。
具体要求如下：
（1）私有成员数据
int*array:
一维整型数组。
intn:
数组中元素的个数。
（2）公有成员函数
MOVE（floatb[],intm）:
构造函数，初始化成员数据。
voidexchange（）:
输出平均值，并将数组中的元素按照要求重新放置。
voidprint（）:
输出一维数组。
~MOVE（）：
析构函数。
（3）在主程序中用数据{21，65，43，87，12，84，44，97，32，55}对该类进行测试。
任务四分析
1、任务分析
给成员数据array分配合适大小的动态空间。
初始化后，通过for从句计算得出所有元素的和，之后求出平均值。
通过互换函数exchange（）互换最值。
最后释放动态空间。
类的定义如下：
#include
classMOVE
{
int*array;
intn;
public:
MOVE（intb[],intm）
voidexchange（）
voidprint（）
~MOVE（）
};
2、算法设计
初始化后，通过for从句计算得出所有元素的和，之后求出平均值。
互换最值：
将第一个元素array[0]分别赋给最大值max和最小值min。
通过for从句，依次将后续元素和最值比较。
若比最大值大，则将该元素的值赋给max，同时记录元素位置，记为array[x]；若比最小值小，则将该元素的值赋给min，同时记录元素位置array[y]。
遍阅完毕后，互换最值。
1、系统测试
在主函数中初始化对象数组，并调用其成员函数print（）输出结果。
主函数的定义如下：
voidmain（）
{
intb[]={21,65,43,87,12,84,44,97,32,55};
MOVEtest（b,10）;
test.exchange（）;
test.print（）;
}
用以测试的数据为：
{21,65,43,87,12,84,44,97,32,55}
预期的结果为：
21,65,43,87,97,84,44,12,32,55
任务四程序
#include
classMOVE
{
int*array;
intn;
public:
MOVE（intb[],intm）
{
n=m;
array=newint[n];
for（inti=0;iarray[i]=b[i];
}
voidexchange（）
{
ints=0,max,min,x,y;
floatave;
max=min=array[0];
for（inti=0;i{
s+=array[i];
if（array[i]>max）{max=array[i];x=i;}
if（array[i]}
ave=s/n;
cout<<"该数组的平均值为:
"<array[y]=max;array[x]=min;
}
voidprint（）
{
for（inti=0;icout<}
~MOVE（）
{
delete[]array;
}
};
voidmain（）
{
intb[]={21,65,43,87,12,84,44,97,32,55};
MOVEtest（b,10）;
test.exchange（）;
test.print（）;
}
任务五（第6题）：
定义一个字符窜类String，实现判断该字符窜是否为回文字符窜，所谓回文字符窜就是指该字符窜左右对称。
具体要求如下：
（1）私有数据成员
char*str;
nty:
标记是否为回文字符窜
（2）公有成员函数
String（char*s）:
构造函数，用给定的参数s初始化成员数据str。
Y初始化为0.
voidhuiwen（）:
判断str所指的字符窜是否为回文字符窜。
voidshow（）:
在屏幕上显示字符窜。
（3）在主程序中定义字符窜chars[]=”ababcedbaba”作为原始字符窜。
定义一个String类对象test，用s初始化test,完成对该类的测试。
任务五分析
1、任务分析
给数据成员str分配合适大小的动态空间。
初始化后，通过回文字符窜判断函数huiwen（）进行判断。
输出字符窜，最后释放动态空间。
类的定义如下：
#include
#include
classString
{
char*str;
inty;
public:
String（char*s）
voidhuiwen（）
voidshow（）
~String（）{delete[]str;}
};
2、算法设计
初始化后，定义变量y=1。
将字符窜str赋值给数组t，让数组t指针自增到指向最后一个元素。
同时让指针q指向原数组str的第一个元素。
通过for语句和if语句判断，循环时让t自减，q自增。
若循环过程中出现两指针所指元素不相等，则y=0。
最后通过switch语句输出判断提示语。
3、系统测试
在主函数中初始化对象数组，并调用其成员函数show（）输出结果。
主函数的定义如下：
voidmain（）
{
chars[]="ababcedbaba";
Stringtest（s）;
test.show（）;
test.huiwen（）;
}
用以测试的数据为：
"ababcedbaba"
预期的结果为：
"ababcedbaba"
该数组不是回文字符窜。
任务五程序
#include
#include
classString
{
char*str;
inty;
public:
String（char*s）
{
y=0;
str=newchar[strlen（s）+1];
strcpy（str,s）;
}
voidhuiwen（）
{
char*t,*q=str;
inty=1;
t=str;
while（*t）t++;
t--;
for（;q{
if（q++!
=t--）y=0;
}
switch（y）
{
case1:
cout<<"该数组为回文数组."<case0:
cout<<"该数组不是回文数组."<}
}
voidshow（）
{
cout<}
~String（）{delete[]str;}
};
voidmain（）
{
chars[]="ababcedbaba";
Stringtest（s）;
test.show（）;
test.huiwen（）;
}
任务六（第11题）：
建立一个STRING,将一个字符窜交叉插入到另一个字符窜中（假定字符窜等长）。
例如将字符窜”abcde”交叉插入字符窜”ABCDE”的结果为”aAbBcCdDeE”或是”AaBbCcDdEe”。
具体要求如下：
（1）私有数据成员
charstr1[80]:
存放被插入的字符窜。
charstr2[40]:
存放待插入的字符窜。
（2）公有成员函数
STRING（char*s1,char*s2）:
构造函数，用s1和s2初始化str1和str2。
voidprocess（）:
将str2中的字符串插入到str1中。
voidprint（）:
输出插入后的字符串。
（3）在主程序中定义STRING类的对象test对该类进行测试。
任务六分析
1、任务分析
定义2个字符数组，保存需要交相出入的2个字符串。
再临时定义第三个字符串t用以保存被插入的字符串str1。
通过循环语句把需插入的字符串str2插入到被插入字符串str1中。
类的定义如下：
#include
#include
classSTRING
{
charstr1[80];
charstr2[40];
public:
STRING（char*s1,char*s2）
voidprocess（）
voidprint（）
};
2、算法设计
初始化2个字符串str1和str2。
定义第三个字符串t，将被插入字符串str1复制到t中。
通过while语句，让指向str1的指针在每被插入一次字符就自增一次。
插入字符串str2和t在每次插入一个字符之后都自增一次。
3、系统测试
在主函数中初始化对象数组，并调用其成员函数print（）输出结果。
主函数的定义如下：
voidmain（）
{
chars1[20]="abcde";chars2[20]="ABCDE";
STRINGtest（s1,s2）;
test.process（）;
test.print（）;
}
用以测试的数据为：
"abcde""ABCDE"
预期的结果为：
”aAbBcCdDeE”
任务六程序
#include
#include
classSTRING
{
charstr1[80];
charstr2[40];
public:
STRING（char*s1,char*s2）
{
strcpy（str1,s1）;
strcpy（str2,s2）;
}
voidprocess（）
{
chart[80];
strcpy（t,str1）;
inti=0,j=0;
while（str2[i]）
{
str1[j++]=str2[i];
str1[j++]=t[i];
i++;
}
str1[j]='\0';
}
voidprint（）
{
cout<}
};
voidmain（）
{
chars1[20]="abcde";chars2[20]="ABCDE";
STRINGtest（s1,s2）;
test.process（）;
test.print（）;
}
升级会员 