2023年浙江省宁波市全国计算机等级考试C++语言程序设计真题(含答案)

2023年浙江省宁波市全国计算机等级考试C++语言程序设计真题(含答案) 学校:________ 班级:________ 姓名:________ 考号:________
一、1.选择题(10题)
1.若进栈序列为a，b，C，则通过入出栈操作可能得到的a，b，C的不同排列个数为( )。

A.4
B.5
C.6
D.7
2. 下列叙述中，错误的是()。

A.派生类可以使用private派生
B.对基类成员的访问必须是无二义性的
C.基类成员的访问能力在派生类中维持不变
D.赋值兼容规则也适用于多继承的组合
3.以下不是结构化程序设计方法的技术是（）。

A.自顶向下，逐步求精
B.自底向上，逐步求精
C.从整体到局部
D.结构清晰，层次分明
4. 当一个函数无返回值时，函数的类型应为( )。

A.任意
B.void
C.int
D.char
5. 有如下程序：#include ＜iostream＞using namespace std;class point{ int x, y;public: point( int vx, int vy ) { x = vx; y = vy; } point ( ) x = 0; y= 0; } point operator+( point p1 ) { point p; int px = x+ p1.x; int py = y + p1.y; return
point( px, py ); point operator-( point p1 ) { point p; int px = x -p1.x; int py = y - p1.y; return point ( px, py ); } void print() { cout＜＜x＜＜" , "＜＜y＜
＜end1; }};int main (){ point p1(10, 10 ), p2( 20, 20 ); p1 = p1 - p2; p1.print (); return 0;} 执行后的输出结果是
A.10，10
B.20，20
C.10，20
D.30，30
6.相对于数据库系统，文件系统的主要缺陷有数据关联差、数据不一致
性和（）。

A.可重用性差
B.安全性差
C.非持久性
D.冗余性
7.下列关于模板的说法正确的是（）。

A.模板的实参在任何时候都可以省略
B.类模板与模板类所指的是同一概念
C.类模板的参数必须是虚拟类型的
D.类模板中的成员函数全部都是模板函数
8. 有以下程序#include ＜iostream＞using namespace std; static int days []={31,28.31,30,31,30,31,31,30,31,30,31}; class date { private: int month, day, year: public: date (int m, int d, int y { month = m; day = d; year = y; } date{} {} void disp {) { cout ＜＜year＜＜" - "＜＜month＜＜"- "＜＜
day＜＜end1; } date operator+(int day) { date dt = *this: day += dt.day; while
{ day ＞days[ dt.month - 1 ] ) { day -= tays[ dt.month - 1 ]; if ( ++dt.month == 13 { dt.month = 1; dt.yeare++; } } dr. day = day; return dt; } }; int main() { date d1( 6, 20, 2004 ), d2; d2.= d1 + 20; d2.disp (); return 0; } 执行后的输
出结果是
A.2004-7-10
B.2004-6-20
C.2004-7-20
D.程序编译时出错
9. 下列数组的定义中，会产生错误的是
A.int a[]=('0'，'1'，'2'，'3'，'4'，'5'，'6')；
B.int a[10]={0，1，2，3，4，5，6}；
C.char a[5]="hello"；
D.char a[5]={'h'，'e'，'1'，'1'，'o'}；
10.将两个字符串连接起来组成一个字符串时，选用()函数。

A.strlen()
B.strcpy()
C.strcat()
D.strcmp()
二、单选题(13题)
11.有如下程序：
#nclude＜iostream＞
using namespace std；
class MyClass{
public：MyClass(int x):val(x){}
void Set(int x){Val=x;}
void Print()const{cout＜＜"val="＜＜Val＜＜'\t';} private：int val；
}；
int main(){
const MyClass obj1(10)；
MyClass obj2(20)；
obj1.Print()；//语句1
obj2.Print()；//语句2
obj1.Set(20)；//语句3
obi2.Set(30)；//语句4
return0；
}
其主函数中错误的语句是()。

A.语句1
B.语句2
C.语句3
D.语句4
12.栈通常采用的两种存储结构是
A.A.线性存储结构和链表存储结构
B.散列方式和索引方式
C.链表存储结构和数组
D.线性存储结构和非线性存储结构
13.软件生命周期是指（）。

A.软件产品从提出、实现、使用维护到停止使用退役的过程
B.软件从需求分析、设计、实现到测试完成的过程
C.软件的开发过程
D.软件的运行维护过程
14.对于一个类定义，下列叙述中错误的是
A.如果没有定义拷贝构造函数，编译器将生成一个拷贝构造函数。

B.如果没有定义缺省的构造函数，编译器将一定生成一个缺省的构造函数。

C.如果没有定义构造函数，编译器将生成一个缺省的构造函数和一个拷贝构造函数。

D.如果已经定义了构造函数和拷贝构造函数，编译器不会生成任何构造函数。

15.索引属于（）。

A.模式
B.内模式
C.外模式
D.概念模式
16. 有以下语句，则对a数组元素的引用不正确的是(0≤i≤9)( )。

int a[10]={0，1，2，3，4，5，6，7，8，9}，*P=a；
A.a[P-a]
B.*(&a[i])
C.P[i]
D.*(*(a+i))
17.有如下程序：
#include<iostream>
usingnamespacestd；
classTestClass
{public：
virtualvoidfunl（）
{cout<<"funlTestClass"；}
virtualvoidfun2（）
{cout<<“fun2TestClass”；}}；
classTestClassl：publicTestClass
{voidfun（）
{cout<<“funlTestClassl”；}}；
intmain（）
{TestClassobj1，*P；
TestClasslobj2；
p=＆obj2；
p->fun1（）；
p->fun2（）；
return0；}
该程序执行后的输出结果是（）。

A.funlTestClasslfun2TestClass
B.funlTestClass1fun2TestC1ass1
C.funlTestClassfun2TestClass
D.funlTestClassfun2TestClassl
18.算法的空间复杂度是指()。

A.算法在执行过程中所需要的计算机存储空间
B.算法所处理的数据量
C.算法程序中的语句或指令条数
D.算法在执行过程中所需要的临时工作单元数
19.若有表达式“(w)?(--x)：(＋＋y)”，则其中与w等价的表达式是（）。

A.w==1
B.w==0
C.W!=1
D.W!=0
20.当派生类从一个基类保护继承时，基类中的一些成员在派生类中成为保护成员，这些成员在基类中原有的访问属性是（）。

A.任何
B.公有或保护
C.保护或私有
D.私有
21.下列有关模板的叙述中，正确的是( )。

A.函数模板不能含有常规形参
B.函数模板的一个实例就是一个函数定义
C.类模板的成员函数不能是模板函数
D.用类模板定义对象时，绝对不能省略模板实参
22.下面对静态数据成员的描述中，正确的是( )。

A.静态数据成员是类的所有对象共享的数据
B.类的每个对象都有自己的静态数据成员
C.类的不同对象有不同的静态数据成员值
D.静态数据成员不能通过类的对象调用
23.有下列程序：
#include<stdi0．h>
#defineN4
voidfun(inta[][N]，intb[])
{inti；
for(i=0;i<N，i＋＋)b[i]=a[i][i]；
voidmain（）
{intx[][N]={{1，2，3}，{4)，{5，6，7，8)，{9，10})，
y[N]，i；
fun(x，y)；
for(i=0；i<n；i＋＋)printf("％d，"，y[i])；
printf("＼n")；
}
程序的运行结果是（）。

A.1，2，3，4，B.1，0，7，0，C.1，4，5，9，D.3，4，8，10，
三、2.填空题(12题)
24. 假定A为一个类，则语句A(A&a)；为该类【】函数的原型说明。

25. 多态具体体现运行和编译两个方面，在程序运行时的多态性通过继承和______来体现，而程序编译时多态性体现函数和运符的重载上。

26. 以下程序的执行结果是
#include＜iostream.h＞
void main()
{
cout.fill1('*')；
cout.width(10)；
cout＜＜123.45＜＜endl；
cout.width(8)：
cout＜＜123.45＜＜endl；
cout.width(4)；
cout＜＜123.45＜＜endl；
}
27. 从实现的角度划分，c++所支持的两种多态性分别是【】时的多态性和运行时的多态性。

28. 为了在两个关系中提取所有相同的元组，则在交与并这两种关系运算中，应使用【】运算。

29. 下列程序的输出结果是非曲直【】。

#include＜iostream, h＞
class base
{
int x, y;
public:
base(int i, int j){x=i; y=j;}
virtual int add(){return x+ y;}
};
class three: public base
{
int z;
public:
three(int i, int j, int k) :base(i, j){z=k; }
int add() { return (base:: add()+z); }
};
void main()
{
three * q=new three(lO,20,30);
cout＜＜q-＞add()＜＜end1;
}
30. 前置自增运算符++重载为类的友元函数的形式为【】，重载为类的成员函数的形式为【】。

(设类为A，类对象为a)
31. 请在下列程序的横线处填写正确的语句。

#include＜iostream＞
using namespace std;
class Base{
public:
void fun(){cout＜＜"Base fun"＜＜endl;}
};
class Derivde:public Base{
public:
void fun(){
______∥调用基类的函数
32. 下列程序的输出结果为【】。

#include ＜iostream. h＞
void main()
{
char a[]="abcdabcabfgacd";
int i1=0,i2=0,i=0;
while (a[i])
{
if (a[i]=='a') i1++;
if (a[i]=='q') i2++;
i++;
}
cout＜＜i1＜＜''＜＜i2＜＜end1;
33. Jackson方法是一种面向______的结构化方法。

34. 【】允许用户为类定义一种模式，使得类中的某些数据成员及某些成员函数的返回值能取任意类型。

35. 下列程序从保存整数的文本文件"c:Sample. dat"中依次取出每个数据并显示出来，同时统计并显示出所有数据的个数。

程序划线处的表达式为【】。

#include＜stream, h＞
#include＜stdlib, h＞
void main( )
{
ifstream fin ("c: Sample. dat" , ios: :nocreate);
if( ! fin)
{
cerr＜＜"文件无法打开!"＜＜end1;
exit(1);
}
int x,i=0;
while(______)
{
cout＜＜x＜＜"";
i++;
}
fin. close( );
cout＜＜endl＜＜"文件中所有整数个数:"＜＜i＜＜end1;
}
四、程序改错题(10题)
36.使用VC＋＋6．0打开考生文件夹下的源程序文件
1．cpp，该程序运行时有错误，请改正程序中的错误。

本程序要求实现的功能为从键盘输入一个字符串，并将结果保存到文件1．txt中。

注意：不要改动main函数，不能增加或删除行，也不能更改程序的结构，错误的语句在
／／******error******的下面。

试题程序：
#include<iostream>
#include<fstream>
／／********error********
usingstd；
voidWriteFile(char*s)
{
ofstreamout1；
／／********error********
out1．open("1．txt"，binary|app)；
for(inti=0；s[i]!=0；i＋＋)
{
／／********error********
out1．puts(s[i])；
}
out1．close；
}
voidClearFile
ofstreamout1；
out1．open("1．txt")；
out1．close；
}
intmain
{
chars[1024]；
ClearFile；
cout<<"pleaseinputastrin9："<<endl；
cin．getline(s，1024)；
WriteFile(s)；
return0；
}
37.使用VC＋＋6．0打开考生文件夹下的源程序文件
1．cpp，该程序运行时有错误，请改正程序中的错误。

本程序要求实现的功能为从键盘输入一个字符串，并将结果保存到文件1．txt中。

注意：不要改动main函数，不能增加或删除行，也不能更改程序的结构，错误的语句在
／／******error******的下面。

试题程序：
#include<iostream>
#include<fstream>
／／********error********
usingstd；
voidWriteFile(char*s)
{
ofstreamout1；
／／********error********
out1．open("1．txt"，binary|app)；for(inti=0；s[i]!=0；i＋＋)
{
／／********error********
out1．puts(s[i])；
}
out1．close；
}
voidClearFile
{
ofstreamout1；
out1．open("1．txt")；
out1．close；
}
intmain
{
chars[1024]；
ClearFile；
cout<<"pleaseinputastrin9："<<endl；cin．getline(s，1024)；
WriteFile(s)；
return0；
}
38.使用VC＋＋6．0打开考生文件夹下的源程序文件1．cpp，但该程序运行有问题，请改正main函数中的错误，使该程序的输出结果正确。

程序输出：
8
8
注意：错误的语句在／********error********／的下面。

修改该语句即可，其他的语句不能修改。

试题程序：
#include(iostream．h>
classCO
{
public：
／********error********／
staticintn=0：
CO
{
n＋＋：
}
～CO
{
n--：
}
}：
／********error********／
intCO：：n；
voidmain
{
COobj；
COobj2[7]；
CO*C=NULL：
c=＆obj：
／********error********／
eout<<C．n<<endl；
cout<<C0：：n<<endl；
}
39.使用VC＋＋6．0打开考生文件夹下的源程序文件1．cpp，该程序运行时有错。

请改正程序中的错误，使程序输出的结果为
100
37
32
注意：错误的语句在／／******error******的下面，修改该语句即可。

试题程序：
#include<iostream．h>
／／******error******
voidmain
{
／／******error******
intm=0142：
／／******error******
intn=0X27：
intq=32；
cout＜＜m＜＜endl；
cout＜＜n＜＜endl；
cout＜＜q＜＜endl；
return；
}
40.使用VC＋＋6．0打开考生文件夹下的源程序文件1．cpp，该程序运行时有错误，请改正错误，使程序正常运行，并且要求最后一个catch必须抛出执行的任何异常。

程序异常，输出信息为
error
O
ERROR
注意：不要改动main函数，不能增加或删除行，也不能更改程序的结构，错误的语句在／／******error******的下面。

试题程序：
#include<iostream．h)
intmain
{
try
{
throw("error")；
}
／／********error******** catch(chars)
{
cout<<s<<endl；
}
try
{
throw((int)0)；
}
／／********error******** catch
{
cout<<i<<endl；
}
try
{
throw(O)；
throw("error")；
}
／／********error******** catch
{
cout<<"ERROR"<<endl；
}
return0；
}
41.使用VC＋＋6．0打开考生文件夹下的源程序文件1．cpp，该程序运行时有错误，请改正错误，使程序正常运行，并且要求最后一个catch必须抛出执行的任何异常。

程序异常，输出信息为
error
O
ERROR
注意：不要改动main函数，不能增加或删除行，也不能更改程序的结构，错误的语句在／／******error******的下面。

试题程序：
#include<iostream．h)
intmain
{
try
{
throw("error")；
}
／／********error********
catch(chars)
{
cout<<s<<endl；
}
try
{
throw((int)0)；
}
／／********error********
catch
{
cout<<i<<endl；
}
try
{
throw(O)；
throw("error")；
}
／／********error********
catch
{
cout<<"ERROR"<<endl；
}
return0；
}
42.使用VC＋＋6．0打开考生文件夹下的源程序文件1．cpp，该程序运行时有错，请改正其中的错误，使程序正常运行，并使程序输出的结果为：
sizeof(S1)=5
sizeof(s2)=10
sizeof(s3)=1
注意：不要改动main函数，不能增加或删除行，也不能更改程序的结构，错误的语句在／／******error******的下面。

(1)不能删除assert（）语句。

(2)只能修改后面的数字。

提示：assert函数如果为假，则会产生一个中断异常。

试题程序：
#include<iostream．h>
#include<assert．h>
voidmain（）
{
char*s1="abc"：
／／********error********
assert(sizeof(s1)==3)：
cout<<"sizeof(s1)=5"<<endl；
chars2[10]="ab"：
／／********error********
assert(sizeof(s2)==2)；
cout<<"sizeof(s2)=10"<<endl；
chars3=23：
／／********error********
assert(sizeof(s3)==4)；
cout<<"sizeof(s3)=1"<<endl；
return；
}
43.使用VC＋＋6．0打开考生文件夹下的源程序文件1．cpp，该程序运行时有错误，请改正程序中的错误，使得程序输出：
9，8，7，6，5
注意：错误的语句在／********error********／的下面，修改该语句即可。

其他的语句不能修改。

试题程序：
#include(iostream．h> classTC
{
／********error********／TC(inti)
{
m_i=i；
}
voidprint
{
cout<<--m_i<<，；
}
public：
intm_i；
}；
intmain
{
／********error********／inti；
TC04(10)；
while(i>5)
{
／********errOr********／i＋＋：
04．print；
}
cout<<endl；
return0；
}
44.使用VC＋＋6．0打开考生文件夹下的源程序文件1．cpp，该程序运行时有错，请改正其中的错误，使程序正常运行，输出的结果为Constructor，i=0，
Destructor
注意：错误的语句在／／******error******的下面，修改该语句即可。

试题程序：
#include(iostream．h)
classTC
{
inti；
public：
TC；
voiddisplay；
～TC；
}；
／／******error******
TC：TC
{
cout<<"Constructor"<<"，"；
i=0；
)
／／******error******
{
tout<<"i="<<i<<"，"<<endl；
}
／／******error******
TC：TC
{
COUI<<"Destructor"<<endl：
}
voidmain
{
TCa；
a．display；
}
45.使用VC＋＋6．0打开考生文件夹下的源程序文件1．cpp，该程序运行时有错，请改正其中的错误，使程序正常运行，输出的结果为Constructor，i=0，
Destructor
注意：错误的语句在／／******error******的下面，修改该语句即可。

试题程序：
#include(iostream．h)
classTC
{
inti；
public：
TC；
～TC；
}；
／／******error****** TC：TC
{
cout<<"Constructor"<<"，"；i=0；
)
／／******error****** TC：display
{
tout<<"i="<<i<<"，"<<endl；}
／／******error****** TC：TC
{
COUI<<"Destructor"<<endl：}
voidmain
{
TCa；
a．display；
}
五、综合应用题(2题)
46.使用VC＋＋6．0打开考生文件夹下的源程序文件3．cpp，其中定义了用于表示矩形的CRect类，但类CRect的定义并不完整。

请按要求完成下列操作，将类CRect的定义补充完整。

(1)定义私有数据成员leftPoint、topPoint、rightPoint、bottomPoint，分别用于表示矩形左上角及右下角的点的坐标，它们都是double型的数据。

请在注释1之后添加适当的语句。

(2)完成默认构造函数CRect的定义，指定默认实参为0，它们都是double型的数据。

请在注释2之后添加适当的语句。

(3)定义函数体为空的析构函数。

请在注释3之后添加适当的语句。

(4)在main函数中定义GReet类的实例rect2，并把re-
ct1的值赋给rect2。

请在注释4之后添加适当的语句。

注意：除在指定位置添加语句之外，不要改动程序中的其他内容。

试题程序：
#include<iostream．h>
classCRect
{
private：
／／********1********
public：
／／********2********
／／********3********
voidSetPoints(double，double，double，double)；
voidSetLeftPoint(doublem){leftPoint=m；}
voidSetRightPoint(doublem){rightPoint=m；} voidSetTopPoint(doublem){topPoint=m；} voidSetBottomPoint(doublem){bottomPoint=m；} voidDisplay（）；
}；
CReet：：CRect(double1，doublet，doubler，doubleb)
{
leftPoint=1；topPoint=t；
rightPoint=r；bottomPoint=b；
}
voidCRect：：Setpoints(double1，doublet，doubler，doubleb) {
leftPoint=1；topPoint=t；
rightPoint=n；bottomPoint=b；
}
voidCRect：：Display（）
{
cout<<"left-toppointis("<<leftPoint<<"，"<<top-
Point<<")"<<＼n；
cout<<"right-bottompointis("<<rightPoint<<"，"
<<bottomPoint<<")"<<＼n；
}
voidmain（）
{
CRectrect0；
rect0．Display（）；
rect0．SetPoints(20，20．6，30，40)；
rect0．Display（）;
CRectrectl(0，0，150，150)；
rect1．SetTopPoint(10．5)；
rect1．SetLeftPoint(10．5)；
／／********4******** rect2．Display（）；}
47.(1)“while”应改为“while(infile．get(ch))”。

(2)应添加“bur[len＋＋]=ch；bur[len]=ch；len＋＋；”。

(3)应添加“outfile2<<bur[i＋＋]；”或“outfile2<<buf[i]；i＋＋；”。

(4)“TCobj；”应改为“TCobi("in．txt")；”。

【解析】本题考查了文件流的使用。

根据题意，第1处要获得一个字符，并判断是否到文件结尾，所以应使用get函数；第2处应将ch存入buf 数组，同时让len增1；第3处将buf中的字节输出给outfile2，注意同时让i增1，否则while循环将进入死循环；第4处TC只确一个带char*参数的构造函数，所以创建对象时必须使用构造参数，根据题意这个参数应该是“"in．txt"”。

六、3.综合应用题(2题)
48. 使用VC6打开考生文件夹下的工程test29_3。

此工程包含一个test29_3.cpp，其中定义了二维坐标类Coordinate和三维坐标类
ThreeDCoord，其中ThreeDCoord类由Coordinate类public派生，但两个类的定义并不完整。

请按要求完成下列操作，将程序补充完整。

(1)定义类Coordinate的保护数据成员x和y，它们都是int型的数据，代表二维坐标的横纵坐标值。

请在注释“//**1 **”之后添加适当的语句。

(2)根据类Coordinate定义后的成员函数Display的实现，补充该函数在类Coordinate定义体内的声明，Display为二维坐标类的虚函数。

请在注释“//**2**。

”之后添加适当的语句。

(3)完成二维坐标类Coordinate的构造函数，将参数a和b分别赋值给数据成员x和y。

请在注释“//**3**”之后添加适当的语句。

(4)根据ThreeDCoord类构造函数的声明，补充ThreeDCoord构造函数的实现，参数a和b通过调用基类的构造函数来初始化基类的数据成员x和y，c赋值给数据成员2。

请在注释“//**4**”之后添加适当的语句。

输出结果如下；
[1，2]
[3，4，5]
注意：除在指定位置添加语句之外，请不要改动程序中的其他内容。

源程序文件tese9_3.cpp清单如下：
#include＜iostream.h＞
class Coordinate
{protected:
//** 1 **
public:
Coordinate(int a=0, int b=0);
//** 2 **
};
Coordinate::Coordinate(int a, int b)
{
//** 3 **
}
void Coordinate::Display() const
{
cout ＜＜'[' ＜＜x ＜＜", "＜＜y ＜＜']' ＜＜end1;
}
class ThreeDCoord:public Coordinate
{
int z;
public:
ThreeDCoord(int a=0, int b=0, int c=0);
virtual void Display() const;
};
//** 4 **
void ThreeDCoord::Display() const
{
cout ＜＜'[' ＜＜x ＜＜", "＜＜y ＜＜", "＜＜z ＜＜']' ＜＜end1;
}
void main ( )
{
Coordinate c(1, 2);
ThreeDCoord t(3, 4, 5);
c.Display ();
t.Display ();
}
49. 使用VC6打开考生文件夹下的工程test2_3。

此工程包含一个test2_3.cpp，其中定义了类Stud，但类的定义并不完整。

请按要求完成—下列操作，将程序补充完整。

(1)定义类的公有数据成员no,name[10]，其中no是int型的数据，name[10]是字符型一维数组。

请在注释“//**1**”之后添加适当的语句。

(2)完成函数set的定义，分别将参数n，na的值赋给数据成员no，name。

注意：请使用this指针完成对no的赋值，使用字符串函数实现对name
和cname的赋值。

请在注释“//**2**”之后添加适当的语句。

(3)完成类的成员函数disp的定义，使其按no,deg,name和cname的顺序输出类的数据成员的值，中间使用跳格符分隔，请在注释“//**3**”之后添加适当的语句。

输出结果如下：
1 李华95 990701
2 王东8
3 990702
注意：除在指定的位置添加语句外，请不要改动程序中的其他语句。

源程序文件test2_3．cpp清单如下：
#include＜iostream．h＞
#include＜string．h＞
class Stud
{
public:
// ** 1 **
int deg;
char cname[10];
Stud(){}
void set(int n,char na[],int d,char cn[])
{
// ** 2 **
deg=d;
strcpy(cname,cn);
}
void disp()
{
// ** 3 **
}
};
void main()
{
Stud obj[2];
obj[0]．set(1,,"李华",95,"990701");
obj[1]．set(2,"王东",83,"990702");
obj[0]．disp();
obj[1]．disp();
}
参考答案
1.B本题考查的是栈的操作。

栈是先进后出的线性表。

可能的出栈排列有：\nabc．acb，bac，bca，cba
2.C解析：在建立派生类时，并不是简单地把基类的私有成员直接作为派生类的私有成员，把基类的公用成员直接作为派生类的公用成员。

涉及如何确定基类的成员在派生类中的访问属性问题，不仅要考虑对基类成员所声明的访问属性，还要考虑派生类所声明的对基类的继承方式，根据这两个因素共同决定基类成员在派生类中的访问属性。

所以本题选择选项C)。

3.BB．【解析】结构化程序设计的主要原则可以概括为自顶向下、逐步求精、模块化、限制使用GOTO语句。

4.B解析：如果函数所体现的计算不需要返回结果，则数据类型可以指定为void类型。

注意，这种情况下在主调函数中调用该函数，该函数调用表达式不能被用作子表达式给其他变量赋值。

5.D解析：本题主要考查C++中运算符重载的机制与实现。

运算符重载函数一般分为成员函数形式和友元函数形式，这两种形式都可以访问类
中的私有成员。

本题中的运算符重载形式为成员函数形式。

程序在类point中声明了私有数据成员int x和int y，并定义了两种形式的构造函数以完成对对象的初始化；之后，程序对运算符“+”进行了重载，另其输入参数为类point的对象，输出为操作符“+”右侧该对象的私有数据成员x和y与操作符“+”左侧同类型对象的私有数据成员x和y的加和：print()函数则输出对象中数据成员的值。

程序main()函数中，实例化了类point 的两个对，象p1和p2，并完成对对象的初始化．在语句“p1= p1+p2；”中，由于操作符“+”左右两端的操作数为point类的对象，复合类point 定义中的操作符“+”的重载函数，因此程序将调用重载后的操作符函数，并返回两point对象数据成员的加和值，覆盖对象p1的数据成员．因此print()函数输出对象p1的数据成员值己应该为：x=10+20=30，
y=10+20=30
6.D解析：文件系统所管理的数据文件基本上是分散的、相互独立的，因此相对于数据库系统，以此为基础的数据处理存在3个缺点，数据冗余大、数据的不一致性、程序与数据的相互依赖(简称为数据依赖)。

注意：文件系统和数据库系统各自的特点，人工管理阶段及数据库系统三代的特点。

7.D
D。

【解析】在C＋＋中规定如果一个类被声明为类模板，那么其中的所有成员函数就都成为了模板函数。

8.A解析：本题考核运算符的重载。

本题通过将“+”运算符重载为类date 的成员函数实现简单的对象加法。

9.C解析：本题考核数组的定义和初始化。

下面逐项进行分析：A) 选项
中，数组a的定义和初始化符合数组的定义和初始化语法，故正确：B) 选项中，数组a初始化的值虽然没有10个，但对于少的部分，系统会自动补0，所以B) 选项中数组的定义也是正确；C) 选项中，数组a的长度为5，但字符串“hello”的长度为5+1=6，字符串结束符‘\\0’无法存储在数组中，所以是错误的；D) 选项中，数组a的定义是正确的。

10.C
将两个字符串连接起来组成一个字符串，选用strcat 函数来连接。

11.C
解析：此题考查的是常对象。

使用const关键字修饰的对象称为常对
象，它不能被更新。

主函数中声明的obj1是常对象，因此obj1不能被
更新，即语句3更新。

均1的语句错误。

12.A解析：和线性表类似，栈也有两种存储方法，一是顺序栈，二是链
式栈。

栈的顺序存储结构是利用一组地址连续的存储单元一次存储自栈
底到栈顶的数据元素，同时附设指针top指示栈顶元素的位置，由于栈
的操作是线性表操作的特例，相对而言，链式栈的操作更易于实现。

注
意：这3种运算方法在各种存储结构中的应用。

13.A通常，将软件产品从提出、实现、使用维护到停止使用退役的过程
称为软件生命周期。

也就是说，软件产品从考虑其概念开始，到该软件
产品不能使用为止的整个时期都属于软件生命周期。

14.B
解析：本题考查的知识点是：构造函数。

如果一个类中没有定义任何
构造函数，编译器将生成一个不带参数的公有缺省构造函数。

但只要
定义了一个任意的构造函数，就不会生成缺省构造函数了。

故本题应
该选择B。

15.B解析：内模式(Internal SchemA)又称物理模式(Physical SchemA)，它给出了数据库物理存储结构与物理存取方法，如数据存储的文件结构、索引、集簇及hash等存取方式与存取路径。

数据库系统的数据具有高共享性和低冗余性，但不能完全避免数据冗余；数据的一致性是指在系统中同一数据的不同出现应保持相同的值。

16.D解析：本题考查数组指针的应用。

选项D)第一层括号中为数组a 中第i项元素的值，外面再加指针运算符没有意义。

17.A
A。

【解析】TestClass为基类，TestClass1是TestClass的派生类。

基
类中的funl和fun2被定义为虚函数，C＋＋规定，当一个成员函数被声明为虚函数后，其派生类中的同名函数都自动成为虚函数，所以派
生类中的funl和fun2也是虚函数。

本题从main主函数入手，首先定
义了TestClass类型的对象obil和指针P，然后又定义了TestClassl的
对象obj2。

指针指向对象obj2，然后调用其成员函数fun1，即输出“funlTestClassl”。

18.A算法的空间复杂度是指算法在执行过程中所需要的内存空间。

所以选择A项。

19.D
D。

【解析】本题考查三目运算等。

条件表达式的格式为a?b；c。

它
的含义是，当a为真时，取b的值，否则取c的值。

在C语言程序中
“为真”即“不等于零”，“为假”即等于0。

所以和w等价的表达式是w
非零。

20.B
B。

【解析】保护继承时基类的public和proteeted是保护的，私有继承时基类的public和protected是私有的。

21.BB。

【解析】本题考查的是模极的概念。

函数模板可以含有常规形参；函数模板的一个实例就是一个函数定义；类模板中的成员函数都是模板函数；在用类模板定义对象时，由于没有像函数实参表这样的额外信患渠道，因此无法按函数模板的方式省略模板形参，但是可以为类模板的参数设置默认值。

22.A静态成员表示整个类范围共享的信息；必须对静态数据成员进行初始化；静态数据成员是属于类的，不能通过类的对象调用。

23.B
B。

【解析】本题考查数组的初始化，在对二维数组元素赋初值时，如果只对部分元素赋初值，那未赋初值的元素自动取0。

fun函数是将二维数组a中主对角线上的元素赋给数组b，所以y[4]=(1，0，7，0)。

24.拷贝构造拷贝构造解析：本题考核拷贝构造函数的定义。

拷贝构造函数是一种特殊的成员函数，它的作用是使用一个已存在的对象来初始化一个被创建的同类的对象。

25.虚函数虚函数
26.****123.45 **123.45 123.45
27.编译编译解析：多态性的定义。

28.交交解析：为了在两个关系中提取所有相同的元组，则在交与并这两种关系运算中，应使用交运算。

29.6060 解析：本题考察继承中子类对父类的继承方式，注意子类的add 成员函数，它直接使用了父类的成员函数进行运算。

30.friend A operator++(A &) a. operator++().
31.Base∷fun()Base∷fun() 解析：此题考查的是派生类对基类成员的访问。

本题中派生类Derived覆盖了基类Base中的fun()，如果需要调用基类中的fun()，则需要使用域运算符“∷”。

故应填写Base∷fun()。

32.43
33.数据结构数据结构
34.类模板类模板
35.fin＞＞xfin＞＞x 解析：while语句用于完成题目指定的功能，则while 的条件判断部分应完成从文件读取字符的功能，并能够判断出读入字符失败后的情况。

36.(1)应改为“usingnamespacestd；”。

(2)应改为“outl．open("1．txt"，ios：：binary｜ios：：app)；”。

(3)应改为“out1．put(s[i])；”。

【解析】本题第1处的“usingstd；”是在程序中引入标准命名空间std，对于C＋＋中引入标准命名空间的格式，缺少namespace，所以第1处的语句修改为“usingnamespacestd；”。

第2处，调用成员函数open 中，输入、输出方式是在ios类中定义的，所以“out1．open("1．txt"，binary｜app)；”语句缺少类ios，即第2处的语句修改为
“out1．open("1．txt"，ios：：binary｜ios：：app)；”。

第3个标识应
该用流成员函数put输出字符，所以第3处的语句修改为
“out1．put(s[i])；”。

37.(1)应改为“usingnamespacestd；”。

\n(2)应改为“outl．open('1．txt'，ios：：binary｜ios：：app)；”。

\n(3)应改为“out1．put(s[i])；”。

\n【解析】本题第1处的“usingstd；”是在程序中引入标准命名空间std，对于C＋＋中引入标准命名空间的格式，缺少namespace，所以第1处的语句修改为“usingnamespacestd；”。

第2处，调用成员函数open中，输入、输出方式是在ios类中定义的，所以“out1．open('1．txt'，binary｜app)；”语句缺少类ios，即第2处的语句修改为“out1．open('1．txt'，ios：：binary｜ios：：app)；”。

第3个标识应该用流成员函数put输出字符，所以第3处的语句修改为“out1．put(s[i])；”。

38.(1)“staticintn=O”应改为“staticintn；”。

(2)“intCO：：n；”应改为“intCO：：n=0；”。

(3)“cout<<c．n<<endl；”应改为“cout<<c->n<<endl；”。

【解析】本题要在屏幕上输出两个字符，首先要静态变量初始化，第1处应改为“staticintn；”，第2处要给n赋值，第3处输出时引用c的对象，应改为“cout<<c->n<<endl；”。

39.(1)“voidmain”。

(2)“int m=0144；”。

(3)“intn=OX25；”或“intn===0x25；”。

【解析】本题主要考查了主函数定义及幂同进制之间的转换，包括十进制到八进制，十进制到十六进制。

主函数定义的定义形式为“main”，函数名之后必须是一对括号，因此第1处应改为“voidmain”。

cout输出默认是以十进制方式输出的，根据题目要求输出的结果可发现变量的初值不正确，十进制的100对应八进制的144，卡进制的37对应十六进制的25，因此2和3应分别改成“intm=0144；”，
“intn=0×25；”或“intn=0×25；”。

40.(1)应改为“catch(char*s)”。

(2)应改为“cateh(inti)”。

(3)应改为“catch(…)”。

【解析】本题中第1个标识前的异常抛出语句为“throw("error")；”，其中的类型为字符串。

所以对应的异常捕捉语句catch中应该符合这个类型，而程序中给出的语句“catch(chars)”是字符型的，所以第1处的语句修改为“catch(char*S)”。

第2个标识前的异常抛出语句为
“throw((int)0)；”，其中的类型为int。

对应的异常捕捉语句catch中应该符合这个类型，所以补充catch子句中的类型，否则如果找不到匹配的catch块，系统就会调用一个系统函数，使程序终止运行。

即第2处的语句修改为“catch(inti)”。

如果在catch子句中没有指定异常信息的类。