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

在结构化程序设计中,模块划分的原则是 。

下列叙述中正确的是 。

下面选项中不属于面向对象程序设计特征的是 。

下列对列的叙述正确的是 。

对下列二叉树
  
进行前序遍历的结果是

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

在下列关系运算中,不改变关系表中的属性个数但能减少元组个数的是 。

在E-R图中,用来表示实体之间是联系的图形是 。

下列叙述中错误的是 。

为了取代C中带参数的宏，在C++中使用

下列关于类定义的说法中，正确的是

下列关于派生类构造函数和析构函数的说法中，错误的是

通过运算符重载，可以改变运算符原有的

有如下函数模板：
template <class T> T souare（T x） （retumx * x ;）
基中T是

使用输入输出操作符setw,可以控制

下列字符串中，不可以用作C++标识符的是

字面常量42、4.2、42L的数据类型分别是

执行下列语句段后，输出字符“*”的个数是
for（int i =50;I>1;— i ）cout<<”*”

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

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

有如下程序：
#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;
retum0;
}
运行时输出的结果是

下列有关继承和派生的叙述中，正确的是

下列运算符中，不能被重载的是

下列函数模板的定义中，合法的是

在语句cin>>data;中，cin是

有如下程序：
#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=_testa;
cout<<”copy constructor”<<endl;
}
test（）{cout<<”destructor”<<endl;}
};
int main（）
}
test A（3）
return0;
运行时输出的结果是

若有如下类声明
class My Class {
public:
MyClass（） {cout<<1;}
};
执行下列语句
MyClass a,b[2],*P[2];
以后，程序的输出结果是

有如下程序：
#include<iostream>
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<<point::number<<endl;
delete[]ptr;
}
运行时输出的结果是

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

有如下程序：
#include<iostream>
using namespace std;
class A
{
public;
A（int i ）{x= i ;}
Void sispa（）{cout<<x<<’,’;}
Private:
int x ;
};
class B;publicA
{
public;
B（int i）:A（i +10） {x =i ;}
voud dispb（） {dispa（）;cout<<x<,endl;}
Private:
Int x;
};
int main（）
{
B b（2）;
b.dispb（）
retum 0:
}
运行时输出的结果是

虚函数支持多态调用，一个基类的指针可以指向派生类的对象，而且通过这样的指针调用虚函数时，，被调用的是指针所指的实际对象的虚函数，而非虚函数不支持多态调用。有如下程序：
#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:
}
运行时输出的结果是

下面程序中对一维坐标点类Point进行运算符重载
#include<iostream>
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<<（++a）.GetX（）;
cout<<a++.GetX（）;
retum（）;
}
编译和运行情况是

有如下程序：
#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;
retum 0;
}
运行这个程序时，若输入字符串为
abcdefg abcd
则输出结果是

有如下程序：：
#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）retum 1;
retum s.x*fun（Sample（s.x-a））;
}
int main（）
{
int sum=0
for（int i =0; i <6; i ++） { sum+=fun（Sample（ i ）;） }
cout<<sum;
retum 0;
}
运行时输出的结果是

在深度为7的满二叉树中，度为2的结点个数为 ＿＿ 。

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

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

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

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

C++中只有两个逻辑常量：true和 ＿＿ 。

若要访问指针变量p所指向的数据，应使用表达式 ＿＿ 。

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

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

如下类定义中包含了构造函数和拷贝数的原型声明请在横线处写正确的内容，使拷贝构造函数的声明完整。
Class my Class{
Private:
Int data:
Public:
MyClass（int value）; //构造函数
MyClass（const ＿＿ another Object）; //拷贝构造函数
}

用来派生新类的称为 ＿＿ ，而派生出的新类称为它的子类或派生类。

有如下程序：
#include<iostream>
using namespace std;
clsaa CA{
public:
CAD{cout<<A’;}
};
class CB ;private CA{
public;
CB（）{cout<<B’;}
};
int main（）{cout<<B’;}
};
int main（）{
CA a;
CB b;
retum0;
}
这个程序的输出结果是 ＿＿ 。

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

有如下程序：
#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;
return0;
}
这个程序的输出结果是 ＿＿ 。

C++语言中的多态性分为编译时的多态性和 ＿＿ 时的多态性。