C++ 类的构造函数和析构函数

一、单选题
2-1在类的定义中，用于为对象分配内存空间，对类的数据成员进行初始化并执行其他内部管理操作的函数是 C
A 友元函数
B 虚函数
C 构造函数
D 析构函数

2-2类的析构函数的作用是 D
A 一般成员函数的初始化
B 类的初始化
C 对象的初始化
D 删除类创建的对象

2-3下列函数中，（ C ）不能重载。
A 成员函数
B 非成员函数
C 析构函数
D 构造函数

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

2-5下列属于类的析构函数特征的是 A
A 一个类中只能定义一个析构函数
B 析构函数名与类名不同
C 析构函数的定义只能在类体内
D 析构函数可以有一个或多个参数

2-6下列关于类定义的说法中，正确的是 A
A 类定义中包括数据成员和函数成员的声明
B 类成员的缺省访问权限是保护的
C 数据成员必须被声明为私有的
D 成员函数只能在类体外进行定义

2-7假设MyClass是一个类，则该类的拷贝初始化构造函数的声明语句为（ ） C
A MyClass&(MyClass x);
B MyClass(MyClass x);
C MyClass(MyClass &x);
D MyClass(MyClass *x);

2-8下列关于类的构造函数的描述中，错误的是 D
A 类的构造函数可以重载
B 类可以没有构造函数
C 类的构造函数可以缺省
D 类的构造函数可以作为其它类型向本类类型进行转换的函数
此答案报错

2-9下列对重载函数的描述中，（ A ）是错误的。
A 重载函数中不允许使用默认参数
B 重载函数中编译根据参数表进行选择
C 不要使用重载函数来描述毫无相干的函数
D 构造函数重载将会给初始化带来多种方式

2-10建立一个类对象时，系统自动调用 A
A 构造函数
B 析构函数
C 友元函数
D 成员函数

2-11下面程序的运行结果为 C

#include<iostream.h>
class A
{
public:    
   A（）{cout<<"1";}
   ~A（）{cout<<"2";}
};
class B:public A
{
public:
     B（）{cout<<"3";}
     ~B（）{cout<<"4";}
};
void main（）
{  B b; }

A 1234
B 1324
C 1342
D 3142

2-12类的析构函数是在什么时候调用的？ C
A 类创建时
B 创建对象时
C 删除对象时
D 不自动调用

2-13 C++提供的可有效分配对象空间的运算符是（ ） B

A delete
B new
C pos
D auto

2-14对于任意一个类，析构函数的个数最多为（ ） B
A 0
B 1
C 2
D 3

二、函数题
6-1 实现数组类（C++ 拷贝构造函数、拷贝函数） (10分)
裁判测试程序样例中展示的是一段实现“数组类”的代码，其中缺失了部分代码，请补充完整，以保证测试程序正常运行。

函数接口定义：

提示：要想程序正确运行，至少需要补充以下函数（可能还需要补充其他函数）：
1. 带参构造函数
2. 拷贝构造函数
3. 拷贝函数（赋值运算符重载）

裁判测试程序样例：

#include <iostream>
using namespace std;
class ArrayIndexOutOfBoundsException{  // 异常类
public:
    int index;
    ArrayIndexOutOfBoundsException(int k){
        index = k;
    }
};
class Array{
private:
    int *data;
    int size;
    static const int dSize = 10;   // 数组默认大小
public:
    Array( ){  // 无参构造
        size = dSize;
        data = new int[size]( );
    }
		
/** 你提交的代码将被嵌在这里（替换本行内容） **/		
		
    int& operator [] (int k){     // 运算符 [ ] 重载，以方便数组的使用
        if(k<0 || k>=size) throw ArrayIndexOutOfBoundsException(k);
        return data[k];
    }
    friend ostream& operator << (ostream& o, const Array& a);   // 运算符 << 重载，以方便输出
};
ostream& operator << (ostream& o, const Array& a){
    o << '[' ;
    for(int i=0; i<a.size-1; i++)
        o << a.data[i] << ',' ;
    o << a.data[a.size-1] << ']';
    return o;
}
// 注意：实际测试程序中，在此处之前的代码与样例中相同
// 注意：实际测试程序中，在此处之后的代码（即main函数）可能与样例中不同
int main(){
    int n, k;
    cin >> n >> k;
    Array a(n);  // 构造数组，大小为 n
    for(int i=0; i<n; i++) a[i] = i;
    Array b = a;  // 拷贝构造数组
    b[n/2] = k;
    cout << a << endl;
    cout << b << endl;
    Array c;  // 构造数组，默认大小
    c = a; // 拷贝数组
    c[n/2] = k;
    cout << a << endl;
    cout << c << endl;
    a = a;
    a[n/2] = 2223;
    cout << a << endl;
    return 0;
}

输入样例：

15 666

输出样例：

[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
[0,1,2,3,4,5,6,666,8,9,10,11,12,13,14]
[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
[0,1,2,3,4,5,6,666,8,9,10,11,12,13,14]
[0,1,2,3,4,5,6,2223,8,9,10,11,12,13,14]

Array(int n) 
{
    size = n;
    data = new int[size]();
}
Array(const Array& a) 
{
    size = a.size;
    data = new int[size];
    for (int i = 0; i < size; i++) 
    {
        data[i] = a.data[i];
    }
}
~Array() 
{
    delete[] data;
}
Array& operator=(const Array& a) 
{
    if (a.size != size) 
    {
        delete[] data;
        size = a.size;
        data = new int[size];
    }
    for (int i = 0; i < size; i++) 
    {
        data[i] = a.data[i];
    }
    return *this;
}