答案为博主本人自作或查询，仅供参考
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;
}