Neusoft——高质量C++程序设计

选择题

1.下列关于友元的描述错误的是( b )。

A.友元关系是单向的且不可传递。
    B.在友元函数中可以通过this指针直接引用对象的私有成员。
C.友元可以是一个普通函数也可以是一个类。
D.通过友元可以实现在类的外部对类的私有成员的访问。

2.虚析构函数的作用是( c )。

A.虚基类必须定义虚析构函数
B.类对象作用域结束时释放资源
    C. delete动态对象时释放资源
D.无意义

3.为了避免嵌套的if-else语句的二义性，C语言规定else总是与( c )组成配对关系。

A.缩排位置相同的if								
B.在其之前未配对的if
    C.在其之前未配对的最近的if							
D.同一行上的if

4.下列关于异常的叙述错误的是( a )。

    A.编译错属于异常，可以抛出。
B.运行错属于异常。
C.硬件故障也可当异常抛出。
D.只要是编程者认为是异常的都可当异常抛出。

5.下列说法正确的是( d )。

A.如果从一个带单个static数据成员的类模板产生几个模板类，则每个模板类共享类模板static数据成员的一个副本。
B.模板函数可以用同名的另一个模板函数重载。
C.同一个形参名只能用于一个模板函数。
    D.关键字class指定函数模板类型参数，实际上表示“任何用户自定义类型”。

6.对于"int *pa[5]；"的描述中，( d )是正确的。

A. pa是一个指向数组的指针，所指向的数组是5个int型元素。
B. pa是一个指向某数组中第5个元素的指针，该元素是int型变量。
C. pa [5]表示某个元素的第5个元素的值。
    D. pa是一个具有5个元素的指针数组，每个元素是一个int型指针。

7.在下列表示引用的方法中，( a )是正确的。已知：int m=10;

    A. int &x=m;								
B. int &y=10;
C. int &z;								
D. float &t=&m;

8.下列for循环的次数为( b )。for（i=0, x=0; !x&&i<=5; i++）

A.5								
    B. 6
C.1								
D.无限

9.对于C/C++语言的函数，下列叙述中正确的是( a )。

    A.函数的定义不能嵌套，但函数调用可以嵌套。
B.函数的定义可以嵌套，但函数调用不能嵌套。
C.函数的定义和调用都不能嵌套。
D.函数的定义和调用都可以嵌套。

10. 在一个被调用函数中，关于return语句使用的描述，( d )是错误的。

A.被调用函数中可以不用return语句。
B.被调用函数中可以使用多个return语句。
C.被调用函数中，如果有返回值，就一定要有return语句。
    D.被调用函数中，一个return语句可以返回多个值给调用函数。

11.在一个函数中，要求通过函数来实现一种不太复杂的功能，并且要求加快执行速度，选用( a )。

    A.内联函数								
B.重载函数
C.递归调用								
D.嵌套调用

12.若一个类中含有纯虚函数，则该类称为( c )。

A.基类								
B.纯基类
    C.抽象类							
D.派生类

13.下列存储标识符中，( c )的可见性与存在性不一致。

A.外部类								
B.自动类
    C.内部静态类							
D.寄存器类

14.在C++中，要实现动态联编，必须使用( d )调用虚函数。

A.类名								
B.派生类指针
C.对象名							
    D.基类指针

15.下列关于类模板的模板参数说法正确的是( d )。

A.只可作为数据成员的类型。
B.可作为成员函数的参数类型。
C.只可作为成员函数的返回值类型。
    D.以上三者都可以。        

16.已知：类A中一个成员函数说明如下：void Set(A&a);其中，A&的含义是( c )。

A.指向类A的指针为a。
B.将a的地址值赋给变量Set。
    C. a是类A对象的引用，用来作函数Set()的参数。
D.变量A与a按位与作为函数Set( )的参数。

17.已知：print( )函数是一个类的常成员函数，它无返回值，下列表示中，( a )是正确的。

    A.void print( ) const;		
B.const void print( );
C.void const print( );		
D.void print(const);

18. 关于虚函数的描述中，( c )是正确的。

A.虚函数是一个static类型的成员函数。
B.虚函数是一个非成员函数。
    C.基类中说明了虚函数后，派生类中将其对应的函数可不必说明为虚函数。
D.派生类的虚函数与基类的虚函数具有不同的参数个数和类型。

19.关于new运算符的下列描述中，( d )是错的。

A.它可以用来动态创建对象和对象数组。
B.使用它创建的对象和对象数组可以使用运算符delete删除。
C.使用它创建对象时要调用构造函数。
    D.使用它创建对象数组时必须指定初始值。

20.下列关于构造函数的说法错误的是( b )。

A.构造函数的名字必须与类的名字相同。
    B.构造函数可以定义为void类型。
C.构造函数可以重载、可以带有默认参数。
D.构造函数可以由用户自定义也可以由系统自动生成。

26.在下列哪种情况下不会调用拷贝构造函数( d )。

A.用一个对象去初始化本类的另一个对象时。
B.函数的形参是类的对象，在进行形参和实参的结合时。
C.函数的返回值是类的对象，函数执行完返回时。
    D.将类的一个对象赋值给另一个本类的对象时。

27.下列说法正确的是( a )。

    A.基类的构造函数和析构函数不能被派生类继承。
B.在派生类中用户必须自定义派生类构造函数。
C.析构函数与构造函数被调用的顺序是一致的。
D.在多重继承中，多个基类的构造函数的调用顺序由定义派生类构造函数时指定的初始化表中的次序决定。

28.在公有派生的情况下，有关派生类对象和基类对象的关系的关系，不正确的叙述是( c )。

A.派生类的对象可以赋给基类对象。
B.派生类的对象可以初始化基类的引用。
    C.派生类的对象可以直接访问基类中的成员。
D.派生类的对象的地址可以赋给指向基类的指针。

29.下列关于抽象类的说明中不正确的是( c )。

A.含有纯虚函数的类称为抽象类。
B.抽象类不能被实例化，但可声明抽象类的指针变量。
    C.抽象类的派生类可以实例化。
D.纯虚函数可以被继承。

30.下列关于虚基类的描述中，错误的是 ( c )。

A.使用虚基类可以消除由多继承产生的二义性。
B.构造派生类对象时，虚基类的构造函数只被调用一次。
    C.声明 class B:virtual public A 说明类B为虚基类。
D.建立派生类对象时，首先调用虚基类的构造函数。

31. ( a )是一个在基类中说明的虚函数，它在该基类中没有定义，但要求任何派生类都必须定义自己的版本。

    A.纯虚函数                       
B.虚析构函数
C.虚构造函数                     
D.静态成员函数

32. 下列数据类型不是C++语言基本数据类型的是( d )。

A.字符型                       
B.整型
C.浮点型                       
    D.数组

33. 关于虚函数的描述中，( b )是正确的。

A.派生类的虚函数与基类的虚函数具有不同的参数个数和类型。x
    B.基类中说明类虚函数后，派生类中其对应的函数一定要说明为虚函数。
C.虚函数是一个成员函数。
D.虚函数是一个static类型的成员函数。

34.下列表达式选项中，( c )是正确的。

A. ++(a++)                       
B. a++b
    C. a+++b                         
D. a++++b

35.循环语句

for(int i=0;i<=5&&!i;i++) cout<<i<<endl;

执行循环次数为( a )。

    A. 1次                       
B. 3次
C. 5次                       
D. 6次

36.实现运行时的多态性要使用( d )。

A.构造函数                       
    B.析构函数
C.重载函数                        
D.虚函数

37.下列关于C++函数的叙述中，正确的是( c )。

A.每个函数至少要具有一个参数。
B.每个函数都必须返回一个值。
    C.函数在被调用之前必须先声明或定义。
D.函数不能自己调用自己。

38. 运行下列程序后，” constructing A!” 和” destructing A!”分别输出几次( b )。

#include<iostream.h>
class A
{
	int x;
public:
	A()
	{cout<<" constructing A!"<<endl;}
	~A()
	{cout<<" "<<endl;}
};
void main()
{
	A a[2];
	A *p=new A;
	delete p;
}

A. 2次，2次                       
    B. 3次，3次
C. 1次，3次                       
D. 3次，1次

39. 若类A是类B的友元，类B是类C的友元，则下列说法正确的是( d )。

A. 类B是类C的友元。
    B. 类A是类C的友元。
C. 类A，B，C互为友元。
D. 以上说法都不对。

40. 有如下程序

#include <iostream>
using namespace std;
class AA{
	int n;
public:
	AA(int k):n(k){ }
	int get( ){ return n;}
	int get( )const{ return n+1;}
};
int main( )
{
	AA a(5);
	const AA b(6);
	cout<<a.get( )<<b.get( );
	return 0;
}

运行该程序结果为( b )。

A. 56                       
    B. 57
C. 67                       
D. 66

判断题

1.使用关键字class定义的类中默认的访问权限是私有(private)的。( 1 )

2.作用域运算符(::)只能用来限定成员函数所属的类。( 0 )

3.构造函数和析构函数都不能重载。( 0 )

4.说明或定义对象时,类名前面不需要加class关键字( 1 )

5.析构函数是一种函数体为空的成员函数。( 0 )

6.对象成员的表示与结构变量成员的表示相同,使用运算符.或->。( 1 )

7.所谓私有成员是指只有类中所提供的成员函数才能直接使用它们,任何类以外的函数对它们的访问都是非法的。( 1 )

8.某类中的友元类的所有成员函数可以存取或修改该类中的私有成员。( 1 )

9.可以在类的构造函数中对静态数据成员进行初始化。( 0 )

10.函数的定义不可以嵌套,类的定义可以嵌套。( 1 )

11. C++语言中,既允许单继承,又允许多继承。（ 1 ）

12.派生类是从基类派生出来,它不能再生成新的派生类。（ 0 ）

13.派生类的继承方式中有两种:公有继承和私有继承。（ 0 ）

14.在公有继承中,基类中的公有成员和私有成员在派生类中都是可见的（ 0 ）

15.在公有继承中,基类中只有公有成员对派生类对象是可见的。（ 1 ）

16.在私有继承中,基类中只有公有成员对派生类是可见的。（ 1 ）

17.在私有继承中,基类中所有成员对派生类的对象都是不可见的。（ 1 ）

18.在保护继承中,对于派生类的访问同于公有继承,而对于派生类的对象的访问同于私有继承。（ 1 ）

19.派生类中至少包含了它的所有基类的成员,在这些成员中可能有的是不可访问。（ 1 ）

20.构造函数可以被继承。（ 0 ）

改错题

1.下列程序有一处错误，指出改正并说明理由。

#include <iostream.h> 
class A 
{
private: 
int x; 
public: 
A(int i){x=i;} A(){x=0;} 
friend int min(A&,A&); 
}; 
int min(A & a,A &b)  
{
 	return (a.x>b.x)?a.x:b.x;
} 
void main() 
{
 A a(3),b(5);  
cout<<a.min(a,b)<<endl; 
}  

//return (a.x>b.x)?a.x:b.x;  取最小值，而表达式的结果返回的是最大值
//[改正]return (a.x<b.x)?a.x:b.x;

2. 下列程序有一处错，请改正并说明理由

#include <iostream.h> 
class A 
{  
 int X,Y;           
protected: 
int zx,zy; 
public: 
void init(int i,int j) {zx=i;zy=j;} 
A(int i,int j,int n=0,int m=0) {X=i,Y=j,zx=m,zy=n;}
 }; 
void main() 
{  
 A a(25,20,3,5); 
a.init(5,9); 
cout<<a.X()<<endl;   
} 

//intX,Y因为X,Y都是私有的，在类外无法直接访问
[修改]public :int X,Y

3. 下列程序有错，请改错并说明理由

 #include <iostream.h> 
Class A 
{   
int a,b; 
public: 
A(int i=0,int j=0);
 		{a=i;b=j;}             
}; 
void main() {    
A *p; 
*p=A(4,5); 
}

//*p=A(4,5);  应该调用带参构造函数生成由p指向的动态对象，使a和b成员分别被初始化为4和5
[改正]p=new A(4,5)

4. 下列程序有错，请改错并说明理由

#include <iostream> 
#include <fstream> 
#include <string>
 using namespace std; 
class A 
{ 
public: 
A(const char *na){strcpy(name,na);} 
private: 
char name［80］; 
}; 
class B:public A 
{  
public: 
B(const char *nm):A(nm){} 
void show(); 
}; 
void show() 
{ cout<<"name:"<<name<<endl; }   
void main() 
{  
B b1("B"); 
show();
} 

//private；因为name如果是私有的，在派生类中无法访问，而基类没有提供成员函数来访问
name，所以更改name访问权限为公有或保护，这样派生类来说是透明。
[修改]public：或protected