如何避免被C++默认拷贝构造函数忽悠？

一、背景介绍

          因为工作关系，需要用到C++编程。对于我来说，虽然一直从事的是linux平台下的嵌入式软件开发，但深入用到C++的特性的地方并不多。对于C++,用得最多的无非是指针、封装、继承、组合以及虚函数。对于复制构造函数、重载操作符、智能指针等概念，虽然也时有接触，但真正自己写代码需要用到的时候，并不多。

          本文尝试对复制构造函数的定义、作用及需要注意的地方做一个简单的解剖。希望能抛砖引玉，对大家的学习起到一个帮助作用。

           虽然复制构造函数对于基本的C++编程来说，可能不太用得着。不过这并不说明复制构造函数没什么用，其实复制构造函数能解决一些我们常常会忽略的问题。

            假设有一个CStudent类,有数据成员char* name;

            现在有一个对象CStudent stu1("tom");//数据成员name="tom";

            再生成一对象,stu2,把stu1拷贝给stu2,即CStudent stu2(stu1);

            如果我们没有写拷贝构造函数,那么编译器会调用默认的拷贝构造函数.即进行浅拷贝.

浅拷贝的意思就是内存中只有一份"tom",对象stu1的name指针指向了它.把stu1拷贝给stu2后,stu2的name指向也指向了"tom",指向的是内存中同一块地址.这就会出现一个问题:当stu1的对象被销毁了,那么stu1的name指向的"tom"也会被销毁,由于stu2中的name也是指向"tom"的,所以这时stu2中的name就变成空的了,甚至是乱码.

           如果我们自己写了拷贝构造函数,那么在内存中就会有两份"tom"了,这时stu1的name和stu2的name就没有什么关系了,只不过他们的值都是"tom"而已!

           类似的问题，我们看看如下代码，并编译运行看看结果：

#include <iostream>
 
class Array {
public:
    int size;
    int* data;
 
    implicit Array(int size) 
        : size(size), data(new int[size])
    {
    }
 
    ~Array() 
    {
        delete[] this->data;
    }
};
 
int main() 
{
    Array first(20);
    first.data[0] = 25;
 
    {
        Array copy = first;
        std::cout << first.data[0] << " " << copy.data[0] << std::endl;
    }    // (1)
 
    first.data[0] = 10;    // (2)
}

运行结果：

25 25

Segmentation fault

为什么会出现segmentation fault段错误这么严重的问题呢？

根本原因跟前面那个例子一样，我们没有写拷贝构造函数。因此，编译器会为我们生成一个默认的拷贝构造函数。默认的构造函数形式如下：

Array(const Array& other)
  : size(other.size), data(other.data) {}

该默认构造函数有什么问题呢？

它对data 指针执行的是浅拷贝。也就是说，它只是拷贝原始data成员的地址，这样就带来了两个对象共享指向同一块内存的指针的风险。代码执行到main函数（1）处时，即执行到：

    {
        Array copy = first;
        std::cout << first.data[0] << " " << copy.data[0] << std::endl;
    }    // (1)

（1）处时，copy的析构函数会被调用，因为分配在stack上的对象，是自动释放的。当我们进入一个特定的作用域时，堆栈指针会向下移动一个单位，为那个作用域内创建的、以堆栈为基础的所有对象分配存储空间。而当我们离开作用域的时候（调用完毕所有局部构建器后），堆栈指针会向上移动一个单位，也就是copy对象的析构函数在执行到（1)处后会自动得到调用。Array的析构函数，删除了copy的data.由于first和copy对象都共享一个data指针，因此当执行到（2）处，即调用first.data[0]=10时，就会产生令人头痛的段错误：：segmentation fault.

如何解决这个问题呢？

写一个自己的拷贝构造函数，并执行深拷贝：

// for std::copy
#include <algorithm>
 
Array(const Array& other)
    : size(other.size), data(new int[other.size]) 
{
    std::copy(other.data, other.data + other.size, data); 
}

二、浅拷贝与深拷贝

浅拷贝：仅仅逐个成员拷贝，而不拷贝资源的方式；浅拷贝是指源对象与拷贝对象共用一份实体，仅仅是引用的变量不同（名称不同）。对其中任何一个对象的改动都会影响另外一个对象。举个例子，一个人一开始叫张三，后来改名叫李四了，可是还是同一个人，不管是张三缺胳膊少腿还是李四缺胳膊少腿，都是这个人倒霉。比较典型的就有Reference（引用）对象，如Class（类）。

深拷贝：既拷贝成员，又拷贝资源的方式。深拷贝是指源对象与拷贝对象互相独立，其中任何一个对象的改动都不会对另外一个对象造成影响。举个例子，一个人名叫张三，后来用他克隆（假设法律允许）了另外一个人，叫李四，不管是张三缺胳膊少腿还是李四缺胳膊少腿都不会影响另外一个人。比较典型的就是Value（值）对象，如预定义类型Int32，Double，以及结构（struct），枚举（Enum）等。

系统提供的默认拷贝构造函数为浅拷贝，深拷贝必须自己定义。

这也解释了背景中的段错误原因及为什么要自己写拷贝构造函数.

三、什么是拷贝构造函数

拷贝构造函数，是一种特殊的构造函数，它由编译器调用来完成一些基于同一类的其他对象的构建及初始化。其唯一的参数（对象的引用）是不可变的（const类型）。也就是说，当用一个已经存在的对象为一个新的对象进行赋值时，首先要给新对象的数据成员分配空间资源以创建新对象，然后用源对象的成员值进行初始化。这个行为必须在对象构造的时候进行完成，而普通的构造函数无法完成这项工作，因此拷贝构造函数应运而生！

在C++中，下面三种对象需要拷贝的情况。因此，拷贝构造函数将会被调用。
  1)． 一个对象以值传递的方式传入函数体
  2)． 一个对象以值传递的方式从函数返回
  3)． 一个对象需要通过另外一个对象进行初始化搜索
  以上的情况需要拷贝构造函数的调用。如果在前两种情况不使用拷贝构造函数的时候，就会导致一个指针指向已经被删除的内存空间。对于第三种情况来说，初始化和赋值的不同含义是构造函数调用的原因。事实上，拷贝构造函数是由普通构造函数和赋值操作赋共同实现的。

拷贝构造函数的标准写法如下：

class  Base

{ 

    public:

       Base(){} 
       Base( const Base &b){..}  //拷贝构造函数的参数必须是该对象的引用

}

 进一步总结：

1) 拷贝构造函数的作用就是用来复制对象的，在使用这个对象的实例来初始化这个对象的一个新的实例。
2）如果不显式声明拷贝构造函数的时候，编译器也会生成一个默认的拷贝构造函数，只执行浅拷贝在一般的情况下，浅拷贝运行的也很好。

但是在遇到类有指针数据成员时就出现问题了：因为默认的拷贝构造函数是按成员拷贝构造，这导致了两个不同的指针(如ptr1=ptr2)指向了相同的 内存。当一个实例销毁时，调用析构函数free(ptr1)释放了这段内存，那么剩下的一个实例的指针ptr2就无效了，在被销毁的时候free(ptr2)就会出现错误了, 这相当于重复释放
一块内存两次。这种情况必须显式声明并实现自己的拷贝构造函数，来为新的实例的指针分配新的内存。

 

 

 

 

 

 

 

 

 

 

: