VC 课程实践正确答案(1)

更新时间：2024-01-14 03:24:01 阅读量：教育文库文档下载

说明：文章内容仅供预览，部分内容可能不全。下载后的文档，内容与下面显示的完全一致。下载之前请确认下面内容是否您想要的，是否完整无缺。

vc片的作用和功效推荐度：
相关推荐

江苏科技大学

课程实践报告

设计题目: 程序设计(VC++)实践设计时间: 至学院: 专业班级: 学生姓名: 学号指导老师:

1．试建立一个类PP，求出下列多项式的前n项的值。具体要求如下：（1）私有数据成员

? int n：前若干项的项数。 ? double x：存放x的值。

? double *p：根据n的大小动态申请存放Pn(x) 前n项的数组空间。（2）公有成员函数

? PP(int num,double x1)：构造函数，初始化数据成员n和x，使p指向动态申请的数组空间。

? ～PP（）：析构函数，释放p指向的动态内存空间。

? double fun(int n1,double x)：递归函数，用于求多项式的第n1项。注意：将递归公式中的n用作函数参数。本函数供process函数调用。

? void process( )：完成求前n项的工作，并将它们存放到p指向的动态数组中。 ? void show( )：输出n和x，并将前n项以每行4个数的形式输出到屏幕上。

（3）在主函数中完成对该类的测试。先输入num和x1，并定义一个PP类的对象items，用num和x1初始化items的成员n和x，调用items的成员函数，求出并输出多项式前num项的值。

程序源代码

#include class pp{ int n; double x; double *p; public:

pp(int num,double x1); ~pp();

double fun(int n1,double x); void process(); void show(); };

pp::pp(int num,double x1) {

n=num; x=x1;

p=new double[num+1]; }

pp::~pp() {

delete []p; }

double pp::fun(int n1,double x) {

if(n1==0)return 1;

if(n1==1)return x;

if(n1>1)return ((2*n1-1)*x*fun(n1-1,x)-(n1-1)*fun(n1-2,x))/n1; }

void pp::process() {

int i;

for(i=0;i<=n;i++) { *(p+i)=fun(i,x); } }

void pp::show() {

cout<<\ for(int i=0,m=1;i

void main() {

int num; double x1;

cout<<\ cin>>num>>x1; pp items(num,x1); items.process(); items.show(); }

运行结果

2．试建立一个类SP，求，另有辅助函数power(m,n)用于求。具体要求如下：

（1）私有成员数据。

? int n，k：存放公式中n和k的值；（2）公有成员函数。

? SP(int n1,int k1)：构造函数，初始化成员数据n和k。 ? int power(int m, int n)：求mn。 ? int fun( )：求公式的累加和。 ? void show( )：输出求得的结果。

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

#include class SP{ int n,k; public: SP(int n1,int k1); int power(int m,int n); int fun(); void show(); };

SP::SP(int n1,int k1) { n=n1; k=k1; }

int SP::power(int m,int n) { int i; if(n==0)return 1; else for(i=1;i

int SP::fun() { int y=0,x; for(x=1;x<=n;x++) y+=power(x,k); return y; }

void SP::show() { cout<<\前n项的和为：\

}

void main() { int n1,k1; cout<<\输入n1和k1的值\ cin>>n1>>k1; SP s(n1,k1); s.fun(); s.show(); }

运行结果：

3．建立一个类MOVE，不进行排序，将数组中小于平均值的元素放到数组的左边，大于平均值的元素放到数组的右边。具体要求如下：（1）私有数据成员

? float array[20]：一维整型数组。 ? int n：数组中元素的个数。（2）公有成员函数

? MOVE(float b[],int m)：构造函数，初始化成员数据。

? void average()：输出平均值，并将数组中的元素按要求重新放置。 ? void print()：输出一维数组。

（3）在主程序中用数据{1.3,6.2,3,9.1,4.8,7.4,5.6,9.2,2.3}对该类进行测试。程序源代码

#include class MOVE{

float array[20]; int n; public:

MOVE(float b[],int m); void average(); void print(); };

MOVE::MOVE(float b[],int m) {

? void show( ) ：在屏幕上显示字符串。

（3）在主程序中定义字符串char s[]=”ababcedbaba”作为原始字符串。定义一个String类对象test，用s初始化test，完成对该类的测试。

程序源代码

#include #include class string{ char *str; int y; public: string(char *s); void huiwen(); void show(); };

string::string(char *s) { str=new char[strlen(s)]; strcpy(str,s); y=0; }

void string::huiwen() { char *p1,*p2; p2=p1=str; for(int i=0;str[i];i++,p2++); p2--; for(;p1!=p2;p1++,p2--) { if(*p1!=*p2) {y=0;break;} else y=1; } }

void string::show() {

cout<<”字符串为：”<

void main() { char s[]=\ string test(s);

test.huiwen(); test.show(); }

运行结果：

7．建立一个类PHALANX，生成并显示一个折叠方阵。折叠方阵如下图所示。折叠方阵的生成过程为：起始数置于方阵的左上角，然后从起始数开始递增，依次折叠构成方阵。

具体要求如下：（1）私有数据成员

? int (*p)[20]：指向按照折叠规律存放方阵的二维整型数组。 ? int startnum：折叠方阵的起始数。 ? int n：存放方针的层数。（2）公有成员函数

? PHALANX (int s, int m )：构造函数，初始化成员数据。 ? void process()：生成起始数为startnum的n行方阵。 ? void print()：输出折叠方阵。 ? ~ PHALANX( )：析构函数。（3）在主程序中对该类进行测试。程序源代码

#include #include class phalanx{ int(*p)[20]; int starnum; int n; public: phalanx(int s,int m); void process(); void print(); ~phalanx(); };

phalanx::phalanx(int s,int m) { starnum=s; n=m; }

void phalanx::process() { int num=starnum; int y=n,i,j,x; p=new int[20][20]; for(x=0;x=0;j--) { p[i][j]=num; num++; } } }

void phalanx::print() { int i,j,m=0; for(i=0;i

phalanx::~phalanx() { delete []p; }

void main() { int s,m; cout<<\输入s和m的值\ cin>>s>>m; phalanx pp(s,m); pp.process(); pp.print();

}

运行结果

8．建立一个MATRIX，生成并显示一个螺旋方阵。螺旋方阵如下图所示，起始数置于方阵的左上角，然后从起始数开始依次递增，按顺时针方向从外向里旋转填数而成。

具体要求如下：（1）私有数据成员

? int a[20] [20]：二维整型数组存放螺旋方阵。 ? int startnum：螺旋方阵的起始数。 ? int n：存放方针的层数。（2）公有成员函数

? MATRIX (int s, int m )：构造函数，初始化成员数据startnum和n。 ? void process()：生成起始数为startnum的n行螺旋方阵。 ? void print()：输出螺旋方阵。

（3）在主程序中定义MATRIX类的对象t对该类进行测试。程序源代码

#include #include class matrix{ int a[20][20]; int starnum; int n; public: matrix(int s,int m); void process(); void print(); };

matrix::matrix(int s,int m) { starnum=s; n=m; }

void matrix::process() { int st=starnum; int i,j,x=0,y=n; for(;x<=(y-1)/2;x++) { for(i=x,j=x;j<(y-x-1);j++) { a[i][j]=st; st++; } for(;i<(y-x-1);i++) { a[i][j]=st; st++; } for(;j>x;j--) { a[i][j]=st; st++; } for(;i>x;i--) { a[i][j]=st; st++; } if(x==(y-1)/2)a[i][j]=st; } }

void matrix::print() { int i,j; for(i=0;ivoid main() { int s,m; cout<<\输入s和m的值\ cin>>s>>m;

}

matrix pp(s,m); pp.process(); pp.print();

运行结果

9．定义一个字符串类CString，并设计一个算法对该串中各个不同字符出现的频率进行统计。具体要求如下：

（1）私有数据成员

? char *str：指向要统计的字符串。

? char (*p)[2]：动态分配二维空间，用以存放str所指字符串中出现的字符及其出现的次数（次数在存放时，用该数字对应的ASCII值存放；在输出次数时，输出该ASCII字符对应的ASCII值即可）。

? int size：存放字符串中出现的所有不同的字符的个数。（2）公有成员函数

? CString (char *s) ：根据s参数初始化数据成员str；p和size初始值为0。

? void Count()：p根据s所指字符串长度分配空间。然后把str所指字符串中的每个字符放入p数组中，设置每个字符的出现次数为1。根据p数组统计不同字符出现的频率，并求得size的实际大小。最后根据size的实际大小，重新分配p所指空间，并把不同字符及其出现次数重新放回p数组（提示：可以借助临时数组或指针来实现）。

? void Show()：屏幕显示字符串、字符串的每个字符和与之对应的次数。 ? ~CString()：释放动态分配的空间。

（3）在主程序中定义字符串char s[]=”abdabcdesffffd”。定义一个CString类对象test，用s以初始化test，完成对该类的测试。

程序源代码

#include #include class cstring{ char*str; char (*p)[2]; int size; public: cstring(char *s);

void count(); void show(); ~cstring(); };

cstring::cstring(char*s) { p=0; size=0; str=s; }

void cstring::count() { p=new char[strlen(str)][2]; char n; char *p1,*p2; for(int i=0;str[i];i++) { n='\\0'; p1=&str[i]; for(int m=0;str[m];m++) { p2=&str[m]; if(*p1==*p2)n++; p2++; } p[i][0]=str[i]; p[i][1]=n; } }

void cstring::show() { for(int i=0;i

}

cstring::~cstring() { delete []p; }

void main() { char s[]=\ cstring test(s); test.count(); test.show(); }

运行结果

10．定义一个字符串类CString，并设计一个算法实现，给定关键字str1在字符串str中出现时用关键字str2进行替换的功能。具体要求如下：

（1）私有数据成员

? char *str; 原始字符串。 ? char *str1; 目标关键字。 ? char *str2; 替换关键字。

? int flag; 标记替换是否完成替换。（2）公有成员函数

? CString (char *s,char s1[ ],char *s2) ：用给定的参数s、s1和s2相对应的初始化数据成员str、str1和str2。flag设置缺省0。

? void Replace () ：判断str字符串中是否出现str1，若出现就用str2替换，否则什么都不做。若替换成功了标记flag为1，若替换不成功则标记flag为0。

? void Show( ) ：若替换成功，则在屏幕上显示目标关键字、替换关键字和替换后的原始字符串；若不成功则显示原始字符串。 ? ~ CString() ：释放动态分配的空间。

（3）在主程序中定义字符串char s[]=”I am student, you are student too, we are all student.”作为原始字符串，定义char s1[]=” student”作为目标关键字，定义char s2[]=”teacher”作为替换关键字。定义一个CString类对象test，用s，s1和s2初始化test，完成对该类的测试。

程序源代码

#include #include class cstring{ char *str; char *str1; char *str2; int flag; public: cstring(char*s,char s1[],char *s2); void replace(); void show(); ~cstring(); };

cstring::cstring(char*s,char s1[],char *s2) { str=new char[strlen(s)+1]; str1=new char[strlen(s1)+1]; str2=new char[strlen(s2)+1]; strcpy(str,s); strcpy(str1,s1); strcpy(str2,s2); flag=0; }

void cstring::replace() { int i,n1,n2,y=1; for(i=0;str[i];i++) { if(str[i]==str1[0]) { for(n1=i,n2=0;str1[n2];n1++,n2++) if((str[n1]!=str1[n2])||(str[n1]=='\\0')) { y=0; break; } if(y==1) { char pp[100]; for(int x=0,p=i;x<(strlen(str1));p++,x++) { str[p]=str2[x]; } flag=1;

} } } }

void cstring::show() {

if(flag==1) cout<<\改后\else cout<<\未改\}

cstring::~cstring() { delete []str; delete []str1; delete []str2; }

void main() { char s[]=\ char s1[]=\ char s2[]=\ cstring test(s,s1,s2); test.replace(); test.show(); }

运行结果

11．建立一个STRING，将一个字符串交叉插入到另一个字符串中（假定两字符串等长）。例如将字符串“abcde” 交叉插入字符串“ABCDE”的结果为“aAbBcCdDeE”或“AaBbCcDdEe”。具体要求如下：（1）私有数据成员

? char str1[80] ：存放被插入的字符串。 ? char str2[40] ：存放待插入的字符串。（2）公有成员函数

? STRING (char *s1, char *s2 )：构造函数，用s1和s2初始化str1和str2。 ? void process()：将str2中的字符串插入到str1中。 ? void print()：输出插入后的字符串。

（3）在主程序中定义STRING类的对象test对该类进行测试。程序源代码

#include #include class STRING{ char str1[80]; char str2[40]; public:

STRING(char *s1,char *s2); void process(); void print(); };

STRING::STRING(char *s1,char *s2) {

for(int i=0;i<80;i++) str1[i]=s1[i];

for(int j=0;j<40;j++) str2[j]=s2[j]; }

void STRING::process() {

char s[40]; strcpy(s,str1); int i=0,j=0; while(str2[i]) {

str1[j++]=str2[i]; str1[j++]=s[i]; i++; }

str1[j]='\\0'; }

void STRING::print() {

cout<<\交叉后的字符串为：\cout<

void main() {

char str1[80],str2[40];

cout<<\输入字符串1\cin.getline(str1,39);

cout<<\输入字符串2\cin.getline(str2,39);

STRING test(str1,str2); test.process(); test.print(); }

运行结果

12．建立一个STRING，将一个字符串交叉插入到另一个字符串中（假定两字符串不等长）。例如将字符串“abcde” 交叉插入字符串“ABCDEFG”的结果为“aAbBcCdDeEFG”或“AaBbCcDdEeFG”。具体要求如下：（1）私有数据成员

? char str1[60] ：存放被插入的字符串。 ? char str2[40] ：存放待插入的字符串。 ? char str3[100] ：存放插入后的字符串。（2）公有成员函数

? STRING (char *s1, char *s2 )：构造函数，用s1和s2初始化str1和str2。 ? void process()：将str2中的字符串插入到str1中，存放到str3中。 ? void print()：输出插入后的字符串。

（3）在主程序中定义STRING类的对象test对该类进行测试。程序源代码

#include #include class STRING{ char str1[60]; char str2[40]; char str3[100]; public:

STRING(char *s1,char *s2); void process(); void print(); };

STRING::STRING(char *s1,char *s2) {

for(int i=0;i<60;i++) str1[i]=s1[i];

for(int j=0;j<40;j++)

str2[j]=s2[j]; }

void STRING::process() {

int i=0,j=0,x;

while(str1[i]&&str2[i]) {

str3[j++]=str2[i]; str3[j++]=str1[i]; i++; } x=i;

if(str2[x]) while(str2[x]) str3[j++]=str2[x++]; if(str1[i]) while(str1[i]) str3[j++]=str1[i++]; str3[j++]='\\0'; }

void STRING::print() { cout<<\合并后的字符串为：\cout<

void main() {

char str1[60],str2[40];

cout<<\输入字符串1\cin.getline(str1,59);

cout<<\输入字符串2\cin.getline(str2,39); STRING test(str1,str2); test.process(); test.print(); }

运行结果

13．建立一个类MOVE，对数组中元素进行循环换位，即每个元素后移三位，最后三个元素移到最前面。具体要求如下：（1）私有数据成员

? int array[20]：一维整型数组。 ? int n：数组中元素的个数。（2）公有成员函数

? MOVE(int b[],int m)：构造函数，初始化成员数据。 ? void change()：进行循环换位。 ? void print()：输出一维数组。

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

#include class MOVE{ int array[20]; int n; public: MOVE(int b[],int m); void change(); void print(); };

MOVE::MOVE(int b[],int m) { n=m; for(int i=0;i

void MOVE::change() { int a[20]; for(int i=0;i

void MOVE::print() { for(int i=0;i

void main() { int b[20]={21,65,43,87,12,84,44,97,32,55}; MOVE p(b,10); p.change(); p.print(); }

运行结果

14．建立一个类MOVE，实现将数组中大字字母元素放在小写字母元素的左边。具体要求如下：（1）私有数据成员

? char *array：一维字符数组。 ? int n：数组中元素的个数。（2）公有成员函数

? MOVE(char b[],int m)：构造函数，初始化成员数据。 ? void change()：进行排序换位。 ? void print()：输出一维数组。 ? ~MOVE()：析构函数。

（3）在主程序中用数据\对该类进行测试。程序源代码

#include #include class move{ char*array; int n; public: move(char b[],int m); void change(); void print(); ~move(); };

move::move(char b[],int m) { array=new char[strlen(b)+1]; n=m; strcpy(array,b); }

void move::change() { char *p; int m=0; p=new char[strlen(array)]; strcpy(p,array); for(int i=0;p[i];i++) if(p[i]<='Z'&&p[i]>='A') array[m++]=p[i]; for(i=0;p[i];i++) if(p[i]<='z'&&p[i]>='a') array[m++]=p[i]; }

void move::print() { cout<<\改后字符串为：\}

move::~move() { delete []array; }

void main() { char b[1000]; int m; cout<<\输入字符串和字符串个数\ cin>>b>>m; move pp(b,m); pp.change(); pp.print(); }

运行结果：

15．定义一个一维数组类Carray，并根据给定算法实现对原始一维数组进行线性变换。这里给定的线性变换算法为：T(bx) = bT(x) + i; 其中，b为变换常量，x为变量，i为当前类中成员数组的下标值。根据该算法，原始数组在变化后，当前数组元素的值是由常量b和i下标来决定的。具体要求如下：

（1）私有数据成员

? int *a：指针a指向一个动态分配的原始数组。 ? int n：n表示该数组的大小。 ? int b：线性变换的常量。（2）公有成员函数

? Carray (int a[ ],int n,int x) ：用给定的参数a、n和x初始化数据成员a、n和b。缺省都设置为0。

? void Transform () ：根据上述变化算法，求解数组变换。 ? void Show( ) ：在屏幕上显示数组元素。 ? ~ Carray () ：释放动态分配的空间。

（3）在主程序中定义数组int arr[ ]={1,2,3,4,5,6,7,8,9,10}作为原始数组，int b;由键盘输入，作为线性变换的常量。定义一个Carray类对象test，用arr初始化test，完成对该类的测试。

程序源代码 #include class carray{ int *a; int n; int b; public: carray(int a[],int n,int x); void transform(); void show(); ~carray(); };

carray::carray(int a[],int n=0,int x=0) { this->a=new int[n]; this->n=n; b=x; for(int i=0;ia[i]=a[i]; } }

void carray::transform() { for(int i=0;i

void carray::show() { cout<<\变换后的数组为：\ for(int i=0;i

cout<

carray::~carray() { delete []a; }

void main() { int arr[]={1,2,3,4,5,6,7,8,9,10}; int m=10,b; cout<<\输入线性变换常量\ cin>>b; carray test(arr,m,b); test.transform(); test.show(); }

运行结果：

16．定义一个方阵类CMatrix，并根据给定算法实现方阵的线性变换。方阵的变换形式为： F=W*fT

f为原始矩阵，fT为原始矩阵的转置，w为变换矩阵，这里设定为 1 0 0 1 0 1 1 0 0 1 1 0 1 0 0 1 具体要求如下：

（1）私有数据成员

? int (*a)[4]：a指向方阵数组。 ? int w[4][4]：w为变换矩阵。 ? int m：m表示方阵的行和列数。（2）公有成员函数

? CMatrix (int a[][4],int m) ：用给定的参数a和m 初始化数据成员a和m；对变换矩阵w进行初始化，要求必须用循环实现。

? void Transform () ：根据上述变换算法，求出变换后的数组形式，存放在原始数组内。 ? void show( ) ：在屏幕上显示数组元素。 ? ~ CMatrix () ：释放动态分配的空间。

（3）在主程序中定义数组int arr[][4]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}作为原始数组。

定义一个CMatrix类对象test，用arr初始化test，完成对该类的测试。程序源代码：

#include #include class cmatrix{ int (*a)[4]; int w[4][4]; int m; public:

cmatrix(int a[][4],int m); void transform(); void show(); ~cmatrix(); };

cmatrix::cmatrix(int a[][4],int m) {

this->a=new int [4][4]; for(int i=0;i<4;i++) for(int j=0;j<4;j++) this->a[i][j]=a[i][j]; this->m=m;

for(int p=0;p<4;p++) for(int q=0;q<4;q++) if((p+q!=3)&&(p-q!=0))w[p][q]=0; else w[p][q]=1; }

void cmatrix::transform() {

int b[4][4],i,j; for(i=0;i<4;i++) for(j=0;j<4;j++) b[i][j]=a[j][i]; for(i=0;i<4;i++) for(j=0;j<4;j++) a[i][j]=w[i][0]*b[0][j]+w[i][1]*b[1][j]+w[i][2]*b[2][j]+w[i][3]*b[3][j]; }

void cmatrix::show() {

cout<<\变换后的数组是：\ for(int i=0;i<4;i++) { for(int j=0;j<4;j++) cout<

} }

cmatrix::~cmatrix() {

delete []a; }

void main() {

int arr[][4]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}; int m=4;

cmatrix test(arr,m); test.transform(); test.show(); }

运行结果：

17．定义一个类SIN，求具体要求如下：（1）私有成员数据。

? int x：输入公式中x的值，求sin(x)。 ? int n：输入公式中n的值。（2）公有成员函数。

? SIN(int x, int n )：构造函数，用于初始化x和n的值。 ? int power( int q)：求q!的值。 ? int mi( int m,int n)：求的值。 ? int fun( )：用于求SIN(X)的值。 ? void show( )：输出求得的结果。

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

#include class sin{ int x; int n; public:

sin(int x,int n); int power(int q); int mi(int m,int n); int fun(); void show();

};

sin::sin(int x,int n) {

this->x=x; this->n=n; }

int sin::power(int q) {

for(int i=1;i<=q;i++) q*=i; return q; }

int sin::mi(int m,int n) {

for(int i=1;i

int sin::fun() {

float s=0;

for(int i=1;i<=n;i++) s+=mi(-1,i+1)*mi(x,2*i-1)/power(2*i-1); return s; }

void sin::show() {

cout<<\}

void main() {

int x,n;

cout<<\输入x和n的值\ cin>>x>>n; sin test(x,n); test.show(); }

18．试建立一个类VAR，用于求n（）个数的均方差。均方差的计算公式为，其中平均值

为。

具体要求如下：

（1）私有成员数据。

? double a[100]：用于存放输入的n个数。 ? int n：实际输入数的个数n。（2）公有成员函数。

? VAR(double x[], int n1)：构造函数，初始化成员数据a和个数n。 ? double average(double x[], int n)：求平均值，数组x具有n个元素。 ? void variance(double x[],int n)：求均方差，数组x具有n个元素。 ? void show()：输出求得的均方差。

（3）在主程序中定义一个对象test，对该类进行测试。 #include class var{ double a[100]; int n; public: var(double x[],int n1); double average(double x[],int n); void variance(double x[],int n); void show(); };

var::var(double x[],int n1) { for(int i=0;i

double var::average(double x[],int n) { double ave=0; for(int i=0;i

void var::variance(double x[],int n) { double ff=0; for(int i=0;i

void var::show()

{ cout<<\平均值为：\ variance(a,n); }

void main() { double x[100]={23,56,77,568,34,54,9.5,31,78}; int n1=9; var test(x,n1); test.show(); }

19．定义一个方阵类Array，实现对方阵进行顺时针90度旋转。如图所示。

具体要求如下：

（1）私有数据成员

? int a[4][4]：用于存放方阵。（2）公有成员函数

? Array (int a1[][4],int n) ：构造函数，用给定的参数a1初始化数据成员a。 ? void xuanzhuan ( ) ：实现对方阵a进行顺时针90度的旋转。 ? void show( ) ：在屏幕上显示数组元素。

（3）在主程序中定义数组int b[ ][4]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}作为原始数组。定义一个Array类对象test，用b初始化test，完成对该类的测试。 #include #include class array{ int a[4][4]; public: array(int a1[][4],int n); void xuanzhuan(); void show(); };

array::array(int a1[][4],int n) { for(int i=0;i

void array::xuanzhuan() { int b[4][4],i,j; for(i=0;i<4;i++) for(j=0;j<4;j++) b[i][j]=a[i][j]; for(i=0;i<4;i++) for(j=0;j<4;j++) a[j][3-i]=b[i][j]; }

void array::show() { cout<<\旋转后的矩阵为：\ for(int i=0;i<4;i++) { for(int j=0;j<4;j++) cout<void main() { int b[][4]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}; int n=4; array test(b,n); test.xuanzhuan(); test.show(); }

20．定义一个方阵类Array，实现对方阵进行逆时针90度旋转。如图所示。

1 2 3 4 4 8 12 16 5 6 7 8 3 7 11 15 9 10 11 12 2 6 10 14 13 14 15 16 1 5 9 13

具体要求如下：

（1）私有数据成员

? int a[4][4]：用于存放方阵。（2）公有成员函数

? Array (int a1[][4],int n) ：构造函数，用给定的参数a1初始化数据成员a。 ? void xuanzhuan ( ) ：实现对方阵a进行逆时针90度的旋转。 ? void show( ) ：在屏幕上显示数组元素。

（3）在主程序中定义数组int b[ ][4]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}作为原始数组。定义一个Array类对象test，用b初始化test，完成对该类的测试。

#include #include class array{ int a[4][4]; public:

array(int a1[][4],int n); void xuanzhuan(); void show(); };

array::array(int a1[][4],int n) {

for(int i=0;i

void array::xuanzhuan() {

int b[4][4],i,j; for(i=0;i<4;i++) for(j=0;j<4;j++) b[i][j]=a[i][j]; for(i=0;i<4;i++) for(j=0;j<4;j++) a[3-j][i]=b[i][j]; }

void array::show() {

cout<<\旋转后的矩阵为：\ for(int i=0;i<4;i++) { for(int j=0;j<4;j++) cout<void main() {

}

int b[][4]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}; int n=4;

array test(b,n); test.xuanzhuan(); test.show();

21．建立一个类NUM，求指定数据范围内的所有合数（非质数）。提示：合数定义是“一个数，除了1和它本身，还有其它约数，这样的数叫合数”。具体要求如下：（1）私有数据成员

? int *data：动态存放在指定范围内求出的所有合数。 ? int span1,span2：存放指定范围的下限和上限。 ? int num：存放span1与span2之间的合数个数。（2）公有成员函数

? NUM(int n1, int n2) ：构造函数，用参数n1和n2初始化span1和span2，同时初始化num。

? int isComposite (int x )：判断x是否为合数。若是合数，返回1，否则，返回0。

? void process( ) ：求指定范围内的所有合数，把它们依次存放在数组data中，并将求出的合数个数赋给num。

? void print( )：输出求出的素数个数及所有合数，每行输出8个合数。 ? ~NUM( )：释放动态分配的存储空间。（3）在主函数中完成对该类的测试。定义一个NUM类对象test，指定查找范围为100~200，即求100至200之间的所有合数。通过test调用成员函数完成求合数及输出合数的工作。

#include class Num{ int *data;

int span1,span2; int num; public:

Num(int n1,int n2); int iscomposite(int x); void process(); void print(); ~Num(); };

Num::Num(int n1,int n2) {

span1=n1; span2=n2; num=0;

data=new int[n2-n1]; }

int Num::iscomposite(int x) {

for(int i=2;i

void Num::process() {

for(int i=span1;i<=span2;i++) if(iscomposite(i)) data[num++]=i; }

void Num::print() {

cout<<\在\和\之间的合数个数为：这些合数为：\ for(int i=0;i

cout<

Num::~Num() {

delete []data; }

void main() {

int n1,n2;

cout<<\输入下限和上限：\ cin>>n1>>n2; Num test(n1,n2); test.process(); test.print(); }

22．建立一个类Saddle_point，求一个数组中的所有鞍点。提示：鞍点是这样的数组元素，其值在它所在行中为最大，在它所在列中为最小。具体要求如下：（1）私有数据成员

? int a[4][4]：存放二维数组元素。

? int b[4][4]：存放二维数组中的鞍点值。 ? int num：存放鞍点个数。（2）公有成员函数

? Saddle_point(int data[][4])：构造函数，用参数int data[][4]初始化数组a,，同时初始化数组b与num 的值均为0。

? void process( )：求数组a所有鞍点（如果有鞍点），把它们行、列、及值相应存放在数组b中，并将求出的鞍点个数赋给num。

? void print( )：输出数组a、鞍点个数，与鞍点坐标及相应值。

（3）在主程序中定义数组int b[ ][4]={2, 6, 3, 4, 5, 6, 5, 5, 5, 7, 6, 7, 1, 9, 2, 7}作为原始数组。定义一个Saddle_point类对象fun。通过fun调用成员函数完成求鞍点及输出工作。（4）#include （5）class var{

（6） double a[100]; （7） int n; （8）public:

（9） var(double x[],int n1);

（10） double average(double x[],int n); （11） void variance(double x[],int n); （12） void show(); （13）};

（14）var::var(double x[],int n1)

（15）{

（16） for(int i=0;i

（20）double var::average(double x[],int n) （21）{

（22） double ave=0;

（23） for(int i=0;i

（28）void var::variance(double x[],int n) （29）{

（30） double ff=0;

（31） for(int i=0;i

（34） cout<<\均方差为：\

（35）}

（36）void var::show() （37）{

（38） cout<<\平均值为：\（39） variance(a,n); （40）}

（41）void main() （42）{

（43） double x[100]={23,56,77,568,34,54,9.5,31,78}; （44） int n1=9; （45） var test(x,n1); （46） test.show(); （47）}

23．分数相加，两个分数分别是1/5和7/20，它们相加后得11/20。方法是先求出两个分数

分母的最小公倍数，通分后，再求两个分子的和，最后约简结果分数的分子和分母（如果两个分数相加的结果是4/8，则必须将其约简成最简分数的形式1/2），即用分子分母的最大公约数分别除分子和分母。求m、n最大公约数的一种方法为：将m、n较小的一个数赋给变量k，然后分别用{ k，k-1，k-2，?，1}中的数（递减）去除m和n，第一个能把m和n同时除尽的数就是m和n的最大公约数。假定m、n的最大公约数是v，则它们的最小公倍数就是m*n/v。试建立一个分数类Fract，完成两个分数相加的功能。具体要求如下：（1）私有数据成员

? int num，den ：num为分子，den为分母。（2）公有成员函数

? Fract（int a=0,int b=1）：构造函数，用a和b分别初始化分子num、分母den。 ? int ged（int m，int n）：求m、n的最大公约数。此函数供成员add()函数调用。 ? Fract add（Fract f）：将参数分数f与对象自身相加，返回约简后的分数对象。 ? void show( )：按照num/den的形式在屏幕上显示分数。

（3）在主程序中定义两个分数对象f1和f2，其初值分别是1/5和7/20，通过f1调用成员函数add完成f1和f2的相加，将得到的分数赋给对象f3，显示分数对象f3。

#include class fract{

int num,den; public:

fract(int a=0,int b=1); int ged(int m,int n); fract add(fract f); void show(); };

fract::fract(int a,int b) {

num=a; den=b; }

int fract::ged(int m,int n) {

for(int i=m;i>=1;i--) if(m%i==0&&n%i==0)return i; }

fract fract::add(fract f) {

int n,d,p,q;

p=ged(den,f.den); d=den*f.den/p;

n=num*f.den/p+f.num*den/p; q=ged(n,d);

Return fract(n/q,d/q); }

void fract::show() {

cout<<\相加后的值为：\}

void main() {

fract f1(1,5),f2(7,20),f3; f3=f1.add(f2); f3.show(); }

24．建立一个类NUM，并统计特定序列中相同的数字的个数。具体要求如下：（1）私有数据成员

? int data[25]：随机生成25个在0-9之间的数字。 ? int num[10]：储存每个数字出现的个数。（2）公有数据成员

? NUM(int data)：构造函数，初始化数组data。

? void process( )：统计数组data中每个数字出现的个数，并保存到数组num中。 ? void print( )：输出每个数字出现的个数，每行输出5个（3）在主程序中定义一个对象，对该类进行测试。

#include #include #include class Num{

int data[25]; int num[10]; public: Num();

void process(); void print(); };

Num::Num() {

srand(time(0));

for(int i=0;i<25;i++) data[i]=rand()%9; }

void Num::process() {

int i,x=0;

for(i=0;i<10;i++) { for(int m=0,n=0;m<25;m++) if(data[m]==i) n++; num[x++]=n; } }

void Num::print() {

cout<<\随机数为：\ for(int j=0;j<25;j++) cout<

cout<

void main() {

Num test; test.process(); test.print(); }

25．建立一个类NUM，并统计特定序列中相同的字符的个数。具体要求如下：（1）私有数据成员

? char data[25]：随机生成25个字符。

? int num[128]：储存每个字符出现的个数。（2）公有数据成员

? NUM(int data)：构造函数，同时初始化数组data。

? void process( )：统计数组data中每个字符出现的个数，并保存到数组num中。

? void print( )：输出每个出现过的字符及其出现的个数，每行输出5个，没有出现过的字符不显示。

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

#include #include #include

class Num{

char data[25]; int num[128]; public: Num();

void process(); void print(); };

Num::Num() {

srand(time(0));

for(int i=0;i<25;i++) data[i]=rand()8; }

void Num::process() {

int i,x=0;

for(i=1;i<=128;i++) { for(int m=0,n=0;m<25;m++) if(data[m]==i) n++; num[x++]=n; } }

void Num::print() {

cout<<\输出随即字符串\

cout<

for(int i=0;i<128;i++) { if(num[i]>0) { cout<

void main() {

Num test; test.process(); test.print(); }

26．建立一个类NUM，随机生成25个字符序列，并为特定序列进行排序。具体要求如下：（1）私有数据成员

? int data[25]：随机生成25个字符。（2）公有数据成员

? NUM(int data)：构造函数，初始化数组data。

? void process( )：为数组data进行排序，要求按照ASCII码进行升序排列。 ? void print( )：输出数组data，每行输出5个字符。（3）在主程序中定义一个对象，对该类进行测试。

#include #include #include class num{

int data[25]; public: num();

void process(); void print(); };

num::num() {

srand(time(0));

for(int i=0;i<25;i++) data[i]=rand()8; }

void num::process() {

int m;

for(int i=0;i<25;i++) for(int j=i;j<25;j++)

if(data[i]>data[j]) { m=data[i]; data[i]=data[j]; data[j]=m; } }

void num::print() {

cout<<\排序后的数组为：\ for(int i=0;i<25;i++) { cout<

cout<

void main() {

num test; test.process(); test.print(); }

27．建立一个类NUM，求指定数据范围内的所有素数（质数）。提示：素数定义是“只能被1和它本身整除的整数”，即质数。具体要求如下：（1）私有数据成员

? int data[10]：依次存放原始数据。

? int prime[10]：存放指定数据内所求出的所有素数。 ? int num：存放素数个数。（2）公有数据成员

? NUM(int n[ ])：构造函数，用参数n初始化data，同时初始化num为0。 ? int isprime (int x )：判断x是否为素数。若是素数，返回1，否则，返回0。

? void process( )：求指定data数组中的所有素数，把它们依次存放在数组prime中，并将求出的素数个数赋给num。

? void print( )：输出求出的素数个数及所有素数，每行输出4个素数。

（3）在主函数中完成对该类的测试。定义NUM类对象test，通过test调用成员函数完成求素数及输出素数的工作。原始数据为{4, 5, 9, 11, 36, 29, 31, 101, 56, 199}。

#include class Num{

int data[10]; int prime[10]; int num; public:

Num(int n[]); int isprime(int x); void process(); void print(); };

Num::Num(int n[]) {

num=0;

for(int i=0;i<10;i++) data[i]=n[i]; }

int Num::isprime(int x) {

for(int i=2;i

void Num::process() {

int m=0;

for(int i=0;i<10;i++) { if(isprime(data[i])==1) { prime[m++]=data[i]; num++; } } }

void Num::print() {

int m=0;

cout<<\素数的个数为：\ for(int i=0;i

if(m%4==0)cout<

void main() {

int n[]={4,5,9,11,36,29,31,101,56,199}; Num test(n); test.process(); test.print(); }

28．编程实现对大于1的整数进行质因数分解，并求出其和。所谓整数的质因子分解是指将整数分解为其所有质数（素数）因数的积，例如，60=2*2*3*5，则整数60的质因数之和为12。定义一个类Decompose实现上述功能。具体要求如下：（1）私有数据成员

? int *a：指向存放对应整数的质因数之和的动态存储空间。 ? int *num：指向待分解质因数整数的动态存储空间。 ? int n：整数的个数。（2）公有数据成员

? Decompose(int m，int b[ ])：用m初始化n，并用n初始化为动态申请空间的指针a与num。用参数b给数组a赋值。

? void print( )：输出数组a以及num所指向的存储空间中的内容。 ? void primenum( )：求整数a[i]的所有质因数（保留重复部分，例如60的质因数为 2,2,3,5，之和为12），并将这些质因数之和存放到指针num所指向的存储空间中。 ? ~Decompose( )：释放动态分配的存储空间。

（3）在主函数中完成对该类的测试。从键盘输入一组大于1的整数，存放在number数组中，定义类Decompose的对象d ，并用 number初始化d ，调用函数primenum( ) 求number 的所有质因数，最后输出测试结果。

#include class decompose{ int *a; int *num; int n; public:

decompose(int m,int b[]); void print();

void primenum(); ~decompose(); };

decompose::decompose(int m,int b[]) {

n=m;

a=new int[n]; num=new int[n]; for(int i=0;i

void decompose::primenum() {

int s,b,flag;

for(int i=0;i1;) { flag=1; for(int m=2;m

void decompose::print() {

cout<<\输出整数：\ for(int i=0;i cout<