面向对象程序设计课程期末针对性训练.docx

面向对象程序设计课程期末针对性训练
训练第一套
一、单项选择题（每小题2分，共20分）
1.设x和y均为bool量，则x || y为假的条件是（）。

A.它们均为真
B.其中一个为真
C.它们均为假
D.其中一个为假
2.假定一个二维数组的定义语句为“ int a⑶[4] = { {3, 4）, （2, 8,6}}; ”,则元素a[l] [2]
的值为（）=
A. 2
B. 4
C. 6
D. 8
3.假定p是具有int**类型的指针变量，则给p赋值的正确语句为（）。

A. p=new int;
B. p=new int*;
C. p=new int**;
D. p=new int[10]:
4.软件产品在需求发生变化、运行环境发生变化或发现软件产品本身的错误或不足时进行相应的软件更新的难易程度叫做软件的（）o
A,可维护性 B.可复用性C,兼容性 D.正确性
5.若需要把一个类外定义的成员函数指明为内联函数，则必须把关键字（）放在函数原型或函数头的前面。

A. in
B. inline
C. inLine
D. InLiner
6.在一个用数组实现的队列类中，假定数组长度为MS,队首元素位置为first,队列长度为length,则队尾的后一个位置为（）o
A. length+1
B. first+length
C. （f irst+length-1）%MS
D. （f irst+length）%MS
7.假定一个类的构造函数为“A（int aa, int bb） {a=aa; b=aa*bb;}",则执行“A x（4, 5）;”语句后，x. a和x. b的值分别为（）。

A. 4 和 5
B. 5 和 4
C. 4 和 20
D. 20 和 5
8.假定AB为一个类，则执行“AB *p=new AB（1, 2）;"语句时共调用该类构造函数的次数为（）o
A. 0
B. 1
C. 2
D. 3
9.一个类的成员函数也可以成为另一个类的友元函数，这时的友元声明（）类域的限定。

A,需加上 B.不需加上 C.可加可不加 D.取消
10,队列具有（）的操作特性。

A.先进先出 B,先进后出 C,进出无序 D.仅进不出
二、填空题(每小题2分，共20分)
1.多行注释的开始标记符为 O
2.假定x=5, y=6,则表达式x++*++y的值为。

3.假定x是一个逻辑量，则x && true的值与x的值___________ 。

4.含随机函数的表达式rand()%20的值在0至_______ 的整数区间内。

5.程序的编译是以为单位进行的。

6.一个数组的实际上是指向该数组的第一个元素的指针，并且在任何时候都
不允许修改它。

7.指针变量 pv 和 pc 定义为"void *pv ="Hello, word!,,; char *pc;”,要将 pv 值赋给pc,则正确的赋值语句是pc=()pvo
8.一个类的——函数通常用于实现释放该类对象中指针成员所指向的动态存储
空间的任务。

9.假定用户为类AB定义了一个构造函数“AB(int aa) :a(aa) {} ”，则是该
类的数据成员。

10.在多文件结构的程序中，通常把含有main。

函数的文件称为该程序的—
三、程序填充题，根据题意在横线上填写合适的内容。

(每小题6分，共24分)
1.采用辗转相除法求出两个整数的最大公约数。

#include<iostream. h>
void main ()
(
int a, b;
cout«，z请输入两个正整数:”;
cin>>a>>b;
while(a<=0 | | b<=0) (cout«，z重新输入:";cin»a»b;}
while(b) {
int r;
r=a%b;
；； //分另U修改 a 和 b 的值
cout«a«endl; 〃输出最大公约数
2.用插入排序方法对table指针数组中size个指针所指向的字符串进行按升序排序的算法。

void sort(char stable[], int size){
for(int i=l; i<size; i++) (
char *p=table[i];
for (int j=iT; j>=0 ; j—)
if (strcmp(p, table[j])<0) table[j+l]=;
else break;
table[j+l] =;
3.类A的定义
class A {
char *a;
public:
A() {a=NULL;} //定义无参构造函数，使a为空指针
A(char *aa) {
a= char[strlen(aa)+1];
strcpy (a, aa); 〃用aa所指字符串初始化a所指向的动态存储空间}
〃定义析构函数，删除a所指向的动态存储空间
}；
4.类Goods的定义
class
{
private:
char Name[20];
int Weight;
static int totalWeight;
public:
Goods (char^str, int
w){ strcpy(Name, str);
Weight=w;
totalWeight+=Weight;
}
〜Goods (){totalWeight-二Weight;}
char* GetN () (;} int GetW()(return weight;} static int GetTotalWeight() { //返回商品名称
〃定义静态成员函数返回总重量
〃商品名称
//商品重量
//同类商品总重量
四、理解问答题，分别写出前2小题的程序运行结果和指出后2小题的程序或函数功能。

(每小题6分，共24分)
1.#include<iostream. h> const int T=6;
void main () ( int i, j, k=0; for(i=l;i<=T;i+=2){ for(j=2;j<=T;j+=2) k++;
} cout<<,,k=,,<<k«endl;
}
运行结果：
2.#include<iostream. h>
class CE { private: int a, b; int
getmax() (return (a>b? a:b);} public:
int c;
void SetValue(int xl, int x2, int x3)
( a=xl; b二x2; c=x3;
} int GetMax ();
}；
int CE: : GetMax () ( int d二getmax(); return (d>c? d:c); ) void main()
( int x=5, y=12, z=8; CE ex;
ex. SetValue (x, y, z); cout<<ex. GetMax()<<endl; )
运行结果:
3.#include<iostream. h>
void main ()
{
int i,p=l;
int N;
cout〈〈〃输入一个正整数:”;
cin>>N;
for (i=l;i<=N;i++) p*=i;
cout<<,,N!=,,«p«endl;
}
程序功能：
4.int f(char *s)
(
int i=0;
while(*s++)i++;
return i;
};
函数功能：
五、编程题(每小题6分，共12分)
1.编写一个函数，分别求出由指针a所指向的字符串中包含的每种十进制数字出现的次数，把统计结果保存在数组b的相应元素中，该函数的原型声明如下：
void fun(char* a, int b[]);
2.根据下面类中CompareBig函数成员的原型和注释写出它的类外定义。

class AA {
int* a;
int n;
int MS;
public:
void InitAA(int aa[], int nn, int ms) (
if (nn>ms) (cout«z'Error!，z<<endl; exit (1) ;}
MS二ms;
n=nn;
a=new int[MS];
for(int i=0; i<n; i++) a[i]=aa[i];
}
int CompareBig(AA& b) ; //比较*this与b的大小，从前向后按两数组〃中的对应元素比较，若*this中元素值大则返回1,若b中 //元素值大则返回T,若相等则继
续比较下一个元素，直到〃一个数组中无元素比较，此时若两者的n值相同则返
回0, //否则若*this中的n值大则返回1,若b中的n值大则返回-1。

}；
答案供参考
一、单项选择题（每小题2分，共20分）
二、填空题（每小题2分，共20分） 1. /*
2. 35
3.相同 6. 数组名 7. char *
8.析构
三、程序填充题，根据题意在横线上填写合适的内容。

（每小题6分，共24分） 评分标准：每空3分 1. a=b 、 b=r 2. table [j]> p
3. new 、〜A （） {delete []a;}
4. return Name> return totalWeight
四、理解问答题，分别写出前2小题的程序运行结果和指出后2小题的程序或函数功 能。

（每小题6分，共24分）
1. k=9
2. 12
3. 计算并输出N 阶乘的值，其中N 值由键盘输入。

4. 求出并返回字符指针参数s 所指向的字符串长度。

五、编程题(每小题6分，共12分) 评分标准：按编程完整程度酌情给分。

1. void fun (char* a, int b[])
(
int i;
for (i=0; i<10; i++) b[i]=0; 〃2 分
while(*a) {
int j=*a-，0';
if(j>=0 && j<=9) b[j]++; a++; } //6 分 }
2. int AA::CompareBig(AA& b)
1. C
2. C 6. D
7. C 3. B 4. A 8. B 9. A 5. B 10. A
4. 19
5.文件 9. a
10.主文件
int k;
if (n>b. n) k=b. n; else k=n;
//I分
for(int i=0; i<k; i++) if (a[i]>b. a[i]) return 1;
else if (a[i]<b. a[i]) return T; 〃3 分 if(k=n && k=b. n) return 0;
〃4 分
else if(k<n) return 1;
else return -1; //6 分
)
训练第二套
一、单项选择题(每小题2分，共20分)
1.字符串"a+b=12\n〃的长度为( )o
A. 6
B. 7
C. 8
D. 9
2.假定一个二维数组的定义语句为“ int a⑶[4] = { {3, 4), (2, 8,6}}; ”,则元素a[2] [1]
的值为( )=
A.0
B. 4
C. 8
D. 6
3.以下正确的描述是( )o
A.函数的定义可以嵌套，函数的调用不可以嵌套
B.函数的定义不可以嵌套，函数的调用可以嵌套
C.函数的定义和函数的调用均可以嵌套
D.函数的定义和函数的调用均不可以嵌套
4.设有定义“double array [10];则表达式 sizeof (array)/sizeof (array [0])的结果为array数组的()。

A,首地址B,元素个数
C.每个元素所占的字节数
D.总字节数
5.若使p指向包含30个整型元素的动态数组空间，则使用的定义语句为( )。

A. int *p=new int [30]:
B. int *p=new int (30):
C. int *p=new [30]:
D. *p=new int [30]:
6.软件产品与其他软件产品组合成一个整体的难易程度叫做软件的( )。

A,可维护性 B.可复用性 C,兼容性 D.正确性
7.在多文件结构的程序中，通常把类的声明单独存放于( )中。

A.主文件
B.实现文件
C.库文件
D.头文件
8.在一个用数组实现的队列类中，假定数组长度为MS,队首元素位置为first,队列长度为length,则队首的后一个位置为()o
A. first+1
B. (first+l)%MS
C. (first-1)%MS
D. (first+length)%MS
9.假定一个类的构造函数为“A(intaa=l, int bb=0) {a=aa; b=bb;}则执行"Ax⑷；" 语句后，x. a和x. b的值分别为()o
A. 1 和 0
B. 1 和 4
C. 4 和 1
D. 4 和 0
10.假定AB为一个类，则执行“ABa(2), b[3], *p[4];”语句时共调用该类构造函数的
次数为()。

A. 3
B. 4
C. 5
D.9
二、填空题(每小题2分，共20分)
1.用于输出表达式值的标准输出流对象是—。

2.假定x=5, y=6,则表达式x—*—y的值为。

3.假定x是一个逻辑量，则x || true的值为。

4.C++提供的预处理命令有宏定义命令，条件编译命令和命令。

5.假定a是一个一维数组，则a[i]的指针访问方式为 o
6.变量v定义为“double v=23.4;",要使指针pv指向v,则定义pv的语句为
7.若在类的定义体中只给出了一个成员函数的原型，则在类外给出完整定义时，其函数名前必须加上——和两个冒号分隔符。

8.若采用x. abc(y)表达式调用一个成员函数，在成员函数中使用的就代表了
类外的x对象。

9.假定用户没有给一个名为AB的类定义析构函数，则系统为其定义的析构函数为
10.假定用户只为类AB定义了一个构造函数"AB(int aa, int bb=O) (a=aa; b=bb;}”, 则定义该类的对象时，其实参表中至多带有个实参。

三、程序填充题，根据题意在横线上填写合适的内容。

(每小题6分，共24分)
1.下面函数是求两个整型参数a和b的最小公倍数。

int f2(int a, int b)
(
int i=2, p=l;
do {
while(a%i==0 && ) { p*=i; a/=i: b/=i; } i++；
}while(a>=i && );
return p*a*b;
}
2.对数组a中的元素按相反次序重新排列。

void PV(int a[], int n)
int i;
for(i=0; i<n/2; i++) { int x=a[i];
3. 假定有定义为a
struct NODE {int data; NODE* next;};”，下面算法是把以L 为表 头指针的链表中各结点依次按相反次序链接并返回新链表的表头指针。

NODE* f8(NODE* L)
if(L==NULL) return NULL; NODE *p=NULL, *q=L, *t; while(q!=NULL) {
t 二q ； q=q->next; t~>next=;
P ：
return p; }
int GetValue(int i) (return a[i] ;} 〃函数体返回 a[i]的值
}；
四、理解问答题，分别写出前2小题的程序运行结果和指出后2小题的程序或函数功 能。

(每小题6分，共24分)
1. #include<iostream. h>
const int B 二2;
//p 为新链表的表头指针，初始值为空
4.类A 的定义 class A { int
*a; int n; int MaxLen;
public:
A() : a(0), n(0), MaxLen
(0)
A(int *aa, int nn, int MM)
n=nn; MaxLen 二MM;
if(n>MaxLen) exit (1); a=new int[MaxLen];
(}
//无参构造函数
//带参构造函数 ；//利用数组如给数组a 赋值
〜A() {_ ；}
//释放动态存储空间
void main 0
{
int p=l, s=l;
while(s<50) (
p*二 B;
s+=p;
}
cout〈〈〃s=〃〈<s«endl;
}
运行结果：
2.#include<iostream. h>
class CE (
private:
int a, b;
int getmin() (return (a<b? a:b) ;}
public:
int c;
void SetValue(int xl,int x2, int x3)
a=xl; b二x2; c二x3;
}
int GetMin ();
}；
int CE: :GetMinO { int d=getmin(); return (d<c? d:c);
}
void main ()
{
int x=5, y=12, z二8;
CE *ep=new CE;
ep->SetValue(x+y, y-z, 10); cout«ep->GetMin () «endl;
}
运行结果：
3.int ff (int x, int y, char op) {
int z;
switch(op) {
case ' +':
cout<<x<<‘+'二'；cin»z; if(x+y=z) return 1; else return 0;
break;
case '-':
cout«x«，-' <<y<<，=';cin»z;
if(x-y=z) return 1; else return 0;
break;
case ' *':
cout〈〈x〈〈'*'二’；cin»z;
if(x*y=z) return 1; else return 0;
break;
case ' /':
cout<<x<〈'/'二'；cin»z;
if(x/y=z) return 1; else return 0;
break;
default: cout«，z运算符错，退出!exit (1);
}
)
函数功能：
4.char* f(char *s){
int n=strlen (s);
char* r=new char[n+1];
for(int i=0; i<n; i++)
if(s[i]> ='a' && s[i]〈='z') r [i]= s [i]-'a'+'A';
else r[i]=s[i];
r[n]=A\0,;
return r;
}
函数功能：
五、编程题(每小题6分，共12分)
1.按照下面函数原型语句编写一个递归函数求出并返回数组a中n个元素的平方和。

int
f (int a[], int n);
2.根据下面类中拷贝构造函数的原型写出它的类外定义。

class Array {
int *a; //指向动态分配的整型数组空间
int n; //记录数组长度
public:
Array (int aa[], int nn); 〃构造函数，利用aa数组长度nn初始化n, //利用aa
数组初始化a所指向的数组空间
Array (Array& aa) ; //拷贝构造函数
}；
答案供参考
一、单项选择题每小题2分，共20分）
1. B
2. A
3. B
4. B
5. A
6. C
7. D
8. B
9. D 10. B
二、填空题（每小题2分，共20分）
1.cout
2. 25
3. true （或 1）
4.文件包含
5. *（a+i）
6. double *pv=&v;
7.类名
8. *this
9. ~AB（）（｝10. 2
三、程序填充题，根据题意在横线上填写合适的内容。

（每小题6分，共24分）
评分标准：每空3分。

1.b%i==0> b>=i
2.a[i]=a[n-i-l]> a[n-i-l]=x
3.p、t
4.a[i]=aa[i]> delete []a
四、理解问答题，分别写出前2小题的程序运行结果和指出后2小题的程序或函数功能。

（每小题6分，共24分）
评分标准：第3、4小题根据叙述完整程度酌情给分。

1.s=63
2. 4
3.以参数x和y作为运算对象，以参数op所存字符作为运算符，要求从键盘上输入运算结果，若正确则返回1否则返回0。

4.根据参数s所指向的字符串，生成一个由r所指向的新字符串并返回，该字符串使 s 字符串中的小写字母均变为大写。

五、编程题(每小题6分，共12分)
评分标准：按编程完整程度酌情给分。

1.int f (int a[], int n)
(
if(n==0) return 0; 〃1 分
else return a[n-l]*a[n-l]+f(a, n~l); //6 分
}
2.Array::Array(Array& aa) {
n=aa. n; //1 分
a=new int[n]; //3 分
for (int i=0; i<n; i++) a[i]=aa. a[i]; //6 分
训练第三套
一、单项选择题(每小题2分，共20分)
1.C++程序的基本功能模块为( )。

A.表达式 B,标识符 C,语句 D.函数
2.当处理特定问题的循环次数已知时，通常采用( )来解决。

A. for循环
B. while循环
C. do循环
D. switch语句
3.下面函数原型语句正确的是( )。

A. int Function(void a);
B. void Function (int);
C. int Function(a):
D. int(double a):
4.假定变量m定义为“int m=7;,, ,则定义变量p的正确语句为( )。

A. int p=&m;
B. int *p=&m;
C. int &p=*m;
D. int *p=m;
5.假定变量a和pa定义为"double a[10], *pa=a;”，要将12. 35赋值给数组a中的下标为5的元素，不正确的语句是( )。

A. pa[5]=12. 35;
B. a[5]=12. 35;
C. *(pa+5)=12. 35;
D. * (a [0]+5)=12. 35;
6.假定AA为一个类，a为该类私有的数据成员，GetValueO为该类公有函数成员，它
返回a的值，乂为该类的一个对象，则访问x对象中数据成员a的格式为( )。

A. X. a
B. x. a()
C. x-〉GetValue ()
D. x. GetValue 0
7.类的构造函数是在定义该类的一个()时被自动调用执行的。

A.成员函数
B.数据成员
C.对象
D.友元函数
8.假定AB为一个类，贝愀行“AB x;”语句时将自动调用该类的()。

A.带参构造函数
B.无参构造函数 C,拷贝构造函数 D.赋值重载函数
9.假定一个类AB只含有一个整型数据成员a,当用户不定义任何构造函数时，系统为该类定义的无参构造函数为()O
A. AB() {a=0;}
B. AB (int aa=0) : a(aa) ()
C. AB (int aa) : a(aa) (}
D. AB () ()
10.如果表达式a++中的"++”是作为普通函数重载的运算符，若采用运算符函数调用
格式，则可表示为( )。

A. a. operator++()
B. operator++(a)
C. operator++(a, 1)
D. operator++(l, a)
二、填空题(每小题2分，共20分)
1.存储字符，a，和字符串，，a〃分别需要占用和个字节。

2.重载一个函数的条件是：该函数必须在参数的或参数对应的___________________ 上与其它同名函数不相同。

3.假定p是一个指向整数对象的指针，则用——表示该整数对象，用——表示指针变量P的地址。

4.元素a[i]和b[i] [j]的指针访问方式分别为和。

5.已知有定义“int x, a[] = (5, 7, 9), *pa=a;",在执行"x=++*pa;"语句后,x 的
值是, *(pa+l)的值为 o
6.在一个用数组实现的队列类中，假定数组长度为MS,队首元素位置为first,队列
长度为length,则队列为空和队列为满的条件分别为和。

7.对类中和成员的初始化只能通过在构造函数中给出的初始化表项
来实现的。

8.假定AB为一个类，该类中含有一个指向动态数组空间的指针成员pa,则在该类的
析构函数中应该包含有一条语句。

9.假定派生类及其基类中都定义有同名函数成员，若要在派生类中调用基类的同名函
数成员时，就需要在其函数名前加上______ 和。

10.派生类的成员函数能够直接访问所含基类的成员函数和成
员函数。

三、程序填充题，对程序、函数或类中划有横线的位置，根据题意按标号把合适的内容填写到程序后面的标号处。

(每小题5分，共20分)
1.统计字符串中英文字母个数的程序。

#include<iostream. h>
int count(char str[]);
void main () {
char si[80];
cout«,z Enter a line:,r;
cin>>sl;
cout〈<〃count二”〈〈count (si) «endl;
}
int count(char str[]) {
int num=0; //给统计变量赋初值
for(int i=0;str[i];i++)
if (str[i]>=z a f && str[i]<=A z f | | ____ (1) __ ) ___ (2) ___ ;
(3);
(1) (2) (3)
2.对数组a[n]中的n个元素按升序进行的选择排序算法。

void SelectSort(int a[], ____ (1) __ )
{
int i, j, k;
for(i=l;i<n;i++) ( //进行nT次选择和交换
k=i-1;
for(j=i;j<n;j++)
if(a[j]<a[k]) __ ⑵ ___ ；
int x=a[i-l]; a[i-l]=a[k]; ___ (3) ___ ;
(1) (2) (3)
3.下面是一维数组类ARRAY的定义，ARRAY与普通一维数组的区别是：(a)用()而不是口进行下标访问，(b)下标从1而不是从0开始，(c)要对下标是否越界进行检查。

class ARRAY{
int *v; //指向存放数组数据的空间
int s; 〃数组大小
public:
ARRAY(int a[], int n);
〜ARRAY。

(delete []v;} int size() ( return s;} int& operator() (int n);
⑴ ___ operator () (int n) // 0的运算符成员函数定义
if ( _ ⑵_____ ) {ceir<〈〃下标越界！〃； exit (1) ;}
return ___ (3) __ ;
4.一种类定义如下: class Goods
private:
char gd name[20];
int weight;
static int totalweight; public: 〃商品名称〃商品重量
Goods (char^str, int w) ( //构造函数
strcpy(gd_name, str);
weight二w;
totalweight+=weight;
}
〜Goods ()(totalweight -二 weight;}
char* GetN() ( __ ⑴____ ;} //返回商品名称
int GetW()(return weight;}
___ (2) __ GetTotal_Weight () ( //定义静态成员函数返回总重量
—(3)—；
(1) (2) (3)
四、理解问答题，写出前三小题的程序运行结果和指出后两小题的程序(或函数)所能实现的功能。

(每小题6分，共30分)
1.#inc 1 ude<iomanip. h>
const int N=3;
void main ()
{
int a[N] [N] = ({7, -5, 3), (2, 8, -6), {1,-4, -2});
int b [N] [N]二{{3, 6, -9}, (2, -8, 3}, (5, -2,-7}};
int i, j, c [N] [N];
for (i二0; i〈N; i++) //计算矩阵 C
for(j=0;j<N;j++)
c[i] [j]=a[i] [j]+b[i] [j];
for(i=0;i<N;i++) ( //输出矩阵 C
for(j=0; j<N; j++)
cout<<setw(5)«c[i] [j];
cout<<endl;
}
}
运行结果：
2.#include<iostream. h>
#include<string. h>
class A(
char *a;
public:
A (char *s) {
a二new char[strlen(s)+l];
strcpy (a, s);
cout<<a<<endl;
}
~A() (delete []a;}
}；
void main () {
A x(〃xuxiaokai〃);
A *y=new A(〃weirong〃);
delete y;
}
运行结果：
3.#include<iostream. h> class A {
int a, b;
public:
A () (a=b=0;}
A(int aa, int bb) {a=aa; b=bb;} int Sum() (return a+b;} int* Mult () { int *p=new int(a*b);
return p;
}
)；
void main () {
A x(2, 3), *p;
p=new A(4, 5);
cout«x. Sum () <〈，' <〈* (x. Mult ()) «endl;
cout<<p->Sum() <〈，Y〈*(p->Mult ()) «endl; }
运行结果：
4.void fun5(char* a, const char* b)
while(*b) *a++=*b++;
*a=0;
函数功能:
5.template<class T>
bool fun8(T a[], int n, T key)
{
for(int i=0;i<n;i++)
if(a[i]=key) return true;
return false ;
)
函数功能：
五、编程题(每小题5分，共10分)
1.按照下面函数原型语句编写一个递归函数求出并返回数组a中n个元素的平方和。

int
f (int a[], int n);
2.根据下面类中拷贝构造函数的原型写出它的类外定义。

class Array {
int *a; 〃指向动态分配的整型数组空间
int n; //记录数组长度
public:
Array (int aa[], int nn); 〃构造函数，利用aa数组长度nn初始化n,
〃利用aa数组初始化a所指向的数组空间Array (Array& aa) ; //拷贝构造函数
Array& Give (Array& aa); 〃实现 aa 赋值给*this 的功能并返回*this
Array Uion(Array& aa); 〃实现+this和aa中的数组合并的
〃功能，把合并结果存入临时对象并返回
int Lenth() (return n;} //返回数组长度
void Print () ( 〃输出数组
for (int i=0; i<n; i++) cout«a[i]<<z ';
cout<<endl;
)
};
答案供参考
一、单项选择题（每小题2分，共20分）
1. D
2. A
3. B
4. B
5. D
6. D
7. C
8. B
9. D 10. C
二、填空题（每小题2分，共20分）
评分标准：每小题若有两个空，则每空1分；若只有一个空，则每空2分。

1. 1 2
2.个数（或数目）类型
3.*p &p
4. *（a+i） *（*（b+i）+j）
5. 6 7
6. length==0 length~MS
7.对象基类常量引用（四取二即可） 8. delete :]pa;
9,基类名类区分符10.公有保护
三、程序填充题，对程序、函数或类中划有横线的位置，根据题意按标号把合适的内容填写到程序后面的标号处。

（每小题5分，共20分）
评分标准：对一空给2分，对两空给4分，对二空给5分。

1.
(1) str[i]>=z A r&& str[i]<=f Z r
( 2) num++
( 3) return num
2.
(1) int n
( 2) k=j
( 3) a[k]=x
3.
(1) int& ARRAY::
( 2) n<l n>s
( 3) v[n-l]
4.
(1) return gd_name
( 2) static int
(
3)
return totalweight
四、理解问答写出前三小题的程序运行结果和指出后两小题的程序（或函数）所能实现的功能。

（每小题6分，共30分）
1. 10
1 ~6 〃
2 分
4_3 〃2 分
6 -6 _9 〃2 分
2. xuxiaokai //3分
weirong //3分
3. 5 6 //3分
9 20 //3分
4.实现字符串系统函数strcpy的功能，把b所指的字符串拷贝到a所指的字符数组空间中。

5.函数模板，从一维数组a[n]中查找值为key的元素，若查找成功则返回真否则返回假。

第4、5小题评分标准：按叙述完整程度酌情给分。

五、编程题(每小题5分，共10分)
评分标准：按编程完整程度酌情给分。

1.int f (int a[], int n)
(
if(n=0) return 0;
else return a[n-l]*a[n-l]+f(a, n~l): )
2.Array::Array(Array& aa) {
n=aa. n;
a二new int[n];
for(int i=0; i<n; i++) a[i]=aa. a[i];
训练第四套
一、单项选择题（每小题2分，共20分）
1.
程序中主函数的名字为（ ）。

A. main B. MAIN C. Main 2. 为了提高程序的运行速度，可将不太复杂的功能用函数实现，此函数应选择（
）o A.内联函数 B.重载函数 C.递归函数 D.函数模板
3. 将两个字符串连接起来组成一个字符串时，选用（ ）函数。

A. strlen （）
B. strcap （）
C. strcat （）
D. strcmp 0
4. 用new 运算符创建一维整型数组的正确语句是 o
A. int *p=new a[10]:
B. int *p=new float[10]:
C. int *p=new int [10] :
D. int *p=new int[5] = {l, 2, 3, 4, 5}
5. 假定有定义"int b[10] : int *pb;",则不正确的赋值语句为（
）。

A. pb=b; B. pb=&b[0]; C. pb=new int: D. pb=b[5]; 假定AA 为一个类，a 为该类公有的数据成员，乂为该类的一个对象，则访问x 对象
8. 对于任一个类，用户所能定义的析构函数的个数至多为（）。

A. 0
B. 1
C. 2 D,任意个
9. 对类中引用成员的初始化是通过构造函数中给出的（）实现的。

A,函数体 B,参数表 C.初始化表
D,初始化表或函数体 10. 如果表达式a==b 中的“==”是作为普通函数重载的运算符，若采用运算符函数调 用格式，则可表示为（ ）。

A. a. operator" （b ）
B. b. operator== （a ）
C. operator" （a, b ）
D. operator== （b, a ）
二、填空题（每小题2分，共20分）
D.任意标识符
6. 中数据成员a 的格式为（
A. x （a ）
B. )0 x[a]
C. x->a
D. x. a
7. 假定AB 为一个类, 则执行“AB x （a, 5）;"语句时将自动调用该类的（ A,带参构造函数 C,拷贝构造函数 B. 无参构造函数
1.常数-4. 205和6. 7E-9分别具有和 __________________ 位有效数字。

2.元素类型为double的二维数组a[4] [6]共有个元素，共占用字节
的存储空间。

3.假定对二维数组a⑶⑷进行初始化的数据为{{3, 5, 6}, {2,8}, {7}},则a[l] [1]和
a[2] [3]分别被初始化为和 o
4.假定p为指向二维数组int d[4] [6]的指针，则p的类型为,其中一个元
素d[i] [j]表示成指针访问方式为 o
5.已知变量a定义为"int a=5;"，要使ra成为a的引用，则ra应定义为, 要使rb指向a,则rb应定义为。

6.若只需要通过一个成员函数读取其数据成员的值，而不需要修改它们，则应在函数
头的后面加上_______ 关键字；若只需要读取引用参数的值，不需要对其修改，则应在该参
数说明的开始使用关键字。

7.假定一个类对象数组为A[N],当定义该数组时，将自动调用该类的无参构造函数的
次数为次，当离开它的作用域时，将自动调用该类析构函数的次数为次。

8.假定AB为一个类，贝U类定义体中的“AB(AB&x);”语句为该类的原
型语句，而"operator=(AB& x);”为该类的原型语句。

9.在定义一个派生类时，使用关键字表示为私有继承，使用关
键字表示为公有继承。

10.重载一个运算符时，该运算符的、以及操作符的个数不允许改变。

三、程序填充题，对程序、函数或类中划有横线的位置，根据题意按标号把合适的内容填写到程序后面的标号处。

(每小题5分，共20分)
1.在输出屏幕上打印出一个由字符，*，组成的等腰三角形，该三角形的高为5行，从上到下每行的字符数依次为1, 3,5, 7, 9o
#include<iostream. h>
void main ()
{
int i, j;
for (i=l; _ ⑴___ ; i++) (
for(j=l;j<=9;j++)
if (j<=5~i || _ (2) ___ ) cout<<z ';
else __ (3) __ ;
cout«endl;
}
2.从一个字符串中删除所有同一字符后得到一个新字符串并输出。

#include<iostream. h> const int len=20;
void delstr(char a[], char b[], char c);
void main () {
char strl[len], str2[len];
char ch;
cout«，z输入一个字符串：〃； cin>>strl;
cout«，z输入一个待删除的字符:〃;
cin>>ch;
delstr(strl, str2, ch);
cout<<str2<<endl;
}
void delstr(char a[], char b[], char c)
{
int j二0;
for(int i=0; ___ (1)___ ; i++)
if(—(2)—) b[j++]=a[i];
b[j]二—⑵
}
(1) (2) (3)
3.已知一维数组类ARRAY的定义如下，ARRAY与普通一维数组区别是：其重载的运算符[]要对下标是否越界进行检查。

class ARRAY(
int *v; 〃指向存放数组数据的空间
int s; 〃数组大小
public:
ARRAY(int a[], int n);
ARRAY() (delete []v;} int size()( return s;} int& operator[](int n);
}；
__ (1) __ operator[] (int n) //[]的运算符成员函数定义
(
if (n<0 | | _ (2) __ ) (cerr«，z下标越界！〃； exit (1) ;}
return ___ (3) __ ;
4.一个类定义如下：
class Point
(
private:
int x, y;
public:
Point 0 (x=y=0;}
Point(int xO, int yO) (x=xO;y=yO;} int GetX() (return x; } int GetY ()
(return y; }
void Print(){cout〈〈"Point("〈<x<<〃，"<<y<〈〃)"〈〈endl;}
—⑴—；//友元函数声明
—⑵—；//友元函数声明
}；
Point operator+(Point& pt, int dd)
//加号操作符重载函数，实现Point类对象与整数的加法
{
Point temp二pt;
temp. x+=dd;
temp. y+=dd;
return temp;
}
Point operator+(Point& ptl, Point& pt2)
〃加号操作符重载函数，实现两个Point类对象的加法
{
Point temp=ptl;
temp. x+=pt2. x;
temp. y+=pt2. y;
—⑶—；
}
(1) (2) (3)
四、理解问答题，写出前三小题的程序运行结果和指出后两小题的程序(或函数)所能实现的功能。

(每小题6分，共30分)
1. #include<iostream. h> const int B=2;
void main ()
int p=l, s=l;
while(s<50) {
p*二B;
s+=p;
cout〈〈〃s=〃〈<s«endl;
)
运行结果：
2.#include<iostream. h>
class CE (
private:
int a, b;
int getminO (return (a<b? a:b) ;} public:
int c;
void SetValue(int xl,int x2, int x3) a=xl; b=x2; c=x3;
}
int GetMin ();
}；
int CE::GetMin() {
int d二getminO ;
return (d<c? d:c);
)
void main ()
{
int x=5, y=12, z二8;
CE *ep;
ep二new CE;
ep->SetValue(x+y, y-z, 10);
cout<<ep->GetMin ()<<endl;
CE a=*ep;
cout«a. GetMin () *3+15«endl;
}
运行结果：
3.#include<iostream. h>
class A {
int a[10]; int n;
public:
A(int aa[], int nn) : n(nn) {
for(int i二0; i<n; i++) a[i]=aa[i];
int Get(int i) {return a[i];}
int SumA(int nn) ( int s二0;
for(int j二0; j<nn; j++) s+二a[j];
return s;
}
)；
void main () {
int a[]-(2, 5, 8, 10, 15, 20);
A x(a, 4);
A y (a, 6);
int d=1;
for (int i=0; i<4; i++) d*二x. Get(i);
int f二y. SumA(5);
cout<<zz d=，z<<d«endl;
cout<<，z f=，z<<f«endl;
)
运行结果：
4.#include<iostream. h>
#include<stdlib. h>
#include<time. h>
const int N二10;
int ff(int x, int y) {
int z;
cout«x«，+' 二’;
cin>>z;
if(x+y=z) return 1; else return 0;
}
void main ()
{
int a, b, c=0;
srand(time (0)); 〃初始化随机数序列
for(int i=0;i<N;i++) {
a=rand()%20+l; //rand()函数产生0-32767之间的一个随机数
b=rand()%20+l;
c+=ff(a, b);
cout〈〈〃得分:z，«c*10«endl;
程序功能：
5.char *f(char *s){
int n=strlen(s);
char* r二new char[n+1];
for(int i=0; i<n; i++)
if(s[i]> 二'a' && s[i]〈='z') r [i]=s [i]-'a'+'A';
else r[i]=s[i];
r[n]=z\0f ;
return r;
)
程序功能：
五、编程题(每小题5分，共10分)
1.编写一个函数，分别求出由指针a所指向的字符串中包含的每种十进制数字出现的次数，把统计结果保存在数组b的相应元素中，该函数的原型如下。

void fun (char* a, int b[]);
2.根据下面类中CompareBig函数成员的原型和注释写出它的类外定义。

class AA {
int* a;
int n;
int MS;
public:
void InitAA(int aa[], int nn, int ms) (
if (nn>ms) (cout«z'Error!，z<<endl; exit (1) ;}
MS二ms;
n=nn;
a二new int[MS];
for(int i=0; i<n; i++) a[i]=aa[i];
)
int CompareBig(AA& b); 〃比较*this与b的大小，从前向后按两数组//中的对应元素比较，若*this中元素值大则返回1,若b中
〃元素值大则返回T,若相等则继续比较下一个元素，直到
//一个数组中无元素比较，此时若两者的n值相同则返回0,
〃否则若*this中的n值大则返回1,若b中的n值大则返回-1。

}；
答案供参考
一、单项选择题(每小题2分，共20分)
1. A
2. A
3. C
4. C
5. D
6. D
7. A
8. B
9. C 10. C
二、填空题(每小题2分，共20分)
评分标准：每小题若有两个空，则每空1分；若只有一个空，则每空2分。

1. 4 2 224 192
3. 8 0 4
. int (*) [6] * (* (d+i) +j)
5. int &ra=a; int *rb=&a; 6
. const const
7. N N 8
. 拷贝构造函数赋值重载函数
9. private public 1
优先级结合性
三、程序填充题，对程序、函数或类中划有横线的位置，根据题意按标号把合适的内容填写到程序后面的标号处。

(每小题5分，共20分)
评分标准：对一空给2分，对两空给4分，对三空给5分。

1.(1) i〈=5
(2)j>=5+i
(3)cout〈〈，*，
2.(1) a[i](或 a[i] !=,\0r)
(2) a[i] !=c
⑶'\0'
3.(1) int& ARRAY::
(2)n>=s
(3)v[n](或*(v+n))
4.(1) friend Point operator+(Pointfe pt, int dd)
(2)friend Point operator+(Point& pt 1, Point& pt2)
(3)return temp
四、理解问答题，写出前三小题的程序运行结果和指出后两小题的程序(或函数)所
能实现的功(每小题6分，共30分)
评分标第4、5小题根据叙述完整程度酌情给分。

1. s=63
2. 4 //3分
27 //3分
3. d=800
//3分f=40 //3分
4.让计算机随机产生出10道20以内整数的加法题供用户计算，每道题10分，计算完成后打印出得分。

5.根据参数s所指向的字符串，生成一个由r所指向的新字符串并返回，该字符串使 s字符串中的小写字母均变为大写。

五、编程题(每小题5分，共10分)
评分标准：按编程完整程度酌情给分。

1. void fun (char* a, int b[])
(
int i;
for(i=0;i<10;i++) b[i]=0;
while(*a) {
int j=*a-，0';
if(j>=0 && j<=9) b[j]++;
a++;
2.int AA::CompareBig(AA& b)
{
int k;
if (n>b. n) k=b. n; else k=n;
for(int i二0; i<k; i++)
if(a[i]>b. a[i]) return 1;
else if(a[i]<b. a[i]) return -1;
if(k=n && k==b. n) return 0;
else if(k<n) return 1;
else return -1;。