【补充习题】

一、            选择题

1、以下有关构造函数的叙述不正确的是（　　）。
A、构造函数名必须和类名一致
B、构造函数在定义对象时自动执行
C、构造函数无任何函数类型
D、在一个类构造函数有且仅有一个

2、以下有关析构函数的叙述不正确的是（　　）。
A、一个类只能定义一个析构函数
B、析构函数和构造函数一样可以有形参
C、析构函数不允许有返回值
D、析构函数名前必须冠有符号“~”

3、系统提供的默认拷贝构造函数中形参表和函数体分别为（　　）。
A、形参表为空，函数体为空
B、形参表为空，函数体不为空
C、形参表不为空，函数体为空
D、形参表不为空，函数体不为空

4、设A为test类的对象且赋有初值，则语句test B=A;　表示（　　）。
A、语法错
B、为对象A定义一个别名
C、调用复制构造函数，将对象A复制给对象B
D、仅说明B和A属于同一类

5、若有如下类定义，则下列叙述正确的是（　　）。
   class Time
   {   int H,M,S;
     public:
       void Time(int h,int m,int s) { };   //A
   }    //B
A、A行有错误
B、B行有错误
C、A和B行都有错误
D、A和B行都没有错误

6、若有如下类定义，则下列叙述正确的是（　　）。
   class S
   {   int x;
     public:
       S ( ) {x=0;}
       S (int a) {x=++a;}
       void show( ) {cout<<”x=”<<x<<endl; }
   };
   int main()
   {  S s1=100;
      s1.show();
     return 0;
   }
A、有语法错
B、100
C、101
D、0

7、若有如下类定义，x的值是（　　）。
   class S
   {  int x;
      S (int a=0) {x=++a;}
      ~S ( ) { };
   };
   int main( )
   {  S a (10);
      return 0;
}

A、0
B、10
C、11
D、有语法错，得不到值

8、假定AB为一个类，则执行“AB a(4),b[3],*p[2];”语句时，自动调用该类构造函数的次数为（　　）。
A、3
B、4
C、6
D、9

9、已定义类A，该类构造函数的参数都没有缺省值，执行语句：
A a1(2),a2(1,2),*p=new A[3];
则自动调用该类缺省的构造函数的次数为（　　）。
A、1
B、2
C、3
D、5

10、假定AB为一个类，则该类的拷贝构造函数的声明语句为（　　）。
A、AB &(AB x);
B、AB(AB x);
C、AB(AB &);
D、AB(AB *x);

11、C++中不能被派生类继承的是（　　）。
A、虚函数
B、析构函数
C、静态成员函数
D、运算符重载函数

12、若有以下程序：
   # include
   using namespace std;
   class Q{
     int x,y;
   public:
     Q(int a=0,int b=0) { x=a; y=b; }
     ……
   };
   int main( )
   {  Q q( );      //L
      ……
      return 0;
}
则以下说法正确的是（　　）。
A、L行说明了一个对象q
B、L行说明了一个函数原型
C、L行说明了一个对象数组
D、以上说法都不正确

13、不属于构造函数的特点是（　　）。
A、具有与类名相同的函数名
B、带返回值
C、允许重载
D、在定义类的对象时自动调用

14、以下属于析构函数特征的是（　　）。
A、析构函数名与类名不能相同
B、析构函数的定义必须在类体内
C、析构函数可以带或不带参数
D、在一个类中析构函数有且仅有一个

15、当系统提供一个默认的构造函数时，该构造函数的形参表和函数体为（　　）。
A、无形参，函数体为空
B、有形参，函数体为空
C、无形参，函数体不为空
D、有形参，函数体不为空

16、下列关于构造函数与析构函数的叙述中错误的是（　　）。
A、均无返回值
B、均不可定义为虚函数
C、构造函数可以重载，而析构函数不可重载
D、构造函数可带参数，而析构函数不可带参数

17、当对象要消除的时候，系统自动调用的函数是（　　）。
A、拷贝构造函数
B、复制函数
C、构造函数
D、析构函数

18、析构函数与构造函数非共同具有的特点是（　　）。
A、函数名与类名相同
B、允许重载
C、不能使用void说明返回类型
D、不带返回值

19、拷贝函数的作用为（　　）。
A、创建一个与已知对象共用同一内存地址的对象
B、用一个已知对象来初始化一个被创建的同类的对象
C、创建一个与已知对象完全相同的对象
D、创建一个临时对象

20、通常拷贝构造函数的形参是（　　）。
A、指向对象的指针
B、对象的引用
C、一个对象
D、类

21、假定A为一个类，并执行语句A a; 后，则（　　）。
A、系统将自动调用构造函数
B、系统将自动调用析构函数
C、系统将自动调用拷贝构造函数
D、系统将自动调用复制构造函数

二、            填空题：

1、若AB为一个类的类名，执行语句：
   AB a[10];
则系统自动调用该类的构造函数的次数为（　　　　）。

2、下列程序的输出结果是（　　　　）。
   class Sample
   {  public: 
          int x,y;
          Sample(int a) {x=a;}
          Sample(int a,int b) {x=a; y=b; cout<<x<<’\n’; }
          ~Sample( ) { cout<<”delete”<<’\n’; }
   };
   int main( )
   {  Sample s1(5);
      s1.~Sample( );
      return 0;
   }

3、下列程序的输出结果是（　　　　）。
   class S
   {      int x;
       public:
          S(int a)  { x=a; }
          S(S &a)  { x=a.x+1; }
          void show( )  { cout<<”x=”<<x<<endl; }
   };
   int main( )
   {   S s1(2),s2(s1);
       s2.show( );
       return 0;
}

4、下列程序的输出结果是（　　　　）。
   class A
   {  public:
          int X;
          A(int x) { X=x*x; }
   };
   class S
   {      int x;
          A a;
       public:
          S(int b, int c): a(c) { x=b+a.X; }
          void show( )  { cout<<”x=”<<x<<endl; }
   };
   int main( )
   {   S s1(2,3);
       s1.show( );
       return 0;
 }

5、写出以下程序的执行结果（　　　　）。
   #include
   using namespace std;
   class B
   {      int x,y;
      public:
          B( ) { x=y=0; cout<<”Con1”<<’\t’; }
          B(int i) { x=i; y=0; cout<<”Con2”<<’\t’; }
          B(int i,int j) { x=i; y=j; cout<<”Con3<<’\t’; }
          ~B( ) { cout<<”Des”<<’\t’; }
   };
   int main( )
   {   B *ptr;
       ptr=new B[3];
       ptr[0]=B( );
       ptr[1]=B(1);
       ptr[2]=B(2,3);
       delete [ ]ptr;
       return 0;
   }

6、下列程序的输出结果分别为（　　　　）和（　　　　）。
   class A
   {  public:
          double m; int n;
          A(double i=5,int j=6) { m=i; n=j; }
   };
   int main( )
   {   A a(12);
       cout<<a.m<<’\t’<<a.n;
       return 0;
}

7、下列程序第一行和第二行输出结果分别是（　　　　）。
class Sample
{  public:
       int x,y;
       Sample( ) { x=y=0; }
       Sample(int a) { x=a; }
       Sample(double a) { x=++(int) a; }
       void show( ) { cout<<”x=”<<x<<’\n’; }
};
int main( )
{   Sample s1(5),s2(10/5.0);
    s1.show( );
    s2.show( );
    return 0;
}

8、下列程序的第一行输出的结果是（　　　　），第二行输出的结果是（　　　　）。
class S
{    int x.y;
   public:
       S( ) { x=y=0; }
       S(int a,int b) { x=a;y=b; }
       ~S( ) { if(x==y)  cout<<”x=y”<<endl;
             else cout<<”x!=y”<<endl;
            }
};
int main( )
{  S s1,s2(2,3);   return 0;  }

9、下列程序的输出结果分别是（　　　　）和（　　　　）。
class A
{  public:
       A(double i=5,int j=10) { m=i; n=j; }
       double m; int n;
};
int main( )
{  A a(5,6);
   a=A(20);
   cout<<a.m<<’\t’<<a.n;
   return 0;
}

10、如下程序的第一行输出结果是（　　　　），第二行输出结果是（　　　　），第三行输出结果是（　　　　）。
#include
using namespace std;
class Test
{      int x,y;
   public:
      Test(int a,int b) { x=a; y=b; cout<<”调用了构造函数!\n”; }
      Test(Test &t) { x=t.x; y=t.y; cout<<”调用了拷贝构造函数!\n”; }
      void show( ) { cout<<”x=”<<x<<”\ty=”<<y<<endl; }
};
int main( )
{  Test t1(10,20);
   Test t2=t1;
   Test t3(t1);
   return 0;
}

11、下列程序的输出结果是（       ）。
#include
using namespace std;
class Sample
{  int x;
  public:
    Sample ( ) { }
    Sample (int a) {x=a;}
    Sample (Sample &a) {x=a.x+++10;}
   void disp(char *ob) { cout<<” “<<ob<<”.x=”<<x;}
};
int main()
{  Sample s1,s2 (20),s3 (s2);
   s1=s2;
   s1.disp(“s1”);
   s2.disp(“s2”);
   s3.disp(“s3”);
   return 0;
}

12、若有下列类定义，请对其构造函数进行完善。
class A
{  public:
       int X;
       A(int x) { X=x*x; };
};
class S
{      int x;
       A a;
   public:
       S( int b, int c) ______________
       {  x=b+_______ .X;  }
};

13、下面的字符串类实现了对英语单词的初始化，并且实现搜寻子串的功能，若存在相应的子串，则进行相应的统计。请完善该程序。
   #include
   #include
   #include
   using namespace std;
   static int n=0;
   class Word
   {   char name[20];
     public:
       Word (char n[])
        {  if (strlen(n)>19)  cout<<”单词太长！”, exit(0);
           for (int i=0;n[i]!=’\0’;i++)
               __________;
           name[i]=’\0’;
        }
       void search(char s[ ])
       {   int j;
           for (j=0; s[j]!=’\0’&&name[j]!=’\0’&&s[j]= =name[j]; j++) ;
           if (_________)  
              {  cout<<name<<“ ”<<endl;
                  __________;
               }
        }
   };
   int main( )
   {   Word w[4]={Word(“China”), Word(“American”),Word(“England”),Word(“India”)};
       char find[12];
       cout<<”请输入要查找的字符串：”;
       cin>>find;
       for (int i=0;i<4;i++) {
         __________;
       }
       cout<<”找到了”<<n<<”个匹配的单词”;
       return 0;  }

【上期课后习题答案】

1、抽象，形象

2、封装性、继承性、多态性

3、class,私有，公有，公有，私有

4、public，private，protected，private，无，允许

5、略