c++ 拷贝构造函数的一点理解

函数形参，分配内存有3种情况：

1. 定义形参类型是值传递：函数调用时分配内存；
2. 定义形参类型是引用传递：函数调用时不分配内存。
3. 定义形参类型是指针传递：函数调用时不分配内存。

1、定义形参类型是值传递，函数调用分配内存，如下

定义一个函数

int func(int a)
{
    printf("value=%d\n",a);
    return 0;
}

当函数调用时，

func(2);

实际执行如下

{
    a = 2;
    printf("value=%d\n",a);
    return 0;
}

如上，函数调用时，形参分配内存，然后将实参的值赋值给形参。

2、定义形参类型是引用传递：函数调用时不分配内存，直接使用实参进行操作

3、再来看一下类，如下

#include <iostream>
#include <cstdlib>
using namespace std;

//变长数组类
class Array{
public:
    Array();
    Array(int len);
    Array(const Array &arr);  //拷贝构造函数
    ~Array();
private:
    int m_len;
    int *m_p;
};

Array::Array()
{
    printf("%s %d\n",__FUNCTION__,__LINE__);
}

Array::Array(int len): m_len(len)
{
    printf("%s %d\n",__FUNCTION__,__LINE__);
    m_p = (int*)calloc( len, sizeof(int) );
}

Array::Array(const Array &arr){  //拷贝构造函数
    printf("%s %d\n",__FUNCTION__,__LINE__);
}

Array::~Array()
{
    printf("%s %d\n",__FUNCTION__,__LINE__);
}

Array func(Array arr)
{
    printf("%s %d\n",__FUNCTION__,__LINE__);
    Array ret;
    printf("%s %d\n",__FUNCTION__,__LINE__);
    ret = arr;
    printf("%s %d\n",__FUNCTION__,__LINE__);
    return ret;
}

int main(){
    Array a(10);
    func(a);
    printf("%s %d\n",__FUNCTION__,__LINE__);

    return 0;
}

 

 执行后打印如下

Array 24        第48行创建对象a，调用的类构造函数
Array 29        第49行a作为实参传递给func函数时，a拷贝给arr，调用拷贝函数
func 39         func函数体内第一次打印
Array 19        第40行创建对象ret，调用构造函数
func 41         func函数体内第二次打印
func 43         func函数体内第三次打印
~Array 34       func函数退出，ret析构
~Array 34       func函数退出，arr析构
main 50
~Array 34       main函数退出，a析构

func函数定义为引用类型形参，如下

#include <iostream>
#include <cstdlib>
using namespace std;

//变长数组类
class Array{
public:
    Array();
    Array(int len);
    Array(const Array &arr);  //拷贝构造函数
    ~Array();
private:
    int m_len;
    int *m_p;
};

Array::Array()
{
    printf("%s %d\n",__FUNCTION__,__LINE__);
}

Array::Array(int len): m_len(len)
{
    printf("%s %d\n",__FUNCTION__,__LINE__);
    m_p = (int*)calloc( len, sizeof(int) );
}

Array::Array(const Array &arr){  //拷贝构造函数
    printf("%s %d\n",__FUNCTION__,__LINE__);
}

Array::~Array()
{
    printf("%s %d\n",__FUNCTION__,__LINE__);
}

Array func(Array &arr)
{
    printf("%s %d\n",__FUNCTION__,__LINE__);
    Array ret;
    printf("%s %d\n",__FUNCTION__,__LINE__);
    ret = arr;
    printf("%s %d\n",__FUNCTION__,__LINE__);
    return ret;
}

int main(){
    Array a(10);
    func(a);
    printf("%s %d\n",__FUNCTION__,__LINE__);

    return 0;
}

打印如下

Array 24
func 39
Array 19
func 41
func 43
~Array 34
main 50
~Array 34 

与 按值类型传递，少了2个打印

Array 29       第49行a作为实参传递给func函数时，a拷贝给arr，调用拷贝函数

~Array 34      func函数退出，arr析构 

可以看出，按引用传递时，少了一次对象构造和析构，即 形参没有单独创建一次对象，没有执行拷贝动作，这就是按引用类型传递参数的好处，减少一次拷贝过程。 

4、基于以上按引用类型传递形参的代码， 此时，析构函数添加一条释放指针的操作，如下

Array::~Array()
{
    printf("%s %d\n",__FUNCTION__,__LINE__);
    free(m_p);
}

则执行结果如下

Array 24
func 40
Array 19
func 42
func 44
~Array 34
main 51
~Array 34
dlmalloc abort!

main函数退出，对象a析构时出错。原因是，如果不定义拷贝构造函数（即  使用默认拷贝构造函数）或者定义的拷贝构造函数里没有对指针做特别处理，那么，拷贝的执行动作，就是简单的成员变量对等赋值。也就是说，ret.m_p = arr.m_p，即 ret.m_p = a.m_p。那么，当ret析构时，执行了内存释放动作free(m_p)。a析构时再次执行内存释放就出错了。

为了解决不同对象之间相互干扰，修改一个对象的数据会影响另外的对象这个问题，就需要定义拷贝构造函数，对于类中的指针或者其他资源进行处理，如下定义拷贝构造函数

Array::Array(const Array &arr)//拷贝构造函数
{  
    this->m_len = arr.m_len;
    this->m_p = (int*)calloc( this->m_len, sizeof(int) );
    memcpy( this->m_p, arr.m_p, m_len * sizeof(int) );
}

以上的拷贝构造函数，对于普通成员函数进行赋值；对于指针，则申请独立空间，并把形参的数据赋值过来。这样一来，形参析构时，不会对本对象造成影响。

以上修改拷贝构造函数之后，对应func函数也需要修改一下，使用拷贝构造的方式来创建对象ret，如下

Array func(Array &arr)
{
    printf("%s %d\n",__FUNCTION__,__LINE__);
    Array ret = arr;
    return ret;
}

整体修改后的代码如下

#include <iostream>
#include <cstdlib>
#include <string.h>
using namespace std;

//变长数组类
class Array{
public:
    Array();
    Array(int len);
    Array(const Array &arr);  //拷贝构造函数
    ~Array();
private:
    int m_len;
    int *m_p;
};

Array::Array()
{
    printf("%s %d\n",__FUNCTION__,__LINE__);
}

Array::Array(int len): m_len(len)
{
    printf("%s %d\n",__FUNCTION__,__LINE__);
    m_p = (int*)calloc( len, sizeof(int) );
}

Array::Array(const Array &arr)//拷贝构造函数
{
    printf("%s %d\n",__FUNCTION__,__LINE__);
    this->m_len = arr.m_len;
    this->m_p = (int*)calloc( this->m_len, sizeof(int) );
    memcpy( this->m_p, arr.m_p, m_len * sizeof(int) );
}

Array::~Array()
{
    printf("%s %d\n",__FUNCTION__,__LINE__);
    free(m_p);
}

Array func(Array &arr)
{
    printf("%s %d\n",__FUNCTION__,__LINE__);
    Array ret = arr;
    return ret;
}

int main(){
    Array a(10);
    func(a);
    printf("%s %d\n",__FUNCTION__,__LINE__);

    return 0;
}

执行结果如下

Array 25
func 45
Array 31
~Array 39
main 53
~Array 39