面向对象与C++程序设计第13次练习题（堆与复制构造函数）

答案为博主本人自作或查询，仅供参考

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

友元函数
虚函数
构造函数
析构函数

2-2
类的析构函数的作用是

一般成员函数的初始化
类的初始化
对象的初始化
删除类创建的对象

2-3
下列函数中，（ ）不能重载。

成员函数
非成员函数
析构函数
构造函数

2-4
下列关于类和对象的叙述中，错误的是

一个类只能有一个对象
对象是类的具体实例
类是对某一类对象的抽象
类和对象的关系是一种数据类型与变量的关系

2-5
下列属于类的析构函数特征的是

一个类中只能定义一个析构函数
析构函数名与类名不同
析构函数的定义只能在类体内
析构函数可以有一个或多个参数

2-6
下列关于类定义的说法中，正确的是

类定义中包括数据成员和函数成员的声明
类成员的缺省访问权限是保护的
数据成员必须被声明为私有的
成员函数只能在类体外进行定义

2-7
假设MyClass是一个类，则该类的拷贝初始化构造函数的声明语句为（ ）

MyClass&(MyClass x);
MyClass(MyClass x);
MyClass(MyClass &x);
MyClass(MyClass *x);

2-8
下列关于类的构造函数的描述中，错误的是

类的构造函数可以重载
类可以没有构造函数
类的构造函数可以缺省
类的构造函数可以作为其它类型向本类类型进行转换的函数

2-9
下列对重载函数的描述中，（ ）是错误的。

重载函数中不允许使用默认参数
重载函数中编译根据参数表进行选择
不要使用重载函数来描述毫无相干的函数
构造函数重载将会给初始化带来多种方式

2-10
建立一个类对象时，系统自动调用

构造函数
析构函数
友元函数
成员函数

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

#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; }
1234
1324
1342
3142

2-12
类的析构函数是在什么时候调用的？

类创建时
创建对象时
删除对象时
不自动调用

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

delete
new
pos
auto

2-14
对于任意一个类，析构函数的个数最多为（ ）

0
*1
2
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]

答案

#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]();
    }

    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& operator=(const Array& a)//重载“=”，便于类对象的data数组赋值
    {
        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; //this指针返回本函数本身的Array
    }
    ~Array()
    {
        delete[]data;//写析构函数是个好习惯，节约内存
    }
    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;
}