VC课程实践正确答案解析.docx

上传人:b****8 文档编号:12899206 上传时间:2023-06-09 格式:DOCX 页数:109 大小:619.49KB
下载 相关 举报
VC课程实践正确答案解析.docx_第1页
第1页 / 共109页
VC课程实践正确答案解析.docx_第2页
第2页 / 共109页
VC课程实践正确答案解析.docx_第3页
第3页 / 共109页
VC课程实践正确答案解析.docx_第4页
第4页 / 共109页
VC课程实践正确答案解析.docx_第5页
第5页 / 共109页
VC课程实践正确答案解析.docx_第6页
第6页 / 共109页
VC课程实践正确答案解析.docx_第7页
第7页 / 共109页
VC课程实践正确答案解析.docx_第8页
第8页 / 共109页
VC课程实践正确答案解析.docx_第9页
第9页 / 共109页
VC课程实践正确答案解析.docx_第10页
第10页 / 共109页
VC课程实践正确答案解析.docx_第11页
第11页 / 共109页
VC课程实践正确答案解析.docx_第12页
第12页 / 共109页
VC课程实践正确答案解析.docx_第13页
第13页 / 共109页
VC课程实践正确答案解析.docx_第14页
第14页 / 共109页
VC课程实践正确答案解析.docx_第15页
第15页 / 共109页
VC课程实践正确答案解析.docx_第16页
第16页 / 共109页
VC课程实践正确答案解析.docx_第17页
第17页 / 共109页
VC课程实践正确答案解析.docx_第18页
第18页 / 共109页
VC课程实践正确答案解析.docx_第19页
第19页 / 共109页
VC课程实践正确答案解析.docx_第20页
第20页 / 共109页
亲,该文档总共109页,到这儿已超出免费预览范围,如果喜欢就下载吧!
下载资源
资源描述

VC课程实践正确答案解析.docx

《VC课程实践正确答案解析.docx》由会员分享,可在线阅读,更多相关《VC课程实践正确答案解析.docx(109页珍藏版)》请在冰点文库上搜索。

VC课程实践正确答案解析.docx

VC课程实践正确答案解析

江苏科技大学

课程实践报告

设计题目:

程序设计(VC++)实践

设计时间:

学院:

专业班级:

学生姓名:

学号

指导老师:

 

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

具体要求如下:

(1)私有数据成员

intn:

前若干项的项数。

doublex:

存放x的值。

double*p:

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

(2)公有成员函数

PP(intnum,doublex1):

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

~PP():

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

doublefun(intn1,doublex):

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

注意:

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

本函数供process函数调用。

voidprocess():

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

voidshow():

输出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)私有成员数据。

intn,k:

存放公式中n和k的值;

(2)公有成员函数。

SP(intn1,intk1):

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

intpower(intm,intn):

求mn。

intfun():

求公式的累加和。

voidshow():

输出求得的结果。

(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)私有数据成员

floatarray[20]:

一维整型数组。

intn:

数组中元素的个数。

(2)公有成员函数

MOVE(floatb[],intm):

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

voidaverage():

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

voidprint():

输出一维数组。

(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)私有数据成员

int*array:

一维整型数组。

intn:

数组中元素的个数。

(2)公有成员函数

MOVE(intb[],intm):

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

voidexchange():

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

voidprint():

输出一维数组。

~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)私有数据成员

intn:

整型数字。

inty:

标记是否为回文数。

(2)公有成员函数

Palindrome(intx):

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

voidhuiwen():

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

voidshow():

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

(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)私有数据成员

char*str;

inty:

标记是否为回文字符串。

(2)公有成员函数

String(char*s):

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

y初始化为0。

voidhuiwen():

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

voidshow():

在屏幕上显示字符串。

(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)私有数据成员

int(*p)[20]:

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

intstartnum:

折叠方阵的起始数。

intn:

存放方针的层数。

(2)公有成员函数

PHALANX(ints,intm):

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

voidprocess():

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

voidprint():

输出折叠方阵。

~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)私有数据成员

inta[20][20]:

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

intstartnum:

螺旋方阵的起始数。

intn:

存放方针的层数。

(2)公有成员函数

MATRIX(ints,intm):

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

voidprocess():

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

voidprint():

输出螺旋方阵。

(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)私有数据成员

char*str:

指向要统计的字符串。

char(*p)[2]:

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

intsize:

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

(2)公有成员函数

CString(char*s):

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

voidCount():

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

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

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

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

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

voidShow():

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

~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

{

展开阅读全文
相关资源
猜你喜欢
相关搜索
资源标签

当前位置:首页 > 自然科学 > 物理

copyright@ 2008-2023 冰点文库 网站版权所有

经营许可证编号:鄂ICP备19020893号-2