（二十四）拷贝构造函数

定义

• 拷贝构造函数是一种特殊的构造函数
• 函数名是类名，没有返回值，没有返回值，参数形式固定

class Object
{
public:
    Object(const Object& other)
    {
        
    }
};

Object b;
Object a(b);//Object a = b;

以一个对象b为蓝本，创建一个新对象a，这意味着a是b的一份拷贝。

• 动态创建对象

Object a;
Object* p = new Object(a);

拷贝构造函数的调用

• 函数的传值调用，会自动调用到拷贝构造函数

#include<stdio.h>

class Object
{
public:
    Object(int v) : value(v)
    {
        printf("构造对象...\n");
    }
    Object(const Object& other)
    {
        this->value = other.value;
        printf("拷贝构造对象...\n");
    }
private:
    int value;
};

void Test(Object obj)//此句执行时，执行拷贝构造函数
{
    
}

int main()
{
    Object a(123);
    Object b(a);  //1，以a为蓝本创建对象b
    
    Object* p = new Object(a); //2
    Test(a);  //3
    return 0;
}

执行结果

构造对象...
拷贝构造对象...//1
拷贝构造对象...//2
拷贝构造对象...//3

默认的拷贝构造函数

默认情况下，不需要添加拷贝构造函数，编译器会默认配置一个。

直接拷贝就行了

#include<stdio.h>
#include<string.h>

class Object
{
public:
    Object(int id,const char* name)
    {
        this->id = id;
        strcpy(this->name,name);
    }
private:
    int id;
    char name[128];
};

int main()
{
    Object a(1,"hello");
    Object b(a);
    return 0;
}

自定义拷贝构造函数

默认拷贝构造函数是够用的，如果非要自己定义的话，较为复杂。

1. 首先，要调用父类的拷贝构造函数
2. 依次添加每个成员

class Base
{
public:
    int m1;
}
class Object : public Base
{
public:
    Object(int id,const char* name)
    {
        this->id = id;
        strcpy(this->name,name);
    }
    
    Object(const Object& other)
        :Base(other)   //调用父类的拷贝构造函数
    {
        //依次复制所有成员
        this->id = other.id;
        strcpy(this->name,other.name);
    }
private:
    int id;
    char name[128];    
}

Object a(1,"hello");
a.m1 = 123;
Object b(a);

深度拷贝

虽然自定义拷贝构造函数复杂，但在有些情况默认构造函数不能胜任，非自己定义不可。

#include<stdio.h>
#include<string.h>

class Text
{
public:
    Text(const char* str)
    {
        m_size = strlen(str)+1;
        m_buf = new char[m_size];
        strcpy(m_buf,str);
    }
    ~Text()
    {
        delete[] m_buf;
    }
private:
    int m_size;
    char* m_buf;
};

int main()
{
    Text t1("hello");
    Text t2(t1);
}

这种情况下使用了默认拷贝构造函数，程序会崩溃，因为执行t2.m_buf等于t1.m_buf，这是不正确的，字符串的复制不能用指针直接赋值。又因为，t1被析构时t1.m_buf指向的内存被delete了，t2被析构时试图delete掉t2.m_buf，而这一块内存早就被delete掉了。

两个对象t1和t2拥有同一块内存，而设计者却想当然认为二者各自占有一块内存，默认的拷贝构造函数使用的是浅拷贝，即只对指针复制，没有复制内存。应该自定义一个新的拷贝构造函数，使其进行深拷贝。

Text(const Text& other)
{
    m_size = other.m_size;
    m_buf = new char[m_size];
    strcpy(m_buf,other.m_buf);
}