2021年福建省厦门市全国计算机等级考试C++语言程序设计真题(含答案)

2021年福建省厦门市全国计算机等级考试C++语言程序设计真题(含答案) 学校:________ 班级:________ 姓名:________ 考号:________
一、1.选择题(10题)
1. 下面程序的运行结果为( )。

#include＜iostream.h＞void swap(int &a，int B) { int temp；temp＝a++；a＝b；b＝temp；} void main() { int a ＝2，b＝3；swap(a，b)；cout＜＜a＜＜“，”＜＜b＜＜end1；}
A.2，3
B.3，2
C.2，2
D.3，3
2. 对于语句const int x=10；的描述正确的是( )。

A.该语句不允许定义为int const x=10；
B.在程序中可以重新对X赋值
C.变量X不能使用++运算符
D.const关键字只能用来修饰常量
3.下列关于构造函数和析构函数的描述，错误的是（）。

A.析构函数中调用虚函数采用静态联编
B.对虚析构函数的调用可以采用动态联编
C.当基类的析构函数是虚函数时，其派生类的析构函数也一定是虚函数
D.构造函数可以声明为虚函数
4. 在下列枚举类型的定义中，包含枚举值3的是
A.entire test(RED，YELLOW，BLUE，BLACK)；
B.entire test(RED，YELLOW，BLUE，BLACK)；
C.enum test(RED=-1，YELLOW，BLUE，BLACK)；
D.enum test(RED，YELLOW=6，BLUE，BLACK)；
5. 设有下列二叉树：对此二叉树前序遍历的结果为()
A.ZBTYCPXA
B.ATBZXCYP
C.ZBTACYXP
D.ATBZXCPY
6. ( )是以一种完全通用的方法来设计函数或类而不必预先说明将被使用的每个对象的类型。

A.模板
B.类
C.对象
D.函数
7. 已知fl(int)是类A的公有成员函数，p是指向成员函数fl()的指针，采用赋值，( )是正确的。

A.p=fl
B.P=A::fl
C.P=A::fl()
D.P=fl()
8. 按照标识符的要求，下列选项中，( )符号不能组成标识符。

A.连接符
B.下划线
C.大小写字母
D.数字字符
9. 下列关于C++语言类的描述中错误的是
A.类用于描述事物的属性和对事物的操作
B.类与类之间通过封装而具有明确的独立性
C.类与类之间必须是平等的关系，而不能组成层次结构
D.类与类之间可以通过一些方法进行通信和联络
10. 设有数组定义：char array[]＝"China"；则数组array所占的空间为()
A.4个字节
B.5个字节
C.6个字节
D.7个字节
二、单选题(13题)
11.按照“后进先出”原则组织数据的数据结构是（）。

A.队列
B.栈
C.双向链表
D.二叉树
12.有如下类定义
class MyClass
public:
Private:
int data;
};
若要为MyClass类重载流输入运算符＞＞，使得程序中可以“cin＞＞obj;”形式输入MyClass类的对象obj，则横线处的声明语句应为( )。

A.friend istream& operator＞＞(istream& is, MyClass&A);
B.friend istream& operator＞＞(istream& is, MyClassA);
C.istream& operator＞＞(istream& is, MyClass&A);
D.istream& operator＞＞(istream& is, MyClassA);
13. 下面的语句中错误的是( )。

A.int a=5；int x[a]；
B.eonst int a=5；int x[a]；
C.int n=5；int *P=new int[a]；
D.const int n=5；int *p=new int[a]；
14.使用ifstream流类定义流对象并打开磁盘文件时，文件的隐含打开方式为（）。

A.ios：：in
B.ios：：out
C.ios：：inlios：：out
D.没有默认
15.有如下程序：
#include<iostream>
usingnamespacestd；
classXA{
inta；
public：
staticintb；
XA(intaa)：a(aa){b＋＋；}
～XA（）{}
intget（）{returna；}
}；
intXA：：b=0
intmain（）{
XAdl(1)，d2(3)；
cout<<dl．get{}＋d2．get{｝＋XA：：b<<endl；
return0；
}
运行时的输出结果是（）。

A.5 B.6 C.7 D.8
16. 下列不是关系模型的组成部分的是()。

A.关系列表
B.关系数据结构
C.关系操作集合
D.关系完整性约束
17.c++语言类体系中，不能被派生类继承的有( )。

A.转换函数
B.构造函数
C.虚函数
D.静态成员函数
18.有如下程序：
#include<iostream>
using namespace std；
classBase{
public：
void fun{
__________________
cout<<”Base：：fun”<<endl；}
}；
class Derived：public Base{
public：
voidfun{
cout<<”Derived：：fun”<<endl：
}
}；
int main{
Derived d；
A fun；
return 0；
}
已知其执行后的输出结果为：
Base：：fun
Derived：：fun
则程序中下画线处应填入的语句是（）。

A.Base．fun； B.Base：：fun；
C.Base—>fun；
D.fun；
19. 在下列字符中，不允许作为C＋＋标识符的是（）。

A.b
B.B
C._
D.2
20.下列定义中P指向的地址可更改，但*P不能够更改的是（）。

A.constint*P；
B.int*constP；
C.constint*constP；
D.int*P；
21.下列程序段中包含4个函数，其中具有隐含this指针的是
（）。

intfunl（）；
classTest{
public：
intfun2（）；
friendintfun3（）；
staticintfun4（）；
}；
A.funl
B.fun2
C.fun3
D.fun4
22.对于模板定义关键字class和typename说法不正确的是（）。

A.程序中的class并不能都替换为typename
B.class和typename都可互相替换
C.程序中的typename都能替换为class
D.程序中的部分class可以替换为typename
23. 为了提高函数调用的实际运行速度，可以将较简单的函数定义为()。

A. 内联函数
B. 重载函数
C. 递归函数
D. 函数模板
三、2.填空题(12题)
24. 以下程序的输出结果是【】。

#include＜iostream＞
using namespace std；
void fun()
{
static int a=0；
a+=2；
cout＜＜a；
}
int main()
{
int cc；
for(cc=1；cc＜4；cc++)
fun()；
cout＜＜end1；
return 0；
}
25. 若有以下定义及初始化语句：
int i=100；
int *ip=& i；
int k=*ip；
并假设整型数i的地址为0x12345678，指针中的地址为0x21000000，则k的值为【】。

26. 有如下程序：
#inClude＜iostream＞
using namespace std；
class AA
{
public：
viltual void f()
{
cout＜＜"AA"；
}
}；
class BB：public AA
{
public：
BB()
{
cout＜＜"BB"；
}
}；
class CC：public BB
{
public：
virtual void f()
{
BB::f()；
cout＜＜"CC"；
}
}；
int main()
{
AA aa,*p；BB bb；CC cc；
p=&cc；
p-＞f()；
return 0；
}
运行后的输出结果【】。

27. 在双链表中，每个节点有两个指针域，一个指向前驱节点，另一个指向【】。

28. 在下列的程序的横线处填上适当的语句，使该程序的输出为12。

#include＜iostream.h＞
using namespace std；
class Base
{
public：
int a，b；
Base(int i){a＝i;}
}；
class Derived：public Base
{
int a；
public：
Derived(int x)：Base(x)，b(x+1){}；void show()
{
29. 下面程序的输出结果为【】。

#include＜iostream．h＞
void main( )
{
int num=0，i=8；
do{
i－－；
num ++；
}while(－－i)；
cout＜＜num＜＜end1；
30. 下列程序将x、y和z按从小到大的顺序排列，请将下面的函数模板补充完整。

template ＜class T＞
void order(【】)
{
T a；
if(x＞y)
{
a=x；
x=y；
y=a;
}
if (y＞z)
{
a=y;
y=z;
z=a;
}
if (x＞y)
{
a=x;
x=y;
y=a;
}
}
31. 若要把类B定义为类A的友元类，则应在类A的定义中加入语句______。

32. 程序流程图(框图)中的箭头代表【】。

33. 数据流图有两种典型的结构形式，它们分别是变换型和【】。

34. 下列for语句的循环次数为_____。

for(int a＝0,b＝1;b&&a＜5;a＋＋) ;
35. 数据的逻辑结构在计算机存储器内的表示，称为数据的【】。

四、程序改错题(10题)
36.使用VC＋＋6．0打开考生文件夹下的源程序文件1．cpp。

本程序要求输入一个字符串，然后将其中的小写字母改成大写字母，字符可能输入多行，当输入字符“?”时，默认字符输入结束，最后把结果输出到屏幕中。

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

试题程序：
#include<iostream．h>
voidmain
{
inti=0；
charstr[120]；
cout<<"Enterastringendwith?．"<<endl；
／／********error********
cin．getline(str，120)；
／／********error********
while(str)
{
／／********error********
if(str[i])=a)
str[i]=str[i]-a＋A；
i＋＋；
}
cout<<str<<endl；
return；
}
37.使用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；
}
38.使用VC＋＋6．0打开考生文件夹下的源程序文件1．cpp，该程序运行有问题，请改正main函数中的错误，使程序的输出结果为：number=1
number=10
number=100
注意：不要改动main函数，不能增加或删除行。

也不能更改程序的结构，错误的语句在／／******error******的下面。

试题程序：
#include<iostream．h>
classTC
{
public：
TC(inti)
{
number=i；
}
voidSetNumber(intm)
{
number=m；
}
intGetNumberconst
{
returnnumber；
}
voidPrintconst
{
cout<<"number="<<number<<endl；}
private：
intnumber；
}；
voidmain
{
／／********error******** TCobjl；
objl．Print；
TCobj2(3)；
／／********error******** objl．number=10；
／／********error*‰****** TC．SetNumber(100)；objl．Print；
obj2．Print；
}
39.使用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；
}
40.使用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；
}
41.使用VC＋＋6．0打开考生文件夹下的源程序文件1．cpp，该程序运行有问题，请改正main函数中的错误，使程序的输出结果为：number=1
number=10
number=100
注意：不要改动main函数，不能增加或删除行。

也不能更改程序的结构，错误的语句在／／******error******的下面。

试题程序：
#include<iostream．h>
classTC
{
public：
TC(inti)
{
number=i；
}
voidSetNumber(intm)
{
number=m；
}
intGetNumberconst
{
returnnumber；
}
voidPrintconst
{
cout<<"number="<<number<<endl；
}
private：
intnumber；
}；
voidmain
{
／／********error********
TCobjl；
objl．Print；
TCobj2(3)；
／／********error********
objl．number=10；
／／********error*‰******
TC．SetNumber(100)；
objl．Print；
obj2．Print；
}
42.使用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；
}
43.使用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******
TC：display
{
tout<<"i="<<i<<"，"<<endl；
}
／／******error******
TC：TC
{
COUI<<"Destructor"<<endl：
}
voidmain
{
TCa；
a．display；
}
44.使用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；
}
45.使用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；
}
五、综合应用题(2题)
46.使用VC＋＋6．0打开源程序文件3．cpp。

其中类TC用于把文件输出到屏幕，然后进行文件的分割。

分割的方法如下：第一个文件的大小是文件的前一半，另外一个文件的大小是剩余部分。

此程序将in．txt文件中的内容输出到
屏幕，并且将文件按照以上方式分割，存于文件out1．txt和out2．txt 中。

其中定义的类并不完整，按要求完成下列操作，将类的定义补充完整。

(1)从输入文件中获得一个字符，并判断是否到文件结
尾，如果到文件结尾，则退出循环。

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

(2)把获得的输入文件的内容存储到bur中，并且用len
记录下文件的长度。

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

(3)将输入文件的后一半内容存储在第二个文件中，请
在注释3后添加适当的语句。

(4)使用文件流对象打开输入文件in．txt，请在注释4
后添加适当的语句。

注意：增加代码或者修改代码的位置已经用符号表示出来。

请不要修改其他的程序代码。

试题程序：
#include<iostream．h>
#include<fstream．h>
#include<stdlib．h)
classTC
{
public：
TC(char*fileName)
{
len=0；
fstreaminfile；
infile．open(fileName，ios：：in)；
charch；
／／********1********
while
{
cout<<ch；
／／********2********
}
infile．close；
}
voidsplit
{
fstreamoutfilel；
fstreamoutfile2；
outfile1．open("out1．txt"，ios：：out)；outfile2．open("out2．txt"，ios：：out)；inti=0：
for(i=0；i<len／2；i＋＋)
{
outfilel<<buf[i]；
}
do
{
／／********3********
}
while(i!=len)；
outfilel．close；
outfile2．close；
}
prwate：
intlen；
charbuf[1024]；
}；
voidmain
{
／／********4********
TCobj；
obj．split；
return；
}
47.使用VC＋＋6．0打开考生文件夹下的源程序文件3．cpp。

其中定义的类不完整，按要求完成下列操作，将类的定义补充完整。

(1)定义类的公有数据成员函数N0、Name[32]，其中N0是int型的数据，Name[32]为字符型。

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

(2)完成函数Set的定义，分别设置N0和Name的值，请在注释2后添加适当的语句。

(3)完成函数print，请在注释3后添加适当的语句，输出结果如下：
N0=12345
Name=HelloWorld!
(4)添加默认构造函数，设置N0为0，Name为空，请在注释4后添加适当的语句。

注意：增加或者修改代码的位置已经用符号表示出来，请不要修改其他的程序代码。

试题程序：
#include<iostream．h>
classTC
{
public：
／／********1********
／／********2********
{
No=no；
for(inti=0；strName[i]!=0；i＋＋)
{
Name[i]=strName[i]；
Name[i＋1]=0；
}
}
voidprint（）
{
／／********3********
}
TC（）
{
／／********4********)
}；
intmain（）
{
TCstu：
stu．Set(12345，"HelloWorld!")；stu．print（）；return0；
}
六、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打开考生文件夹下的工程MyProj8。

此工程包含一个源程序文件MyMain8.cpp，该程序实现栈的入栈和出栈的操作。

其中有两个类：一个是节点类node，它包含节点值和指向上一个节点的指针prey；
另一个类是栈类stack，它包含栈的头指针top。

但类的定义并不完整。

请按要求完成下列操作，将类Sample的定义补充完成：
①定义私有节点值data，它是血型的数据，以及定义一个指向上一个节点的指针prev。

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

②完成构造函数node(int d,node*n)的定义，使得私有成员data和prev分别初始化为d和n。

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

③完成类stack的成员函数push(int i)的类体内的定义。

函数push()实现入栈这个操作，即把形参i压入栈中，那么此时应该创建一个新的节点，并让这个节点的prev指针指向栈顶。

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

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

源程序文件MyMain8.cpp清单如下：
//MyMain 8.cpp
#include ＜iostream＞
using namespace std;
class stack;
class node
{
private:
//* * 1 * *
public:
node(int d, node *n)
{
//* * 2 * *
}
friend class stack;
};
class stack
{
node *top; //栈头
public:
stack()
{
top=0;
}
void push(int i) {
//* * 3 * *
}
int pop()
{
node*t=top；
if(top)
{
top=top-＞prev；int c=t-＞data；delete t；return c；
}
return 0；
}
}；
int main()
{
stack s；
s.push(6)；
s.push(3)；
s.push(1)；return 0；
}
参考答案
1.D解析：本题考查的是引用调用，因为函数swap引用调用参数a，所以在swap函数中a的变化会改变主函数中a的值，即a自加1，但b的值并未改变。

2.C
3.DD。

【解析】构造函数的主要作用是对数据成员初始化。

构造函数不能声明为虚函数，这是因为在执行构造函数时类对象还未完成建立过程，当然谈不上函数与类对象的关联。

4.A解析：枚举变量中的枚举元素系统是按照常量来处理的，如果没有进行元素赋值操作，那么元素将会被系统自动从0开始自动递增地进行赋值操作，但是，如果一旦定义了某一个元素，那么系统将对下一个元素进行前一个元素的值加1操作。

5.B解析：所谓二叉树的前序遍历(DLR)是指在访问根结点、遍历左子树与遍历右子树这3者中，首先访问根结点，然后遍历左子树，最后遍历右子树，并且，在遍历左右子树时，上述规则同样适用，即“根-左-右”。

故该二叉树的前序遍历结果为“A TBZXCYP”。

对于本题，若使用后序遍历和中序遍历的结果分别为“ZBTYCPXA”和“TZBACYXP”。

6.A解析：此题考查的是模板的特点。

模板是以一种完全通用的方法来设计函数或类而不必预先说明将被使用的每个对象的类型。

7.B
8.A【解析】此题考查的是标识符。

标识符是由数字、字母以及下划线构
成，其第一个字符必须是字母或下划线，中间不能有空格；标识符的长度是任意的，但由于编译系统的限制一般不超过31个字符：标识符中的大小写字母是不同的；定义标识符时不能采用系统的保留字。

9.C解析：C++语言中的类是可以组成层次结构的，类是用于描述事物的属性和对事物的操作，类与类之间有相对的独立性，但其可以通过一些方法进行信息的通信。

10.C解析：在给数组赋值时，可以用一个字符串作为初值，这种方法直观、方便，而且符合人们的习惯。

数组array的长度不是5，而是6，这点必须要注意。

因为字符串常量的最后由系统加上一个'\\0'，因此，上面的初始化与下面的等价:
Char array[ ] ＝{'C','h','i','n','a','\\0'};
11.B解析：“后进先出”表示最后被插入的元素最先能被删除。

选项A中，队列是指允许在—端进行插入、而在另一端进行删除的线性表，在队列这种数据结构中，最先插入的元素将最先能够被删除，反之，最后插入的元素将最后才能被删除，队列又称为“先进先出”的线性表，它体现了“先来先服务”的原则：选项B中，栈顶元素总是最后被插入的元素，从而也是最先能被删除的元素，栈底元素总是最先被插入的元素，从而也是最后才能被删除的元素。

队列和栈都届于线性表，它们具有顺序存储的特点，所以才有“先进先出”和“后进先出”的数据组织方式。

双向链表使用链式存储方式，二叉树也通常采用链式存储方式，它们的存储数据的空间可以是不连续的，各个数据结点的存储顺序与数据元素之间的逻辑关系可以不一致。

所以选项C和选项D错误。

本题的正确答案为选
项B。

12.A
13.A
在c++中定义数组时，数组的范围参数在静态定义时必须是一个常数，而在动态分配内存定义时可以是常数，也可以是一个赋了值的参数故选项A是错误的定义方法。

14.DD。

【解析】使用ifstream流类定义流对象并打开磁盘文件时，文件没有默认的打开方式。

其中ios：：in是为输入而打开；iso：：out是为输出而打开。

15.C
C。

【解析】每调用一次get函数时，对新的类A对象进行一次实例化，调用一次构造函数，类A的静态成员变量b便加1。

16.A解析：关系模型由关系数据结构、关系操作集合和关系完整性约束三部分组成。

17.B解析：派生类对象的数据结构是由基类中说明的数据成员和派生类中说明的数据成员共同构成，所以不能继承基类的构造函数，必须重新定义。

18.B
本题考查公用继承对基类成员的访问属性。

在公用继承中，基类的公用成员和保护成员在派生类中保持原有的访问属性，其私有成员仍为基类私有。

本题中想要输出Base：：fun，则必须调用基类的公用成员函数fun，所以使用Base：：fun；来调用基类的成员函数fun。

D。

【解析】在C＋＋中，标识符只能以字母、数字和下画线组成，并且首字母不能为数字。

所以D选项错误。

20.A解析：const int * p;是只能改变指针地址，int * const p;是只能改变* p的内容，const int * const p;是指针的地址和* p的内容都不能改变，int * p;是两者都能改变。

21.B
B。

【解析】this指针是成员函数所属对象的指针，是指向类对象的地址，是一个隐含的指针，隐含于每个类的非静态成员函数中。

funl是
外部函数，fun3是友元函数，fun4是静态成员函数，故选B。

22.BB。

【解析】在C＋＋程序中的typename是都可以替换为class的，但class不能都替换为typename。

23.A\n一般函数进行调用时，要将程序执行权转到被调用函数中．然后再返回到调用它的函数中；而内联函数在调用时，是将调用表达式用内联函数体来替换，一般只将{将规模很小而使用频繁的函数声明为内联函数，可以避免函数调用时间开销，从而提高运行速度。

\n
24.246246 解析：本题考核函数调用和静态变量。

在主函数中通过一个for循环调用了3次fun()函数。

第1次调用fun()函数时，a的初始值为0，执行语句“a+=2;”后，a的值为2，输出2。

第2次调用时，a的初始值为2，执行语句“a+=2；”后，a的值为4，最后输出4。

第3次调用时，a的初始值为4，执行语句“a+=2；”后，a的值为6，最后输出6。

26.BBBBAACCBBBBAACC 解析：本题考核虚函数。

本题中，函数f()在基类AA中派生类CC中都声明为虚函数，所以采用动态联编。

主函数首先定义类AA的对象aa和指针对象p，然后定义了类BB的对象bb，此时调用了类BB的构造函数输出BB。

再定义类CC的对象cc，由于类CC是类BB的派生类，所以此时又调用类BB的构造函数输出BB。

最后执行语句“p=&cc；p-＞f()；”，输出AA和CC。

27.后续节点(后继节点)后续节点(后继节点) 解析：链式存储结构的节点中，只有一个指示直接后继的指针域。

因此从某个点出发，只能顺指针往后寻查其他节点。

若要寻查节点的直接前驱，则需要从表头指针出发，影响查找效率。

为了克服单链表这种单向性的缺点，可利用双向链表。

双向链表的节点中，有两个指针域，其一指向直接后继，另一个指向直接前驱。

28.eout＜＜Base：：a。

eout＜＜Base：：a。

解析：本题考查的是基类和派生类的构造函数。

派生类构造函数的执行顺序：首先调用基类的构造函数，调用顺序按它们被继承时说明的顺序；然后调用子对象的构造函数，调用顺序按它们在类中说明的顺序；最后是派生类构造函数中的内容。

本题要求结果是输出12，分析题目，首先调用基类的构造函数，然后是调用子对象的构造函数，横线处要求输出基类成员a的值，填入tout ＜＜Base：：a即可。

29.44 解析：本题考查的是考生分析简单循环结构的能力。

大体过程为第1次进入循环，i变成7，num变为1，i变为6；第2次进入循环，i变成5，num变为2，i变为4；第3次进入循环，i变成3，num变为
3，i变为2；第4次进入循环，i变成1，num变为4，i变为0，循环结束。

30.T &xT &yT &zT &x，T &y，T &z 解析：本题要填入的是函数的形参表。

此函数的功能是：x、y和z按从小到大的顺序排列，那么就涉及到改变传入的实参值的情况，因此要采用引用传递的方式。

所以此题空白处应填入：T &x，T &y，T &z。

31.friend class B
32.控制流控制流
33.事务型事务型解析：数据流图中有众多的加工，但必有一个加工是起核心作用的，这样的加工称为中心加工。

由数据流图导出结构图的关键是找出中心加工。

一般来说，中心加工有两种存在形态，即数据流图有两种典型的结构形式：一种是变换型，另一种是事务型。

34.55 解析：因为b的值为1，所以b && a＜5 相当于a＜5，当a＝5时退出循环，一共进行5次循环。

35.存储结构存储结构解析：数据的逻辑结构在计算机存储器内的表示，称为数据的存储结构。

36.(1)应改为“ein．getline(str，120，?)；”。

\n(2)应改为“while(str[i])”。

\n(3)应改为“if(str[i]>=a＆＆str[i]<=2)”。

\n【解析】本题中要求以输入字符“?”为结束符，用于字符输入的流成员函数getline函数读入一行字符，格式为“cin．getline(字符数组，字符个数，终止标志字符)”，所以第1处改为“cin．getline(str，120，?)；”。

第2处的“while(str)”语句应该是判断字符串str中的每一个字符是否为结
束符，若不是结束符，在循环中判断每一个字符是否为小写，若为小写，则转换。

所以应该修改为“while(str[i])”。

第3处的“if(str[i]>=a)”语句是判断字符str[i]是否为小写字符，而现有的语句只是判断字符是否大于a，但是小写字符应该是a到2，所以修改为“if(str[i]>=a＆＆str[i]>=z)”。

37.(1)“voidmain”。

(2)“intm=0144；”。

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

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

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

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

38.(1)应改为“TCobjl(1)；”。

\n(2)应改为“0bj1．SetNumber(10)；”。

\n(3)应改为“0bj2．SelNumber(100)；”。

\n【解析】本题第1处的“TCobjl；”语句是声明TC类的对象0bj1，根据TC类构造函数的定义TC(inti)，存在整型参数，并且题目要求第一个输出结果两1，所以补全参数1，即第1处的“TCobjl(1)；”。

第2处处的
“objl．number=10；”应该是调用成员函数SetNumber赋值。

在C＋＋中成员函数的使用形式应该是：对象名．成员函数，所以修改为“obj1．SetNumber(10)；”。

类是对象的抽象，而对象是类的具体实例。

第3处“TC．SetNumber(100)；”语句中的TC为类，并不是对象，这里应该使用定义的对象，即obj2，所以将语句修改为“obj2．SetNumber(100)；”。

39.(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；”。

40.(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：：。