全国计算机等级考试历年真题 &2007年9月计算机二级考试C++语言笔试试题

软件调试的目的是

在面向对象方法中，实现信息隐蔽是依靠

下列叙述中，不符合良好程序设计风格要求的是

下列叙述中正确的是

下列叙述中正确的是

冒泡排序在最坏情况下的比较次数是

一棵二叉树中共有70个叶子结点与80个度为1的结点，则该二叉树中的总结点数为

下列叙述中正确的是

下列叙述中正确的是

在函数中，可以用auto、extern、register和static这四个关键字中的一个来说明变量
的存储类型，如果不说明存储类型，则默认的存储类型是

对于一个类定义，下列叙述中错误的是

如果派生类以protected方式继承基类，则原基类的protected成员和public成员在派
生类中的访问属性分别是

下列运算符函数中肯定不属于类FunNumber的成员函数的是

C++中的模板包括

如果利用C++流进行输入输出，下面的叙述中正确的是

下列符号中不属于C++关键字的是

下列各组类型声明符中，含义想通的一组是

必须用一对大括号括起来的程序段是

语句　int　*p=&k;定义了指针p，与这个语句等效的语句序列是

关于函数重载，下列叙述中错误的是

有如下头文件：
int　f1();
static　int　f2();
class　MA{
public:
int　f3();
static　int　f4();
}
在所描述的函数中，具有隐含的this指针的是

派生类的成员函数不能访问基类的

下列关于运算符重载的描述中，正确的是

下列关于类木不安的模板参数的叙述中，错误的是

已知一程序运行后执行的第一个输出操作是
cout<<setw(10)<<setfill('*')<<1234;
此操作的输出结果是

有如下程序：
#include　<iostream>
using　namespace　std;
class　MyClass{
public:
MyClass(){++count;}
~MyClass(){--count;}
static　int　getCount(){return　count;}
private:
static　int　count;
};
int　MyClass::count=0;
int　main(){
MyClass　obj;
cout<<obj.getCount();
MyClass　*ptr=new　MyClass;
cout<<MyClass:getCount();
delete　ptr;
cout<<MyClass::getCount();
return　0;
}
程序的输出结果是

有如下程序：
#include　<iostream>
using　namespace　std;
class　MyClass{
public:
MyClass(int　x):val(x){}
void　Print()　const　{cout<<"const:val="<<val<<'\t';}
void　Print(){cout<<"val="<<val<<'\t';}
private:
int　val;
};
int　main(){
const　MyClass　obj1(10);
MyClass　obj2(20);
obj1.Print();
obj2.Print();
return　0;
}
程序的输出结果是

有如下程序：
#include　<iostream>
using　namespace　std;
class　Part{
public:
Part(int　x=0):val(x){cout<<val;}
~Part(){cout<<val;}
private:
int　val;
};
class　Whole{
public:
Whole(int　x,int　y,　int　z=0):p2(x),p1(y),val(z){cout<<val;}
~Whole(){cout<<val;}
private:
Part　p1,p2;
int　val;
};
int　main(){
Whole　obj(1,2,3);
return　0;
}
程序的输出结果是

有如下程序：
#include　<iostream>
using　namespace　std;
class　Base{
public:
Base(int　x=0){cout<<x;}
};
class　Derived:public　Base{
public:
Derived(int　x=0){cout<<x;}
private:
Base　val;
};
int　main(){
Derived　d(1);
return　0;
}
程序的输出结果是

若有如下类定义
class　B{
void　fun1(){}
protected:
double　var1;
public:
void　fun2(){}
};
class　D:public　B{
protected:
void　fun3(){}
};
已知obj是类D的对象，下列语句中不违反类成员访问控制权限的是

有如下程序：
#include　<iostream>
using　namespace　std;
class　Base{
public:
void　output(){cout<<1;}
virtual　void　Print(){cout<<'B';}
};
class　derived:public　Base{
public:
void　output(){cout<<2;}
void　Print(){cout<<'D';}
};
int　main(){
Base　*ptr=new　Derived;
ptr->output();
ptr->Print();
delete　ptr;
return　0;
}
程序的输出结果是

下列是重载惩罚运算符的函数原型生命，其中错误的是

如下函数的作用是以双倍行距输出文件：
void　double_space(ifstream&　f,ofstream&　t){
char　c;
while　(__________){
____________;
if(c=='\n')　t.out(c);
}
}
画线处缺失的部分是

有如下程序：
#include　<iostream>
using　namespace　std;
class　B{
public:
virtual　void　show(){cout<<"B";}
};
class　D:public　B{
public:
void　show(){cout<<"D";}
};
void　fun1(B　*ptr){ptr->show();}
void　fun2(B　&ref){ref.show();}
void　fun3(B　b){b.show();}
int　main(){
B　b,*p=new　D;
D　d;
fun1(p);
fun2(b);
fun3(d);
return　0;
}
程序的输出结果是

软件需求规格说明书应具有完整性，无岐义性、正确性、可验证性、可修改性等特征，其中最重要的是＿＿　　。

在两种基本测试方法中，＿＿　　测试的原则之一是保证所测模块中每一个独立路径至少执行一次。

线性表的存储结构主要分为顺序存储结构和链式存储结构。队列是一种特殊的线性表，循环队列是队列的＿＿　　存储结构。

对下列二义树进行中序遍历的结果为＿＿　　。
  

在E-R图中，矩形表示＿＿　　。

若有定义语句：int　a=3,b=2,c=1;，则表达式a<b?a:b的值是＿＿ 

执行下列语句后，变量sum的值是＿＿
int　sum=0;
for(int　i=1;i<=3;i++)
for(int　j=1;j<=i;j++)
sum++;

已知有函数f的定义如下：
int　f(){
static　int　s=0;
s+=2;
return　s;
}
则在程序中第二次执行函数调用语句f();时，函数f的返回值是＿＿。

已知如下程序的输出结果是23，请将画线处缺失的部分补充完整。
#include　<iostream>
using　namespace　std;
class　MyClass{
public:
void　Print()　const{cout<<23;}
};
int　main(){
MyClass　*p=new　MyClass();
＿＿.Print();
return　0;
}

有如下程序：
#include　<iostream>
using　namespace　std;
class　A{
public:
A(){cout<<"A";}
~A)(){cout<<"A";}
};
class　B{
A　a;
public:
B(){cout<<"B";}
~B(){cout<<"B";}
};
int　main(){
B　b;
return　0;
}
程序的输出结果是＿＿。

请在如下程序中的空格处填写正确的语句：
#include　<iostream>
using　namespace　std;
class　Base{
public:
void　fun(){cout<<"Base　fun"<<endl;}
}
class　Derived:public　Base{
public:
void　fun(){
＿＿;//调用基类的函数fun()
cout<<"Derived　fun"<<endl;
}
};

已知类sample是一个抽象类，其成员函数display是无形参，无返货类型的纯虚函数，
请完成其声明：
class　sample{
public:
sample(){};
＿＿
};

有如下复数类的生命，请补充完整。
class　complex{
double　real;　　//实部
double　imag;　　//虚部
public:
complex(double　x,double　y){
real=x;
imag=y;
}
complex　operator　+(complex　c){//重载加法运算符“+”
return　complex(＿＿);
}
};

请将如下程序补充完整，使得输出结果为：bbaa
#include　<iostream>
using　namespace　std;
class　A{
public:
＿＿{cout<<"aa";}
};
class　B:public　A{
public:
~B(){cout<<"bb";}
};
int　main(){
B　*p=new　B;
delete　p;
return　0;
}

请将下列栈类Stack补充完整
class　Stack{
private:
int　pList[100];
int　top;
public:
Stack():top(0){}
void　Push　(const　int　&item);　//新元素item压入栈
int　Pop(void);　　　　//将栈顶元素弹出栈
};
void　Stack::Push(const　int　&item){
if(top==99)　　　　　　　　//如果栈满，程序终止
exit(1);
top++;
＿＿;
}
int　Stack::Pop(){
if(top<0)　　　　　　　　　　//如果栈空，程序终止
exit(1);
return　pList[top--];
}