2008年9月计算机等级考试二级C++笔试试题答案与解析

2008年9月计算机等级考试二级C++笔试试题

一、选择题（每小题2分，共70分）

（1）一个栈的初始状态为空。现将元素 1、2、3、4、5、A、B、C、D、E 依次入栈，然后再依次出栈，则元素出栈的顺序是（B）。

A）123456ABCDE        B）EDCBA54321

C）ABCDE12345                 D）54321EDCBA

【答案】B）EDCBA54321

【解析】栈的规则是：先进后出，是我们公共基础的重点考点。栈和队列是每年必考的题目。

栈是一种特殊的线性表，这种线性表只能在固定的一端进行插入和删除操作，允许插入和删除的一端称为栈顶，另一端称为栈底。一个新元素只能从栈顶一端进入，删除时，只能删除栈顶的元素，即刚刚被插入的元素。这表明栈的运算规则是“先进后出”(或称“后进先出”)。在栈顶进行插入运算，称为进栈(或入栈)，在栈顶进行删除运算，称为退栈(或出栈)。本题中，依次进栈，即依次插入元素1、2，3、4、5、A、B、C、D、E，依次出栈，即依次删除元素，根据栈“先进后出”的规则，应该以倒序出栈。即元素出栈顺序为EDCBA54321。

【再如问题】一个栈的初始状态为空。首先将元素5，4，3，2，1 依次入栈，然后退栈一次，再将元素A，B，C，D 依次入栈，之后将所有元素全部退栈，则所有元素退栈（包括中间退栈的元素）的顺序为？为什么答案是 1DCBA2345？

栈是先进后出，后进先出。所以“首先将元素5，4，3，2，1 依次入栈，然后退栈一次”这次退栈出来的是1，栈中剩下素为5，4，3，2。再将元素A，B，C，D，依次入栈栈中元素为5，4，3，2，A，B，C，D，然后出栈，先进后出，可知序列为D，C，B，A，2，3，4，5加上先前出的则所有元素退栈（包括中间退栈的元素）的顺序为1DCBA2345

 

（2）下列叙述中正确的是（D）。

A）循环队列有队头和队尾两个指针，因此，循环队列是非线性结构

B）在循环队列中，只需要队头指针就能反映队列中元素的动态变化情况

C）在循环队列中，只需要队尾指针就能反映队列中元素的动态变化情况

D）循环队列中元素的个数是由队头指针和队尾指针共同决定

【答案】D）

 

（3）在长度为 n 的有序线性表中进行二分查找，最坏情况下需要比较的次数是（C）。

A）O(n)                              B）O(n2)

C）O(log2n)                 D）O(nlog2n)

【答案】C）O(log2n)  

[知识点] 二分查找法的时间复杂度

【解析】二分法检索要求线性表结点按关键值排序且以顺序方式存储。二分查找法也称为折半查找法。二分法检索的效率比较高，它的基本思想是：在查找时，将 n 个元素分成个数大致相同的两组，取 a[n/2]与欲查找的 x 作比较。如果 x=a[n/2]，则找到 x，算法终止；如果 x<a[n/2]，则只要在数组 a 的左半部继续搜索 x（这里假设数组元素呈升序排列）；如果 x>a[n/2]，则只要在数组 a的右半部继续搜索 x。每次余下的 n/2个元素待比较，当最后剩下一个时，即 n/2 =1。故，n=2 ，  比较的次数i=log2n。

（4）下列叙述中正确的是（A）。

A）顺序存储结构的存储一定是连续的，链式存储结构的存储空间不一定是连续的

B）顺序存储结构只针对线性结构，链式存储结构只针对非线性结构

C）顺序存储结构能存储有序表，链式存储结构不能存储有序表

D）链式存储结构比顺序存储结构节省存储空间

【答案】A）

知识点] 顺序存储结构和链式存储结构

【解析】顺序存储结构就是用一组地址连续的存储单元依次存储该线性表中的各个元素，链式存储结构中各数据结点的存储序号是不连续的，并且各结点在存储空间中的位置关系与逻辑关系也不一致，所以选项A是正确的。

顺序存储方式是把逻辑上相邻的结点存储在物理上相邻的存储单元里，结点之间的关系由存储单元的邻接关系来体现。顺序存储方式的优点是占用最少的存储空间，所以选项 D 错误。

顺序存储结构可以存储如二叉树这样的非线性结构，所以选项 B 错误。

链式存储结构也可以存储线性表，所以选项C 错误。

 

（5）数据流图中带有箭头的线段表示的是（D）。

A）控制流                          C）模块调用

B）事件驱动                       D）数据流

【答案】D）数据流

【知识点】数据流图的表示

【解析】在数据流图中，矩形表示数据的外部实体，圆角的矩形表示变换数据的处理逻辑，双横线表示数据的存储，箭头表示数据流。

矩形表示数据的外部实体，是系统和环境的接口，属系统之外的实体。

双横线表示存储文件(数据源)：表示处理过程中存放各种数据的文件。

箭头表示数据流：沿箭头方向传送数据的通道，一般在旁边标注数据流名。

 

（6）在软件开发中，需求分析阶段可以使用的工具是（B）。

A）N-S 图                         B）DFD 图（数据流图）

C）PAD 图                         D）程序流程图

 【答案】B）DFD 图（数据流图）

【解析】知识点：软件开发。软件开发阶段包括需求分析、总体设计、详细设计、编码和测试5个阶段。其中需求分析阶段常用的工具是数据流图(简称DFD)和数据字典(简称DD)。常见的详细设计的图形描述工具主要有程序硫程图、N-S结构图、问题分析图(简称PAD图)。

数据流图简称 DFD 图，采用图形方式来表达系统的逻辑功能、数据在系统内部的逻辑流向和逻辑变换过程，是结构化系统分析方法的主要表达工具及用于表示软件模型的一种图示方  法。所以 DFD 图可以用于需求分析阶段。

 

（7）在面向对象方法中，不属于“对象”基本特点的是（A）。

A）一致性                          B）分类性

C）多态性                          D）标识唯一性

【答案】A

【解析】面向对象方法中最基本的概念是对象，它的基本特点有：标识唯—性、分类性、多态性、封装性和模块独立性好。

 

（8）一间宿舍可住多个学生，则实体宿舍和学生之间的联系是（B）。

A）一对一                          B）一对多

C）多对一                          D）多对多

【答案】B）一对多

【解析】一间宿舍可以住多个学生，但每个学生只能住一个宿舍，所以宿舍和学生之  间是一对多关系。

[知识点] E-R模型的基本概念。

两个实体间的联系可以归纳为3种类型：一对一联系：一对一的联系表现为主表中的每一条记录只与相关表中的一条记录相关联。一对多联系或多对一：一对多的联系表现为主表中的每一条记录与相关表中的多条记录相关联。多对多联系：多对多的联系表现为一个表中的多个记录在相关表中同样有多个记录与其匹配。

 

（9）在数据管理技术发展的三个阶段中，数据共享最好的是（C）。

A）人工管理阶段        B) 文件系统阶段

C）数据库系统阶段     D) 二个阶段相同

【答案】C）数据库系统阶段    

 【解析】[知识点]数据库管理技术的发展特点。数据库管理发展至今已经历了三个阶段：人工管理阶段、文件系统阶段和数据库系统阶段。

（1）人工管理阶段：计算机出现的初期，主要用于科学计算，没有大容量的存储设备。处理方式只能是批处理，数据不共享，不同程序不能交换数据。人工管理阶段的特点：数据不保存、数据不独立、数据不能共享、数据无结构，没有专门的数据管理软件。

（2）文件系统阶段：把有关的数据组织成一种文件，这种数据文件可以脱离程序而独立存在，由一个专门的文件管理系统实施统一管理。但是，数据文件仍高度依赖于其对应的程序，不能被多个程序通用。文件系统阶段的特点：数据可以长期保存，有专门的数据管理软件——文件系统。但是数据独立性低，共享性差、冗余度大，数据记录内有结构，整体无结构。

（3）数据库系统阶段：对所有的数据实行统一规划管理，形成一个数据中心，构成一个数据仓库，数据库中的数据能够满足所有用户的不同要求，供不同用户共享，数据共享性显著增强。数据库系统阶段的特点：数据结构化，数据独立性高，数据共享性高，冗余度小，易于扩充，数据库管理系统提供统一的数控制功能，包括数据安全性、完整性、并发控制和数据恢复功能。

故本题答案为 C。

 

（10）有三个关系 R、S 和 T 如下：

 R           S          T

A

B

 

B

C

  

A

B

C

m

1

1

3

m

1

3

n

2

3

5

 

由关系 R 和 S 通过运算得到关系 T，则所使用的运算为（D）。

A）笛卡尔积                      B）交

C）并                                        D）自然连接

【答案】D）自然连接

 【解析】[知识点] 关系代数运算

笛卡尔积：设关系R和S的元数分别是r和s，定义R和S的笛卡尔积是一个(r+s)元元组集合，每一个元组的前r个分量来自R的一个元组，后s个分量来自S的一个元组。若R有k1个元组，s有k2个元组，则关系R和关系S的广义笛卡尔积有k1×k2个元组。

交：设关系R和关系S具有相同的目n，且相应的属性诹自同一个域，则关系R与关系S的交由属于R又属于S的所有元组组成。

并：设关系R和关系S具有相同的目n(即两个关系都有n个属性)，且相应的属性取自同一个域，则关系R与关系S的并由属于R或属于S的元组组成。

自然连接：是一种特殊的等值连接，它要求两个关系中进行比较的分量必须有相同的属性组，并且要将结果中重复的属性去掉。

 

（11）在下列原型所示的 C++函数中，按“传值”方式传递参数的是（A）。

A）void f1(int x);                B）void f2(int*x);

C）void f3(const int*x); D）void f4(int&x);

【答案】A）void f1(int x);

【解析】A）void f1(int x); 整型              B）void f2(int*x);  整型指针

C）void f3(const int*x); 常指针  D）void f4(int&x); 引用符&，按“引用”方式传递参数

 

（12）在 C++中，编译系统自动为一个类生成缺省构造函数的条件是（C）。

A）该类没有定义任何有参构造函数

B）该类没有定义任何无参构造函数

C）该类没有定义任何构造函数

D）该类没有定义任何成员函数

【答案】C）该类没有定义任何构造函数

【解析】如果你没有声明任何构造函数,编译器会自动为你提供一个默认构造函数。

 

（13）在一个派生类的成员函数中，试图调用其基类的成员函数“void f();”，但无法通过编译。这说明（A）。

A）f()是基类的私有成员

C）派生类的继承方式为私有

B）f()是基类的保护成员

D）派生类的继承方式为保护

【答案】A）f()是基类的私有成员

 

（14）下列关于运算符重载的叙述中，错误的是（B）。

A）有的运算符可以作为非成员函数重载

B）所有的运算符都可以通过重载而被赋予新的含义

C）不得为重载的运算符函数的参数设置默认值

D）有的运算符只能作为成员函数重载

【答案】B

运算符重载，就是对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。运算符重载就是赋予已有的运算符多重含义。C++中通过重新定义运算符，使它能够用于特定类的对象执行特定的功能，这便增强了C++语言的扩充能力。

哪些运算符可以用作重载？
大部分的运算符都可用作重载。具体包含：
算术运算符：+,-,*,/,%,++,--;
位操作运算符：&,|,~,^,<<,>>
逻辑运算符：!,&&,||;
比较运算符：<,>,>=,<=,==,!=;
赋值运算符：=,+=,-=,*=,/=,%=,&=,|=,^=,<<=,>>=;
其他运算符：[],(),->,,(逗号运算符),new,delete,new[],delete[],->*。
下列运算符不允许重载： .  .*  ::  ?:

运算符重载后，优先级和结合性怎么办？
用户重载新定义运算符，不改变原运算符的优先级和结合性。这就是说，对运算符重载不改变运算符的优先级和结合性，并且运算符重载后，也不改变运算符的语法结构，即单目运算符只能重载为单目运算符，双目运算符只能重载双目运算符。

 

（15）下列关于模板的叙述中，错误的是（）。

A）调用模版函数时，在一定条件下可以省略模板实参

B）可以用 int、double 这样的类型修饰符来声明模版参数

C）模板声明中的关键字 class 都可以用关键字 typename 替代

D）模板的形参表中可以有多个参数

【答案】B

模板，顾名思义就是类型不固定，就是想什么类型就什么类型。不能用某一个固定类型如int或者double修饰作为类型修饰符来声明模版参数，而是要用一个泛型如templete <class T>，其中T 泛指任意类型。
编译时编译器根据用户指定的特定类型，如 int 来决定声明什么样的函数。

有的人有争议说答案是C，但“模板声明中的关键字 class 都可以用关键字 typename 替代”这是书上写过的。

  

（16）要利用 C++流进行文件操作，必须在程序中包含的头文件是（B）。

A）iostream                        B）fstream

C）strstream                       D）iomanip

【答案】B）fstream

【解析】fstream是一个头文件的名字,属于c++的。

<fstream>库包含了三个基本的类：ifstream, ofstream和fstream。这三个类分别代表一个输入文件,一个输出文件,以及一个输入输出文件。

 

（17）下列字符串中不能作为 C++标识符使用的是（D）。

A）WHILE   B）user   C）_lvar   D）9stars

【答案】D）9stars

 

（18）下列语句中错误的是（A）。

A）const int a;

B）const int a=10;

C）const int*point=0;

D）const int*point=new int(10);

【答案】A）

A语句const int a;错误的原因是定义一个const的常量的时候务必同时进行初始化。

D选项中const int*point=new int(10);意思是定义一个指向初始化为10的int的常量指针，不过很少有这么写的。一般在stl的模板中为了统一，int、char这样写也是可以的。

 

（19）有如下程序：

#include<iostream> 

using namespace std;

int main(){

int sum;

for(int i=0; i<6; i+=3){

sum=i;

for(int j = i; j<6; j++)sum+=j;

}

cout<<sum<<end1;

return 0;

}

运行时的输出结果是（D）。

A）3               B）10          C）12           D）15

【答案】D

【解析】当i=0的时候，因为跳出j循环后将sum重新赋值为sum=i=3，所以可以忽略当i=0，j从0到5的循环后sum的值。

当i=3  j=3，sum=3+3=6

当i=3  j=4，sum=6+4=10

当i=3  j=5，sum=10+5=15跳出j循环和i循环，输出结果15.

 

（20）下列语句中，正确的是（A）。

A）char*myString="Hello-World!";

B）char myString="Hello-World!";

C）char myString[11]="Hello-World!";

D）char myString[12]="Hello-World!";

【答案】A

【解析】定义char字符型变量时，不能直接把字符串"Hello-World!"赋值给myString，所以B是错误的。

关于C和D,编译会报错error C2117: 'Hello-World!' : array bounds overflow数组溢出，若下标改为13或者以上则为对,即可以写为char myString[13]="Hello-World!";也可以写为：char myString[] = "Hello-World!";

 

（21）若已经声明了函数原型“void fun(int a, double b=0.0）;”，则下列重载函数声明中正确的是（C）。

A）void fun(int a=90, double b=0.0);

B）int fun(int a, double B);

C）void fun(double a, int B);

D）bool fun(int a, double b = 0.0);

【答案】C）void fun(double a, int B);

【解析】所谓函数重载是指同一个函数名可以对应着多个函数的实现。例如，可以给函数名add()定义多个函数实现，该函数的功能是求和，即求两个操作数的和。其中，一个函数实现是求两个int型数之和，另一个实现是求两个浮点型数之和，再一个实现是求两个复数的和。每种实现对应着一个函数体，这些函数的名字相同，但是函数的参数的类型不同。这就是函数重载的概念。函数重载在类和对象的应用尤其重要。
函数重载要求编译器能够唯一地确定调用一个函数时应执行哪个函数代码，即采用哪个函数实现。确定函数实现时，要求从函数参数的个数和类型上来区分。这就是说，进行函数重载时，要求同名函数在参数个数上不同，或者参数类型上不同。否则，将无法实现重载。

 

（22）有如下程序：

#include<iostream> 

using namespace std;

class Sample{

public:

Sample(){}

~Sample(){cout<<'*';}

};

int main(){

Sample temp[2], *pTemp[2];

return 0;

}

执行这个程序输出星号（*）的个数为（B）。

A）1              B）2                     C）3                     D）4

【答案】B）2      

【解析】当对象脱离其作用域时（例如对象所在的函数已调用完毕），系统自动执行析构函数。析构函数往往用来做“清理善后” 的工作（例如在建立对象时用new开辟了一片内存空间，应在退出前在析构函数中用delete释放）。

本题中temp[2]生成两个sample对象，*pTemp[2]不生成对象。

当在函数内定义的数组函数Sample temp[2]执行完成后会释放，会调用析构函数，并且是2次，因为数组的个数是2.
但是pTemp[2]定义的是指针数组不会创建对象不用申请内存，所以不会调用析构析构函数。

  

（23）下列选项中，与实现运行时多态性无关的是（A）。

A）重载函数                      B）虚函数

C）指针                                    D）引用

【答案】A）重载函数       

【解析】运行时多态与虚函数有关。派生类的对象可以认为是基类的对象，但基类的对象不是其派生类的对象。因此，C++允许一个基类对象的指针指向其派生类对象，但不允许一个派生类对象指向其基类对象。在调用虚函数的过程中指针和引用会起到一定的作用。

 

（24）下列运算符函数中，肯定不属于类 Value 的成员函数的是（B）。

A）Value operator+(Value);

B）Value operator-(Value, Value);

C）Value operator*(int);

D）Value operator/(Value);

【答案】B

【解析】ABCD四个选项都是重载操作符。但+、-、*、/四个操作符作为成员函数重载只能接收一个参数。如果以非成员函数形式重载的运算符函数原型参数才可以有两个。

减法运算符重载为成员函数其参数只能有一个，所以B是错误的。

 

（25）下列模板声明中，有语法错误的是（D）。

A）template<typename T>T fun(T x){return x;}

B）template<typename T>T fun(T x, int n){return x*n;}

C）template<class T>T fun(T *p){return *p;}

D）template<class T>T classA{T n;};

【答案】D

【解析】ABC均是正确的函数模板。

选项D不是正确的函数模板，但是如果作为类模板表述又有错误，其class前面多了个T,  class 和A中间没空格。选项D的句子template<class T>T classA{T n;};  如果改成template<class T> class A{T n;};则是类模板，语法正确。

 

（26）在语句“cout<<'A';”中，cout 是（B）。

A）类名                             B)对象名

C）函数名                          D)C++的关键字

【答案】B)对象名

 

（27）有如下程序：

#include<iostream> 

using namespace std；

class MyClass{

public: 

MyClass(int i=0){cout<<1;}

MyClass(const MyClass&x){cout<<2;}

MyClass& operator=(const MyClass&x)

{cout<<3; return*this;}

~MyClass(){cout<<4;}

};

int main(){

MyClass obj1(1),obj2(2),obj3(obj1);

return 0:

}

运行时的输出结果是（A）。

A）112444                  B）11114444

C）121444                          D）11314444

【答案】A）112444

【解析】程序是这样执行：
1、首先执行obj1(1)，这是创建一个对象，所以调用与之对应的构造函数，也就是MyClass(int i=0){cout<<1;}，所以先输出1。
2、接着执行obj2(2)，这也是创建一个对象，也调用与之对应的构造函数，也是
MyClass(int i=0){cout<<1;}，，所以又输出1。
3、再执行obj3(obj1)，这一个创建一个对象，但是这是进行对象的拷贝，将对象obj1拷贝给obj3，所以要调用与之对应的拷贝构造函数，也就是MyClass(const MyClass&x){cout<<2;}函数，所以再输出2。
4、再执行return语句，执行return语句后，要对上边创建的三个对象进行析构，要执行三次析构函数，所以输出三次4。
所以最后的输出结果是：112444

 

（28）有如下程序：

#include<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

obj2.Set(30); //语句 4

return 0;

}

其主函数中错误的语句是（C）。 

A）语句 1                          B）语句 2

C）语句 3                          D）语句 4

【答案】C

【解析】关键是在const。const MyClass obj1(10);在类中的成员函数后加一个const表示不能改变类成员函数的值
this是Rational const* const this，限定不能到非限定转换，所以报错。

关于Const函数的几点规则：

1、 const对象只能访问const成员函数,而非const对象可以访问任意的成员函数,包括const成员函数.

2、const对象的成员是不可修改的,然而const对象通过指针维护的对象却是可以修改的.

3、const成员函数不可以修改对象的数据,不管对象是否具有const性质.它在编译时,以是否修改成员数据为依据,进行检查.

4、然而加上mutable修饰符的数据成员,对于任何情况下通过任何手段都可修改,自然此时的const成员函数是可以修改它的

  

（29）在类声明中，紧跟在“public:”后声明的成员的访问权限是（B）。

A）私有        B）公有         C）保护        D）默认

【答案】B

 

（30）对于通过公有继承定义的派生类，若其成员函数可以直接访问基类的某个成员，说明该基类成员的访问权限是（D）。

A）公有或私有                          B）私有

C）保护或私有                          D）公有或保护

【答案】D）公有或保护

 

（31）定义派生类时，若不使用关键字显式地规定采用何种继承方式，则默认方式为（A）。

A）私有继承                             B）非私有继承

C）保护继承                             D）公有继承

【答案】A）私有继承

 

（32）建立一个有成员对象的派生类对象时，各构造函数体的执行次序为（C）。

A）派生类、成员对象类、基类

B）成员对象类、基类、派生类

C）基类、成员对象类、派生类

D）基类、派生类、成员对象类

【答案】C

 

（33）如果表达式 a>=b 中的“>=”是作为非成员函数重载的运算符，则可以等效地表示为（C）。

A）a.operator>=(b)      B）b.operatotr>=(a)

C）operator>=(a,b)     D）operator>=(b,a)

【答案】C

【解析】表达式 a>=b 中的“>=” 作为运算符重载为成员函数其参数只能有一个，但是如果以非成员函数形式重载的运算符函数原型参数是两个。

  

（34）当使用 ofstream 流类定义一个流对象并打开一个磁盘文件时，文件的默认打开方式为（D）。

A）ios base::in

B）ios_base::binary

C）ios_base::in|ios_base::out

D）ios_base::out

【答案】D

 

（35）在一个抽象类中，一定包含有（B）。

A）虚函数                          B）纯虚函数

C）模板函数                      D）重载函数

【答案】B 

【解析】凡是含有纯虚函数的类叫做抽象类。

纯虚函数是一种特殊的虚函数，它的一般格式如下：

class <类名>

{

virtual <类型><函数名>(<参数表>)=0;

…

};

在许多情况下，在基类中不能对虚函数给出有意义的实现，而把它声明为纯虚函数，它的实现留给该基类的派生类去做。这就是纯虚函数的作用。也就是说，纯虚函数可以让类先具有一个操作名称，而没有操作内容，让派生类在继承时再去具体地给出定义。

凡是含有纯虚函数的类叫做抽象类。这种类不能声明对象，只是作为基类为派生类服务。除非在派生类中完全实现基类中所有的的纯虚函数，否则，派生类也变成了抽象类，不能实例化对象。

 

 

二、填空题（每空2分，共30分）

（1）对下列二叉树进行中序遍历的结果_DBXEAYFZC_。

 

  

 

（2）按照软件测试的一般步骤，集成测试应在__单元__测试之后进行。

【解析】根据不同的测试阶段，测试可以分为单元测试、集成测试、系统测试和验收测试。
体现了测试由小到大、又内至外、循序渐进的测试过程和分而治之的思想。

单元测试、集成测试、系统测试的顺序可否调换，为什么？

1、单元测试的粒度最小，一般由开发小组采用白盒方式来测试，主要测试单元是否符合“设计”。
2、集成测试界于单元测试和系统测试之间，起到“桥梁作用”，一般由开发小组采用白盒加黑盒的方式来测试，既验证“设计”，又验证“需求”。
黑盒测试不考虑程序内部结构和逻辑结构，主要是用来测试系统的功能是否满足需求规格说明书。一般会有一个输入值，一个输入值，和期望值做比较。
白盒测试主要应用在单元测试阶段，主要是对代码级的测试，针对程序内部逻辑结构，测试手段有：语句覆盖、判定覆盖、条件覆盖、路径覆盖、条件组合覆盖
集成测试主要用来测试模块与模块之间的接口，同时还要测试一些主要业务功能。
系统测试的粒度最大，一般由独立测试小组采用黑盒方式来测试，主要测试系统是否符合“需求规格说明书”。

3、系统测试是在经过以上各阶段测试确认之后，把系统完整地模拟客户环境来进行的测试
4、验收测试与系统测试相似，主要区别是测试人员不同，验收测试由用户执行。

（3）软件工程三要素包括方法、工具和过程，其中，__过程__支持软件开发的各个环节的控制和管理。

 

（4）数据库设计包括概念设计、_逻辑设计_和物理设计。

 

（5）在二维表中，元组的__分量__不能再分成更小的数据项。

 

（6）当使用关键字__void__作为函数返回类型时，该函数不返回任何值。

 

（7）已知数组 a 中有 n 个元素，下列语句将数组 a 中从下标 x1 开始的 k 个元素移动到从下标 x2 开始的 k 个元素中，其中 0<=x1<x2<n，x2+k<n，请将下列语句补充完整。

for (int i = x1+k-1; i>=x1; i--)

a[  _x2+k-1_  ]=a[i];

 

（8）有如下程序：

#include<iostream> 

using namespace std;

int fun1(int x) {return++x;}

int fun2(int &x) {return++x;}

int main(){

int x=1,y=2;

y=fun 1(fun2(x));

cout<<x<<','<<y;

return 0:

}

程序的输出结果是_2,3_。

 

（9）有如下程序：

#include<iostream> 

using namespace std;

class pumpkin{

public:

pumpkin(){++count;}

~pumpkin(){--count;}

static void total_count(){

cout<<count<<"pumpkin(s)"<<endl;

}

private:

static int count;

};

int pumpkin::count=0;

int main(){

pumpkin pl[10];

pumpkin::total_count();

return 0;

}

这个程序的输出结果是__10pumpkin(s)__。

 

（10）有如下递归函数：

int Fun(int n){

if(n<=1) return 1;

__else return n*Fun(n-1);__

}

请补充完整，使得函数 Fun 能够正确计算形参 n 的阶乘。

 

 

（11）请在下列程序中的空格处填写正确的语句：

class Sample{

public:

Sample(){}

~Sample(){}

void SetData(int data)

{ //将 Sample 类成员变量 data 设置成形参的值

__Sample::data=data__ //注意形参与成员同名

}

private: int data;

};

 

（12）有如下类定义，请将Sample类的拷贝构造函数补充完整。

class Sample{ 

public:

Sample(){)

~Sample() {if(p) delete p;)

Sample (const Sample& s){

__p=new int;*p=s.*p__

}

void SetData(int data) {p=new int(data);}

private:

int*p;

};

（13）重载加法运算符“+”，其函数名是__operator +_。

 

（14）有如下程序：

#include<iostream> 

using namespace std;

class Wages{ //“工资”类

double base; //基本工资

double bonus; //奖金

double tax; //税金

public:

       Wages(double CBase, double CBonus,

double CTax)

:base(CBase), bonus(CBonus),

tax(CTax){}

double getPay()const; //返回应付工资额

Wages operator+(Wages w)const; //重载加法

};

double Wages::getPay()const

{return base+bonus-tax;}

Wages Wages::operator+(Wages w)const

{ return Wages(base+w.base, bonus+w.bonus,

tax+w.tax);

}

int main(){

Wages wl(2000,500,100),w2(5000,1000,300);

cout<<(wl+w2).getPay()<<end1;

retun 0;

}

程序的输出结果是__8100__

 

 

（15）有如下程序：

#include<iostream>

using namespace std; 

class Pet{

char name[10];

public:

Pet(char*name){strcpy(this->name, name);}

const char*getName()const {return name;}

virtual void call()const=0;

};

class Dog: public Pet{

public:

Dog(char*name):Pet(name){}

void call()const{cout<<"汪汪叫";}

};

class Cat:public Pet{

public:

Cat(char*name):Pet(name){}

void call()const{cout<<"喵喵叫";}

};

int main(){ 

Pet  *pet1=new Dog("哈克"),

*pet2=new Cat("吉米");

cout<<pet1->getName();

pet1->call();

cout<<end1;

cout<<pet2->getName();

pet2->call();

cout<<end1;

return 0;

}

程序的输出结果是__哈克汪汪叫__

__吉米喵喵叫__

 

 

 

 

2008年9月二级 C++笔试试卷参考答案

一、选择题

（1）B）（2）D）（3）C）（4）A）（5）D）（6）B）（7）A）（8）B）（9）C）（10）D（11）A）（12）A）（13）C）（14）B）（15）D（16）B）（17）B）（18）D）（19）A）（20）D（21）C）（22）C）（23）A）（24）D）（25）C）（26）B）（27）C）（28）B）（29）A）（30）D（31）A）（32）C）（33）A）（34）B）（35）C）

二、填空题

（1）DBXEAYFZC

（2）单元

（3）过程

（4）逻辑设计

（5）分量

（6）void

（7）X2+k-1

（8）2,3

（9）10pumpkin(s)

（10）else return n*Fun(n-1);

（11）Sample::data

（12）p=new int; *p=s.*p;

（13）operator +

（14）8100