2007年4月计算机等级考试C++考试试卷参考答案及解析

来源：互联网发布：怎么禁止装软件编辑：程序博客网时间：2024/05/16 12:11

该试题网上流传的参考答案错漏比较多，本文已经对其进行修正，并添加了答案解析。

因本人水平有限，如果有错漏的地方还请多多指教！

一、选择题（每小题2分，共70分）
下列各题A）、B）、C）、D）四个选项中，只有一个选项是正确的。请将正确选项涂写在答题卡相应位置上，答在试卷上不得分。
（1）下列叙述中正确的是。
A）算法的效率只与问题的规模有关,而与数据的存储结构无关.
B）算法的时间复杂度是指执行算法所需要的计算工作量
C）数据的逻辑结构与存储结构是一一对应的.
D）算法的时间复杂度与空间复杂度一定相关.

【答案】B 考点：算法的基本概念，包括时间复杂度和空间复杂度两个方面。

（2）在结构化程序设计中,模块划分的原则是。
A）各模块应包括尽量多的功能
B）各模块的规模应尽量大
C）各模块之间的联系应尽量紧密
D）模块内具有高内聚度,模块间具有低耦合度

【答案】D考点：模块划分的原则，牢记：模块内要高内聚，模块间要低耦合。

（3）下列叙述中正确的是。
A）软件测试的主要目的是发现程序中的错误.
B）软件测试的主要目的是确定程序中错误的位置.
C）为了提高软件测试的效率,最好由程序编制者自己来完成软件测试的工作
D）软件测试是证明软件没有错误

【答案】A软件测试的主要目的是发现程序中的错误.

考点：软件测试的目标，牢记：软件测试的目的就是为了发现程序中的错误

（4）下面选项中不属于面向对象程序设计特征的是。
A）继承性 B）多态性 C）类比性 D）封装性

【答案】C）

考点：面向对象程序设计的特征，

牢记对象的特征有以下几点：分类性，封装性，多态性，继承性，模块性

（5）下列对列的叙述正确的是。
A）队列属于非线性表
B）队列按”先进后出”的原则组织数据
C）队列在队尾删除数据
D）队列按“先进先出”原则组织数据

【答案】D

考点：队列基本特点，牢记：队列是先进先出的数据结构，栈是先进后出的数据结构，它们都是特殊的线性表

（6）对下列二叉树

进行前序遍历的结果为：

A）DYBEAFCZX B）YDEBFZXCA C）ABDYECFXZ D）ABCDEFXYZ

【答案】C

解析：考点：树的遍历。

掌握：二叉树的三种遍历方式。二叉树的前序遍历中序遍历后序遍历。

前序遍历是先访问根结点，再访问左子树，再访问右子树，对于左子树和右子树仍旧按照前序访问方式遍历。

所以本题目中前序遍历先访问根结点A，再对左子树前序访问，依次是B D Y E ,然后访问A的右子树，依次是C F X Z。所以遍历顺序:A B D Y E C F X Z

（7）某二叉树中有n个度为2的结点则该二叉树中的叶子结点数为
A）n+1 B ）n-1 C）2n D）n/2

【答案】A 考点：二叉树的性质。

在任意一颗二叉树中，度为0的结点总比度为2的结点多一个。

（8）在下列关系运算中,不改变关系表中的属性个数但能减少元组个数的是。
A）并 B）交 C）投影 D）笛卡儿乘积

【答案】B

考点：关系运算，了解掌握：

并运算会增加元组个数，

并和交都不会改变属性的个数,因为他们都是针对同类关系的关系运算,但并会增加元组的个数,而交会减少元组的个数

投影运算会减少属性的个数,但不改变元组个数。

笛卡尔积既会增加属性个数，又会增加元组个数。

（9）在E-R图中,用来表示实体之间是联系的图形是。
A）矩形 B）椭圆形 C）菱形 D）平行四边形

【答案】C）菱形

考点：E—R图的相关概念

掌握：E-R模型的图示法，主要是什么类型是什么图形表示

构成E-R图的基本要素是实体型、属性和联系，其表示方法为：

·实体型(Entity)：具有相同属性的实体具有相同的特征和性质，用实体名及其属性名集合来抽象和刻画同类实体;在E-R图中用矩形表示，矩形框内写明实体名；比如学生张三丰、学生李寻欢都是实体。如果是弱实体的话，在矩形外面再套实线矩形。

·属性(Attribute)：实体所具有的某一特性，一个实体可由若干个属性来刻画。在E-R图中用椭圆形表示，并用无向边将其与相应的实体连接起来；比如学生的姓名、学号、性别、都是属性。如果是多值属性的话，在椭圆形外面再套实线椭圆。如果是派生属性则用虚线椭圆表示。

·联系(Relationship)：联系也称关系，信息世界中反映实体内部或实体之间的联系。实体内部的联系通常是指组成实体的各属性之间的联系；实体之间的联系通常是指不同实体集之间的联系。在E-R图中用菱形表示，菱形框内写明联系名，并用无向边分别与有关实体连接起来，同时在无向边旁标上联系的类型（1 : 1，1 : n或m : n）。比如老师给学生授课存在授课关系，学生选课存在选课关系。如果是弱实体的联系则在菱形外面再套菱形。

例如：

（10）下列叙述中错误的是。
A）在数据库系统中,数据的物理结构必须与逻辑结构一致.
B）数据库技术的根本目标是要解决数据的共享问题
C）数据库设计是指在已有数据库管理系统的基础上建立数据库
D）数据库系统需要操作系统的支持

【答案】A 考点：数据库的基本特点

掌握以下几点：

数据库技术的根本目标：解决数据的共享问题

数据库设计：在已有数据库管理系统的基础上建立数据库
数据库系统需要操作系统的支持

数据的物理结构与逻辑有高度独立性，结构不必一致

（11）为了取代C中带参数的宏，在C++中使用
A）重载函数 B）内联函数 C）递归函数 D）友元函数

【答案】B）内联函数

C++通常用内联函数可以替代多数的宏函数。因为效果与宏函数差不多，但编译时有类型匹配等好处。
宏函数功能很强大（比如“#”、“##”的用法），导致其无法被 C++ 中其它元素完全替代。但这些强大的功能并不经常被用到，一般情况下的宏函数是可以被内联函数替代的。

（12）下列关于类定义的说法中，正确的是
A）类定义中包括数据成员和函数成员的声明
B）类成员的缺省访问权限是保护的
C）数据成员必须被声明为私有的
D）成员函数只能在类体外进行定义

【答案】A

【解析】类成员的缺省访问权限是私有的。数据成员必须被声明不仅可以是私有的，也可以是公有成员或者保护成员。成员函数不仅可以在类体外进行定义。成员函数可以在类体中定义的，也可以在类体中只写成员函数的声明。

（13）下列关于派生类构造函数和析构函数的说法中，错误的是
A）派生类的构造函数会隐含调用基类的构造函数
B）如果基类中没有缺省构造函数，那么派生类必须定义构造函数
C）在建立派生类对象时，先调用基类的构造函数，再调用派生类的构造函数
D）在销毁派生类对象时，先调用基类的析构函数，再调用派生类的析构函数

【答案】D

在建立派生类对象时，必须先调用基类的构造函数，再调用派生类的构造函数，

在销毁派生类对象时，先调用派生类的析构函数，再调用基类的析构函数。这是C++的内部规定。

（14）通过运算符重载，可以改变运算符原有的
A）操作数类型 B）操作数个数 C）优先级 D）结合性

【答案】A）操作数类型

运算符重载不可以改变算符原有的操作数个数、优先级，以及结合性。它可以改变的是操作数的数据类型。

（15）有如下函数模板：
template <class T> T souare（T x）（retum x * x ;）
其中T是
A）函数形参 B）函数实参 C）模板形参 D）模板实参

【答案】C）模板形参

定义函数模板的一般形式为：
template < typename T> 或 template <class T>

（16）使用输入输出操作符setw,可以控制
A）输出精度 B）输出宽度 C）对齐方式 D）填充字符

【答案】B输出宽度

setw（int n)是用于设置输入输出宽度；

等价函数调用：io.width（n）

其中n为一个表示宽度的表达式。如果用于输入字符串，实际输入的字符串的最大长度为n-1。也就是说宽度n连字符串结束符也包含在内。函数 width返回此前设置的宽度；如果只需要这个返回值，可不给参数。

注意：宽度设置的效果只对一次输入或输出有效，在完成了一个数据的输入或输出后，宽度设置自动恢复为0（表示按数据实际宽度输入输出）。宽度设置是所有格式设置中唯一的一次有效的设置。

（17）下列字符串中，不可以用作C++标识符的是
A）y_2006 B）____TEST__H C）Retum D）switch

【答案】D

switch是C++里的关键字，所以不可以用作C++标识符。

C选项中C++是区分大小写的，所以Return与关键字return不产生冲突，但它不是一个好的标识符，容易引起混淆

（18）字面常量42、4.2、42L的数据类型分别是
A）long、double int B）long、float、int
C）int、double、long D）int、float、long

【答案】C）int、double、long

【VC 6.0中调试】

#include <iostream>

#include <typeinfo>

using namespace std;

int main()

{

int a;

float b;

cout<<"a的类型是"<<typeid(a).name()<<endl;

cout<<"b的类型是"<<typeid(b).name()<<endl;

a=4.2;

b=42L;

cout<<"赋值后a的类型是"<<typeid(a).name()<<endl;

cout<<"赋值后b的类型是"<<typeid(b).name()<<endl;

cout<<"4.2的类型是"<<typeid(4.2).name()<<endl;

cout<<"42L的类型是"<<typeid(42L).name()<<endl;

return 0;

}

VC++运行结果：

a的类型是int

b的类型是float

赋值后a的类型是int

赋值后b的类型是float

4.2的类型是double

42L的类型是long

可见常量4.2和42L本身是分别以double和long型存储的。

另外，值得注意的是赋值后的变量a、b的数据类型依旧。

（19）执行下列语句段后，输出字符“*”的个数是
for(int i=50;i>1;--i ) cout<<"*";
A）48 B） 49 C） 50 D）51

【答案】B 49 注意其条件是i>1，所以i是从50到2合计49个。

（20）有如下程序段
int i =0, j=1;

int &r=i; // ①

r =j; //②

int *p=&i; //③

*p=&r; //④
基中会产生编译错误的语句是
A）④ B）③ C）② D）①

【答案】A *p=&r; //④报错

error C2440: '=' : cannot convert from 'int *' to 'int'

题外话：如果需要修改那个错误，可以把*p=&r; //④改为p=&r;或者*p=r;

例如int *p,p=&r其意思是：p的值是一个地址，&r也表示一个地址，*p的意思是这个地址的值，p指向r的地址,*p就是r的值。

（21）有如下函数定义：
void func （int a,int＆b） {a++; b++;}
若执行代码段：
int x=0 ,y=1
func（x,y）;
则变量x和y值分别是
A）0和1 B）1和1 C）0和2 D）1和2

【答案】C

相同变量名称的变量，小作用域的会覆盖大作用域的。

全局变量x是将main函数作用域里的值传给了func作用域里的a，但是x的值不会改变。

&b代表传递过来的是这个参数的地址，因为y的传入方式是通过&b取地址传入，所以b++;使得b=2而y也变成2。

（22）有如下程序：
#include<iostream>

using namespace std;

class A{

public:

static int a;

void init(){a=1;}

A(int a=2) {init();a++;}

};

int A::a=0;

A obj;

int main()

{

cout<<obj.a;

return 0;

}
运行时输出的结果是
A）0 B）1 C）2 D）3

【答案】B）1
A (int a =2) {init();a++;}这里的a是局部变量，不影响static int a 的a

在声明对象obj时，系统调用构造函数，该构造函数的传入默认参数a =2。
在函数内部先调用init()
该函数是将类的静态变量a赋值为1
而之后的a++则是对传入的参数局部变量a=2进行加1操作
然后执行cout<<obj.a;输出静态变量a的值为1。
应当注意的我们在实际工作中应尽量避免这样让人发晕的变量命名！

因为只有人能轻松读懂的代码才是优秀的代码。

（23）下列有关继承和派生的叙述中，正确的是
A）派生类不能访问基类的保护成员
B）作为虚基类的类不能被实例化
C）派生类应当向基类的构造函数传递参数
D）虚函数必须在派生类中重新实现

【答案】C）派生类应当向基类的构造函数传递参数

当你定义一个派生类的对象时首先调用的是基类的构造函数,如基类的构造函数是带参的在派生类构造函数的后面会有基类的构造函数的传参否则就会报错。

（24）下列运算符中，不能被重载的是
A）＆＆ B）！= C）. D）++

【答案】C）.

重载操作符的限制：
（1）并不是所有的操作符都能被重载。除了. .* :: ? : sizeof typeid这几个运算符不能被重载，其他运算符都能被重载
（2）重载不能改变该运算符用于内置类型时的函义，程序员不能改变运算符+用于两个int型时的含义。
（3）运算符函数的参数至少有一个必须是类的对象或者类的对象的引用。这种规定可以防止程序员运用运算符改变内置类型的函义。
（4）重载不能改变运算符的优先级。
（5）重载不能改变运算符的结合律。
（6）重载不能改变运算符操作数的个数。比如+需要两个操作数，则重载的+也必须要有两个操作数。

（25）下列函数模板的定义中，合法的是
A）template<typename T> Tabs (T x) {return x <0 - x: x;}
B）template class <T>Tabs（Tx）{retumx<0 -x;x;}
C）template T<class T.>abs（T x）{retum x<0 -x;x;}
D）template T abs（T x）{returm x<0 -x;x;}

【答案】A）template<typename T> Tabs (T x) {return x <0 - x: x;}

（26）在语句cin>>data;中，cin是
A）C++的关键字 B）类名
C）对象名 D）函数名

【答案】C对象名

cin和cout是对象名。
在iostream这个文件里，可以找到下面这几句：
extern istream cin;
extern ostream cout;
extern ostream cerr;
extern ostream clog;
显然它们都是全局对象。

（27）有如下程序：
#include<iostream>

using namespace std;

class test

{

private:

int a;

public:

test () {cout<<"constructor"<<endl;}

test (int a){cout<<a<<endl;}

test (const test&_test)

{

a=_test.a;

cout<<"copy constructor"<<endl;

}

~test(){cout<<"destructor"<<endl;}

};

int main()

{

test A (3);

return 0;

}

运行时输出的结果是
A）3
B）constructor
destruclor
C）copy constructor
D）3
dstructor

【答案】D

【解析】main是程序的入口，test A (3);先调用带参数的构造函数test A (3);输出3。

程序结束前调用析构函数~test(){cout<<"destructor"<<endl;}输出了destructor，故选D

（28）若有如下类声明
class MyClass {

public:

MyClass() {cout<<1;}

};

执行下列语句
MyClass a,b[2],*P[2];
以后，程序的输出结果是
A）11 B）111 C）1111 D11111

【答案】B）111

MyClass a,b[2]这里有3个对象，故而调用了3次构造函数，输出111

*P[2]是指针，编译器无需创建对象，不用调用构造函数。

（29）有如下程序：
#include<iostream>

using namespace std;

class point {

public:

static int number;

public:

point(){number++;}

~point(){number--;}

};

int point::number=0;

void main(){

point *ptr;

point A,B;

{

point* ptr_point=new point[3];

ptr=ptr_point;

}

point C;

cout<<point::number<<endl;

delete[]ptr;

}
运行时输出的结果是
A）3 B）4 C）6 D）7

【答案】C）6

注意static变量属于整个类,不属于某一个对象。当创建一个Point对象时执行构造函数number++,当撤消时执行Point的析构函数number--，这个类里的static成员变量number记录的是创建了多少个该类的对象。

这里一共产生了6个Point对象,包括Point A,Point B,Point C,还有含有3个Point元素的数组.
所以选C。

（30）如果不使用多态机制，那么通过基类的指针虽然可以指向派生类对象，但是只能访问从基类继承的成员，有如下程序，没有使用多态机制。
#include<iostream>

using namespace std;

class Base{

int a,b;

public:

Base (int x ,int y) { a=x; b=y;}

void show(){ cout<<a<<','<<b<<endl;}

};

class Derived:public Base {

int c ,d;

public:

Derived(int x,int y,int z,int m):Base(x,y){c=z; d=m;}

void show(){ cout<<c<<','<<d<<endl;}

};

int main()

{

Base B1(50,50),*pb;

Derived D1(10,20,30,40);

pb=&D1;

pb->show();

return 0;

}
运行时输出的结果是
A）10，20 B）30，40 C）20，30 D）50，50

【答案】A 10 20

Derived D1(10,20,30,40);使得a=10，b=20，c=30，d=40

该题目中没有使用多态机制，pb=&D1;通过基类的指针pb虽然可以指向派生类对象D1，但是只能访问从基类继承的成员，pb->show();这里调用的是基类的void show(){ cout<<a<<','<<b<<endl;}输出结果10 20

（31）有如下程序：
#include<iostream>

using namespace std;

class A

{

public:

A(int i ){x=i;}

void dispa(){cout<<x<<',';}

private:

int x;

};

class B:public A

{

public:

B(int i):A(i +10) {x =i ;}

void dispb() {dispa();cout<<x<<endl;}

private:

int x;

};

int main()

{

B b(2);

b.dispb();

return 0;

}
运行时输出的结果是
A）10，2 B）12，10 C）12，2 D）2，2

【答案】C）12，2

（32）虚函数支持多态调用，一个基类的指针可以指向派生类的对象，而且通过这样的指针调用虚函数时，被调用的是指针所指的实际对象的虚函数，而非虚函数不支持多态调用。有如下程序：
#include<iostream>

using namespace std;

class Base

{

public:

virtual void f(){cout<<"f0+";}

void g() {cout<<"g0+";}

};

class Derived:public Base

{

public:

void f() {cout<<"f+";}

void g() {cout<<"g+";}

};

int main()

{

Derived d;

Base*p=&d;

p->f(); p->g();

return 0;

}
运行时输出的结果是
A）f+g+ B）f0+g+ C）f+g0+ D）f0+g0+

【答案】C）f+g0+

p->f();因为基类Base中的virtual void f(){cout<<"f0+";}虚函数支持多态调用，一个基类的指针可以指向派生类的对象，而且通过这样的指针调用虚函数时，被调用的是指针所指的实际对象的虚函数。所以p->f();调用的是派生类的void f() {cout<<"f+";}输出了f+

p->g();因为基类中的是非虚函数不支持多态调用，因此调用的是基类中的void g() {cout<<"g0+";}输出了g0+

（33）下面程序中对一维坐标点类Point进行运算符重载
#include<iostream>

using namespace std;

class point {

public:

point (int val) {x=val;}

point& operator++(){x++;return *this;}

point operator++ (int) {point old=*this;++(*this);return old;}

int GetX() const {return x;}

private:

int x;

};

int main()

{

point a(10);

cout<<(++a).GetX();

cout<<a++.GetX();

return 0;

}
编译和运行情况是
A）运行时输出1011
B）运行时输出1111
C）运行时输出1112
D）编译有错

【答案】B运行时输出1111

第一步：Point a(10);调用构造函数Point (int val) {x=val;} 此时x=10；
第二步：由于'()'运算符比'.'优先级高，先进行++a，调用重载前置++运算符函数：Point& operator ++() {x++; return *this;} 。即对x的值加1，然后返回改变后的值。然后运行'.'运算符调用GetX(),返回x=11的值.所以输出为：11
第三步：调用重载后置'++'运算符函数Point operator ++ (int) {Point old=*this;++(*this); return old;}
此时a.x=12，但是要注意的是==(int)返回的是++(*this)[即++a]之前的一个临时对象old，即加自增的是a.x，但是返回打印的是自增之前的a的一个副本。
就好像：i++，此时i加了1，但是这个表达式的值还是原来的i。

因此，这个对象调用GetX(),返回x=11的值.所以输出为：11。
最后结果为：
11 11

（34）有如下程序：
#include<iostream>

using namespace std;

int main()

{

char str[100],*p;

cout<<"please input a string:";

cin>>str;

p=str;

for(int i=0;*p!='\0';p++, i++);

cout<< i <<endl;

return 0;

}

运行这个程序时，若输入字符串为
abcdefg abcd
则输出结果是
A）7 B）12 C）13 D）100

【答案】A 7

该程序的功能是计算输入字符串的长度。

因为abcdefg abcd中间有空格，因而str是abcdefg。

关于cin如何结束？输入缓冲是行缓冲。当从键盘上输入一串字符并按回车后，这些字符会首先被送到输入缓冲区中存储。cin,cout是带缓冲的输入和输出

cin.>> 的结束条件为以下任一条：
1. 输入空格，或者换行符
2. 输入EOF（Ctrl-Z）
3. 输入了 n-1 个字符（当 get 用了参数 n）
4. 输入了指定的 delim 字符（当 get 用了参数 delim）

注意*p!='\0';中char是用单引号的。

（35）有如下程序：
#include<iostream>

using namespace std;

class Sample

{

friend long fun (Sample s);

public:

Sample (long a ){x=a;}

private:

long x;

};

long fun (Sample s)

{

if(s.x<2)return 1;

return s.x*fun(Sample(s.x-1));

}

int main()

{

int sum=0;

for(int i=0; i<6; i++) { sum+=fun(Sample( i )); }

cout<<sum;

return 0;

}
运行时输出的结果是
A）120 B）16 C）154 D）34

【答案】C 154

【解析】sum+=fun(Sample( i ));即sum=sum+ fun(Sample( i ));

而其中fun(Sample( i ))调用的是

long fun (Sample s)

{

if(s.x<2)return 1;

return s.x*fun(Sample(s.x-1));

}

其中s.x调用的是Sample (long a ){x=a;}

for(int i=0; i<6; i++) { sum+=fun(Sample( i )); }

第1次循环，当int=0时，fun(Sample( 0 ))的值为1（因为此时s.x为0，long fun (Sample s)

中if(s.x<2)return 1;），所以sum=0+1=1；

第2次循环，当int=1时，fun(Sample(1 ))的值为1（因为此时s.x为1，long fun (Sample s)

中if(s.x<2)return 1;），所以sum=1+1=2；

第3次循环，当int=2时，fun(Sample(2 ))的值为2（因为此时s.x为2，long fun (Sample s)中返回的是s.x*fun(Sample(s.x-1))=2*1，所以sum=2+2=4；

第4次循环，当int=3时，fun(Sample(3 ))的值为6（因为此时s.x为3，long fun (Sample s)中返回的是s.x*fun(Sample(s.x-1))=3*2，所以sum=4+6=10；

第5次循环，当int=4时，fun(Sample(4))的值为24（因为此时s.x为4，long fun (Sample s)中返回的是s.x*fun(Sample(s.x-1))=4*6，所以sum=10+24=34；

第6次循环，当int=5时，fun(Sample(5))的值为120（因为此时s.x为5，long fun (Sample s)中返回的是s.x*fun(Sample(s.x-1))=5*24=120，所以sum=34+120=154；

二、填空题（每空2分，共30分）
请将每一个空的正确答案写在答题卡【1】～【15】序号的横线上，答在试卷上不得分。
（1）在深度为7的满二叉树中，度为2的结点个数为【1】。

【答案】63

根据满二叉树的定义可知，深度为k的满二叉树所有节点个数为2^k-1，并且第i层上有2^(i-1)个结点。

所以根据上两条可知，深度为7的满二叉树中有2^7-1个结点也就是127个结点

而在第7层中全是叶子节点2^(7-1)=64，而叶子节点的度为0，所以要在总结点中减去度为0的叶子节点，也就是127-64=63。

所以度为2的结点个数为63个。

（2）软件测试分为白箱（盒）测试和黑箱（盒）测试，等价类划分法属于【2】测试。

【答案】黑箱（盒）

黑盒测试：把软件当做一个黑盒子，只通过输入和输出，判断程序有无错误。其具体方法主要有：等价类划分法、边界值分析法、错误推测法、因果图等，主要用于软件的确认测试。
白盒测试：把软件当做一个白盒子，对每条可能的执行路径都走一遍，以此检查有无错误。
解析：
与黑盒测试恰恰相反，白盒测试是把软件当做一个白盒子，或者更准确的说，一个透明的盒子，这样内部的构造、走向都一清二楚，这样就能清楚的看见，从入口到出口有几条畅通的路径。于是用“穷举”的办法，每条路径都走一遍，看看有没有错误，以此检查软件的正确与否。
真题演练：
07年9月，填空题2：在两种基本测试方法中，测试的原则之一是保证所测模块中每一个独立路径至少执行一次。
答案：白盒.
09年3月，填空题2：软件测试可分为白盒测试和黑盒测试。基本路径测试属于测试。
答案：白盒.

（3）在数据库系统中，实现各种数据管理体制功能的核心软件称为【3】。

【答案】DBMS即数据库管理系统。

（4）软件生命周期可分为多个阶段，一般分为定义阶段、开发和维护阶段。编码和测试属于【4】阶段。

【答案】开发

（5）在结构化分析使用的数据流图（DFD）中，利用【5】对其中的图形元素进行确切解释。

【答案】数据字典

【分析】数据字典是对数据流图（DFD）中出现的被命名的图形元素的确切解释。

常用的符号有=(表示“等于”，“定义为”，“由什么构成”)、[… ∣…](表示“或”)、+(表示“与”，“和”)、n{}m(表示‘‘重复’’)、(…)表示“可选”)、**(表示“注释”)和．．(连接符)。

（6）C++中只有两个逻辑常量：true和【6】。

【答案】false

在C和C++中都用数值1代表“真”,用0代表“假”。

辑型常量只有两个,即false(假)和true(真)。

（7）若要访问指针变量p所指向的数据，应使用表达式【7】。

【答案】*p

（8）已知一个函数的原型是：
int fn（double x）;
若要以5.27为实参调用该函数，应使用表达式【8】。

【答案】fn(5.27)

（9）有如下定义：
class MA{
int value;
public:
MA（int n=0）:valut（n）{}
};
MA*ta,tb;
其中MA类的对象名标识符是【9】。

【答案】tb

ta是一个指向MA对象的指针，它不是对象。

tb才是MA对象的名字即标识符

（10）如下类定义中包含了构造函数和拷贝数的原型声明请在横线处写正确的内容，使拷贝构造函数的声明完整。
class myClass{

private:

int data;

public:

myClass(int value); //构造函数

myClass(const 【10】anotherObject); //拷贝构造函数

};

【答案】myClass&

（11）用来派生新类的称为【11】，而派生出的新类称为它的子类或派生类。

【答案】基类或者父类

【解析】这题考核的是派生和继承。

我们称已存在的用来派生新类的类为基类,又称为父类。由已存在的类派生出的新类称为派生类,又称为子类。

（12）有如下程序：
#include<iostream>

using namespace std;

class CA{

public:

CA(){cout<<'A';}

};

class CB :private CA{

public:

CB(){cout<<'B';}

};

int main(){

CA a;

CB b;

return 0;

}

这个程序的输出结果是【12】。

【答案】AAB

CA a;为类CA创建对象a，调用CA类的构造函数，输出了A

CB b; 为类CB创建对象b，先调用基类CA的构造函数输出A，然后再调用派生类CB的构造函数输出B。

因此输出结果为AAB

（13）若将一个二元运算符重载为类的成员函数，其形参个数应该是【13】个。

【答案】1个

一个二元运算符重载为类的成员函数，形参只有一个。

因为虽然操作数有两个，但其中一个就是本类的对象，所以只需要把另一个参数传进去就好。

例如
Time Time::operator+(const Time &t)const
{...}
上面就是Time类的加法运算符重载。

（14）有如下程序：
#include<iostream>

using namespace std;

class DA{

int k;

public:

DA(int x=1): k (x){}

~DA(){cout<<k ;}

};

int main(){

DA d[]={DA(3),DA(3),DA(3)};

DA* p=new DA[2];

delete[]p;

return 0;

}
这个程序的输出结果是【14】。

【答案】11333

构造函数的参数是int x=1，这个参数有默认值，如果调用时不传入参数，则x=1，:k(x)这是初始化列表，也就是设置k的初始值为x。
~DA(){cout<<k} 在析构函数中输出k的值，因为k被初始化为x，实际上k也就是构造函数中传入的x值。

main函数中的DA d[]={DA(3),DA(3),DA(3)}; // 在栈上创建三个DA的对象，传入的参数都是3，这三个对象会在退出main函数时析构。
DA*p=new DA[2]; // 在堆上创建两个DA对象，没有传入参数，他们会在被delete时析构。
delete []p; // 删除p，此时p里面的两个DA对象析构，因为创建p时没有传入参数，所以使用默认值1，输出两个1。
return 0; // 函数返回，此时d里面的三个DA对象会被析构，因为创建时传入的是3，所以输出三个3
最终结果是11333

（15）C++语言中的多态性分为编译时的多态性和【15】时的多态性。

【答案】运行

c++中多态性分为编译时的多态性和运行时的多态性。

编译时多态对应运行时多态，静态多态对就动态多态，两种称呼说法都正确。

（1）编译时的多态性
编译时的多态性主要是通过函数重载、运算符重载和模板等来实现的。
（2）运行时的多态性
运行时的多态性就是指直到系统运行时，才根据实际情况决定实现何种操作。C++中，运行时的多态性主要是通过虚函数实现。

0 0