2009年3月全国计算机等级考试C++语言笔试试卷

支持子程序调用的数据结构是

某二叉树有5个度为2的结点，则该二叉树中的叶子结点数是

下列排序方法中，最坏情况下比较次数最少的是

软件按功能可以分为：应用软件、系统软件和支撑软件〔或工具软件)。下面属于应用软件的是

下面叙述中错误的是

耦合性和内聚性是对模块独立性度量的两个标准。下列叙述中正确的是

数据库应用系统中的核心问题是

有两个关系R，S如下由关系R通过运算得到关系S，则所使用的运算为

将E-R图转换为关系模式时，实体和联系都可以表示为

对C++编译器区分重载函数无任何意义的信息是

有如下类定义和变量定义：
class A{
publie:
A（）{data=0;}
~A（）{}
int GetData （ ） coast { return data;}
void SetData（int n） {data=n;}
private:
int data;
};
ccnst A a;
A b;
下列函数调用中错误的是

有如下类定义和变量定义：
class Parents{
public:
int publicuata;
private:
int privateData;
};
class ChildA:public Parents{/*类体略*/};
class ChildB:private Parents{/*类体略*/）；
ChildA a;
ChildBb;
下列语句中正确的是

运算符重载时不需要保持的性质是

下列关于函数模板的描述中，错误的是

要建立文件流并打开当前目录下的文件file.dat用于输入，下列语句中错误的是

下列描述中，不属于面向对象思想主要特征的是

有如下程序段：
Tnt i=4;int j=l;
int main（）{
int i=8，j=i;
cout<<i<<j<<endl;
}
运行时的输出结果是

有如下程序段：
int i=5;
while（int i=0）{cout《'*';i--;}
运行时输出"*"的个数是

己知有数组定义
char a[3][4];
下列表达式中错误的是

已知函数fun的原型为
int fun（int,int,int）；
下列重载函数原型中错误的是

建立一个类对象时，系统自动调用

通过派生类的对象可直接访问其

己知表达式++a中的"++"是作为成员函数重载的运算符，则与十+a等效的运算符函数调用形式为

在定义一个类模板时，模板形参表是用一对括号括起来的，所采用的括号是

当使用ifstream流类定义一个流对象并打开一个磁盘文件时，文件的默认打开方式为

有如下程序：
#include<iostream>
#include<cstring>
using namespace std;
class XCD{
char* a;
int b;
public:
XCD（char* aa, int bb）{
a=new char[strlen（aa）+1];
strcpty（a,aa）；
b=bb;
}
Char* Geta （）{return a;）
int Getb（）{ return b;}
};
int main（）{
char *pl="abcd"，*p2="weirong"；
int dl=6, d2=8;
XCD x（pl,dl），Y（p2，d2）；
cout<<strien （x .Geta（））+y. Getb（）+endl;
return 0;
}
运行时的输出结果是

有如下程序：
#include<iostream>
#include<cstring>
using namespace std;
class XCF{
int a;
public:
XCF（int aa=0）：a （aa）{cout<<"1"；}
XCF（XCF& x）{a=x .a; cout<<"2"；）
~XCF（）{cout<<a;}
int Geta（）{return a;}
};
int main（）{
XCF dl（5），d7 （dl）；
XCF *pd=new XCF（8）；
cout<<pd一>Geta（）；
delete pd;
return 0;
}
运行时的输出结果是

已知类MyClass声明如下：
class MyClass{
int n;
public;
MyClass（int k）：n（k）{}
int getValue（）const{return n;}
};
在下列数组定义中正确的是

有如下程序：
#include<iostream>
using namespace std;
class AA{
lilt  k;
protected:
int    n;
void setK（int k）{ this->k=k;}
public:
void setN（int n）{ this->n=n;}
};
class BB: public }{/*类体略*/};
int main（）{
BB x_ ;              //1
x .n=1;              //2
x.setN （2）；          //3
x.k=3;              //4
x .setK（4）；
return 0;
}
在标注号码的四条语句中正确的是

有如下类定义：
class XX{
int xx;
public:
XX（）：xx（0）{cout<<' A';}
XX（int n）：xx （ n）{tout<<' B';}
};
Class YY:public XX{
Int yy;
public:
YY（）：yy （ 0）{cout+yy;}
YY（int n）：XX（n+1），yy（n）{cout<<yy;}
YY （int m,  int n）：XX （m），yy（n）{cout<<yy;}
};
下列选项中，输出结果为A0的语句是

有如下程序：
#include<iostream>
Using namespace std;
class A{
public:
virtual void f（）{cout+1;}
void g（）{cout<<2;}
};
class B:public A{
public:
virtual void f（）{cout<<3;}
void g（）{ecut<<4;}
};
void show（A &a）{a.f（）；a.g（ ）；}
int main（）{
B b;
show（b）；
return 0;
}
运行时的输出结果是

有如下程序：
#include<iostream>
using namespace std;
class Pair{
int m;
int n;
public:
Pair（int i，int j）：m（i），n（j）{}
boot operator >（pair p）const;  //须在类体外给出定义
}；
int main（）{
Pair Al（3,4），p2（4,3）；p3（4,5）；
Cout<<（pl>p2）<<（P2>P1）<<（p2>p3）<<（p3>p2）；
return 0;
}
运算符函数。operator>的功能是比较两个Pair对象的大小，当左边对象大时，返回true，否则返回false。比较规则是首先比较两对象的m成员，m大者为大；当m相等时比较n，n大者为大。程序输出0101，下列对运算符重载函数的正确定义是

假定下列语句都是程序运行后首次执行的输出语句，其中输出结果与另外三条语句不同的语句是

有如下程序：
#include<iostream>
using namespace std;
class ONE{
int c;
public:
ONE（）：c（0）{cout<<1;}
ONE（int n）：c （n）{cout<<2;}
};
class TWO{
ONE onel;
ONE one2;
public:
TWO（int m）：one2（m）{cout<<3;}
};
int main（）t
TWO t（4）
return 0
}
运行时的输出结果是

假设用一个长度为50的数组(数组元素的下标从0到49)作为栈的存储空间，栈底指针bottom指向栈底元素，栈顶指针top指向栈顶元素，如果bottom=49，top=30(数组下标)，则栈中具有＿＿个元素。

软件测试可分为白盒测试和黑盒测试。基本路径测试属于 ＿＿  测试。

符合结构化原则的三种基本控制结构是：选择结构、循环结构和  ＿＿  。

数据库系统的核心是    ＿＿  。

在E-R图中，图形包括矩形框、菱形框、椭圆框。其中表示实体联系的是  ＿＿  框。

有如下程序段：
int x=1,Y=2,z=3;
x=x^z;
y=y^z;
z=x^y;
cout<<x<<y<<z;
执行这个程序段的输出是＿＿。

有如下程序段：
fer（int i=1; i<=50;i++）{
if（i%3 != 0）
continue;
else
if（i%5!=0）
continue;
tout<<i<<"，"；
}
执行这个程序段的输出是＿＿。

有如下程序段：
Char c [20]="examination"；
c[4]=0;
cout<<c<<endl;
执行这个程序段的输出是＿＿。

下面的函数利用递归实现了求1+2+3+……+n的功能：
int sum（int n）{
if（n==0）
return 0;
else
return n+sum（n-1）；
}
在执行sum（10）的过程中，递归调用sum函数的次数是＿＿。

非成员函数应该声明为类＿＿函数才能访问该类的私有成员。

有如下程序：
#include<iostream>
using namespace std;
class Monitor{
public:
Monitor（char t）：type （t）{}
void print（ ） const
{cout<<"The type of monitor is"<<type<<endl;}
private:
char type;
};
class Computer{
public:
Computer（int i，char c）： ＿＿{}
void Print（）const
{cout<<"The computer is"<<id<<endl;mon.Print（）；}
private:
int id;
Monitor mon;
};
const Computer myComputer（101,'B'）；
myComputer .Print（）；
return 0;
}
请将程序补充完整，使程序在运行时输出：
The computer is 101
'The type of monitor i.s 8

有如下程序：
#include <iostream>
using namespace std
class Animal{
public:
virtual char* getType（）const { return "Animal"；}
virtual char* getVoice（）const { return "Voice"；}
};
Class Dog : public Animal {
public:
char* getType （ ） const {return "Dog"；}
char* getVoice （ ） const {return "Woof"}
};
void type（Animal& a） {cout<<a.getType（）；}
void speak（Animal a） {cout<<a.getVoice（）；}
int main（ ） {
Dog d; type （d）；cout<<" speak"；speak（d）；cout<<endi;
return 0;
}
运行时的输出结果是＿＿。

补充完整下面的类定义：
const double PI=3 .14;
class Circle{  //圆形物体的抽象基类
protected:
double r;      //半径
public:
Circle（double radius=0）：r（radius）{}
＿＿；//计算圆形物体表面积的纯虚函数声明
};
class Cylinder:public Circle { //圆柱体类
double h;      //高度
public:
Cylindr（double radius=0, doubli height=0）：
Circle（radius），h （height）{}
Virtual double Area（） { //计算圆柱体的表面积
return 2*PI*r*（r+h）；
}
};

补充完整下面的类定义：
class XCH{
char* a;
public:
XCH（char* as） { //构造函数
a=new char[strlen（aa）+1];
strcpy（a,aa）；
}
XCH& operator=（const XCH& x）    //重载赋值函数
Delele []a;
A=new char[strlen（x.a）+l];
strcpy（a, x .a）
＿＿；
}
~XCH（） {delete []a;}
};

补充完整下面的模板定义：
template<class Type> //Type为类型参数
class Xtwo{    //由两个Type类型的数据成员构成的模板类
Type a;
Type b;
public:
Xtwe（Type aa=0, Type bb=0）：a（aa），b（bb）{}
int Ccmpare （）{//比较a和b的大小
if （a>b）returm 1;
else if（a==b） return 0;
else return -1;
}
Type Snm（） {return a+b;} //返回a和b之和
Type Mult（）；        //函数声明，返回a和b之乘积
｝；
Template<class Type>
＿＿：：Mult（）{return a*b;} //Mult 函数的类外定义