江苏科技大学C课程实践报告答案.doc

江苏科技大学

课程实践报告

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

2013年12月

任务一
一、实践任务
2．试建立一个类SP，求，另有辅助函数power(m,n)用于求。
二、详细设计
1、类的描述与定义
（1）私有数据成员
l int n，k：存放公式中n和k的值；
（2）公有成员函数
l SP(int n1,int k1)：构造函数，初始化成员数据n和k。
l int power(int m, int n)：求mn。
l int fun( )：求公式的累加和。
l void show( )：输出求得的结果。
2、主要函数设计
在主程序中定义对象s，对该类进行测试。
三、源程序清单
#include <iostream.h>
class SP
{
int n,k;
public:
SP(int n1,int k1)
{
n=n1;k=k1;
}
int power(int m,int n)
{
int p=1;
for (int i=1;i<n+1;i++)
p*=m;
return p;
}
int fun()
{
int s=0;
for (int i=1;i<n+1;i++)
s+=power(i,k);
return s;
}
void A()
{
cout<<"n="<<n<<",k="<<k<<",f(n,k)="<<fun()<<endl;
}
};
void main()
{
SP a(3,3);
a.power(3,3);
a.fun();
a.A();
}四、实践小结
掌握用循环语句求m^n，和m!，熟练掌握函数的调用。
五、运行结果

任务三
一、实践任务
3．建立一个类MOVE，不进行排序，将数组中小于平均值的元素放到数组的左边，大于平均值的元素放到数组的右边。
二、详细设计
1、类的描述与定义
（1）私有数据成员
l float array[20]：一维整型数组。
l int n：数组中元素的个数。
（2）公有成员函数
l MOVE(float b[],int m)：构造函数，初始化成员数据。
l void average()：输出平均值，并将数组中的元素按要求重新放置。
l void print()：输出一维数组。
2、主要函数设计
在主程序中用数据{1.3,6.2,3,9.1,4.8,7.4,5.6,9.2,2.3}对该类进行测试。
三、源程序清单
四、实践小结
应熟练掌握数组与指针的应用。
五、运行结果

任务四
一、实践任务
4．建立一个类MOVE，将数组中最大元素的值与最小元素的值互换。
二、详细设计
1、类的描述与定义
（1）私有数据成员
l int *array：一维整型数组。
l int n：数组中元素的个数。
（2）公有成员函数
l MOVE(int b[],int m)：构造函数，初始化成员数据。
l void exchange()：输出平均值，并将数组中的元素按要求重新放置。
l void print()：输出一维数组。
l ~MOVE()：析构函数。
2、主要函数设计
在主程序中用数据{21,65,43,87,12,84,44,97,32,55}对该类进行测试。
三、源程序清单

四、实践小结
学会求数组中最大元素与最小元素方法，并实现交换。
五、运行结果

任务六
一、实践任务
6．定义一个字符串类String，实现判断该字符串是否为回文字符串。所谓回文字符串，是指该字符串左右对称。例如字符串“123321”是回文字符串。
二、详细设计
1、类的描述与定义
（1）私有数据成员
l char *str;
l int y：标记是否为回文字符串。
（2）公有成员函数
l String (char *s) ：构造函数，用给定的参数s初始化数据成员str。y初始化为0。
l void huiwen () ：判断str所指向的字符串是否为回文字符串。
l void show( ) ：在屏幕上显示字符串。
2、主要函数设计
在主程序中定义字符串char s[]=”ababcedbaba”作为原始字符串。定义一个String类对象test，用s初始化test，完成对该类的测试。
三、源程序清单
四、实践小结
掌握判断回文字符串的一般形式。
五、运行结果

任务十一
一、实践任务
11．建立一个STRING，将一个字符串交叉插入到另一个字符串中（假定两字符串等长）。例如将字符串“abcde” 交叉插入字符串“ABCDE”的结果为“aAbBcCdDeE”或“AaBbCcDdEe”。
二、详细设计
1、类的描述与定义
（1）私有数据成员
l char str1[80] ：存放被插入的字符串。
l char str2[40] ：存放待插入的字符串。
（2）公有成员函数
l STRING (char *s1, char *s2 )：构造函数，用s1和s2初始化str1和str2。
l void process()：将str2中的字符串插入到str1中。
l void print()：输出插入后的字符串。
2、主要函数设计
在主程序中定义STRING类的对象test对该类进行测试。
三、源程序清单
#include<iostream.h>
#include<string.h>
class STRING{
private:
char str1[80];//存放被插入的字符串；
char str2[40];//存放待插入的字符串；
public:
STRING(char*s1,char*s2)
{
strcpy(str1,s1);
strcpy(str2,s2);
}
void process();
void print();
};
void STRING::process()
{
int i,j;
int n=strlen(str1);
if(strlen(str2)>strlen(str1))
{//当待插入的字符串ABCDEFG比被插入的字符串abcde长或相等时，逻辑算法：abcde->a b c d e->空格处依次插入ABCDEFG->aAbBcCdDeEFG;
for(i=n-1;i>0;i--)
{
str1[i+i]=str1[i];//被插入的字符串由最后一位开始各位向后移动i位；
}
for(i=1,j=0;i<2*n;i+=2,j++)
{
str1[i]=str2[j];//在空出的位置处依次插入字符串；
}
i--;
for(;j<=strlen(str2);j++,i++)
{
str1[i]=str2[j];//将过长额字符串放入被插入的字符串尾部,完成插入；
}
}
else//当待插入的字符串abcde比被插入的字符串ABCDEFG短时，逻辑算法：ABCDEFG->A B C D E FG->空格处插入abcde->AaBbCcDdEeFG;
{
for(i=n;i>strlen(str2)-1;i--)
{
str1[i+strlen(str2)]=str1[i];//比待插入的字符串长的部分均向后移strlen(str2)位；
}
for(i=strlen(str2)-1;i>0;i--)
{
str1[i+i]=str1[i];//之前的部分均向后移i位；
}
for(i=1,j=0;i<2*strlen(str2);i+=2,j++)
{
str1[i]=str2[j];//将待插入的字符串插入空格处,完成插入；
}
}
}
void STRING::print()//输出插入后的字符串
{
cout<<"插入后的字符串为:"<<str1<<endl;
}
void main()//测试
{
STRING test("ABCDE","abcde");
test.process();
test.print();
}
四、实践小结
发现字符插入的规律，再依次放入相应字符位置。
五、运行结果

任务十二
一、实践任务
12．建立一个STRING，将一个字符串交叉插入到另一个字符串中（假定两字符串不等长）。例如将字符串“abcde” 交叉插入字符串“ABCDEFG”的结果为“aAbBcCdDeEFG”或“AaBbCcDdEeFG”。
二、详细设计
1、类的描述与定义
（1）私有数据成员
l char str1[60] ：存放被插入的字符串。
l char str2[40] ：存放待插入的字符串。
l char str3[100] ：存放插入后的字符串。
（2）公有成员函数
l STRING (char *s1, char *s2 )：构造函数，用s1和s2初始化str1和str2。
l void process()：将str2中的字符串插入到str1中，存放到str3中。
l void print()：输出插入后的字符串。
2、主要函数设计
在主程序中定义STRING类的对象test对该类进行测试。
三、源程序清单
#include<iostream.h>
#include<string.h>
class STRING{
private:
char str1[60];
char str2[40];
char str3[100];
public:
STRING(char*s1,char*s2)
{
strcpy(str1,s1);
strcpy(str2,s2);
}
void process();
void print();
};
void STRING::process()
{
int i,j;
int n=strlen(str1);
if(strlen(str2)>strlen(str1))
{//当待插入的字符串ABCDEFG比被插入的字符串abcde长或相等时，逻辑算法：abcde->a b c d e->空格处依次插入ABCDEFG->aAbBcCdDeEFG;
for(i=n-1;i>0;i--)
{
str1[i+i]=str1[i];//被插入的字符串由最后一位开始各位向后移动i位；
}
for(i=1,j=0;i<2*n;i+=2,j++)
{
str1[i]=str2[j];//在空出的位置处依次插入字符串；
}
i--;
for(;j<=strlen(str2);j++,i++)
{
str1[i]=str2[j];//将过长额字符串放入被插入的字符串尾部,完成插入；
}
}
else//当待插入的字符串abcde比被插入的字符串ABCDEFG短时，逻辑算法：ABCDEFG->A B C D E FG->空格处插入abcde->AaBbCcDdEeFG;
{
for(i=n;i>strlen(str2)-1;i--)
{
str1[i+strlen(str2)]=str1[i];//比待插入的字符串长的部分均向后移strlen(str2)位；
}
for(i=strlen(str2)-1;i>0;i--)
{
str1[i+i]=str1[i];//之前的部分均向后移i位；
}
for(i=1,j=0;i<2*strlen(str2);i+=2,j++)
{
str1[i]=str2[j];//将待插入的字符串插入空格处,完成插入；
}
}
strcpy(str3,str1);//将str2中的字符串插入到str1中，存放到str3中；
}
void STRING::print()//输出插入后的字符串
{
cout<<"插入后的字符串为:"<<str3<<endl;
}
void main()
{
STRING test("abcde","ABCDEFG");
test.process();
test.print();
}
四、实践小结
发现字符插入的规律，再依次放入相应字符位置。
五、运行结果

任务十三
一、实践任务
13．建立一个类MOVE，对数组中元素进行循环换位，即每个元素后移三位，最后三个元素移到最前面。
二、详细设计
1、类的描述与定义
（1）私有数据成员
l int array[20]：一维整型数组。
l int n：数组中元素的个数。
（2）公有成员函数
l MOVE(int b[],int m)：构造函数，初始化成员数据。
l void change()：进行循环换位。
l void print()：输出一维数组。
2、主要函数设计
在主程序中用数据{21,65,43,87,12,84,44,97,32,55}对该类进行测试。
三、源程序清单
#include<iostream.h>
class MOVE{
private:
int array[20];//一维整型数组；
int n; //数组中的元素个数；
public:
MOVE(int b[],int m)
{
for(int i=0;i<m;i++)
array[i]=b[i];
n=m;
}
void change();
void print();
};
void MOVE::change()//进行循环换位，即每个元素后移3位，最后3个元素移到最前面；
{
int tem[3];//建立临时数组，用于存放最后3个元素；
int i=0;
while(i<3)
{
tem[2-i]=array[n-1-i];//将最后3个元素依次放入临时数组中；
i++;
}
for(i=0;i<n-3;i++)//将原数组的最后一个至第4个元素依次后移3位；
{
array[n-1-i]=array[n-1-3-i];
}
for(i=0;i<3;i++)//将临时数组中存放的最后3个元素依次放入后移后的原数组中，完成循环换位；
{
array[i]=tem[i];
}
}
void MOVE::print()//输出一维数组；
{
for(int i=0;i<n;i++)
cout<<array[i]<<'\t';
cout<<endl;
}
void main()
{
int s[]={21,65,43,87,12,84,44,97,32,55};
int n=sizeof(s)/sizeof(int);
MOVE test(s,n);
test.print();
test.change();
test.print();
}
四、实践小结
利用临时数组先保存后3位，再依次把数放入对应位。
五、运行结果

任务十四
一、实践任务
14．建立一个类MOVE，实现将数组中大字字母元素放在小写字母元素的左边。
二、详细设计
1、类的描述与定义
（1）私有数据成员
l char *array：一维字符数组。
l int n：数组中元素的个数。
（2）公有成员函数
l MOVE(char b[],int m)：构造函数，初始化成员数据。
l void change()：进行排序换位。
l void print()：输出一维数组。
l ~MOVE()：析构函数。
2、主要函数设计
在主程序中用数据"fdsUFfsTjfsKFEkWC"对该类进行测试。
三、源程序清单
#include <iostream.h>
#include<string.h>
class MOVE{
char *array;
int n;
public:
MOVE(char b[],int m)
{ n=m;
array=new char[n+1];
strcpy(array,b);
}
void change()
{
char*p1=new char[strlen(array)+1];//用于存大写；
char*p2=new char[strlen(array)+1];//存小写；
int i,j=0,k=0;
for(i=0;i<strlen(array);i++)//大写与小写分别存放；
{
if(array[i]>='A'&&array[i]<='Z')
{
p1[j]=array[i];
j++;
}
else {p2[k]=array[i];k++;}
}
p1[j]=p2[k]='\0';
strcat(p1,p2);//存放大写组与小写组拼接；
strcpy(array,p1);//拷贝至array；
delete []p1;
delete []p2;
}
void print()
{
cout<<array<<endl;
}
~MOVE()
{ if (array)
delete []array;
}

};
void main()
{
char b[]="fdsUFfsTjfsKFEkWC";
int n;
n=(sizeof(b)-1)/sizeof(char);
MOVE test(b,n);
test.change();
test.print();
}
四、实践小结
利用临时数组，分别保存大写与小写字母，再实现功能。
五、运行结果

任务十五
一、实践任务
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、类的描述与定义
（1）私有数据成员
l int (*a)[4]：a指向方阵数组。
l int w[4][4]：w为变换矩阵。
l int m：m表示方阵的行和列数。
（2）公有成员函数
l CMatrix (int a[][4],int m) ：用给定的参数a和m 初始化数据成员a和m；对变换矩阵w进行初始化，要求必须用循环实现。
l void Transform () ：根据上述变换算法，求出变换后的数组形式，存放在原始数组内。
l void show( ) ：在屏幕上显示数组元素。
l ~ CMatrix () ：释放动态分配的空间。
2、主要函数设计
在主程序中定义数组int arr[][4]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}作为原始数组。定义一个CMatrix类对象test，用arr初始化test，完成对该类的测试。
三、源程序清单
#include<iostream.h>
class CMatrix{
private:
int(*a)[4];
int w[4][4];//变换矩阵
int m;//表示方阵的行和列数；
public:
CMatrix(int a[][4],int m)
{
int i,j;
this->a=new int[m][4];
this->m=m;
for(i=0;i<4;i++)
{
for(j=0;j<4;j++)
{
if(i==j||i+j==4-1)
w[i][j]=1;
else
w[i][j]=0;
}
}
for(i=0;i<m;i++)
{
for(j=0;j<4;j++)
{
this->a[i][j]=a[i][j];
}
}
}
void Transform();
void show();
~CMatrix()
{if(a) delete []a;}
};
void CMatrix::Transform()//根据变换算法，求出变换后的数组形式，存放在原始数组内；
{
int i,j,k;
for(i=0;i<m;i++)//求原始矩阵的转置，并存放在原始数组中；
{
for(j=i;j<4;j++)
{
k=a[i][j],a[i][j]=a[j][i],a[j][i]=k;
}
}
int sum;//用来存放矩阵乘法中，行列中元素依次相乘的累加和；
int turn[4][4];//临时数组，用来存放矩阵乘法所求得的值；
for(i=0;i<4;i++)//实现矩阵的乘法；
{
for(j=0;j<4;j++)
{
sum=0;
for(k=0;k<4;k++)
{
sum+=w[i][k]*a[k][j];
}
turn[i][j]=sum;
}
}
for(i=0;i<4;i++)//将临时数组的值存放入原始数组中；
{
for(j=0;j<4;j++)
{
a[i][j]=turn[i][j];
}
}
}
void CMatrix::show()//在屏幕上显示数组元素；
{
for(int i=0;i<m;i++)
{
for(int j=0;j<4;j++)
{
cout<<a[i][j]<<'\t';
}
cout<<endl;
}
}
void main()
{
int arr[][4]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
CMatrix test(arr,4);
cout<<"原矩阵为:"<<endl;
test.show();
test.Transform();
cout<<"经线性变换后的矩阵为:"<<endl;
test.show();
}
四、实践小结
应熟练掌握矩阵的乘法方式。
五、运行结果

任务十六
一、实践任务
17．定义一个类SIN，求
二、详细设计
1、类的描述与定义
（1）私有数据成员
l float x：输入公式中x的值，求sin(x)。
l int n：输入公式中n的值。
（2）公有成员函数
l SIN(float x, int n )：构造函数，用于初始化x和n的值。
l int power( int q)：求q!的值。
l float mi(float m,int n)：求的值。
l float fun( )：用于求SIN(X)的值。
l void show( )：输出求得的结果。
2、主要函数设计
在主程序中定义对象test，对该类进行测试（x是弧度，弧度不可能大于1）。
三、源程序清单
#include<iostream.h>
#include<math.h>
class SIN{
private:
double x;
int n;
public:
SIN(double x,int n)
{
this->x=x;
this->n=n;
}
double power(int q);
double mi(double m,int n);
double fun();
void show();
};
double SIN::power(int q)//求q的阶乘；
{
double s=1;
while(q!=1)
{
s*=q;
q--;
}
return s;
}
double SIN::mi(double m,int n)//求m^n的值；
{
while(n!=1)
{
m*=m;
n--;
}
return m;
}
double SIN::fun()//用于求sin(x)的值；//注：当n较大时，阶乘和幂的运算可能超出变量的类型的字节大小！改用double类型可提高运算的范围！
{
double s=0;//记录每项相加的和
for(int i=1;i<=n;i++)
{
s+=mi(x,2*i-1)*mi(-1,i+1)/power(2*i-1);//通项为(-1)^(i+1)*x^(2*i-1)/(2*i-1)!,其中n为由1开始的奇数；
}
return s;
}
void SIN::show()//输出求得结果；
{
cout<<"sin("<<x<<")="<<fun()<<endl;
}
void main()
{
int degree,n;
double hudu;
cout<<"请输入度数和公式中的n值:";
cin>>degree>>n;
hudu=degree%360*(3.1415926)/180.0;//度数转换为弧度；
SIN test(hudu,n);
test.show();
}
四、实践小结
找到公式中的相关关系，再进行相应函数的组合。
五、运行结果

任务十七
一、实践任务
18．试建立一个类VAR，用于求n（）个数的均方差。均方差的计算公式为，其中平均值为。
二、详细设计
1、类的描述与定义
（1）私有数据成员
l double a[100]：用于存放输入的n个数。
l int n：实际输入数的个数n。
（2）公有成员函数
l VAR(double x[], int n1)：构造函数，初始化成员数据a和个数n。
l double average(double x[], int n)：求平均值，数组x具有n个元素。
l void variance(double x[],int n)：求均方差，数组x具有n个元素。
l void show()：输出求得的均方差。
2、主要函数设计
在主程序中定义一个对象test，对该类进行测试。
三、源程序清单
#include<iostream.h>
class VAR{
private:
double a[100];//用于存放输入的n个数；
int n;//实际输入数的个数n；
public:
VAR(double x[],int n1)
{
for(int i=0;i<n1;i++)
{
a[i]=x[i];
}
n=n1;
}
double average(double x[],int n);
double variance(double x[],int n);
void show();
};
double VAR::average(double x[],int n)//求平均值，数组x具有n个元素；
{
double ave=0;
for(int i=0;i<n;i++)
{
ave+=x[i];
}
return ave/n;
}
double VAR::variance(double x[],int n)//求均方差，数组x具有n个元素；
{
double d=0;
for(int i=0;i<n;i++)
{
d+=(x[i]-average(x,n))*(x[i]-average(x,n));
}
d/=n;
return d;
}
void VAR::show()//输出求得的均方差；
{
cout<<"均方差为:"<<variance(a,n)<<endl;
}
void main()//测试；
{
double s[]={1,2,3,4,5,6,7,8,9,10};
int n=sizeof(s)/sizeof(double);
VAR test(s,n);
cout<<test.average(s,n)<<endl;
test.show();
}
四、实践小结
理解算数公式，根据题目线索，完成。
五、运行结果

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

二、详细设计
1、类的描述与定义
（1）私有数据成员
l int a[4][4]：用于存放方阵。
（2）公有成员函数
l Array (int a1[][4],int n) ：构造函数，用给定的参数a1初始化数据成员a。
l void xuanzhuan () ：实现对方阵a进行顺时针90度的旋转。
l void show( ) ：在屏幕上显示数组元素。
2、主要函数设计
在主程序中定义数组int b[ ][4]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}作为原始数组。定义一个Array类对象test，用b初始化test，完成对该类的测试。
三、源程序清单
#include<iostream.h>
class Array{
private:
int a[4][4];
public:
Array(int a1[][4],int n)
{
for(int i=0;i<n;i++)
{
for(int j=0;j<4;j++)
a[i][j]=a1[i][j];
}
}
void xuanzhuan();
void show();
};
void Array::xuanzhuan()//实现对方阵a进行顺时针90度的旋转；
{
int t[4][4];//定义临时数组，用于保存旋转后，对应下标上的数值；
int i,j;
for(i=0;i<4;i++)
{
for(j=0;j<4;j++)
{
t[j][i]=a[3-i][j];//对方阵a进行顺时针90度旋转对应位所得值，赋予该对应临时位上；
}
}
for(i=0;i<4;i++)
{
for(j=0;j<4;j++)
{
a[i][j]=t[i][j];//将临时数组中的对应值保存到原数组中；
}
}
}
void Array::show()//输出数组元素；
{
for(int i=0;i<4;i++)
{
for(int j=0;j<4;j++)
cout<<a[i][j]<<'\t';
cout<<endl;
}
}
void main()//测试；
{
int b[][4]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
Array test(b,4);
cout<<"原始方阵为："<<endl;
test.show();
test.xuanzhuan();
cout<<"顺时针90度旋转后的方阵为："<<endl;
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、类的描述与定义
（1）私有数据成员
l int a[4][4]：用于存放方阵。
（2）公有成员函数
l Array (int a1[][4],int n) ：构造函数，用给定的参数a1初始化数据成员a。
l void xuanzhuan () ：实现对方阵a进行逆时针90度的旋转。
l void show( ) ：在屏幕上显示数组元素。
2、主要函数设计
在主程序中定义数组int b[ ][4]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}作为原始数组。定义一个Array类对象test，用b初始化test，完成对该类的测试。
三、源程序清单
#include<iostream.h>
class Array{
private:
int a[4][4];
public:
Array(int a1[][4],int n)
{
for(int i=0;i<n;i++)
{
for(int j=0;j<4;j++)
a[i][j]=a1[i][j];
}
}
void xuanzhuan();
void show();
};
void Array::xuanzhuan()//实现对方阵a进行逆时针90度的旋转；
{
int i,j;
int t[4][4];//定义临时数组，用于保存原始方阵经逆时针90度旋转后对应下标上的值；
for(i=0;i<4;i++)
{
for(j=0;j<4;j++)
t[3-j][i]=a[i][j];//将旋转后对应下标上的值赋给临时数组上的对应位置；
}
for(i=0;i<4;i++)
{
for(j=0;j<4;j++)
a[i][j]=t[i][j];//将保存在临时数组的值，赋给原始数组，从而原始数组完成旋转；
}
}
void A