<?xml:namespace prefix = o ns = "urn:schemas-microsoft-com:office:office" />

一、选择题

1¡¢C++ 对 C 语言作了很多改进，下列描述中（　）使得 C 语言发生了质变，从面向过程变成了面向对象。

A 、增加了一些新的运算符；

B 、允许函数重载，并允许设置缺省参数；

C 、规定函数说明必须用原型；

D 、引进了类和对象的概念；

2¡¢ 下列描述中，（ 　 ）是错误的。

A 、内联函数主要解决程序的运行效率问题；

B 、内联函数的定义必须出现在内联函数第一次被调用之前；

C 、内联函数中可以包括各种语句；

D 、对内联函数不可以进行异常接口声明；

3¡¢ 在 C++ 中，关于下列设置缺省参数值的描述中，（ 　 ）是正确的。

A 、不允许设置缺省参数值；

B 、在指定了缺省值的参数右边，不能出现没有指定缺省值的参数；

C 、只能在函数的定义性声明中指定参数的缺省值；

D 、设置缺省参数值时，必须全部都设置；

4¡¢ （ 　 ）不是构造函数的特征。

  　 A 、构造函数的函数名与类名相同；

  　 B 、构造函数可以重载；

  　 C 、构造函数可以设置缺省参数；

  　 D 、构造函数必须指定类型说明。

5 、（ 　 ）是析构函数的特征。

  　 A 、析构函数可以有一个或多 个 参数；

  　 B 、析构函数名与类名不同；

  　 C 、析构函数的定义只能在类体内；

  　 D 、一个类中只能定义一个析构函数；

6 、关于成员函数特征的下列描述中，（ 　 ）是错误的。

  　 A 、成员函数一定是内联函数；

  　 B 、成员函数可以重载；

  　 C 、成员函数可以设置缺省参数值；

  　 D 、成员函数可以是静态的；

7 、下列静态数据成员的特性中，（ 　 ）是错误的。

  　 A 、说明静态数据成员时前边要加修饰符 static ；

  　 B 、静态数据成员要在类体外进行初始化；

  　 C 、静态数据成员不是所有对象所共用的；

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

8 、友元的作用是（ 　 ）。

  　 A 、提高程序的运用效率；

  　 B 、加强类的封装性；

  　 C 、实现数据的隐藏性；

  　 D 、增加成员函数的种类；

9 、关于 new 运算符的下列描述中，（ 　 ）是错误的。

  　 A 、它可以用来动态创建对象和对象数组；

  　 B 、使用它创建的对象或对象数组可以使用运算符 delete 删除；

  　 C 、使用它创建对象时要调用构造函数；

  　 D 、使用它创建对象数组时必须指定初始值；

10 、关于 delete 运算符的下列描述中，（ 　 ）是错误的。

  　 A 、它必须用于 new 返回的指针；

  　 B 、使用它删除对象时要调用析构函数；

  　 C 、对一个指针可以使用多次该运算符；

D 、指针名前只有一对方括号符号，不管所删除数组的维数。

11 、 const int *p 说明不能修改（ 　 ）。

  　 A 、 p 指针；

  　 B 、 p 指针指向的变量；

  　 C 、 p 指针指向的数据类型；

D 、上述 A 、 B 、 C 三者；

12 、已知： print() 函数是一个类的常成员函数，它无返回值，下列表示中，（ 　 ）是正确的；

  　 A 、 void print() const ；

  　 B 、 const void print() ；

  　 C 、 void const print() ；

D 、 void print(const) ；

13 、派生类的对象对它的基类成员中（ 　 ）是可以访问的。

  　 A 、公有继承的公有成员；

  　 B 、公有继承的私有成员；

  　 C 、公有继承的保护成员；

D 、私有继承的公有成员；

14 、设置虚基类的目的是（ 　 ）。

  　 A 、简化程序；

  　 B 、消除二义性；

  　 C 、提高运行效率；

D 、减少目标代码；

15 、下列描述中，正确的是（ 　 ）

　  A 、虚函数是一个 static  类型的成员函数；

  　 B 、虚函数是一个非成员函数；

  　 C 、抽象类是指具有纯虚函数的类；

D 、抽象类可以说明其对象；

 

二、判断下列描述的正确性，正确填 T ，错误填 F 。

1¡¢C++ 中标识符内的大小写字母是没有区别的。（ 　 ）

2¡¢C++ 是一种以编译方式实现的高级语言。（ 　 ）

3¡¢ 计算函数参数顺序引起的二义性是由不同的编译系统决定的。（ 　 ）

4¡¢ 返回值类型、参数个数和类型都相同的函数也可以重载。（ 　 ）

5¡¢ 使用关键字 class 定义的类中缺省的访问权限是私有（ private ）的。（ 　 ）

6¡¢ 类的私有成员只能被类中的成员函数访问，任何类以外的函数对它们的访问都是非法的。（ 　 ）

7¡¢ 多继承情况下，派生类的构造函数的执行顺序取决于成员初始化列表中的顺序。（ 　 ）

8¡¢ 在公有继承中，基类中的公有成员和私有成员在派生类中都是可见的。（ 　 ）

9¡¢ 在私有继承中，基类中所有成员对派生类都是不可见的。（ 　 ）

10¡¢ 在保护继承中，对于垂直访问等同于公有继承，对于水平访问等同于私有继承。（ 　 ）

11¡¢ 构造函数可以声明为虚函数。（ 　 ）

12¡¢ 在析构函数中调用虚函数时，采用动态束定。（ 　 ）

13¡¢ 在一个成员函数内调用一个虚函数时，对该虚函数的调用进行动态束定。（ 　 ）

14¡¢ 公有继承可以实现子类型。（ 　 ）

15¡¢ 构造函数可以声明为纯虚函数。（ 　 ）

 

三、分析下列程序的输出结果。

  1 、 #include <iostream.h>

class Test;

void fun1(Test t);

Test fun2();

class Test

{

public:

      Test(int n=1) {val=n;   cout<<"Con."<<endl;  }

      Test(const Test& t) {val=t.val; cout<<"Copy con."<<endl;}

      Test& operator = (Test& t) 

      { 

             val=t.val; 

             cout<<"Assignment."<<endl;

             return *this;

      }

private:

      int val;

};

void main()

{

      Test t1(1);

      Test t2=t1;

      Test t3;

      t3=t1;

      fun1(t2);

      t3=fun2();

}

void fun1(Test t){}

Test fun2()

{

      Test t;

      return t;

}

 

  2 、 #include <iostream.h>

class A

{

public:

      A()  {cout<<"A's con."<<endl;}

      ~A(){cout<<"A's des."<<endl;  }

};

class B

{

public:

      B()  {cout<<"B's con."<<endl;}

      ~B(){cout<<"B's des."<<endl;   }

};

class C:public A,public B

{

public:

      C():member(),B(),A()  {cout<<"C's con."<<endl;}

      ~C(){cout<<"C's des."<<endl;  }

private:

      A member;

};

void main()

{

      C obj;

}

 

  3 、 #include <iostream.h>

     class R

{

public:

               R(int r1,int r2) {R1=r1;R2=r2;}

               void print();

               void print() const;

private:

               int R1,R2;

};

void R::print()

{

               cout<<R1<<":"<<R2<<endl;

}

void R::print() const

{

               cout<<R1<<";"<<R2<<endl;

}

void main()

{

　            R a(5,4);

               a.print();

               const R b(20,52);

               b.print();

}

 

4 、 #include <iostream.h>

class A

{

  public:

virtual void act1();

void act2() {act1();}

};

     void A::act1()

     {

        cout<<"A::act1() called. "<<endl;

     }

     class B : public A

{

      public:

     void act1();

     };

     void B::act1()

     {

        cout<<" B ::act1() called. "<<endl;

     }

     void main()

     {

        B b;

        b.act2();

     }