2004年9月全国计算机等级考试二级笔试试卷&公共基础知识及C++语言程序设计

以下数据结构中不属于线性数据结构的是

在一棵二叉树上第5层的结点数最多是

下面描述中，符合结构化程序设计风格的是

下面概念中，不属于面向对象方法的是

在结构化方法中，用数据流程图(DFD)作为描述工具的软件开发阶段是

在软件开发中，下面任务不属于设计阶段的是

数据库系统的核心是

下列叙述中正确的是

下列模式中，能够给出数据库物理存储结构与物理存取方法的是

关于面向对象的程序设计方法，下列说法正确的是

判断字符型变量ch是否为大写英文字母，应使用表达式

已知下列语句中的x和y都是int型变量，其中错误的语句

执行语句序列
int n;
cin >> n;
switch(n)
{    case 1:
case 2: cout << '1';
case 3:
case 4: cout << '2'; break;
default: cout << '3';
}
时，若键盘输入1，则屏幕显示

下列程序的输出结果是
#include <iostream>
using namespace std;
int main()
{
char a[] = "Hello, World";
char *ptr = a;
while (*ptr)
{
if (*ptr >= 'a' && *ptr <= 'z')
cout << char(*ptr + 'A' -'a');
else cout << *ptr;
ptr++;
}
return 0;
}

已知：int m=10；在下列定义引用的语句中，正确的是

下列函数原型声明中错误的是

已知程序中已经定义了函数test，其原型是int test(int, int, int);，则下列重载形式中正确的是

有以下程序
#include<iostream>
int i = 0;
void fun()
{  {
static int i = 1;
std::cout<<i++<<',';
}
std::cout<<i<<',';
}
int main()
{
fun();  fun();
return 0;
}
程序执行后的输出结果是

已知函数f的原型是：void f(int *a, long &b); 变量v1、v2的定义是：int v1;long v2;，正确的调用语句是

有以下类定义
class MyClass
{
public:
MyClass(){cout<<1;}
};
则执行语句MyClass a, b[2], *p[2];后，程序的输出结果是

关于友元，下列说法错误的是

关于动态存储分配，下列说法正确的是

有以下程序
#include<iostream>
using namespace std;
class MyClass
{
public:
MyClass(int n){number = n;}
//拷贝构造函数
MyClass(MyClass &other){ number=other.number;}
~MyClass(){}
private:
int number;
};
MyClass fun(MyClass p)
{
MyClass temp(p);
return temp;
}
int main()
{
MyClass obj1(10), obj2(0);
MyClass obj3(obj1);
obj2=fun(obj3);
return 0;
}
程序执行时，MyClass类的拷贝构造函数被调用的次数是

在公有派生的情况下，派生类中定义的成员函数只能访问原基类的

在C++中用来实现运行时多态性的是

一个类可以同时继承多个类，称为多继承。下列关于多继承和虚基类的表述中，错误的是

在一个类体的下列声明中，正确的纯虚函数声明是

在下面的运算符重载函数的原型中，错误的是

下列是模板声明的开始部分，其中正确的是

执行语句序列
ofstream outfile("DATA.DAT");
if(...) cout << "OK"; else cout << "FAIL";
后，如果文件打开成功显示“OK”，否则就显示“F厶n。”。由此可知，上面if语句的．．．
处的表达式应是

C++流中重载的运算符>>是一个（  ）

有以下类定义
class Point {
public:
Point(int x = 0, int y = 0) { _.x = x; _.y = y; }
void Move(int xOff, int yOff)
{ _x += xOff; _.y += yOff; }
void Print() const
{ cout << '(' << _x << ',' << _y << ')' << endl; }
private:
int _x, _y;
};
下列语句中会发生编译错误的是

有以下类定义
class MyClass
{
private:
int id;
char gender,
char *phone;
public:
MyClass():id(0),gender('#'),phone(NULL) { }
MyClass(int no, char ge='#', char *ph= NULl.)
{ id=no;gende=ge;phone=ph; }
};
下列类对象定义语句中错误的是

有以下程序
#include <iostream>
using namespace std;
class Complex
{
public:
Complex(double r =0, double i =0):re(r), im(i) { }
double real() const { return re; }
double imag() const { return im;}
Complex operator +(Complex c) const
{ return Complex(re+c.re, im+c.im); }
private:
double re, im;
};
int main()
{
Complex a = Complex(l, 1) + Complex(5);
cout << a.real() << '+' << a.imag() <<'i' << endl;
return 0;
}
程序执行后的输出结果是

算法的复杂度主要包括  ＿＿  复杂度和空间复杂度。

数据的逻辑结构在计算机存储空间中的存放形式称为数据的  ＿＿  。

若按功能划分，软件测试的方法通常分为白盒测试方法和  ＿＿  测试方法。

如果一个工人可管理多个设备，而一个设备只被一个工人管理，则实体“工人”与实体“设备”之间存在  ＿＿  的联系。

关系数据库管理系统能实现的专门关系运算包括选择、连接和 ＿＿  。

设有定义语句：int a=12；，则表达式a*=2+3的运算结果是  ＿＿  。

从实现的角度划分，C++所支持的两种多态性分别是  ＿＿  时的多态性和运行时的多态性。

将—个函数声明为一个类的友元函数必须使用关键字  ＿＿  。

请按下面注释的提示，将类B的构造函数定义补充完整。
class A
{
int a;
public:
A(int aa=0) { a=aa; }
};
class B: public A {
int b;
A c;
public:
//用aa初始化基类A，用aa+1初始化类对象成员c
B(int aa):  ＿＿  { b=aa+2; }
};

下列程序的输出结果是  ＿＿  。
#include <iostream>
using namespace std;
int main()
{
int i = 5;
int &r = i; r = 7;
cout << i << endl;
return 0;
}

下列程序的输出结果是  ＿＿  。
#include <iostream>
using namespace std;
class Test {
public:
Test() { cnt++; }
~Test() {cnt--; }
static int Count() { return cnt;}
private:
static int cnt;
};
int Test::cnt = 0;
int main()
{
cout << Test::Count0 <<' ';
Test tl, t2;
Test* pT3 = new Test;
Test* pT4 = new Test;
cout << Test::Count0 <<' ';
delete pT4;
delete pT3;
cout << Test::Count() << endl;
return 0;
}

下面是用来计算n的阶乘的递归函数，请将该函数的定义补充完整。(注：阶乘的定义是n!=n*(n-1)*...*2*1)
unsigned fact(unsigned n)
{
if ( n<= 1)
return 1;
return  ＿＿  ;
}

下列程序的输出结果是  ＿＿  。
#include <iostream>
using namespace std;
template<tytename T>
T fun(T a, T b) { return (a<=b)?:b;}
int main()
{
cout << fun(3, 6) << ',' << fun (3.14F, 6.28F) << endl;
return 0;
}

与成员访问表达式p->name等价的表达式是  ＿＿  。

下列程序的输出结果是  ＿＿  。
#include <iostream>
using namespace std;
class base {
public:
int n;
base(int x) { n = x;}
virtual void set(int m) { n = m; cout << n <<' ';}
};
class deriveA:public base {
public:
deriveA(int x):base(x) { }
void set(mt m) { n += m; cout << n <<' ';}
};
class deriveB:public base [
public:
deriveB(int x):base(x) { }
void set(int m) { n +=m; cout <<n << ' ';}
};
int main()
{
deriveA dl(1);
deriveB d2(3);
base *pbase;
pbase = &dl;
pbase->aet(1);
pbase = &d2;
pbase->set(2);
return 0;
}