（20）有如下程序段
　　int　i =0, j=1;
　　int　＆r=i ; // ①
　r =j; //②
　int*p=＆i ; //③
　*p=＆r ; //④
　　基中会产生编译错误的语句是
　　A）④
　　B）③
　　C）②
　　D）①

（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

（22）有如下程序：
　　#include
　　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%26lt;　　retum0;
　　}
　　运行时输出的结果是
　　A）0
　　B）1
　　C）2
　　D）3

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

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

（25）下列函数模板的定义中，合法的是
　　A） template Tabs（T x） {return x %26lt;0 – x: x;}
　　B）template class Tabs（Tx）{retumx%26lt;0 -x;x;}
　　C）template Tabs（T x）{retum x%26lt;0 -x;x;}
　　D）template T abs（T x）{returm x%26lt;0 -x;x;}

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

（27）有如下程序：
　　#include
　　using namespace std;
　　class test {
　　private:
　　int a;
　　public:
　　test（）{cout%26lt;%26lt;”constructor”%26lt;　　test（int a）{cout%26lt;　　test（const test＆_test）
　　{
　　a=_testa;
　　cout%26lt;%26lt;”copy constructor”%26lt;　　}
　　test（）{cout%26lt;%26lt;”destructor”%26lt;　　};
　　int main（）
　　}
　　test A（3）
　　return0;
　运行时输出的结果是
　　A）3
　　B）constructor
　　destruclor
　　C）copy constructor
　　D）3
　　dstructor destruclor

（28）若有如下类声明
　　class My Class {
　　public:
　　MyClass（） {cout%26lt;%26lt;1;}
　　};
　　执行下列语句
　　MyClass a,b[2],*P[2];
　　以后，程序的输出结果是
　　A）11
　　B）111
　　C）1111
　　D11111

（29）有如下程序：
　　#include
　　using namespace std;
　　class point {
　　public:
　　static int number;
　　public:
　　point（）{number++;
　　～point（）{number-;}
　　};
　　imt point::number=0;
　　void main（）{
　　point*ptr;
　　printA,B;
　　{
　　point*ptr_point=new point{3};
　　ptr=ptr_point;
　　}
　　pointC;
　　cout%26lt;　　delete[]ptr;
　　}
　　运行时输出的结果是
　　A）3
　　B）4
　　C）6
　　D）7

（30）如果不使用多态机制，那么通过基类的指针虽然可以指向派生类对象，但是只能访问从基类继承的成员，有如下程序，没有使用多态机制。
　　#include
　　using namespace std;
　　class Base{
　　int a,b;
　　public:
　　Bace（int x ,int y） { a=x; b=y;}
　　Void show（）{ cout%26lt;　　}
　　clsaa 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%26lt;　　};
　　int main（）
　　{
　　Base B1（50,50）,*pb;
　　Derived DI（10,20,30,40）;
　　Pb=＆D1;
　　Pb-%26gt;show（）;
　　Return 0;
　　}
　　运行时输出的结果是
　　A）10，20
　　B）30，40
　　C）20，30
　　D）50，50

（31）有如下程序：
　　#include
　　using namespace std;
　　class A
　　{
　　public;
　　A（int i ）{x= i ;}
　　Void sispa（）{cout%26lt;　　Private:
　　int x ;
　　};
　　class B;publicA
　　{
　　public;
　　B（int i）:A（i +10） {x =i ;}
　　voud dispb（） {dispa（）;cout%26lt;　　Private:
　　Int x;
　　};
　　int main（）
　　{
　　B b（2）;
　　b.dispb（）
　　retum 0:
　　}
　　运行时输出的结果是
　　A）10，2
　　B）12，10
　　C）12，2
　　D）2，2

（32）虚函数支持多态调用，一个基类的指针可以指向派生类的对象，而且通过这样的指针调用虚函数时，，被调用的是指针所指的实际对象的虚函数，而非虚函数不支持多态调用。有如下程序：
　　#include
　　using namespace std;
　　class Base
　　{
　　public:
　　virtual void f（）{cout%26lt;%26lt;”f0+”;}
　　void g（） {cout%26lt;%26lt;”g0+”;}
　　};
　　　　class Derived:public Base
　　{
　　public:
　　void f（） {cout%26lt;%26lt;”f+”;}
　　void g（） {cout%26lt;%26lt;”g+”;}
　　};
　　int main（）
　　{
　　Derived d;
　　Base*p=＆d;
　　p-%26gt;f（）; p-%26gt;g（）;
　　return 0:
　　}
　　运行时输出的结果是
　　A）f+g+
　　B）f0+g+
　　C）f+g0+
　　D）f0+g0+

（33）下面程序中对一维坐标点类Point进行运算符重载
　　#include
　　using namespace std;
　　class point {
　　public:
　　point （int vaI） {x=val;}
　　point＆ operator++（）{x++;retum*this;}
　　print operator++（int） {point old=*this,++（*this）;retum old;}
　　int GetX（） const {retum x;}
　　private:
　　int x;
　　};
　　int main（）
　　{
　　point a（10）;
　　cout%26lt;%26lt;（++a）.GetX（）;
　　cout%26lt;　　retum（）;
　　}
　　编译和运行情况是
　　A）运行时输出1011
　　B）运行时输出1111
　　C）运行时输出1112
　　D）编译有错

（34）有如下程序：
　　#include
　　using namespace std;
　　int main（）
　　{
　　char str[100],*p;
　　cout%26lt;%26lt;”please input a string:”;
　　cin%26gt;%26gt;str;
　　p=str;
　　for（int i =0;*p!=”\0”;p++, i ++）;
　　cout%26lt;%26lt; i %26lt;　　retum 0;
　　}
　　运行这个程序时，若输入字符串为
　　abcdefg abcd
　　则输出结果是
　　A）7
　　B）12
　　C）13
　　D）100

（35）有如下程序：：
　　#include
　　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%26lt;2）retum 1;
　　retum s.x*fun（Sample（s.x-a））;
　　}
　　int main（）
　　{
　　int sum=0
　　for（int i =0; i %26lt;6; i ++） { sum+=fun（Sample（ i ）;） }
　　cout%26lt;　　retum 0;
　　}
　　运行时输出的结果是
　　A）120
　　B）16
　　C）154
　　D）34

二、填空题（每空2分，共30分）
请将每一个空的正确答案写在答题卡【1】～【15】序号的横线上，答在试卷上不得分。
　　（1）在深度为7的满二叉树中，度为2的结点个数为 【1】 。
　　（2）软件测试分为白箱（盒）测试和黑箱（盒）测试，等价类划分法属于 【2】 测试。
　　（3）在数据库系统中，实现各种数据管理体制功能的核心软件称为 【3】 。
　　（4）软件生命周期可分为多个阶段，一般分为定义阶段、开发和维护阶段。编码和测试属于 【4】 阶段。
　　（5）在结构化分析使用的数据流图（DFD）中，利用 【5】 对其中的图形元素进行确切解释。
　　（6）C++中只有两个逻辑常量：true和 【6】 。
　　（7）若要访问指针变量p所指向的数据，应使用表达式 【7】 。
　　（8）已知一个函数的原型是：
　　int fn（double x）;
　　若要以5.27为实参调用该函数，应使用表达式 【8】 。
　　（9）有如下定义：
　　class MA{
　　int value;
　　public:
　　　MA（int n=0）:valut（n）{}
　　};
　　MA*ta,tb;
　　其中MA类的对象名标识符是 【9】 。
　　（10）如下类定义中包含了构造函数和拷贝数的原型声明请在横线处写正确的内容，使拷贝构造函数的声明完整。
　　Class my Class{
　　Private:
　　Int data:
　　Public:
　　MyClass（int value）; //构造函数
　　MyClass（const 【10】 another Object）; //拷贝构造函数
　　}
　　（11）用来派生新类的称为 【11】 ，而派生出的新类称为它的子类或派生类。
　　（12）有如下程序：
　　#include
　　using namespace std;
　　clsaa CA{
　　public:
　　CAD{cout%26lt;　　};
　　class CB ;private CA{
　　public;
　　CB（）{cout%26lt;　　};
　　int main（）{cout%26lt;　　};
　　int main（）{
　　CA a;
　　CB b;　
　　retum0;
　　}
　　这个程序的输出结果是 【12】 。
　　（13）若将一个二元运算符重载为类的成员函数，其形参个数应该是 【13】 个。
　　（14）有如下程序：
　　#include
　　using namespace std;
　　class DA{
　　int k;
　　public:
　　DA（int x=1）: k （x）{}
　　～DA（）{cout%26lt;　　};
　　int main（）{
　　DA d[]={DA（3）,DA（3）,DA（3）};
　　DA* p=new DA[2];
　　delete[]p;
　　return0;
　　}
　　这个程序的输出结果是 【14】 。
　　（15）C++语言中的多态性分为编译时的多态性和 【15】 时的多态性。

2007年4月计算机等级考试C++考试答案

选择题:

1－5BDACD

6-10CABCA

11-15BADAC

16-20BCDBA

21-25CCCCA

26-30CDBDA

30-35CBBBC

填空：

1、63

2、黑盒

3、DBMS

4、开发

5、数据字典

6、false

7、 *P

8、fn(5.27)

9、tb

10、myclass%26amp;

11、基类

12、AAB

13、1个

14、11333

15、运行