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

2023年广东省江门市全国计算机等级考试C++语言程序设计真题(含答案) 学校:________ 班级:________ 姓名:________ 考号:________
一、1.选择题(10题)
1. 下面的函数原型非法的是______。

A.void f(int a=1，int b=1)
B.int f(double f，char s，int i=1，int j)
C.void f(int a, int b)
D.int f(double f，char s，int i=1，int j=0)
2. 下列叙述中正确的是
A.在模块化程序设计中，一个模块应尽量多的包括与其他模块联系的信息
B.在自顶向下、逐步细化的设计过程中，首先应设计解决问题的每一个细节
C.在模块化程序设计中，一个模块内部的控制结构也要符合结构化原则
D.在程序设计过程中，不能同时采用结构化程序设计方法与模块化程序设计方法
3.结构化程序设计主要强调的是______。

A.程序的规模
B.程序的易读性
C.程序的执行效率
D.程序的可移植性
4. 二叉树是节点的有限集合，它有( )根节点。

A.有0个或1个
B.有0个或多个
C.有且只有1个
D.有1个或1个以上
5. 当输入“Thank you”时下列程序的输出结果为( )。

#include＜iostream.h＞#include＜iomanip.h＞void main() { char line[80]；cin.getline(line,sizeof(80)，'k')；cout＜＜line；}
A.Tha
B.Thank you
C.Thank
D.以上结果都不对
6. 下列描述中错误的是
A.析构函数可以被继承
B.虚函数不能被继承
C.派生类可以有多个基类
D.纯虚基类的子类可以是虚基类
7. 有如下定义语句：int a[]={1,2,3,4,5}；，则对语句int*p=a；正确的描述是( )。

A.语句int*p=a；定义不正确
B.语句int*p=a；初始化变量p，使其指向数组对象a的第一个元素
C.语句int*p=a；是把a[0]的值赋给变量p
D.语句iht*p=a；是把a[l]的值赋给变量p
8.数据库设计包括两个方面的设计内容，它们是()。

A.概念设计和逻辑设计
B.模式设计和内模式设计
C.内模式设计和物理设计
D.结构特性设计和行为特性设计
9. 为了取代C中带参数的宏，在C+十中使用
A.重载函数
B.内联函数
C.递归函数
D.友元函数
10. 下列程序的运行结果为( )。

#include＜iostream.h＞void main() { int a=2；int b=a+1；cout＜＜a/b＜＜endl；}
A.0.66667
B.0
C.0.7
D.0.66666666…
二、单选题(13题)
11.下列关于赋值运算符“=”重载的叙述中，正确的是
A.赋值运算符只能作为类的成员函数重载
B.默认的赋值运算符实现了“深层复制”功能
C.重载的赋值运算符函数有两个本类对象作为形参
D.如果已经定义了复制(拷贝)构造函数，就不能重载赋值运算符
12. 下列程序的输出结果是#include＜iostream．h＞int min(int a，int b) { if(a＜b)return a；else return b；return 0；} void main() { cout＜＜min(1，min(2，3))＜＜end1；}
A.0
B.1
C.2
D.3
13.有下列程序：
#include<stdi0．h>
voidf(int*P，int*q)；
voidmain（）
(intm=1，n=2，*r=＆m；
f(r，＆n)；printf("％d，％d"，m，n)；
}
voidf(int*P，int*q)
{p=p＋1；*q=*q＋1；}
程序运行后的输出结果是（）。

A.1，3 B.2，3 C.1，4 D.1，2
14.下面对静态数据成员的描述中，正确的是( )。

A.静态数据成员可以在类体内进行初始化
B.静态数据成员不可以被类的对象调用
C.静态数据成员不能受private控制符的作用
D.静态数据成员可以直接用类名调用
15. 派生类的构造函数的成员初始化列表中，不能包含( )。

A.基类的构造函数
B.派生类中子对象的初始化
C.基类的子对象初始化
D.派生类中一般数据成员的初始化
16.下列程序的运行结果是( )。

#include<iostream．h>
class A
{
int a；
public：
A{a=0；}
A(int aA．
{
a=aa；
cout<<a++：
}
}；
void main
{
A X，Y(2)，z(3)；
cout<<end
A.00
B.23
C.34
D.25
17.有如下函数模板声明：template＜typenameT> TMax(Ta，Tb){return(a>b)？a：b；} 下列对函数模板Max（）的调用中错误的是（）。

A.Max(3．5，4．5)
B.Max(3．5，4)
C.Max＜double>(35，4．5)
D.Max＜double>(3．5，4)
18.
19.设计数据库的存储结构属于（）。

A.需求分析
B.概念设计
C.逻辑设计
D.物理设计
20.关于静态数据成员的描述中正确的是（）。

A.类的静态数据成员不是类的所有对象共享的数据
B.类的静态数据成员不能被类的成员函数调用
C.类的静态数据成员不能被类的构造函数调用
D.类的静态数据成员必须进行初始化
21.当派生类从一个基类保护继承时，基类中的一些成员在派生类中成为保护成员，这些成员在基类中原有的访问属性是（）。

A.任何
B.公有或保护
C.保护或私有
D.私有
22.以下不能输出字符A的语句是()。

(注：字符A的ASCIl码值为65，字符a的ASCIl码值为97)
A.printf ("%c \n",'a'-32)
B.printf("%d \n",'A')
C.printf("%c \n",65)
D.printf("%c \n",'b'-1)
23.下列定义中P指向的地址可更改，但*P不能够更改的是（）。

A.constint*P；
B.int*constP；
C.constint*constP；
D.int*P；
三、2.填空题(12题)
24. 以下程序运行后的输出结果是【】。

#include ＜iostream＞
#include ＜string＞
using namespace std;
class Y;
class X
{
int x;
char *strx;
public:
X(int a, char *str)
{
x=a;
strx=new char[strlen(str)+l]; strcpy(strx,str);
}
void show(Y &ob) ;
};
class Y
{
private:
int y;
char *stry;
public:
Y(int b,char *str)
{
y=b;
stry=new char[strlen(str)+l]; strcpy(stry, str);
}
friend void X::show(Y &ob) ; };
void X::show(Y &ob)
{
cout＜＜strx＜＜",";
cout＜＜ob.stry＜＜end1;
}
int main()
{
X a(10,"stringX");
Y b(20,"stringY");
a. show (B) ;
return 0;
}
25. 在一个有n个元素的顺序表的第i个元素(1≤i≤n)之前插入一个新元素时，需要向后移动【】个元素
26. 下面程序的运行结果是【】和【】。

#include＜iostream.h＞
#define N 10
#define s( x ) x*x
#define f( x ) ( x*x )
void main( )
{int i1,i2；
i1=1000/s(N);i2=1000/f(N)；
cout ＜＜i 1 ＜＜" " ＜＜i2；
}
27. 类ostream的成员函数______用于执行无格式输出，成员函数______用于输出单个字符。

28. 在面向对象方法中,______描述的是具有相似属性与操作的一组对象。

29. 数据库系统阶段的数据具有较高独立性，数据独立性包括物理独立性和【】两个含义。

30. 基类为虚函数，撤销对象调用析构函数时，采用______联编。

31. 以下程序的输出结果是【】。

#include＜iostream．h＞
void main( )
{ char s[ ]="abcdef"；s[3]='\0'；
cout＜＜s＜＜endl；}
32. 请将下列栈类Stack的横线处补充完整。

class Stack{
private:
int pList[100]; ∥int数组，用于存放栈的元素
int top; ∥栈顶元素(数组下标)
public:
Stack():top(0){}
void Push(const int &item); ∥新元素item
33. 以下程序运行后的输出结果是【】。

#include ＜iostream.h＞
main()
{
int i=10,j=0;
do
{
j=j+ i; i--;
}
while(i＞2);
cout＜＜j;
}
34. 有如下程序：
#include＜iostream＞
using namespace std；
template＜typename T＞
T total(T*data){
T s=0；
While(*data)s+=*data++；
return s；
}
int main(){
int x[]={2，4，6，8，10，12，14，16，18}；
cout＜＜total(x)；
return 0；
}
执行上面程序的输出是______。

35. 在深度为5的完全二叉树中，度为2的结点数最多为【】。

四、程序改错题(10题)
36.使用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******
{
COUI<<"Destructor"<<endl：
}
voidmain
{
TCa；
a．display；
}
37.使用VC＋＋6．0打开考生文件夹下的源程序文件1．cpp，该程序运行时有错。

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

试题程序：
#include<iostream．h>
／／******error******
voidmain
{
／／******error******
intm=0142：
／／******error******
intn=0X27：
cout＜＜m＜＜endl；
cout＜＜n＜＜endl；
cout＜＜q＜＜endl；
return；
}
38.使用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；
}
39.使用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；
}
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，该程序运行时有错误，请改正错误，使程序正常运行，并且要求最后一个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，该程序运行时有错误，请改正程序中的错误，使得程序输出：
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；
}
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，该程序运行时有错，请改正其中的错误，使程序正常运行，并使程序输出的结果为：
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；
}
45.使用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；
}
五、综合应用题(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.使用VC＋＋6．0打开考生文件夹下的源程序文件3．cpp。

类People包括姓名和年龄两个字段。

函数fun获得年龄比较大的人的姓名，然后输出这个姓名到屏幕。

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

(1)完成类的构造函数功能，请在注释1后添加适当的语句。

(2)完成构造函数对姓名的赋值，请在注释2后添加适当的语句。

(3)定义类的友元函数fun，请在注释3后添加适当的语句。

(4)补充函数fun的年龄比较功能，请在注释4后添加适当的语句。

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

试题程序：
#include<iostream．h>
classPeople
{
public：
／／********1********
{
inti；
for(i=0；sUserName[i]!=0；i＋＋)
{m_UserName[i]=sUserName[i]；
}
／／********2********
m_Old=nOld；
}
private：
charm_UserName[32]；
intm_Old；
／／********3********
}；
voidfun(char*s，People＆personl，People＆person2 {
／／********4********
if
{
for(inti=0；personl．m_UserName[i]!=0；i＋
＋)
{
s[i]=personl．m_UserName[i]；
s[i＋1]=0；
}
}
else
{
for(inti=0；person2．m_UserName[i]!=0；i＋
＋)
{s[i]=person2．m_UserName[i]；
s[i＋1]=0；
}
}
}
voidmain
{
chars[32]；
Peoplepl("abc"，20)；
Peoplep2("def"，30)：
fun(S，p1，p2)；
cout<<s<<endl：
return；
}
六、3.综合应用题(2题)
48. 使用VC6打开考生文件夹下的工程test41_3。

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

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

(1)定义类Rectangle的私有数据成员left，top和fight，bottom，它们都是int型的数据。

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

(2)添加类Rectangle的带四个int型参数1、t、r、b的构造函数的声明，并使这四个参数的默认值均为0，请在注释“//**2**”之后添加适当的语句。

(3)添加类Rectangle的成员函数SetTop()参数为int型的t，作用为把t的值赋给类的数据成员top，添加类Rectangle的成员函数SetBottom()参数为int型的t，作用为把t的值赋给类的数据成员bottom，请在注释“//**3**”之后添加适当的语句。

(4)完成派生类Rectangle的成员函数Show()的定义，使其以格式“right-bottom point is(right，bottom)”输出，请在注释“//**4**”之后添加适当的语句。

源程序文件test41_3.cpp清单如下：
#include ＜iostream.h＞
class Rectangle
{
// ** 1 **
int right, bottom;
public:
// ** 2 **
～Rectangle(){};
void Assign(int 1, int t, int r, int b);
void SetLeft(int t){left = t;}
void SetRight(int t){right = t;}
// ** 3 **
void SetBottom(int t){bottom = t;}
void Show();
};
Rectangle::Rectangle(int 1, int t, int r, int b)
{
left = 1; top = t;
right = r; bottom = b;
}
void Rectangle::Assign(int 1, int t, int r, int b)
{
left = 1; top = t;
right = r; bottom = b;
}
void Rectangle::Show()
{
cout＜＜"left-top point is ("＜＜left＜＜","＜＜top＜＜")"＜＜'\n';
// ** 4 **
}
void main()
{
Rectangle rect;
rect.Show();
rect.Assign(100,200,300,400);
rect.Show();
}
49. 使用VC6打开考生文件夹下的工程test33_3。

此工程包含一个test33_3.cpp，其中定义了表示时间的类Time，但Time类定义并不完整。

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

(1)定义类Time的私有数据成员hours、minutes和seconds，它们都是int 型的数据，分别表示时间的小时、分和秒。

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

(2)完成类Time缺省构造函数的定义，该函数将数据成员hours、minutes 和seconds的值初始化为0，请在注释“//** 2**”之后添加适当的语句。

(3)完成类Time带参构造函数的定义，该函数将数据成员hours、minutes 和seconds的值分别初始化为参数h、m和s的值，请在注释“//**3**”
之后添加适当的语句。

(4)完成类Time中运算符“+”的重载，注意小时、分和秒在相加时的进位问题。

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

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

程序输出结果如下：
8：17：11
源程序文件test33_3.cpp清单如下：
#include ＜iostream.h＞
class Time
{
//** 1 **
public:
Time ( )
{
//** 2 **
seconds=0;
}
Time(int h, int m, int s)
{
//** 3 **
minutes=m;
seconds=s;
}
Time operator +(Time&);
void gettime();
};
Time Time::operator +(Time& time)
{
//** 4 **
s=time.seconds+seconds;
m=time.minutes+minutes+s/60;
h=time.hours+hours+m/60;
Time result(h,m%60,s%60);
return result;
}
void Time::gettime()
{
cout＜＜hours＜＜":"＜＜minutes＜＜":"＜＜seconds＜＜end1;
}
void main( )
{
Time t1(3,20,15),t2(4,56,56),t3;
t3=t1+t2;
t3.gettime();
}
参考答案
1.B
2.C解析：在模块化设计中，要求将一个大程序按人们能理解的大小规模进行分解，使每个模块都能易于理解，各模块的功能尽量单一，各模块之间的联系尽量的少。

因此，选项A中的说法是错误的。

自顶向下、逐步细化的设计过程，主要包括两个方面：一是将一个复杂问题的解法分解和细化成由若干模块组成的层次结构；二是将一个模块的功能逐步分解细化为一系列的处理步骤，直到某种程序设计语言的语句或某种机器指令。

即在自顶向下、逐步细化的设计过程中，是按照先全局后局部，先整体后细节、先抽象后具体的方法设计程序。

因此．选项B中的说法也是错误的。

\u3000在模块化程序设计中．每一个模块完成一个功能，相对独立，要求一个模块内部的控制结构也要符合结构化原则。

因此，选项C中的说法是正确的。

由于在模块化程序设计中，一个模块内部的控制结构也要符合结构化原则，因此，在程序设计过程中，结构化程序设计方法与模块化程序设计方法是要同时采用的。

因此，选项D中的说
法是错误的。

3.B解析：采用结构化编程方法的好处主要在于：一是便于控制、降低程序的复杂性，因此便于编写程序。

二是程序清晰易读，可理解性好。

因此，结构化程序设计主要强调的是程序的易读性，而不是程序的规模、程序的执行效率和程序的可移植性。

4.A解析：二叉树是一种特殊的树，它要求非空二叉树只有一个根节点，所以它可以是空树。

答案为A。

5.A
6.B解析：本题考查关于C++语言基类中虚函数的继承问题。

C++语言中基类的虚函数是可以被派生类继承的。

7.B
8.A解析：模式设计和内模式设计是概念设计的两种方法。

物理设计是根据特定的计算机系统，对数据的存储结构和存取方法进行设计，从而实现从逻辑结构到物理结构的转换。

从系统开发的角度来看，结构特性设计和行为特性-设计是数据库应用系统所具有的两个特性。

结构特性的设计，设计各级数据库模式(静态特性)：行为特性的设计，改变实体及其特性，决定数据库系统的功能(动态特性)。

9.B解析：内联函数是inline，当程序中出现对该函数的调用时，编译器使用函数体中的代码插入到调用该函数的语句处，同时用实参代替形参。

一般在程序运行时不再进行函数调用，代替了C语言中的宏定义。

10.B解析：因为题目中定义的变量a和b均为整型数据，所以a/b即2/3得到的仍然是整型数据，得到0。

11.A
解析：=、[]、()、->以及所有的类型；转换运算符只能作为成员函数
重载，A项正确。

默认的赋值运算符只实现了浅层复制，B项错误。

赋值运算符只能作为成员函数重载，形参表中只有一个参数，对应于
第二操作数，C项错误。

一个类中如果需要重载运算符“="，通常也
就需要定义自己特有的复制构造函数，反之亦然，故D项错误。

12.B解析：本题考查的是函数的调用，第一次调用min(2，3)，因为2＜3，所以返回值为2，第二次调用min(1，2)，因为1＜2，所以返回1。

13.A
A。

【解析】本题中子函数f(int*p，*q)的功能是对指针p的值加1，
*q的值加1。

主函数中调用子函数f(r，＆n)时，子函数的执行结果是r 值加1，n的值加1。

而m的值并没有发生变化，最后程序输出的结果为1，3。

所以正确答案为选项A。

14.D解析：静态数据成员必须在类体外初始化，它是类的所有对象的共有成员，需要使用类名调用，静态数据成员的初始化与权限控制无关。

15.C解析：本题考核构造函数。

在C++中，构造函数不能被继承，因此，派生类的构造函数必须通过调用基类的构造函数来初始化基类子对象。

所以，在定义派生类的构造函数时，除了对自己的数据成员进行初始化外，还必须负责调用基类构造函数使基类的数据成员得以初始化。

如果派生类中还有子对象，还应包含对子对象初始化的构造函数．但是它不负责基类中子对象的初始化。

16.B
本题考查的是对构造函数的掌握，另外“++”运算符是右结合的，所以在进行输出的时候都是先把原来的输出后再自加l。

17.B
B。

【解析】本题考查函数模板的引用。

引用模板函数和引用一般函数在语法形式上基本相同。

需要注意的是，说明一个函数模板后，当编译系统发现有一个对应的函数调用时，将根据实参中的类型来确认是否调用函数模板中的对应形参。

本题选项B中，编译系统从第一个参数“3．5”获得信息“double型数据”和从第二个参数获得信息“int型数据”，两者矛盾。

18.D
19.D
D。

【解析】物理设计阶段主要解决选择文件存储结构和确定文件存取方法的问题。

物理设计阶段包括：选择存储结构、确定存取方法、选择存取路径、确定数据的存放位置。

20.D解析：C＋＋类中的静态成员变量是该类中所有对象所共有的，它能够被类中的任何函数调用，所以选项A) 、选项B) 、选项C) 是错误的。

而类的静态数据成员是必须要进行初始化才能使用的。

21.B
B。

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

22.B
B选项输出的格式为％d，即为整型格式，所以输出字符A的ASCI1
码值65，而不是字符A。

由于大写字母比与其对应的小写字母的
ASCI1码值小32，所以A正确。

字符A的ASCI1码值就是65，所以以％C格式输出可以输出字符A，所以C正确。

由于字符A的ASCI1码值比字符B的小1，所以D正确。

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

24.string Xstring Ystring X,string Y 解析：本题考核类的定义和友元函数的应用。

①该程序中，类X的成员函数show()在类Y中说明为友元，因此，在该友元成员show()中可以访问类Y的私有成员stry。

②成员函数show()的功能就是输出类X的私有成员strx和Y对象ob的私有成员stry。

③主函数中定义了X类的一个对象a和Y类的一个对象b，并且都进行了初始化。

然后调用对象a的成员函数show()，输出对象a中私有成员strx中的内容和对象b中私有成员stry中的内容，即字符串stringX和stringy。

25.n-i+1n-i+1 解析：在一般情况下，要在第i个元素之前插入一个新元素时，首先是从最后一个元素开始，直到第i个元素之间共n-i+1个元素依次向后移动一个位置。

26.1000 101000\r\n10 解析：对于define宏定义语句，系统会在编译前进行替换。

本题替换过程如下：
il=1000/s(N)
il=1000/s(10)
il=1000/10*10
il=1000
i2=1000/f(N)
i2=1000/f(10)
i2=1000/(10*10)
i2=10
27.write、put
28.类类
29.逻辑独立性逻辑独立性解析：数据独立性是数据与程序间的互不依赖性，即数据库中数据独立于应用程序而不依赖于应用程序。

数据独立性一般分为物理独立性与逻辑独立性两个含义。

注意：在人工管理阶段，文件系统阶段和数据库管理阶段中数据独立性的特点。

30.动态动态
31.abcabc 解析：本题中，给数组s中的第4个元素s[3]赋以'\\0'，则s 数组中只有前3个元素有效，输出结果为abc。

32.pList[top]=itempList[top]=item 解析：此题考查的是堆栈数据结构。

堆栈是一种先进后出的队列，每次入栈在栈顶，出栈也在栈顶。

当栈顶指针所指位置是最后一个有效数据时，下次出栈直接取出栈顶指针所指数据，然后栈顶指针再减1；入栈时需要将栈顶指针先增1，然后将数据存入栈顶指针所指位置。

本题中，从Pop()数中可以看出，是先取数然后top才会减1，Push()函数应先增1再取数。

所以应填入pList[top]=item。

33.52
34.20
35.15
36.(1)应改为“TC：：TC”。

(2)应改为“voidTC：：display”。

(3)应改为“TC：：～TC”。

【解析】在类的外部定义成员函数时，必须在成员函数前面加上类名和作用域运算符“：：”，作用域运算符用采表示某个成员属于哪个类，使用格式为“(类名)：：<成员函数>((参数函数))，因此第1处应改为“TC：：TC”，默认构造函数没有参数。

由第2处“TC：：display”后的语句看，这是在类外实现TC函数，因此也有作用域运算符使用错误问题，display函数返回值为void，因此第2处的语句应改为“voidTC：：display”。

由第3处的语句“TC：：TC”可知，显然这里是在类外实现析构函数，析构函数是一个特殊的函数，它的名称和类名相同，并在前面加“～”字符，用采与构造函数加以区别，因此第3处的语句应改为“TC：：～TC”。

37.(1)“voidmain”。

(2)“intm=0144；”。

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

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

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

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

38.(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])；”。

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

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

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

【解析】本题第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)；”。

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

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

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

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

第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])；”。

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

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