PTA-C++(复制构造函数1)

一.单选题

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
下列关于类的构造函数的描述中，错误的是(B)

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
   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 intsize;
   }

/** 你提交的代码将被嵌在这里（替换本行内容） **/

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(Array& a)
    {
        size = a.size;
        data = new int[size];
        for (int i = 0; i < size; i++)
        {
            data[i] = a.data[i];
        }
    }
    Array& operator=(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; //this指针返回本函数本身的Array
    }
    ~Array()
    {
        delete[] data;
    }