面向对象与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;
}
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值