16 复制构造函数【C++】

• 16+
• • 单选题
  • 函数题
  • • 6-1 实现数组类（C++ 拷贝构造函数、拷贝函数）
• 16+
• • 判断题
  • 单选题
  • 函数题
  • • 6-1 学生成绩的快速录入（构造函数）
    • 6-2 解决内存泄漏问题
    • 6-3 为my_string类创建复制构造函数copy constructor

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 C
假设MyClass是一个类，则该类的拷贝初始化构造函数的声明语句为（ ）
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
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 B
C++提供的可有效分配对象空间的运算符是（ ）
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 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
    int n, k;
    cin >> n >> k;
    Array a(n);  // 构造数组，大小为 n
    for(int i=0; i 
Array(int n ){ 
    size = n;
    data = new int[size]( );
}

Array(const Array &arr ){  
	if(arr.size>0){ 
        size = arr.size;
        data = new int[size]( );
        for (int i = 0; i < size; i++){
           data[i] = arr.data[i];
        }
    }
}

Array & operator = (const Array& arr){
	if(this!=&arr)//如果等号右侧的对象和左边的不是一个对象再赋值(没有这句会运行error)，要判断赋值左右对象不相等，坑惨了 
	{
        delete []data;//先释放掉之前的内存，否则会内存超限	
        size = arr.size;
        data = new int[size]( );
        for (int i = 0; i < size; i++){
           data[i] = arr.data[i];
        }
    }
    return *this;
}

~Array() {
    if (this->data != NULL) {//不为空才释放
      delete []data;
    }
}
		

 
16+ 
判断题 
1-1 T
 将构造函数说明为纯虚函数是没有意义的。
 
1-2 F
 对象间赋值将调用拷贝构造函数。
 
单选题 
2-1 C
 设A为自定义类，现有普通函数int fun(A& x)。则在该函数被调用]时：
 A.将执行复制构造函数来初始化形参x
 B.仅在实参为常量时，才会执行复制构造函数以初始化形参x
 C.无需初始化形参x
 D.仅在该函数为A类的友元函数时，无需初始化形参x
 
2-2 B
 在以下哪种情形，复制构造函数会被调用。
 A.当一个对象采用引用方式，作为参数传递给一个函数
 B.当一个函数采用值方式，返回一个对象
 C.当一个对象赋值给另一个对象
 D.以上答案都不对
 
2-3 A
 假设A是一个类的名字,下面哪段程序不会用到A的拷贝构造函数？
 A.A a1,a2; a1=a2;
 B.void func( A a) { cout<<“good”<< endl; }
 C.A func() { A tmp; return tmp;}
 D.A a1; A a2(a1);
 
函数题 
6-1 学生成绩的快速录入（构造函数） 
6-1 学生成绩的快速录入（构造函数）
现在需要录入一批学生的成绩（学号，成绩）。其中学号是正整数，并且录入时，后录入学生的学号会比前面的学号大；成绩分两等，通过(Pass,录入时用1代表),不通过(Fail,录入时用0代表）。

由于很多学号都是相邻的，并且学号相邻的学生成绩常常相同。所以在录入时，适当地加了速。如果当前学生的学号比前面的学号大1，且成绩与前面的成绩相同，则只输入0即可。

类定义：
完成Student类
裁判测试程序样例：
#include
using namespace std;



int main(){
    const int size=100;
    int i, N, no, score;
    Student *st[size];
    cin>>N;
    for(i=0; i
        cin>>no;
        if(no>0){
            cin>>score;
            st[i]=new Student(no, score);
        }
        else
            st[i]=new Student(*st[i-1]);
    }
    cout<display();
    for(i=0;i 
6-2 解决内存泄漏问题 
6-2 解决内存泄漏问题
编译、运行下列程序后。从输出结果发现没有调用 class Y 的析构函数，出现了内存泄漏。请尝试修改class X类的定义解决这个内存泄露问题。并提交定义class X类的代码。

class X类的定义如下：
class X{
public:
    X() { p = new int[2]; cout << "X().    "; }
   ~X() { delete [] p; cout << "~X().n"; }
private:
    int* p;
};
#include  
using namespace std; 
// 你提交的代码将嵌入到这里


class Y : public X
{
public:
   Y( ) { q = new int[1023]; cout << "Y( )    "; }
   ~Y( ) { delete [] q; cout << "~Y().    "; }
private:
   int* q;
};
int main()
{
  int n;
  cin>>n; 
  for (int i = 0; i < n; i++)
  {
    X* r = new Y;
    delete r;
  }
  return 0;
}
从输出结果发现没有调用 class Y 的析构函数，出现了内存泄漏。
3
X().    Y( )    ~X().
X().    Y( )    ~X().
X().    Y( )    ~X().
输入样例：
3
输出样例：（输出显示调用了Y类的析构函数）
X().    Y( )    ~Y().    ~X().
X().    Y( )    ~Y().    ~X().
X().    Y( )    ~Y().    ~X().
 
class X{
public:
    X() { p = new int[2]; cout << "X().    "; }
   
   virtual ~X() { delete [] p; cout << "~X().n"; }
private:
    int* p;
};
 
6-3 为my_string类创建复制构造函数copy constructor 
6-3 为my_string类创建复制构造函数copy constructor
为下面的my_string类创建一个复制构造函数，并将定义该类的代码提交。

my_string类的定义：
class my_string {
   char *s;
public:
   my_string(char *str)  {
      s = new char[strlen(str)+1];
      strcpy(s, str);
   }
   ~my_string() {
       if(s) delete [] s;
       cout << "Freeing sn"; 
    }
   void show() { cout << s << "n"; }
};
裁判测试程序样例：
#include 
#include 
using namespace std;
// 你提交的代码将被嵌入到这里


int main()
{
   char str[80];
   cin>>str;
   my_string obj(str); 

   my_string ob1(obj);    
   my_string ob2=ob1;
  
   ob1.show();
   ob2.show();

   return 0;
}
输入样例：
ByeBye
输出样例：
ByeBye
ByeBye
Freeing s
Freeing s
Freeing s
 
class my_string {
   char *s;
public:
   my_string(char *str)  {
      s = new char[strlen(str)+1];
      strcpy(s, str);
   }
    my_string(const my_string &str){
         s = new char[strlen(str.s)+1];
        strcpy(s, str.s);
    }
   ~my_string() {
       if(s) delete [] s;
       cout << "Freeing sn"; 
    }
   void show() { cout << s << "n"; }
};