VC课程实践正确答案 1.docx

VC课程实践正确答案 1.docx

《VC课程实践正确答案 1.docx》由会员分享，可在线阅读，更多相关《VC课程实践正确答案 1.docx（108页珍藏版）》请在冰豆网上搜索。

VC课程实践正确答案1

江苏科技大学

课程实践报告

设计题目:

程序设计（VC++）实践

设计时间:

至

学院:

专业班级:

学生姓名:

学号

指导老师:

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

具体要求如下：

（1）私有数据成员

lintn：

前若干项的项数。

ldoublex：

存放x的值。

ldouble*p：

根据n的大小动态申请存放Pn（x）前n项的数组空间。

（2）公有成员函数

lPP（intnum,doublex1）：

构造函数，初始化数据成员n和x，使p指向动态申请的数组空间。

l～PP（）：

析构函数，释放p指向的动态内存空间。

ldoublefun（intn1,doublex）：

递归函数，用于求多项式的第n1项。

注意：

将递归公式中的n用作函数参数。

本函数供process函数调用。

lvoidprocess（）：

完成求前n项的工作，并将它们存放到p指向的动态数组中。

lvoidshow（）：

输出n和x，并将前n项以每行4个数的形式输出到屏幕上。

（3）在主函数中完成对该类的测试。

先输入num和x1，并定义一个PP类的对象items，用num和x1初始化items的成员n和x，调用items的成员函数，求出并输出多项式前num项的值。

程序源代码

#include

classpp{

intn;

doublex;

double*p;

public:

pp（intnum,doublex1）;

~pp（）;

doublefun（intn1,doublex）;

voidprocess（）;

voidshow（）;

};

pp:

:

pp（intnum,doublex1）

{

n=num;

x=x1;

p=newdouble[num+1];

}

pp:

:

~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;

for（i=0;i<=n;i++）

{

*（p+i）=fun（i,x）;

}

}

voidpp:

:

show（）

{

cout<<"n="<

for（inti=0,m=1;i

{

cout<<*（p+i）<<'\t';

if（m%4==0）cout<<'\n';

}

}

voidmain（）

{

intnum;

doublex1;

cout<<"putinnumandx1"<

cin>>num>>x1;

ppitems（num,x1）;

items.process（）;

items.show（）;

}

运行结果

2．试建立一个类SP，求，另有辅助函数power（m,n）用于求。

具体要求如下：

（1）私有成员数据。

lintn，k：

存放公式中n和k的值；

（2）公有成员函数。

lSP（intn1,intk1）：

构造函数，初始化成员数据n和k。

lintpower（intm,intn）：

求mn。

lintfun（）：

求公式的累加和。

lvoidshow（）：

输出求得的结果。

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

程序源代码

#include

classSP{

intn,k;

public:

SP（intn1,intk1）;

intpower（intm,intn）;

intfun（）;

voidshow（）;

};

SP:

:

SP（intn1,intk1）

{

n=n1;

k=k1;

}

intSP:

:

power（intm,intn）

{

inti;

if（n==0）return1;

else

for（i=1;i

m*=m;

returnm;

}

intSP:

:

fun（）

{

inty=0,x;

for（x=1;x<=n;x++）

y+=power（x,k）;

returny;

}

voidSP:

:

show（）

{

cout<<"前n项的和为：

"<

}

voidmain（）

{

intn1,k1;

cout<<"输入n1和k1的值"<

cin>>n1>>k1;

SPs（n1,k1）;

s.fun（）;

s.show（）;

}

运行结果：

3．建立一个类MOVE，不进行排序，将数组中小于平均值的元素放到数组的左边，大于平均值的元素放到数组的右边。

具体要求如下：

（1）私有数据成员

lfloatarray[20]：

一维整型数组。

lintn：

数组中元素的个数。

（2）公有成员函数

lMOVE（floatb[],intm）：

构造函数，初始化成员数据。

lvoidaverage（）：

输出平均值，并将数组中的元素按要求重新放置。

lvoidprint（）：

输出一维数组。

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

程序源代码

#include

classMOVE{

floatarray[20];

intn;

public:

MOVE（floatb[],intm）;

voidaverage（）;

voidprint（）;

};

MOVE:

:

MOVE（floatb[],intm）

{

inti;

n=m;

for（i=0;i

array[i]=b[i];

}

voidMOVE:

:

average（）

{

inti,x;

floata=0;

for（i=0;i

a+=array[i];

a/=n;

cout<<"平均值为"<

floatff[20];

for（i=0,x=0;i

if（array[i]

{

ff[x]=array[i];

x++;

}

for（i=0;i

if（array[i]>a）

{

ff[x]=array[i];

x++;

}

for（i=0;i

array[i]=ff[i];

}

voidMOVE:

:

print（）

{

intq,p=1;

for（q=0;q

{

cout<

if（p%5==0）cout<<'\n';

p++;

}

}

voidmain（）

{

floatb[]={1.3,6.2,3,9.1,4.8,7.4,5.6,9.2,2.3};

intm=9;

MOVEaa（b,m）;

aa.average（）;

aa.print（）;

}

运行结果

4．建立一个类MOVE，将数组中最大元素的值与最小元素的值互换。

具体要求如下：

（1）私有数据成员

lint*array：

一维整型数组。

lintn：

数组中元素的个数。

（2）公有成员函数

lMOVE（intb[],intm）：

构造函数，初始化成员数据。

lvoidexchange（）：

输出平均值，并将数组中的元素按要求重新放置。

lvoidprint（）：

输出一维数组。

l~MOVE（）：

析构函数。

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

程序源代码

#include

classMOVE{

int*array;

intn;

public:

MOVE（intb[],intm）;

voidexchange（）;

voidprint（）;

~MOVE（）;

};

MOVE:

:

MOVE（intb[],intm）

{

n=m;

array=newint[n];

for（intx=0;x

array[x]=b[x];

}

voidMOVE:

:

exchange（）

{

floata=0;

inti,*p1,*p2;

for（i=0;i

a+=array[i];

a/=n;

cout<<"Theaverageofthenumberis:

"<

p1=p2=&array[0];

for（i=0;i

{

if（array[i]<*p1）p1=&array[i];

if（array[i]>*p2）p2=&array[i];

}

i=*p1;

*p1=*p2;

*p2=i;

}

voidMOVE:

:

print（）

{

inti,num=1;

for（i=0;i

{

cout<

if（num%5==0）cout<<'\n';

num++;

}

}

MOVE:

:

~MOVE（）

{delete[]array;}

voidmain（）

{

intb[]={21,65,43,87,12,84,44,97,32,55},n=10;

MOVEff（b,n）;

ff.exchange（）;

ff.print（）;

}

运行结果

5．定义一个类Palindrome，实现绝对回文数。

设计一个算法实现对任意整型数字判断是否为绝对回文数。

所谓绝对回文数，是指十进制数和二进制数均对称的数。

具体要求如下：

（1）私有数据成员

lintn：

整型数字。

linty：

标记是否为回文数。

（2）公有成员函数

lPalindrome（intx）：

构造函数，根据x参数初始化数据成员n，y初始化为0。

lvoidhuiwen（）：

判断数n是否为绝对回文数。

lvoidshow（）：

若该数为回文数，则在屏幕显示。

（3）在主程序中定义inta，由键盘输入数字。

定义一个Palindrome类对象p，用a初始化p，完成对该类的测试。

程序源代码

#include

classpalindrome{

intn;

inty;

public:

palindrome（intx）;

voidhuiwen（）;

voidshow（）;

};

palindrome:

:

palindrome（intx）

{

n=x;

y=0;

}

voidpalindrome:

:

huiwen（）

{

intb[20],c[50],m,i,p=0,t1=1,t2=1;

m=n;

for（i=0;m>0;m/=10）

{

p++;

b[i]=m%10;

i++;

}

for（i=0;i

if（b[i]!

=b[p-i-1]）

{

t1=0;

break;

}

for（i=0,m=n,p=0;m>0;m/=2）

{

p++;

c[i]=m%2;

i++;

}

for（i=0;i

if（c[i]!

=c[p-i-1]）

{

t2=0;

break;

}

if（t1&&t2）y=1;

}

voidpalindrome:

:

show（）

{

if（y==0）cout<<"该数不是回文数！

"<

elsecout<<"该回文数是：

"<

}

voidmain（）

{

inta;

cout<<"输入a的值"<

cin>>a;

palindromep（a）;

p.huiwen（）;

p.show（）;

}

运行结果：

6．定义一个字符串类String，实现判断该字符串是否为回文字符串。

所谓回文字符串，是指该字符串左右对称。

例如字符串“123321”是回文字符串。

具体要求如下：

（1）私有数据成员

lchar*str;

linty：

标记是否为回文字符串。

（2）公有成员函数

lString（char*s）：

构造函数，用给定的参数s初始化数据成员str。

y初始化为0。

lvoidhuiwen（）：

判断str所指向的字符串是否为回文字符串。

lvoidshow（）：

在屏幕上显示字符串。

（3）在主程序中定义字符串chars[]=”ababcedbaba”作为原始字符串。

定义一个String类对象test，用s初始化test，完成对该类的测试。

程序源代码

#include

#include

classstring{

char*str;

inty;

public:

string（char*s）;

voidhuiwen（）;

voidshow（）;

};

string:

:

string（char*s）

{

str=newchar[strlen（s）];

strcpy（str,s）;

y=0;

}

voidstring:

:

huiwen（）

{

char*p1,*p2;

p2=p1=str;

for（inti=0;str[i];i++,p2++）;

p2--;

for（;p1!

=p2;p1++,p2--）

{

if（*p1!

=*p2）

{y=0;break;}

else

y=1;

}

}

voidstring:

:

show（）

{

cout<<”字符串为：

”<

if（y==0）cout<<"字符串不是回文数！

"<

elsecout<

}

voidmain（）

{

chars[]="ababcedbaba";

stringtest（s）;

test.huiwen（）;

test.show（）;

}

运行结果：

7．建立一个类PHALANX，生成并显示一个折叠方阵。

折叠方阵如下图所示。

折叠方阵的生成过程为：

起始数置于方阵的左上角，然后从起始数开始递增，依次折叠构成方阵。

具体要求如下：

（1）私有数据成员

lint（*p）[20]：

指向按照折叠规律存放方阵的二维整型数组。

lintstartnum：

折叠方阵的起始数。

lintn：

存放方针的层数。

（2）公有成员函数

lPHALANX（ints,intm）：

构造函数，初始化成员数据。

lvoidprocess（）：

生成起始数为startnum的n行方阵。

lvoidprint（）：

输出折叠方阵。

l~PHALANX（）：

析构函数。

（3）在主程序中对该类进行测试。

程序源代码

#include

#include

classphalanx{

int（*p）[20];

intstarnum;

intn;

public:

phalanx（ints,intm）;

voidprocess（）;

voidprint（）;

~phalanx（）;

};

phalanx:

:

phalanx（ints,intm）

{

starnum=s;

n=m;

}

voidphalanx:

:

process（）

{

intnum=starnum;

inty=n,i,j,x;

p=newint[20][20];

for（x=0;x

{

for（i=0,j=x;i

{

p[i][j]=num;

num++;

}

for（;j>=0;j--）

{

p[i][j]=num;

num++;

}

}

}

voidphalanx:

:

print（）

{

inti,j,m=0;

for（i=0;i

{

for（j=0;j

{

cout<

}

cout<<'\n';

}

}

phalanx:

:

~phalanx（）

{

delete[]p;

}

voidmain（）

{

ints,m;

cout<<"输入s和m的值"<

cin>>s>>m;

phalanxpp（s,m）;

pp.process（）;

pp.print（）;

}

运行结果

8．建立一个MATRIX，生成并显示一个螺旋方阵。

螺旋方阵如下图所示，起始数置于方阵的左上角，然后从起始数开始依次递增，按顺时针方向从外向里旋转填数而成。

具体要求如下：

（1）私有数据成员

linta[20][20]：

二维整型数组存放螺旋方阵。

lintstartnum：

螺旋方阵的起始数。

lintn：

存放方针的层数。

（2）公有成员函数

lMATRIX（ints,intm）：

构造函数，初始化成员数据startnum和n。

lvoidprocess（）：

生成起始数为startnum的n行螺旋方阵。

lvoidprint（）：

输出螺旋方阵。

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

程序源代码

#include

#include

classmatrix{

inta[20][20];

intstarnum;

intn;

public:

matrix（ints,intm）;

voidprocess（）;

voidprint（）;

};

matrix:

:

matrix（ints,intm）

{

starnum=s;

n=m;

}

voidmatrix:

:

process（）

{

intst=starnum;

inti,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;

}

}

voidmatrix:

:

print（）

{

inti,j;

for（i=0;i

{

for（j=0;j

cout<

cout<<'\n';

}

}

voidmain（）

{

ints,m;

cout<<"输入s和m的值"<

cin>>s>>m;

matrixpp（s,m）;

pp.process（）;

pp.print（）;

}

运行结果

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

具体要求如下：

（1）私有数据成员

lchar*str：

指向要统计的字符串。

lchar（*p）[2]：

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

lintsize：

存放字符串中出现的所有不同的字符的个数。

（2）公有成员函数

lCString（char*s）：

根据s参数初始化数据成员str；p和size初始值为0。

lvoidCount（）：

p根据s所指字符串长度分配空间。

然后把str所指字符串中的每个字符放入p数组中，设置每个字符的出现次数为1。

根据p数组统计不同字符出现的频率，并求得size的实际大小。

最后根据size的实际大小，重新分配p所指空间，并把不同字符及其出现次数重新放回p数组（提示：

可以借助临时数组或指针来实现）。

lvoidShow（）：

屏幕显示字符串、字符串的每个字符和与之对应的次数。

l~CString（）：

释放动态分配的空间。

（3）在主程序中定义字符串chars[]=”abdabcdesffffd”。

定义一个CString类对象test，用s以初始化test，完成对该类的测试。

程序源代码

#include

#include

classcstring{

char*str;

char（*p）[2];

intsize;

public:

cstring（char*s）;

voidcount（）;

voidshow（）;

~cstring（）;

};

cstring:

:

cstring（char*s）

{

p=0;

size=0;

str=s;

}

voidcstring:

:

count（）

{

p=newchar[strlen（str）][2];

charn;

char*p1,*p2;

for（inti=0;str[i];i++）

{

n='\0';

p1=&str[i];

for（intm=0;str[m];m++）

{

p2=&str[m];

if（*p1==*p2）n++;

p2++;

}

p[i][0]=str[i];

p[i][1]=n;

}

}

voidcstring:

:

show（）

{

for（inti=0;i