C++中的拷贝构造函数

class Student
{
public:
    Student()
    {cout<<"Student"<<endl;}
private:
    string m_strName;
};

int main()
{
    Student S1;
    Student S2=S1;
    Student S3(S2);
    return 0;
}

此程序的运行结果：

在实例化对象的时候不应该调用3次构造函数吗？

---

拷贝构造函数

实际上，只有S1在被实例化的时候调用了构造函数，而S2和S3调用了拷贝构造函数。

拷贝构造函数的格式

class Student
{
public:
    Student()
    {cout<<"Student"<<endl;}
    Student(const Student &stu){}
private:
    string m_strName;
};

1.当类中没有定义拷贝构造函数，编译器自动生成一个默认拷贝构造函数，这和构造函数是一样的。

2.当采用直接初始化或是复制初始化实例对象时系统自动调用拷贝构造函数。

注意：拷贝构造函数是无法被重载的。

---

如何创建拷贝构造函数

第一种：

class Student
{
public:
    Student()
    {
        cout << "Student" << endl;
    }

    Student(const Student &)//定义的引用变量可以不用
    {
        cout << "Student(const Student &)" << endl;
    }
private:
    string m_strName;
};
int main()
{
    Student S1;
    Student S2 = S1;
    Student S3(S2);
    return 0;
}

输出结果：

第二种 函数参数传递的时候也会调用拷贝构造函数

class Student
{
public:
    Student()
    {
        cout << "Student" << endl;
    }

    Student(const Student &)//定义的引用变量可以不用
    {
        cout << "Student(const Student &)" << endl;
    }![这里写图片描述](http://img.blog.csdn.net/20161010220505715)
private:
    string m_strName;
};

void test(Student t)
{}

int main()
{
    Student S1;
    Student S2 = S1;
    Student S3(S2);
    return 0;
}

运行结果是

---

深拷贝与浅拷贝

浅拷贝：

#include <iostream>
using namespace std;
class A
{
public:
    A(int a)
    {
        p = new int[a];
        cout << "AAAAAAAAAAAAAAAAAAAAA" << endl;
    }
    /*
    A(const A &B)
    {
        _a=B._a;
        p=B.p;
    }
   这种写法与系统默认拷贝构造函数一样都是属于浅拷贝。
*/

    ~A()
    {
        delete[]p;
        p = NULL;
        cout << "~~~~~~~~~~~~~~~~~" << endl;
    }
    void print()
    {
        cout << "地址：" << p << endl;
    }

private:
    int _a;
    int *p;
};


int main()
{
    A student1(6);
    A student2(student1);
    student1.print();
    student2.print();

    return 0;
}

以上代码调用系统默认的拷贝构造函数，但是运行时出现内存泄漏。
运行结果为

由于浅拷贝中两个对象中的成员指针变量p1和p2同时指向了一块内存，而main()函数执行之后，对象student1调用析构函数，释放了student1中指针所指向的那块内存，当对象student2再次调用析构函数，想要释放指向的内存时，就会出现内存泄漏。

深拷贝：

#include <iostream>
using namespace std;
class A
{
public:
    A(int a)
    {
        p = new int[a];
        cout << "AAAAAAAAAAAAAAAAAAAAA" << endl;

        for (int i=0; i < _a; i++)
        {
            p[i] =i ;
        }
    }

    A(const A &B)
    {
        cout << "调用拷贝构造函数" << endl;
        _a = B._a;
        p=new int[_a];
        for (int i=0; i < _a; i++)
        {
            p[i] = B.p[i];
        }
    }
    ~A()
    {
        delete[]p;
        p = NULL;
        cout << "~~~~~~~~~~~~~~~~~" << endl;
    }
    void print()
    {
        cout << "地址：" << p << endl;
    }

private:
    int _a;
    int *p;
};


int main()
{
    A student1(6);
    A student2(student1);
    student1.print();
    student2.print();

    return 0;
}

运行结果为：

深拷贝不会报错，即深拷贝不会出现内存泄漏。