复习题

一、选择题

1）以下关键字不能用来声明类的访问权限的是__B____。
　　A）public   B）static   C）protected   D）private

2）在公有继承的情况下，允许派生类直接访问的基类成员包括___B___。
　　A）公有成员                           B）公有成员和保护成员
　　C）公有成员保护成员和私有成员         D）保护成员

3）关于运算符重载，下列表述中正确的是___C___。
　　A）C++已有的任何运算符都可以重载
　　B）运算符函数的返回类型不能声明为基本数据类型
　　C）在类型转换符函数的定义中不需要声明返回类型
　　D）可以通过运算符重载来创建C++中原来没有的运算符

4）关于关键字class和typename，下列表述中正确的是__D____。
　　A）程序中的typename都可以替换为class
　　B）程序中的class都可以替换为typename
　　C）在模板形参表中只能用typename来声明参数的类型
　　D）在模板形参表中只能用class或typename来声明参数的类型

5）有如下程序
　　#include<iostream>
　　#include<iomanip>
　　using namespace std;
　　class MyClass{
　　public:
　　    MyClass(){cout<<’A”;}
　　    MyClass(char c ){cout<<c;}
　　    ~MyClass(){out<<’B”;}
　　};
　　void  main(){
　　    MyClass  p1,*p2
　　    p2=new MyClass(‘X’);
　　    delete p2;}
　　执行这个程序幕上将显示输出___D___。
　　A）ABX          B）ABXB      C）AXB     D）AXBB

　6）有如下程序
　　#include<iostream>
　　using namespace std;
　　class Base{
　　protected:
　　  Base(){cout<<’A’;}
　　  Base(char c){cout<<c;}
　　};
　　class Derived:public Base{
　　public:
　　  Derived(char c ){cout <<c;}
　　};
　　int main(){
　　   Derived d1(‘B’);
　　return 0;
　　}
　　执行这个程序屏幕上将显示输出____C__。
　　A）B        B）BA         C）AB            D）BB

　7）有如下类定义：
　　class MyBase{
　　int k;
　　public:
　　    MyBase(int n=0):k(n){}
　　    int value(){return k;}
　　};
　　class MyDerived: MyBase{
　　    int j;
　　public;
　　    MyDerived(int i): j(i){}
　　    int getK()const {return k;}
　　    int getJ()const{return j;}
　　};
　　编译时发现有一处语法错误，对这个错误最佳准确的描述是A
　　A）函数getK试图访问基类的私有成员变量K
　　B）在类MyDerived的定义中，基类名MyBase前缺少关键字public、  protected或private
　　C）类MyDerived缺少一个无参的构造函数
　　D）类MyDerived的构造的数没有对基数数据成员K进行初始化

8）在一个派生类对象结束其生命周期时A
　　A）先调用派生类的析构函数后调用基类的析构函数
　　B）先调用基类的析构函数后调用派生类的析构函数
　　C）如果基数没有定义析构函数，则只调用派生类的析构函数
　　D）如果派生类没有定义析构函数，则只调用基类的析构函数

9）有如下程序

#include<iostream>
using namespace std;
class A{
public:
     virtual void funcl(){cout<< "A1";}
     void fune2(){cout<< "A2";}
};
class B: public A{
public:
     void func1(){cout<< "B1";}
     void func2(){cout<< "B2";}
};
void main(){
     B  *p=new B;
     p->funcl();
     p->func2();
}　　

运行程序，屏幕上将显示输出___A___。
　　A）B1B2         B）A1A2           C）B1A2           D）A1B2

10）下列关于C++函数的叙述中，正确的是（ C）。
　A）每个函数至少要具有一个参数
　B）每个函数都必须返回一个值
　C）函数在被调用之前必须先声明
　D）函数不能自己调用自己

11）下列关于类和对象的叙述中，错误的是（A ）。
　A）一个类只能有一个对象
　B）对象是类的具体实例
　C）类是对某一类对象的抽象
　D）类和对象的关系是一种数据类型与变量的关系

12）在C++中，用于实现运行时多态性的是（D ）。
　A）内联函数
　B）重载函数
　C）模板函数
　D）虚函数

13）下列关于运算符重载的叙述中，正确的是（ ）。
　A）通过运算符重载，可以定义新的运算符
　B）有的运算符只能作为成员函数重载
　C）若重载运算符+，则相应的运算符函数名是+
　D）重载一个二元运算符时，必须声明两个形参

14）下列关于模板的叙述中，错误的是（C ）。
　A）模板声明中的第一个符号总是关键字template
　B）在模板声明中用 < 和 > 括起来的部分是模板的形参表
　C）类模板不能有数据成员
　D）在一定条件下函数模板的实参可以省略

15）有如下类声明：
class Foo { int bar; };则Foo类的成员bar是（C）。
　A）公有数据成员
　B）公有成员函数
　C）私有数据成员
　D）私有成员函数

16）有如下类声明：
class MyBASE{
int k;
public:
void set(int n){ k=n;}
int get( )const{ return k; }
};
class MyDERIVED: protected MyBASE{
protected:
int j;
public:
void set(int m, int n){ MyBASE::set(m); j=n;}
int get( )const{ return MyBASE::get( )+j; }
};
则类MyDERIVED中保护的数据成员和成员函数的个数是（ B）。
　A）4   　   B）3 　        C）2 　           D）1

17）已知在一个类体中包含如下函数原型: VOLUME operator-(VOLUME)const;，下列关于这个函数的叙述中，错误的是（ B）。
　A）这是运算符-的重载运算符函数
　B）这个函数所重载的运算符是一个一元运算符
　C）这是一个成员函数
　D）这个函数不改变类的任何数据成员的值

18）有如下函数模板定义：
template <class T>  T func(T x, T y) { return x*x+y*y; }
在下列对func的调用中，错误的是（C ）。
　A）func(3, 5);
　B）func(3.0, 5.5);
　C）func (3, 5.5);
　D）func<int>(3, 5.5);

19）在下列函数原型中，可以作为类AA构造函数的是（D ）。
　A）void AA(int);
　B）int AA( );
　C）AA(int)const;
　D）AA(int);

20）下列关于this指针的叙述中，正确的是（ B）。
　A）任何与类相关的函数都有this指针
　B）类的成员函数都有this指针
　C）类的友元函数都有this指针
　D）类的非静态成员函数才有this指针

21）有如下程序：
#include <iostream>
using namespace std;
class Test {
public:
Test( ) { n+=2; }
~Test( ) { n-=3; }
static int getNum( ) { return n; }
private:
static int n;
};
int Test::n = 1;
int main( )
{
Test* p = new Test;
delete p;
cout << "n=" << Test::getNum( ) << endl;
return 0;
}
执行后的输出结果是（ A）。
　A）n=0   　B）n=1        　C）n=2        　D）n=3

21）有如下程序：
#include <iostream>
using namespace std;
class A {
public:
A( ) { cout << "A"; }
};
class B { public: B( ) { cout << "B"; } };
class C : public A {
B b;
public:
C( ) { cout << "C"; }
};
int main( ) { C obj; return 0; }
执行后的输出结果是（D ）。
　A）CBA   　B）BAC   　 C）ACB      　D）ABC

22）有如下类声明：
class XA{
int x;
public:
XA(int n){ x=n;}
};
class XB: public XA{
int y;
public:
XB(int a,int b);
};
在构造函数XB的下列定义中，正确的是（B ）。
　A）XB::XB(int a,int b): x(a), y(b){ }
　B）XB::XB(int a,int b): XA(a), y(b){ }
　C）XB::XB(int a,int b): x(a), XB(b){ }
　D）XB::XB(int a,int b): XA(a), XB(b){ }

23）有如下程序：
#include <iostream>
using namespace std;
class BASE{
public:
~BASE( ){ cout<<"BASE";}
};
class DERIVED: public BASE {
public:
~DERIVED( ){ cout<<"DERIVED";}
};
int main( ){DERIVED x; return 0 ;}
执行后的输出结果是（D ）。
　A）BASE
　B）DERIVED
　C）BASEDERIVED
　D）DERIVEDBASE

24）在表达式 x+y*z中， + 是作为成员函数重载的运算符，* 是作为非成员函数重载的运算符。下列叙述中正确的是
（ C）。
　A）operator+有两个参数，operator*有两个参数
　B）operator+有两个参数，operator*有一个参数
　C）operator+有一个参数，operator*有两个参数
　D）operator+有一个参数，operator*有一个参数

25）下面关于C++流的叙述中，正确的是（A ）。
　A）cin是一个输入流对象
　B）可以用ifstream定义一个输出流对象
　C）执行语句序列char *y="PQMN"; cout<<y; 将输出字符串 "PQMN"的地址
　D）执行语句序列char x[80]; cin.getline(x,80); 时，若键入Happy new year
     则x中的字符串是"Happy"

26）有如下程序：
#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）55   　       B）57           　C）75       　   D）77

27)下列（B  ）是C++语言的标识符。
A No.1      B void        C 12fef345      D abc$

28) 下面关于类和对象的描述中，错误的是（  B ）。

A 类就是C语言中的结构体类型，对象就是C语言中的结构体变量

B 类和对象之间的关系是抽象和具体的关系

C 对象是类的实例，一个对象必须属于一个已知的类

D 类是具有共同行为的若干对象的统一描述体

29) 决定C++语言中函数的返回值类型的是（ D  ）。

A return语句中的表达式类型        B 调用该函数时系统随机产生的类型

C 调用该函数时的主调用函数类型     D 在定义该函数时所指定的数据类型

30)下面程序的运行结果为（  C ）。

#include<iostream.h>

void swap(int* a,int &b)

{

   int* temp=a;

   a=&b;

   b=*temp;

}

void main( )

{

   int a=5,b=10;

   swap(&a,b);

   cout<<a<<”  ”<<b<<endl;

}

A 10 5    B 5 10    C 5 5     D 10 10

31)、下列程序的输出结果为（  C ）。

#include<iostream.h>

void main( )

{

   char *a[]={"hello","the","world"};

   char **pa=a;

   pa++;

   cout<<*pa<<endl;

}

A hello   B the   C world   D hellotheworld

32) 下面程序的运行结果为（  D ）。

#include<iostream.h>

void main( )

{

   char a='3';

   switch(a)

   {

    case '3': cout<<"3";

    case '2': cout<<"2"; break;

    default:cout<<"1";

   }

}

A 3   B 321   C 31   D 32

33) 在类的定义中，用于为对象分配内存空间，对类的数据成员进行初始化并执行其他内部管理操作的函数是（  C）。

A 虚函数    B友元函数     C 构造函数    D 析构函数

34) 下列说法正确的是（  B）。

A 内联函数在运行时是将该函数的目标代码插入每个调用该函数的地方

B 内联函数在编译时是将该函数的目标代码插入每个调用该函数的地方

C 类的内联函数必须在类体内定义

D 类的内联函数必须在类体外通过加关键字inline定义

35)下面对静态数据成员的描述中，正确的是（ D ）。

A 静态数据成员可以在类体内进行初始化  

B 静态数据成员不可以被类的对象调用

C 静态数据成员不能受private控制符的作用

D 静态数据成员可以直接用类名调用

36) 类的默认的无参构造函数（ A ）。

A 仅当未定义任何构造函数时存在    B 仅当未定义无参构造函数时存在

C 仅当未定义有参构造函数时存在    D在任何情况下都存在

37) 在重载一个运算符时，如果其参数表中有一个参数，则说明该运算符是（ D ）。

A 一元成员运算符   B 二元成员运算符  

C 一元友元运算符   D 选项B）和选项C）都可能

38)  下面叙述不正确的是（ A ）。

A 基类的保护成员在派生类中仍然是保护的成员

B 基类的保护成员在公有派生类中仍然是保护的

C 基类的保护成员在私有派生类中仍然是私有的

D 对基类成员的访问必须是无二义性的

39) 要实现运行时的多态性，必须通过（A  ）调用虚函数。

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

40) 下列关于模板的说法正确的是（ B ）。

A 模板的实参在任何时候都可以省略  B 类模板中的成员函数全部都是函数模板

C 类模板的参数必须是虚拟类型的    D 类模板与模板类所指的是同一概念

41) 对于重载的运算符>>，它是一个（A  ）。

A 用于输入的友元函数  B 用于输入的成员函数

C 用于输出的友元函数  D 用于输出的成员函数

42) 假设person是一个类，p1是该类的一个对象，p2是一个指向pl的指针，getname是其中的一个成员函数，则下面对象的使用不正确的是（ A ）。

A person.getname( )          B p1.getname( )

C p1.person::getname( )      D p2->getname( )

43) 在C++语言中，打开一个文件就是将这个文件与一个（  B）建立关联。

A 结构   B 流   C 类  D 对象

44) C++语言对C语言做了很多改进，C++语言相对于C语言的最根本的变化是（ B ）。

A 增加了一些新的运算符               B 引进了类和对象的概念

C 允许函数重载，并允许设置缺省参数   D 规定函数说明符必须用原型

45)下列关于C++语言类的描述中错误的是（ C ）。

A 类用于描述事物的属性和对事物的操作

B 类与类之间通过封装而具有明确的独立性

C 类与类之间必须是平等的关系，而不能组成层次结构

D 类与类之间可以通过一些方法进行通信和联络

46)、在公有派生情况下，有关派生类对象和基类对象的关系，下列叙述不正确的是（C  ）。

A 派生类的对象可以赋给基类的对象  

B 派生类的对象可以初始化基类的引用

C 派生类的对象可以直接访问基类中的成员

D 派生类的对象的地址可以赋给指向基类的指针

49) 关于构造函数A( )的拷贝构造函数正确的是（ C ）。

A  A(A  * B);   B  A(A  B);     C  A(A  & B);    D  A(A);

50) 对于模板定义关键字class和typename说法不正确的是（ B ）。

A 程序中的class并不能都替换为typename

B class和typename都可互相替换

C 程序中的typename都能替换为class

D 程序中的部分class可以替换为typename

51) 类A是类B的友元，类B是类C的友元，则下列说法正确的是（D  ）。

A 类B是类A的友元      B 类C是类A的友元

C 类A是类C的友元      D 以上都不对

52) 虚函数必须是所在类的（  A）。

A 成员函数  B 友元函数   C构造函数   D 析构函数

53) 下列关于运算符重载不正确的是（ D ）。

A 运算符重载不能改变运算符的操作数个数

B 运算符重载不能改变运算符的优先级

C 运算符重载不能改变运算符的结合性

D 运算符重载能改变对内置类型数据的操作方式

54) 不可以成为类的数据成员的是（ A ）。

A 该类的对象          B 其它类的对象 

C 该类的指针或引用    D 其他内置数据类型

55) 对于重载的运算符<<，它是一个（ C ）。

A 用于输入的友元函数  B 用于输入的成员函数

C 用于输出的友元函数  D 用于输出的成员函数

56) 可以用A.x的形式访问派生类对象A的基类成员x，其中x是（公有继承的公有成员）。

A 私有继承的公有成员    B 公有继承的私有成员   

57) 为了取代C中带参数的宏,在C++中使用B

    A）重载函数     B）内联函数   C）递归函数     D）友元函数

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

A）派生类的构造函数会隐含调用基类的构造函数

B）如果基类中没有缺省构造函数，那么派生类必须定义构造函数

C）在建立派生类对象时，先调用基类的构造函数，再调用派生类的构造函数

D）在销毁派生类对象时，先调用基类的析构函数，再调用派生类的析构函数

 59)  有如下函数模板template<class T>T square(T x){ return x* x;} 其中T是C

A）函数形参   B）函数实参   C）模板形参   D）模板实参

60)  使用输入输出操作符setw，可以控制B

A）输出精度     B）输出宽度     C）对齐方式     D）填充字符

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

A）y_2006       B）_TEST_H    C）Return       D）switch

62)  有如下函数定义：

    void func(int a,int  & b){a++;    b++;}

若执行代码段：

    int x=0,y=1;

    func(x,y);

则变量x和y的值分别是C

A）0和1  B）1和1  C）0和2  D）1和2

63) 有如下程序：

#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;

     return 0;

}

运行时输出的结果是B

A）0       B）1     C）2       D）3

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

A）派生类不能访问基类的保护成员

B）作为虚基类的类不能被实例化

C）派生类应当向基类的构造函数传递参数

D）虚函数必须在派生类中重新实现

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

A）&&         B）!=          C).          D)++

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

A）template<typename T>T abs(T x){return x<0?-x:x;}

B）template class<T>T abs(T x){return x<0 ?-x:x;}

C）template T<class T> abs(T x){return x<0 ?-x:x;}

D）template T abs(T x){return x<0 ?-x:x;}

67) 在语句cin>>data;中，cin是C

A）C++的关键字      B）类名            C）对象名            D）函数名

68)有如下程序：

#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=_test.a;

          cout<<”copy constructor”<<endl;

}

     ~test(){cout<<”destructor”<<endl;}

};

int main()

{

    test A(3);

    return 0;

}

运行时的输出结果是B

A）3        B）3  destructor    C）copy constructor   D）constructor

69) 若有如下类声明

   class MyClass{

   public:

           MyClass(){cout<<1;}

};

执行下列语句

MyClass a,b[2],*p[2];

以后，程序的输出结果是B

A）11    B）111    C）1111    D）11111

70)有如下程序：C

#include<iostream>

using namespace std;

class Point{

public:

    static int number;

public:

    Point(){number++;}

    ~Point(){number--;}

};

int Point::number=0;

void main(){

    Point *ptr;

    Point A,B;

    Point* ptr_point=new Point[3];

    ptr=ptr_point;

    Point C;

    cout<<Point::number<<endl;

    delete[]ptr;

}运行时输出的结果是

A）3      B）4       C）6       D）7

71)如果不使用多态机制，那么通过基类的指针虽然可以指向派生类对象，但是只能访问从基类继承的成员。有如下程序，没有使用多态机制

#include<iostream>

using namespace std;

class Base{

int a,b;

public:

    Base(int x,int y){  a=x;    b=y;}

    void show(){  cout<<a<<’,’<<b<<endl;}

};

class 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 D1(10,20,30,40);

Pb=&D1;

Pb->show();

Return 0;

}

运行后输出的结果是A

A）10,20  B）30,40  C）20,30   D）50,50

72)有如下程序：

#include <iostream>

using namespace std;

class A

{

public:

    A(int i){x=i;}

    void dispa(){cout<<x<<’,’;}

private:

    int x;

};

class B:public A

{

public:

B(int i):A(i+10){x=i;}

      void dispb(){dispa();cout<<x<<endl;}

private:

    int x;

};

int main()

{

     B b(2);

     b.dispb();

     return 0;

}

运行时输出的结果是C

A）10, 2   B）12,10   C）12,2    D）2,2     

73)虚函数支持多态调用，一个基类的指针可以指向派生类的对象，而且通过这样的指针调用虚函数时，被调用的是指针所指的实际对象的虚函数，而非虚函数不支持多态调用。有如下程序：

#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;

}

运行时输出的结果是A

A)f+g+      B)f0+g+    C)f+g0+    D)f0+g0+

74)下面程序中对一维坐标点类Point进行运算符重载

#include <iostream>

using namespace std;

class Point{

public:

         Point(int val){x=val;}

         Point& operator++(){x++;return *this;}

         Point operator++(int){Point old=*this;++(*this);return old;}

         int GetX() const{return x;}

private:

         int x;

};

int main()

{

         Point a(10);

         cout<<(++a).GetX();

         cout<<a++.GetX();

         return 0;

}

编译和运行情况是B

A)运行时输出1011      B)运行时输出1111    C)运行时输出1112         D)编译有错

75)有如下程序：

#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) return 1;

         return s.x*fun(Sample(s.x -1));

 

}

int main()

{

         int sum=0;

         for(int i=0;i<6;i++){sum+=fun(Sample(i));}

         cout<<sum;

         return 0;

}

运行时输出的结果是C

A)120                 B)16                   C)154                 D)34

76)一个函数功能不太复杂但要求被频繁调用，应选用A

　　A)内联函数 B)重载函数 C)递归函数 D)嵌套函数

77)为了使类中的某个成员不能被类的对象通过成员操作符访问，则不能把该成员的访问权限定义为A

　　A)public   B)protected   C)private   D)static

78)类的析构函数是在什么时候调用的?C

　　A)类创建时 B)创建对象时 C)删除对象时 D)不自动调用

79)通常拷贝构造函数的参数是C

　　A)某个对象名 B)某个对象的成员名

　　C)某个对象的引用名 D)某个对象的指针名

80)下面程序的运行结果为D

　　#include

　　class A

　　{

　　static int n;

　　public：

　　A(){n＝1;}

　　A(int num){n＝num;}

　　void print(){coot<<n;

　　}

　　int A：：n=2：

　　void main()

　　{

　　A a.b(3);

　　a.print();

　　b.pint();

　　cout<

　　}

　　A)11 B)13 C)23 D) 33

81)下列不是描述类的成员函数的是C

　　A)构造函数 B)析构函数 C)友元函数 D)拷贝构造函数

83)继承机制的作用是D

　　A)信息隐藏 B)数据封装 C)定义新类 D)数据抽象

84)下面程序的运行结果是A

class base{

protected:

int a;

public:

base(){ cout<<"0";}

};

class base1:virtual base

{

public:

base1(){cout<<"1";}

};

class base2:virtual base

{

public:

      base2(){cout<<"2";}

};

class derived:public base1,public base2

{

public:

derived(){cout<<"3";}

};

void main()

{

derived obj;

}

　　A)0123            B)3120           C)0312        D)3012

86) 不属于C++语言函数的形式参数声明的是（ A）。

   A.值参数                 B.默认参数

   C. 引用参数              D.地址参数

87)  在C++程序中，直接或间接调用自己的函数称为（ A）。

    A. 递归函数              B. 内联函数

    C.  重载函数             D. 成员函数

88) 将函数声明为内联函数的关键字是( C ).

    A. union               B. extern                                                           

    C. inline               D. explicit

89)  在下列语句中,将函数 int find(int x,int y)正确重载的是( C ).

    A. float find(int x,int y)     B. int find(int a,int b)

    C. int find(int x)           D. float find(int x,int y)

90)  有关类和对象的说法不正确的是（  C ）。

   A对象是类的实例

   B 一个类只有一个对象

   C 任何一个对象只能属于一个类

   D 类与对象的关系和数据与变量的关系相似

   E 类是抽象的，对象是具体的

91)有关构造函数的说法不正确的是（  C ）。

   A 构造函数名和类名相同

   B 构造函数可被程序显示调用

   C 构造函数可有返回类型

   D 构造函数可有多个

   E 构造函数都是由系统自动调用的

92) 有关析构函数的说法不正确的是（  B ）。

   A 析构函数有且只有一个

   B 析构函数可有参数

   C 析构函数的作用是在对象被撤消时收回先前分配的内存空间

   D 析构函数无任何返回类型

93) 关于静态数据成员，下列说法错误的是（   ）。

   A 静态数据必须初始化

   B 静态数据的初始化是在构造函数中进行的

   C 说明静态数据成员时前面要加static

   D 引用静态数据成员时，要在静态数据成员名前加<类名>和作用域运算符

94)   C++中的类有两种用法：一种是类的实例化，即生成类的对象，并参与系统的运行；另一种是通过（B  ），派生出新的类。

A．复用      B.继承

B． 单继承     D.多继承

95)   继承具有（B  ），即当基类本身也是某一个类的派生类时，底层的派生类也会自动继承间接基类的成员。

A.规律性    B.传递性

C.      重复性     D.多样性

96)    在多继承中，公有派生和私有派生对于基类成员在派生类中的可访问性与单继承的规则（ A ）

A.完全相同           B.完全不同

C.部分相同，部分不同   D.以上都不对

97) 下列属于动态多态的是( B    ) 

      A函数重载           B运算符重载            C虚函数          D构造函数重载

98) 下列哪种说法是正确的( A    )

      A不能声明虚构造函数

      B不能声明虚析构函数

      C不能定义抽象类的对象,但可以定义抽象类的指针或引用

      D纯虚函数定义中不能有函数体

99) 重载运算符的实质是函数调用,如果重载了后置单目运算符“++”,执行C++,则相当于执行了哪个函数( A    )

      A c.operator++(c,0)                            B c.operator++( )

      C operator++(c)                                D operator++(c,0)

100)关于函数的调用,哪个是错误的(     )

      A 可以使用指向派生类的基类指针                 B 可以使用基类的引用

      C 可以使用派生类的对象直接访问                 D 可以使用基类的对象