一、选择题
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、指针名前只有一对方括号符号,不管所删除数组的维数。
11const int *p说明不能修改( )。
  Ap指针;
  Bp指针指向的变量;
  Cp指针指向的数据类型;
D、上述ABC三者;
12、已知:print()函数是一个类的常成员函数,它无返回值,下列表示中,( )是正确的;
  Avoid print() const
  Bconst void print()
  Cvoid const print()
Dvoid 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();
    }