程序设计基础二题库Word文件下载.docx
《程序设计基础二题库Word文件下载.docx》由会员分享，可在线阅读，更多相关《程序设计基础二题库Word文件下载.docx（40页珍藏版）》请在冰豆网上搜索。
一个进程式程序由一些子进程（函数）组成，每一个子程序对应一个子功能，它实现了功能抽象。
子程序描述了一系列的操作，它是操作的封装体。
进程式程序的执行进程表现为一系列的子程序（函数）挪用。
在进程式程序中，数据处于附属地位，它独立于子程序，在子程序调历时作为参数传给子程序利用。
面向进程程序设计的特点能够描述为：
程序=算法+数据结构
面向对象程序设计是一种以数据为中心、基于数据抽象的程序设计方式。
一个面向对象程序由一些对象组成，对象是由一组数据及能够作用于其上的一组操作所组成的封装体。
对象的特点由相应的类来描述，一个类能够从其他类继承。
面向对象程序的执行进程表现为各个对象之间彼此发送和处置消息。
面向对象程序设计的特点能够描述为：
程序=对象/类+对象/类+…+对象/类
对象/类=数据+操作
三、程序填充题
请将以下程序横线处缺少的部份补上，使其能正确运行。
一、每一个考生的考号及10道试题得分依次在一行内输入。
约定未选做的试题得分用负数（一1）标识。
选答试题多于5道题，按前5道题得分评定成绩。
如有不合理的得分或输入错误，程序要求从头输入。
程序以输入的考生考号为负数表示输入终止。
程序输出各考生的考号、总分和成绩品级。
其中成绩品级按如下所示规那么评定：
总分
等级
90〜100
A
80〜89
B
70〜79
C
60〜69
D
0〜59
E
程序还对实考人数、各品级得分人数及各试题解答人数与平均得分（保留小数两位）进行统计和输出。
8.include<
iostream>
9.include<
iomanip>
usingnamespacestd;
intmain（）
{
constintMAXSCORE=20;
constintQUESTION=10;
constintORDERS=5;
intp[QUESTION]={0,0,0,0,0,0,0,0,0,0};
Error!
Inputagain!
n«
endl;
continue;
}
；
"
⑴
for（c=0,i=0;
i<
QUESTION&
&
c==i;
i++）
cin»
p[i];
if（p[i]<
=MAXSCORE）
⑵-
if（）"
⑶
gets（ch）;
cout«
"
Score:
«
p[c]«
>
20.Error!
'
，《endl;
continue;
for（c=0,score=0,i=0;
i<
QUESTION;
if（）列程序是一个简单的计算器模拟程序。
对任意给定的正确四那么运算表达式，程序计算结果值并输出。
程序无查错功能，假定所输入的都是正确的四那么运算表达式，而且表达式中运算分量为无正负号整数，运算符为“+、一、*、/”，圆括号按常规配对，表达式以字符“二”终止。
程序中，函数指针数组func[]是为了统一加减乘除计算而设置的。
函数getach（）的功能是获取表达式的一个合法字符，并将字符存入变量curch，函数getid（）的功能是判定适才输人的字符是操作数仍是运算符。
假设读入的字符不是数字，要判定一下是哪个运算符，不同的运算符返回不同的值。
函数calO利用了递归算法。
它的功能是：
第一判定已经输入的字符，假设是那么依照括号优先的原那么，先递归挪用自己，求出括号里的表达式的值，不然确信是操作数（假定所输入的都是正确的四那么运算表达式，如此一个表达式的开头不是括号就确信是操作数），将其值从全局变量mim赋给xl。
接着读入一个运算符，假设运算符是“）”或“=”，那么完成一级运算，返回结果xl。
读入第2个操作数，词上，假设读人的字符是“（”，那么依照括号优先的原那么，先递归挪用自己，求出括号里的表达式的值，不然将其值赋给操作数x2。
然后读入第2个运算符。
下一步的操作应当是先读人第3个操作数，再依照opl和op2的优先级决定进行运算opl仍是叩2，并将计算结果作为操作数xl或x2，继续后续计算。
循环的终止条件是碰到“）”或“=”，说明一对括号内的计算完成或整个计算终止。
#include<
string.h>
usingnamespacestd;
intmyadd（intx,inty）{returnx+y;
intmysub（intx,inty）{returnx-y;
intmymul（intx,inty）{returnx*y;
intmydiv（intx,inty）{returnx/y;
int（*func[]）（intx,inty）={myadd,mysub,mymul,mydiv};
intnum,curch};
charchtbl[]=n+-*/（）=n;
charcorch[]="
+-*/（）=09"
;
intgetach（）
inti;
while（l）
{
curch=getchar（）;
if（curch==EOF）return-1;
for（i=0;
corch[i]&
curch!
=corch[i];
i++）;
if（i<
strlen（corch））break;
}
returncurch;
intgetid（）
if（curch>
='
0*&
curch<
='
9'
）
for（num=0;
curch>
01&
91;
getach（））
num=;
于正整数n，输出其和等于n且知足以下限制条件的所有正整数的和式，即组成和式的数字自左至右组成一个非递增的序列。
如n=4，程序输出为
4=4
4=3+1
4=2+2
4=2+1+1
4=1+1+1+1
程序中给出了别离采纳递归和非递归解法的两个函数nl（）和nd（）。
函数rd（）采纳递归解法，它有两个参数n和k。
意义别离是被分解和式的数n，及当前第k深度分解。
算法思想是对n的所有合理的和式分解，将分解出的数（称为和数）存于数
组a[]中。
当其中一个分解再也不需要进一步分解时，即找到一个解，将存于数组a[]中的一个完整和式的和数输出。
当还需要进一步分解时，以要进一步分解的数及分解深度为参数，递归调整甩分解和式函数。
函数nd（）以要分解的数为参数，另幵设一个数组r□，用于存储当前还未分解的余数。
在求一个解的第k步时，a[k]为第k个和数，r[k]为相应的余数。
当找到一个分解后（此步r[k]等于0），输出解，并作回溯处置，从当前k退回到第一个不为1的和数，将其减1，并将其余数加1，预备去找另一个解；
不然，生成下一步的分解和数与余数。
iostream>
constintMAXN=100;
inta[MAXN],r[MAXN];
voidrd（intn,intk）;
voidnd（intn）;
intmain（）
intn;
cout<
<
Pleaseinputaunsignedinteger（>
0）:
;
cin>
>
n;
a[0]=n;
rd（n,1）;
\n____________\n\n"
nd（n）;
cout<
\n_____________\n\n,!
return0;
voidrd（intn,intk）
intj,i;
for（j=_____________;
j>
=1;
j--）保龄球是用一个滚球去冲击10个站立的瓶子，将瓶子击倒。
1局分10轮，每轮可滚球一次或多次，以击倒的瓶子数量为依据计分。
1局得分为10轮得分之和，而每轮得分不仅与本轮滚球情形有关，还可能与后续一两轮的滚球情形有关。
即某轮某次滚球击倒的瓶子数量不仅要计入本轮得分，还可能会计入前一两轮得分。
具体规那么和计分方式如下：
（1）假设某一轮的第一次滚球就击倒全数10个瓶子，那么本轮再也不滚球（假设是第10轮那么还需另加两次滚球>
。
该轮得分为本次击倒瓶子10与另加两次滚球所击倒瓶子数量之和。
（2）假设某一轮的第一次滚球未击倒10个瓶子，那么可对剩下未倒的瓶子再滚球一次。
知果这两次滚球击倒全数10个瓶子，那么本轮再也不滚球（假设是第10轮那么还需另加一次滚球），该轮得分为本次击倒瓶子数量10与另加一次滚球所击倒瓶子数量之和。
（3）假设某一轮的两次滚球未击倒全数10个瓶子，那么本轮再也不继续滚球，该轮得分为这两次滚球击倒的瓶子数量之和。
实例说明如下：
轮次
1
2
3
4
5
6
7
8
9
10
各轮第一次得分
各轮第二次得分
/
各轮得分
20
29
18
19
累计总分
58
78
96
105
125
145
164
182
下面程序是模拟打一局保龄球的进程，统计各轮得分和累计总分。
程序交互地逐轮逐次输入一次滚球击倒的瓶子数量，计算该轮得分和累计总分。
为记录因一轮内击倒10瓶子，还暂不能计算该轮得分和累计总分的情形，程序引入变量ok,用来记录当前已完成完整计算的轮次。
程序每输人一次滚球击倒瓶子数量，就检查还未完成完整计算的轮次，并计算。
#include<
structBowlingRound
<
="
max<
）<
endl"
else
cout<
输人附加的第"
c++<
次滚球击倒柱数.（<
max<
d;
if（d>
=0&
d<
=max）break;
不合理的击倒瓶子数量,请从头输入！
endl;
if（ok<
______________）core+=d;
if（--a[j].m==0）
{
a[j].total=（_________________）+a[j].score;
（3）
ok=_____________________;
core=a[i].f=first=ball（a,i,1,10）;
if（first==10）a[i].m=2;
a[i].n=1;
if（first<
10&
（i<
=10||i==11&
ok<
10））
{m=1;
__________________________;
total=（i>
1?
a[i-1].total:
0）+a[i].score;
_____________________________；
f;
\n各轮第二次得分：
for（k=1-k<
=i;
k++）
if（a[k].n<
2）cout"
setw（4）"
n/"
elsecout<
setw（4）<
a[k].s;
cout<
\n各轮得分:
；
for（k=1;
k<
=ok;
k++）
cout"
setw（4）"
a[k].score;
cout"
\n累计总分：
for（k=1;
k<
cout<
setw（4）<
a[k].total;
endl<
5.以下程序实现两个多项式相乘。
多项式用链表表示，链表上的各结点按多项式的幂指数降序链接。
例如，设f（x）=+，链表表示如图7-1所示。
iostream>
structPolyNode
intindex;
doublecoef;
structPolyNode*next;
}；
PolyNode*inpoly（）;
PolyNode*polymul（PolyNode*f,PolyNode*g）;
voidwrite（PolyNode*g）;
PolyNode*reverse（PolyNode*g）;
PolyNode*f,*g,*s;
请输入多项式f"
f=inpoly（）;
多项式f="
write（f）;
请输入多项式g"
g=inpoly（）;
多项式g="
write（g）;
s=polymul（f,g）;
多项式f*g="
write（s）;
return0;
PolyNode*reverse（PolyNode*g）
PolyNode*u=NULL,*v=g,*w；
while（v）
w=v->
next;
v->
next=u;
u=v;
v=w;
}
returnu;
PolyNode*polymul（PolyNode*f,PolyNode*g）
PolyNode*fp,*gp,*tail,*p=NULL,*q;
inti,maxindex;
doubletemp;
maxindex=f->
index+g->
index;
g=reverse（g）;
for（i=maxindex;
i>
=0;
i--）
fp=f；
gp=g;
while（fp!
=NULL&
fp->
index>
i）fp=fp->
while（gp!
gp->
index<
i-fp->
index）gp=gp->
temp=;
while（fp&
gp）
if（fp->
index+gp->
index==i）
{
temp+=fp->
coef*gp->
coef;
fp=fp->
gp=gp->
}
elseif（___________________）=x;
cout<
'
A'
Foo（）{x=0;
Z'
private:
intx;
};
Foof[3],g（3）;
1.#include<
iostream>
classA{
public:
A（）{cout<
A"
~A（）{cout<
~A"
classB{
A*p;
public：
B（）{cout<
B"
p=newA（）;
~B（）{cout<
~B"
deletep;
Bobj;
2.#include<
classmyClass{
myClass（inti=0）:
n（i）{cout<
myClass（myClass&
c）:
n（c.getValue（））{cout<
C'
intgetValue（）const{returnn;
~myClass（）{cout<
D'
voidshow（myClassc）
{cout<
（）;
myClasscl;
show（cl）;
myClassc2
（2）;
show（c2）;
3.#include<
defaultconstructor"
~B（）{cout"
destructedn"
B（inti）:
data（i）
constructedbyparameter"
data<
intdata;
BPlay（Bb）
{
returnb;
intmain（）{
Btemp=Play（5）;
4.#include<
classTest{
staticintval;
inta;
staticintfunc（）;
staticvoidsfunc（Test&
r）;
intTest:
:
val=20;
func（）
val+=val;
returnval;
voidTest:
sfunc（Test&
r）
=25;
Result3="
Resultl="
Test:
func（）<
Testa;
Result2="
（）<
sfunc（a）;
return0;
5.#include<
classClassOne{
ClassOne（）{i=0;
ClassOne（intvalue）:
i（value）{cout<
}
~ClassOne（）{cout<
C"
voidPrint（）{cout<
i;
classClassTwo{
ClassTwo（）{i=0;
D"
ClassTwo（intvalue）:
i{value）{cout<
E"
}
~ClassTwo（）{cout<
F"
voidPrint（）{cout<
ClassOnemyobj;
ClassTwomyclass{5};
升级会员 