江苏科技大学vc语言全国计算机二级试题及答案专业课程设计实践报告全样本.doc

江苏科技大学vc语言全国计算机二级试题及答案专业课程设计实践报告全

江苏科技大学

课程实践报告

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

2011年02月

任务一
一、实践任务
1．试建立一个类PP，求出下列多项式的前n项的值。

二、详细设计
1、类的描述与定义
（1）私有数据成员
l int n：前若干项的项数。
l double x：存放x的值。
l double *p：根据n的大小动态申请存放Pn(x) 前n项的数组空间。
（2）公有成员函数
l PP(int num,double x1)：构造函数，初始化数据成员n和x，使p指向动态申请的数组空间。
l ～PP（）：析构函数，释放p指向的动态内存空间。
l double fun(int n1,double x)：递归函数，用于求多项式的第n1项。注意：将递归公式中的n用作函数参数。本函数供process函数调用。
l void process( )：完成求前n项的工作，并将它们存放到p指向的动态数组中。
l void show( )：输出n和x，并将前n项以每行4个数的形式输出到屏幕上。
2、主要函数设计
在主函数中完成对该类的测试。先输入num和x1，并定义一个PP类的对象items，用num和x1初始化items的成员n和x，调用items的成员函数，求出并输出多项式前num项的值。
三、源程序清单
#include<>
class PP{
private:
int n;
double x;
double*p;
public:
PP(int num,double x1)
{
n=num;
x=x1;
p=new double[n];
}
~PP()
{
if(p) delete []p;
}
double fun(int n1,double x);
void process();
void show();
};
double PP::fun(int n1,double x)
{
if(n1==0) return 1;
else if(n1==1) return x;
else if(n1>1) return ((2*n1-1)*x*fun(n1-1,x)-(n1-1)*fun(n1-2,x))/n1;
}
void PP::process()
{
for(int i=0;i<n;i++)
{
p[i]=fun(i,x);
}
}
void PP::show()
{
cout<<"n="<<n<<endl<<"x="<<x<<endl;
for(int i=0;i<n;i++)
{
cout<<p[i]<<'\t'<<'\t';
if((i+1)%4==0) cout<<endl;
}
}
void main()
{
int num;
double x1;
cout<<"请输入num和x1:";
cin>>num>>x1;
PP items(num,x1);
();
();
}
四、实践小结
应熟练掌握递归函数的应用，写递归函数时应先进行递归结束条件的判定。
五、运行结果

任务二
一、实践任务
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<>
class SP{
private:
int n,k;
public:
SP(int n1,int k1)
{
n=n1;
k=k1;
}
int power(int m,int n);
int fun();
void show();
};
int SP::power(int m,int n)
{
int s=1;
for(int i=0;i<n;i++)
{
s*=m;
}
return s;
}
int SP::fun()
{
int s=0;
for(int i=1;i<=n;i++)
{
s+=power(i,k);
}
return s;
}
void SP::show()
{
cout<<"f("<<n<<","<<k<<")="<<fun()<<endl;
}
void main()
{
int n1,k1;
cout<<"请输入n1，k1:";
cin>>n1>>k1;
SP s(n1,k1);
();
();
}
四、实践小结
掌握用循环语句求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、主要函数设计
在主程序中用数据{,,3,,,,,,}对该类进行测试。
三、源程序清单
#include<>
class MOVE{
private:
float array[20];
int n;
public:
MOVE(float b[],int m)
{
for(int i=0;i<m;i++)
{
array[i]=b[i];
}
n=m;
}
void average();
void print();
~MOVE()
{};
};
void MOVE::average()
{
float ave=0;
int i,j;
for(i=0;i<n;i++)
{
ave+=array[i];
}
ave/=n;
cout<<ave<<endl;
float turn[20];
j=0;
for(i=0;i<n;i++)
{
if(array[i]<=ave)
{
turn[j]=array[i];
j++;
}
}
j=0;
for(i=0;i<n;i++)
{
if(array[i]>ave)
{
turn[n-1-j]=array[i];
j++;
}
}
for(i=0;i<n;i++)
{
array[i]=turn[i];
}
}
void MOVE::print()
{
for(int i=0;i<n;i++)
{
cout<<array[i]<<' ';
}
}
void main()
{
float b1[]={,,3,,,,,,};
int num;
num=sizeof(b1)/sizeof(float);
MOVE s(b1,num);
();
();
}
四、实践小结
应熟练掌握数组与指针的应用。
五、运行结果

任务四
一、实践任务
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}对该类进行测试。
三、源程序清单
#include<>
class MOVE{
private:
int *array;
int n;
public:
MOVE(int b[],int m)
{
array=new int[m];
n=m;
for(int i=0;i<m;i++)
{
array[i]=b[i];
}
}
void exchange();
void print();
~MOVE()
{
if(array) delete array;
}
};
void MOVE::exchange()
{
float ave=0;
for(int i=0;i<n;i++)
{
ave+=array[i];
}
ave/=n;
cout<<"平均值为"<<ave<<endl;
int max,min;
max=min=array[0];
int m;
for(i=0,m=0;i<n;i++)
{
if(array[i]>=max) m=i,max=array[i];
}
int l;
for(i=0,l=0;i<n;i++)
{
if(array[i]<max) l=i,max=array[i];
}
i=array[m],array[m]=array[l],array[l]=i;
}
void MOVE::print()
{
for(int i=0;i<n;i++)
cout<<array[i]<<' ';
}
void main()
{
int text[]={21,65,43,87,12,84,44,97,32,55};
int num;
num=sizeof(text)/sizeof(int);
MOVE s(text,num);
();
cout<<endl;
();
();
}
四、实践小结
学会求数组中最大元素与最小元素方法，并实现交换。
五、运行结果

任务五
一、实践任务
5．定义一个类Palindrome，实现绝对回文数。设计一个算法实现对任意整型数字判断是否为绝对回文数。所谓绝对回文数，是指十进制数和二进制数均对称的数。
二、详细设计
1、类的描述与定义
（1）私有数据成员
l int n：整型数字。
l int y： 标记是否为回文数。
（2）公有成员函数
l Palindrome (int x) ：构造函数，根据x参数初始化数据成员n，y初始化为0。
l void huiwen () ：判断数n是否为绝对回文数。
l void show( ) ：若该数为回文数，则在屏幕显示。
2、主要函数设计
在主程序中定义int a，由键盘输入数字。定义一个Palindrome类对象p，用a初始化p，完成对该类的测试。
三、源程序清单
#include<>
class Palindrome{
private:
int n;
int y;
public:
Palindrome(int x)
{
n=x;
y=0;
}
void huiwen();
void show();
};
void Palindrome::huiwen()
{
int i=0,j=0;
int m;
m=n;
while(m)
{
m/=10;
i++;
}
m=n;
while(m)
{
m/=2;
j++;
}
int*s10=new int[i];
int*s2=new int[j];
m=n;
for(int k=0;k<i;k++)
{
s10[i-1-k]=m%10;
m/=10;
}
m=n;
for(k=0;k<j;k++)
{
s2[j-1-k]=m%2;
m/=2;
}
int num10=0;
for(k=0;k<i/2;k++)
{
if(s10[i-1-k]==s10[k]) num10++;
else break;
}
int num2=0;
for(k=0;k<j/2;k++)
{
if(s2[j-1-k]==s2[k]) num2++;
else break;
}
if(num10==(i/2)&&num2==(j/2)) y=1;
}
void Palindrome::show()
{
int i=0,j=0;
int m;
m=n;
while(m)
{
m/=10;
i++;
}
m=n;
while(m)
{
m/=2;
j++;
}
int*s10=new int[i+1];
int*s2=new int[j+1];
m=n;
for(int k=0;k<i;k++)
{
s10[i-1-k]=m%10;
m/=10;
}
m=n;
for(k=0;k<j;k++)
{
s2[j-1-k]=m%2;
m/=2;
}
if(y)
{
cout<<"该数为绝对回文数！："<<endl;
cout<<"十进制表示为：";
for(k=0;k<i;k++)
cout<<s10[k];
cout<<"二进制表示为：";
for(k=0;k<j;k++)
cout<<s2[k];
}
else
{
cout<<"该数不是绝对回文数！："<<endl;
cout<<"十进制表示为：";
for(k=0;k<i;k++)
cout<<s10[k];
cout<<"二进制表示为：";
for(k=0;k<j;k++)
cout<<s2[k];
}
cout<<endl;
}
void main()
{
int a;
cout<<"请输入一个数字：";
cin>>a;
Palindrome p(a);
();
();
}
四、实践小结
将整型转换会整型数组类型，再进行回文数判断，从而实现回文数用数组判断的通用性。
五、运行结果

任务六
一、实践任务
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，完成对该类的测试。
三、源程序清单
#include<>
#include<>
class String{
private:
char*str;
int y;
public:
String(char*s)
{
int n=strlen(s);
str=new char[n+1];
strcpy(str,s);
y=0;
}
void huiwen();
void show();
~String()
{ if(str) delete []str;}
};
void String::huiwen()//判断str所指向的字符串是否为回文字符串；
{
int n,judge=0;
n=strlen(str);
for(int i=0;i<(n/2);i++)
{
if(str[i]==str[n-1-i]) judge++;
}
if(judge==i) y=1;
}
void String::show()//输出；
{
if(y==1) cout<<"y=1,¸该字符串是回文数"<<str<<endl;
else cout<<"y=0,该字符串不是回文数"<<str<<endl;
}
void main()//测试；
{
char s[]="ababcedbaba";
String test(s);
();
();
}
四、实践小结
掌握判断回文字符串的一般形式。
五、运行结果

任务七
一、实践任务
7．建立一个类PHALANX，生成并显示一个折叠方阵。折叠方阵如下图所示。折叠方阵的生成过程为：起始数置于方阵的左上角，然后从起始数开始递增，依次折叠构成方阵。
1 2 5 10
4 3 6 11
9 8 7 12
16 15 14 13
1 2
4 3
…
1

二、详细设计
1、类的描述与定义
（1）私有数据成员
l int (*p)[20]：指向按照折叠规律存放方阵的二维整型数组。
l int startnum：折叠方阵的起始数。
l int n：存放方针的层数。
（2）公有成员函数
l PHALANX (int s, int m )：构造函数，初始化成员数据。
l void process()：生成起始数为startnum的n行方阵。
l void print()：输出折叠方阵。
l ~ PHALANX( )：析构函数。
2、主要函数设计
在主程序中对该类进行测试。
三、源程序清单
#include<>
class PHALANX{
private:
int(*p)[20];
int startnum;
int n;
public:
PHALANX(int s,int m)
{
startnum=s;
n=m;
p=new int[m][20];
}
void process();
void print();
~PHALANX()
{ if(p) delete[]p;}
};
void PHALANX::process()//生成起始数为stratnum的n行螺旋方阵；
{
int turn;
turn=p[0][0]=startnum;
int i,j;
for(int k=n-2;k>=0;k--)//按照折叠方阵的生成过程进行赋值；
{
for(i=0,j=n-k-1;i<n-k;i++)
p[i][j]=++turn;
i--;
j--;
for(;j>=0;j--)
p[i][j]=++turn;
}
}
void PHALANX::print()
{
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
cout<<p[i][j]<<'\t';
}
cout<<endl;
}
}
void main()
{
int s1,m1;
cout<<"请输入该折叠方阵的起始数和行数";
cin>>s1>>m1;
PHALANX test(s1,m1);
();
();
}
四、实践小结
根据折叠方阵的产生方式进行相应的逻辑循环实现。
五、运行结果

任务八
一、实践任务
8．建立一个MATRIX，生成并显示一个螺旋方阵。螺旋方阵如下图所示，起始数置于方阵的左上角，然后从起始数开始依次递增，按顺时针方向从外向里旋转填数而成。
1 2 3 4 5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9

二、详细设计
1、类的描述与定义
（1）私有数据成员
l int a[20] [20]：二维整型数组存放螺旋方阵。
l int startnum：螺旋方阵的起始数。
l int n：存放方针的层数。
（2）公有成员函数
l MATRIX (int s, int m )：构造函数，初始化成员数据startnum和n。
l void process()：生成起始数为startnum的n行螺旋方阵。
l void print()：输出螺旋方阵。
2、主要函数设计
在主程序中定义MATRIX类的对象t对该类进行测试。
三、源程序清单
#include<>
class MATRIX{
private:
int a[20][20];
int startnum;
int n;
public:
MATRIX(int s,int m)
{
startnum=s;
n=m;
}
void process();
void print();
};
void MATRIX::process()//生成起始数为startnum的n行螺旋方阵；
{
int i,j;
int k;
int turn=startnum;
for(k=1;k<=n/2;k++)//逻辑性：按照螺旋方阵的生成过程（按顺时针方向从外向里旋转填数），进行赋值；
{
for(i=k-1,j=k-1;j<n-(k-1);j++)
{
a[i][j]=turn++;
}
j--;
turn--;
for(;i<n-k+1;i++)
{
a[i][j]=turn++;
}
i--;
turn--;
for(;j>=k-1;j--)
{
a[i][j]=turn++;
}
j++;
turn--;
for(;i>=k;i--)
{
a[i][j]=turn++;
}
}
a[n/2][(n-1)/2]=n*n-1+startnum;
}
void MATRIX::print()//输出螺旋方阵；
{
int i,j;
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
cout<<a[i][j]<<'\t';
}
cout<<endl<<endl;
}
}
void main()//测试；
{
int s,m;
cout<<"请输入起始数和方阵的层数：";
cin>>s>>m;
MATRIX t(s,m);
();
();
}
四、实践小结
发现本质的逻辑关系，利用循环语句实现。
五、运行结果

任务九
一、实践任务
9．定义一个字符串类CString，并设计一个算法对该串中各个不同字符出现的频率进行统计。
二、详细设计
1、类的描述与定义
（1）私有数据成员
l char *str：指向要统计的字符串。
l char (*p)[2]：动态分配二维空间，用以存放str所指字符串中出现的字符及其出现的次数（次数在存放时，用该数字对应的ASCII值存放；在输出次数时，输出该ASCII字符对应的ASCII值即可）。
l int size：存放字符串中出现的所有不同的字符的个数。
（2）公有成员函数
l CString (char *s) ：根据s参数初始化数据成员str；p和size初始值为0。
l void Count()：p根据s所指字符串长度分配空间。然后把str所指字符串中的每个字符放入p数组中，设置每个字符的出现次数为1。根据p数组统计不同字符出现的频率，并求得size的实际大小。最后根据size的实际大小，重新分配p所指空间，并把不同字符及其出现次数重新放回p数组（提示：可以借助临时数组或指针来实现）。
l void Show()：屏幕显示字符串、字符串的每个字符和与之对应的次数。
l ~CString()：释放动态分配的空间。
2、主要函数设计
在主程序中定义字符串char s[]=”abdabcdesffffd”。定义一个CString类对象test，用s以初始化test，完成对该类的测试。
三、源程序清单
#include<>
#include<>
class CString{
private:
char*str;
char (*p)[2];
int size;
public:
CString(char*s)
{
str=new char[strlen(s)+1];
strcpy(str,s);
size=0;
p=0;
}
void Count();
void Show();
~CString()
{ if(str) delete str;}
};
void CString::Count()
{
p=new char[strlen(str)][2];
int i,j,k;
for(i=0,j=0;i<strlen(str);i++)//每行第0列依次给予字符串中的一个字符，第1列设置每个字符出现的次数为初始值1；
{
p[i][j]=str[i];
p[i][j+1]=1;
}
char*part1=new char[strlen(str)+1];//定义临时的字符数组,用于依次存放不同的字符
int*part2=new int[strlen(str)+1];
for(i=0;i<strlen(str);i++)
{
part1[i]='\0';
}
for(i=0;i<strlen(str);i++)
{
part2[i]=0;
}
for(i=0;i<strlen(str);i++)//abdabcdesffffd
{ //abc
for(j=i;j<strlen(str);j++)
{
int count;
for(k=0,count=0;k<size;k++)
{
if(part1[k]==p[i][0])count++;//如果临时数组中的字符与原数组中相同，则count自增为1；
}
if(count==1) break;//代表原字符串中的字符已与临时数组中的字符相重复，则跳出j控制的内循环；
else {//否则，将未重复的字符存入临时数组1
part1[size]=p[i][0];
size++;
}
}
}
for(k=0;k<size;k++)
{
for(i=0;i<strlen(str);i++)
{
if(part1[k]==p[i][0])//实现对不同字符个数的计数,将记的数存放在临时数组2中。
{
part2[k]++;
}
}
}
delete []p;
p=new char[size][2];//根据size的实际大小，重新分配p所指空间，并借组临时数组把不同字符及其出现次数重新放回p数组。
for(i=0;i<size;i++)
{
p[i][0]=part1[i];
p[i][1]=part2[i];
}
delete []part1;
delete []part2;
}
void CString::Show()
{
cout<<"原字符串为："<<str<<endl;
cout<<"不同的字符数："<<size<<endl;
cout<<"字符串中的每个字符为："<<endl;
for(int i=0;i<size;i++)
cout<<p[i][0]<<' '<<"次数"<<(int)p[i][1]<<endl;
}
void main()
{
char s[]="abdabcdesffffd";
CString test(s);
();
();
}
四、实践小结
可建立临时数组，帮助判断。
五、运行结果

任务十
一、实践任务
10．定义一个字符串类CString，并设计一个算法实现，给定关键字str1在字符串str中出现时用关键字str2进行替换的功能。
二、详细设计
1、类的描述与定义
（1）私有数据成员
l char *str; 原始字符串。
l char *str1; 目标关键字。
l char *str2; 替换关键字。
l int flag; 标记替换是否完成替换。
（2）公有成员函数
l CString (char *s,char s1[ ],char *s2) ：用给定的参数s、s1和s2相对应的初始化数据成员str、str1和str2。flag设置缺省0。
l void Replace () ：判断str字符串中是否出现str1，若出现就用str2替换，否则什么都不做。若替换成功了标记flag为1，若替换不成功则标记flag为0。
l void Show( ) ：若替换成功，则在屏幕上显示目标关键字、替换关键字和替换后的原始字符串；若不成功则显示原始字符串。
l ~ CString() ：释放动态分配的空间。
2、主要函数设计
在主程序中定义字符串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{
private:
char*str;//原始字符串
char*str1;//目标字符串
char*str2;//替换关键字
int flag;
public:
CString(char*s,char s1[],char*s2)
{
str=new char[strlen(s)+strlen(s2)+strlen(s1)+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 Replace();
void Show();
~CString()
{ if(str) delete []str;
if(str1) delete []str1;
if(str2) delete []str2;
}
};
void CString::Replace()
{
int i=0;//i记录原始字符串str中第i位开始出现与目标关键字重合；
int k=0,count=0;
while(str[i])
{
while(str[i]!=str1[0]&&str[i]) i++;
if(i<strlen(str))//当第i位没有超出原始字符串str的范围时，判断目标字符串是否出//现于原始字符串；
{
if(strncmp(str+i,str1,strlen(str1))==0)k=1;//利用strncmp(,)函数判断目标字符串是否出现于原始字符串,出现则k=1;
}
if(k)//若目标字符串出现，则进行替换；
{
char*turn=new char[strlen(str)+strlen(str1)+strlen(str2)+1];//临时数组指针，用于存放替换的字符串；
strncpy(turn,str,i);
turn[i]=0;
strcat(turn,str2);
strcat(turn,str+i+strlen(str1));
strcpy(str,turn);
delete []turn;
i=i+strlen(str2);
k=0;
count++;
}
}
if(count) flag=1;
}
void CString::Show()
{
if(flag) cout<<"目标关键字:"<<str1<<'\n'<<"替换关键字:"<<str2<<'\n'<<"替换后的原始字符串:"<<str<<endl;
else cout<<"原始字符串:"<<str<<endl;
}
void main()
{
char s[]="I am student,you are student too,we are all student.";
char s1[]="student";
char s2[]="teacher";
CString test(s,s1,s2);
();
();
}
四、实践小结
利用临时字符数组，进行字符替代。
五、运行结果

任务十一
一、实践任务
11．建立一个STRING，将一个字符串交叉插入到另一个字符串中（假定两字符串等长）。例如将字符串“abcde” 交叉插入字符串“ABCDE”的结果为“aAbBcCdDeE”或“AaBbCcDdEe”。