拷贝构造函数（复制构造函数）

拷贝构造函数

拷贝构造函数又称复制构造函数，来完成用一个同类型的对象初始化另一个对象。形参必须是引用，但并不限制为const，一般会加上const限制。

使用原则

1、凡是包含动态分配成员或包含指针成员的类都应该手动提供拷贝构造函数

2、在考虑提供拷贝构造函数的同事，还要考虑重载“=”赋值操作符

3、拷贝构造函数必须以引用的形式传递(参数为引用值)。

#pragma warning(disable : 4996)
#include <iostream>
using namespace std;

class Complex
{
public:
    Complex(int a, int b)
    {
        m_a = a;
        m_b = b;
    }
    ~Complex() {}
public:
    int m_a, m_b;
};

int main()
{
    Complex c1(1, 2);
    //Complex c2 = c1;   //初始化法
    Complex c2(c1);      //括号法
    cout <<"a = "<< c2.m_a <<",b = "<< c2.m_b << endl;

    system("pause");
    return 0;
}

调用结果：

特别注意： 初始化操作 和 等号操作 是两个不同的概念

运行上面的代码之后你会发现c2的成员变量有了值，和c1的初始值相同，其实这里调用了拷贝构造函数，而这里我们没有提供拷贝构造函数，为什么会执行通过，是因为它和构造函数的原理相同，在没有明确提供拷贝构造函数时会调用默认的拷贝构造函数。

下面写一个提供拷贝构造函数的例子：

#pragma warning(disable : 4996)
#include <iostream>
using namespace std;

class Complex
{
public:
    Complex(int a, int b)
    {
        m_a = a;
        m_b = b;
    }
    Complex(const Complex &obj)
    {
        m_a = obj.m_a;
        m_b = obj.m_b;
        cout << "调用了提供的拷贝构造函数" << endl;
    }
    Complex & operator=(const Complex &obj)
    {
        m_a = obj.m_a;
        m_b = obj.m_b;
        cout << "调用了operator=重载操作符" << endl;
        return *this;
    }
    ~Complex() {}
public:
    int m_a, m_b;
};

int main()
{
    Complex c1(1, 2);
    //Complex c2 = c1;  //初始化法
    Complex c2(c1);     //括号法
    cout <<"a = "<< c2.m_a <<",b = "<< c2.m_b << endl;
    Complex c3(1, 2), c4(3, 4);
    c3 = c4;            //初始化，调用operator=重载等号操作符
    system("pause");
    return 0;
}

调用结果：

有个特例我们需要看一下

Complex c3(1, 2), c4(3, 4);
c3 = c4;

调用结果：

上面的代码在执行时为什么没有调用拷贝构造函数，这里我们要明确一件事，那就是用已经存在的对象初始化新建对象才会调用拷贝构造函数，说明了就是创建和赋值在一个语句上，而这里c3,c4已经存在了，初始化了，因此他们之间的操作只是初始化，不会调用拷贝构造函数，但会调用重载的=操作符，如果没有实现，也是按内存拷贝。

为什么要用到拷贝构造函数

1、一个对象作为函数参数，以值传递的方式传入函数体

2、一个对象作为函数返回值，以值传递的方式从函数返回

3、一个对象用于给另外一个对象进行初始化（常称为复制初始化）

当对象的成员变量中存在指针变量时，用存在的对象初始化新建对象时指针变量一同初始化，但这时调用一般拷贝构造函数（浅拷贝）会使新对象中的指针指向和初始化对象指针指向一致，那么当用来初始化的对象在释放内存时会释放掉指针指向的内存，而当新创建的对象释放时会出现程序错误，以为这个指针指向的内存被释放了两次。因此我们需要手动提供另一种拷贝构造函数（深拷贝），详情点击浅拷贝和深拷贝解析。

对象作为函数的参数

如果一个函数Fun的参数是类A的对象，当调用Fun函数时，类A的拷贝构造函数也会被调用。

也就是说Fun函数的形参是用拷贝构造函数初始化的。

class Complex
{
public:
    Complex(int a, int b)
    {
        m_a = a;
        m_b = b;
    }
    Complex(const Complex &obj)
    {
        m_a = obj.m_a;
        m_b = obj.m_b;
        cout << "调用了提供的拷贝构造函数" << endl;
    }
    ~Complex() {}
public:
    int m_a, m_b;
};

void Fun(Complex c)
{
    cout << "a = " << c.m_a << ",b = " << c.m_b << endl;
    c.m_a = 10;
    c.m_b = 20;
}

int main()
{
    Complex c1(1, 2);
    Fun(c1);
    cout << "a = " << c1.m_a << ",b = " << c1.m_b << endl;

    system("pause");
    return 0;
}

调用结果：

为什么实参的值没有发生改变，是因为调用拷贝构造函数时只是做了复制的工作，把1,2的值复制给c中。在Fun函数中改变形参的值是不会影响实参值的。如果要通过形参改变实参的值，那么我们可以使用引用来做函数的参数，也可以返回一个类的对象（对象作为函数返回值）。

void Fun(Complex &c)
{
    cout << "a = " << c.m_a << ",b = " << c.m_b << endl;
    c.m_a = 10;
    c.m_b = 20;
}

调用结果：

使用引用不会调用拷贝构造函数，这样提高了执行效率。

对象作为函数返回值（匿名对象）

如果函数的返回值是类A的对象，返回对象时会调用类A的拷贝构造函数，也就是说返回值的对象使用拷贝构造函数初始化的。

拷贝构造函数的实参就是返回的对象。这个返回的对象是一个新的匿名对象。

Complex Fun()
{
    Complex c(10, 20);
    return c;
}

考虑匿名对象的去留问题

如果用匿名对象Fun  初始化  同类型的对象A  匿名对象转成有名对象，此时匿名对象Fun的生命周期就变成了类A的生命周期。
如果用匿名对象Fun  =赋值给  同类型的对象A  匿名对象生命周期结束后直接被析构掉。

Complex Fun()
{
    Complex c(10, 20);
    return c;
}

int main()
{
    //1用匿名对象初始化c1 此时C++编译器 直接把匿名对象转成c1（转正） 从匿名转成有名
    Complex c1 = Fun();

    //2用匿名对象赋值给c1对象，然后匿名对象析构
    //Complex c1(1, 2);
    //c1 = Fun();
    cout << "a = " << c1.m_a << ",b = " << c1.m_b << endl;
    system("pause");
    return 0;
}

用第一种方法（初始化法）去接匿名对象的结果是：

用第二种方法（=赋值）去接匿名对象的结果是：

谁的执行效率更高呢？一目了然

总结：

1、构造函数是C++中用于初始化对象状态的特殊函数

2、构造函数在对象创建时自动被调用

3、构造函数和普通成员函数都遵循重载规则

4、拷贝构造函数是对象正确初始化的重要保证

5、必要的时候，必须手工编写拷贝构造函数

6、默认复制构造函数可以完成对象的数据成员值简单的复制

7、对象的数据资源是由指针指示的堆时，默认复制构造函数仅作指针值复制，需要手动提供深拷贝