C++深拷贝与浅拷贝

对于普通类型的对象来说，它们之间的复制是很简单的，例如：
int a=88;
int b=a; 
而类对象与普通对象不同，类对象内部结构一般较为复杂，存在各种成员变量。下面看一个类对象拷贝的简单例子。

#include <iostream>
using namespace std;

class CExample {
private:
    　int a;
public:
    　CExample(int b)
    　{ a=b;}
    　void Show ()
    　{
        cout<<a<<endl;
    }
};

int main()
{
    　CExample A(100);
    　CExample B=A;
    　B.Show ();
    　return 0;
}

运行程序，屏幕输出100。从以上代码的运行结果可以看出，系统为对象B分配了内存并完成了与对象A的复制过程。就类对象而言，相同类型的类对象是通过拷贝构造函数来完成整个复制过程的。下面举例说明拷贝构造函数的工作过程。

class CExample {
private:
    int a;
public:
    CExample(int b)
    { a=b;}

    CExample(const CExample& C)
    {
        a=C.a;
    }
    void Show ()
    {
        cout<<a<<endl;
    }
};

int main()
{
    CExample A(100);
    CExample B=A;
    B.Show ();
    return 0;
}

CExample(const CExample& C)就是我们自定义的拷贝构造函数。可见，拷贝构造函数是一种特殊的构造函数，函数的名称必须和类名称一致，它的唯一的一个参数是本类型的一个引用变量，该参数是const类型，不可变的。例如：类X的拷贝构造函数的形式为X(X& x)。

当用一个已初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候，拷贝构造函数就会被自动调用。也就是说，当类的对象需要拷贝时，拷贝构造函数将会被调用。以下情况都会调用拷贝构造函数：
一个对象以值传递的方式传入函数体 
一个对象以值传递的方式从函数返回 
一个对象需要通过另外一个对象进行初始化。

如果在类中没有显式地声明一个拷贝构造函数，那么，编译器将会自动生成一个默认的拷贝构造函数，该构造函数完成对象之间的位拷贝。位拷贝又称浅拷贝，后面将进行说明。

自定义拷贝构造函数是一种良好的编程风格，它可以阻止编译器形成默认的拷贝构造函数，提高源码效率。

浅拷贝和深拷贝

　　在某些状况下，类内成员变量需要动态开辟堆内存，如果实行位拷贝，也就是把对象里的值完全复制给另一个对象，如A=B。这时，如果B中有一个成员变量指针已经申请了内存，那A中的那个成员变量也指向同一块内存。这就出现了问题：当B把内存释放了（如：析构），这时A内的指针就是野指针了，出现运行错误。

　　深拷贝和浅拷贝可以简单理解为：如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝，反之，没有重新分配资源，就是浅拷贝.

下面举个深拷贝的例子。

class CA
{
　public:
　　CA(int b,char* cstr)
　　{
　　　a=b;
　　　str=new char[b];
　　　strcpy(str,cstr);
　　}
　　CA(const CA& C)
　　{
　　　a=C.a;
　　　str=new char[a]; //深拷贝
　　　if(str!=0)
　　　　strcpy(str,C.str);
　　}
　　void Show()
　　{
　　　cout<<str<<endl;
　　}
　　~CA()
　　{
　　　delete str;
　　}
　private:
　　int a;
　　char *str;
};
int main()
{
　CA A(10,"Hello!");
　CA B=A;
　B.Show();
　return 0;
}

深拷贝和浅拷贝的定义可以简单理解成：如果一个类拥有资源(堆，或者是其它系统资源)，当这个类的对象发生复制过程的时候，这个过程就可以叫做深拷贝，反之对象存在资源，但复制过程并未复制资源的情况视为浅拷贝。

浅拷贝资源后在释放资源的时候会产生资源归属不清的情况导致程序运行出错。

        Test(Test &c_t)是自定义的拷贝构造函数，拷贝构造函数的名称必须与类名称一致，函数的形式参数是本类型的一个引用变量,且必须是引用。

当用一个已经初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候，拷贝构造函数就会被自动调用，如果你没有自定义拷贝构造函数的时候，系统将会提供给一个默认的拷贝构造函数来完成这个过程，上面代码的复制核心语句就是通过Test(Test &c_t)拷贝构造函数内的p1=c_t.p1;语句完成的。

拷贝有两种：深拷贝，浅拷贝
当出现类的等号赋值时，会调用拷贝函数
在未定义显示拷贝构造函数的情况下，系统会调用默认的拷贝函数——即浅拷贝，它能够完成成员的一一复制。当数据成员中没有指针时，浅拷贝是可行的。
但当数据成员中有指针时，如果采用简单的浅拷贝，则两类中的两个指针将指向同一个地址，当对象快结束时，会调用两次析构函数，而导致指针悬挂现象。
所以，这时，必须采用深拷贝。
深拷贝与浅拷贝的区别就在于深拷贝会在堆内存中另外申请空间来储存数据，从而也就解决了指针悬挂的问题。
简而言之，当数据成员中有指针时，必须要用深拷贝。

无错误的浅拷贝

先看一个简单的例子，该例子是浅拷贝的典型代表，而且没有问题。
接下来看Example  1。
Cperson.h

#ifndef _CPERSON_H
#define _CPERSON_H

class Cperson
{
public:
    Cperson(int age);
    void Print(void);
private:
    int m_age;
};

#endif

Cperson.cpp

#include"Cperson.h"
#include<iostream.h>

Cperson::Cperson(int age):m_age(age)
{

}

void Cperson::Print(void)
{
    cout<<"My age is "<<m_age<<endl;
}

Main.cpp

#include"Cperson.h"
#include<iostream.h>

void main(void)
{
    Cperson Tom(10);
    Tom.Print();

    Cperson Jim(Tom);
    Jim.Print();
}

运行结果:
My age is 10

My age is 10

结果分析:

对于语句Cperson Jim(Tom)，我们并没有定义相应的拷贝构造函数，编译器将会自动生成一个默认的拷贝构造函数。
默认拷贝构造函数所做的工作是，将一个对象的全部数据成员赋值给另一个对象的数据成员。
C++把只对象数据成员简单赋值这种情况称为“浅拷贝”。
听起来，编译器似乎很好，会提供一个我们没有定义的拷贝构造函数，但这后面存在巨大的风险。
所以有些事情（拷贝构造函数）还是自力更生不接受外援的好。

在接下来的Example 2中，我们将看到浅拷贝带来的错误

 

有错误的浅拷贝

Cperson.h

#ifndef _CPERSON_H
#define _CPERSON_H

class Cperson
{
public:
    Cperson(int age,char *name);
    ~Cperson();
    void Print(void);
private:
    int m_age;
    char *m_name;
};

#endif

Cperson.cpp

#include"Cperson.h"
#include<iostream.h>
#include<string.h>

Cperson::Cperson(int age,char *name)
{
    m_name = new char[strlen(name) + 1];
    if(m_name != NULL)
    {
        strcpy(m_name,name);
    }

    m_age = age;

    cout<<m_name<<"的构造函数"<<endl;
}

Cperson::~Cperson()
{
 cout<<"析构姓名:"<<m_name<<endl;


 if(m_name != NULL)
 {
  delete m_name;
 }
}




void Cperson::Print(void)
{
 cout<<"My age is "<<m_age<<",My name is "<<m_name<<endl;
}

Main.cpp

#include"Cperson.h"
#include<iostream.h>

void main(void)
{
    Cperson Tom(10,"Tom");
    Tom.Print();

    Cperson Jim(Tom);
    Jim.Print();
}

结果分析:

可以看到，程序出现了错误。
在执行语句Cperson Tom(10,“Tom”)时，用new动态开辟了一段内存，用来存放”Tom”。
在执行Cperson Jim(Tom)时，只是将Tom的成员（Tom.m_age，Tom.m_name）赋值给Jim相应的成员。
此时，Tom.m_name和Jim.m_name指向同一内存空间，然而，系统并没给Jim.m_name开辟相应的内存空间。
执行完Jim.Print()后，开始执行析构函数，析构函数的执行顺序和对象构造函数的执行顺寻相反，所以先执行Jim的析构函数，执行完Jim的析构函数后，Jim.m_name所指的内存空间已经释放。接着执行Tom的析构函数，此时就会出现问题，即在释放Tom.m_name所指的内存空间时会出现问题，因为这段内存空间在Jim的析构函数中已经释放过了。
出现这种原因的根本在于“浅拷贝”，所以需要定义自己的构造函数。

深拷贝

接下来看Example 3，在该例子中执行深拷贝。

Cperson.h

#ifndef _CPERSON_H
#define _CPERSON_H

class Cperson
{
public:
    Cperson(int age,char *name);
    Cperson(Cperson & per);
    ~Cperson();
    void Print(void);
private:
    int m_age;
    char *m_name;
};

#endif

Cperson.cpp

#include"Cperson.h"
#include<iostream.h>
#include<string.h>

Cperson::Cperson(int age,char *name)
{
 m_name = new char[strlen(name) + 1];
 if(m_name != NULL)
 {
  strcpy(m_name,name);
 }

 m_age = age;

 cout<<m_name<<"的构造函数"<<endl;
}
Cperson::Cperson(Cperson & per)
{
 m_name = new char[strlen(per.m_name) + 1];
 if(m_name != NULL)
 {
  strcpy(m_name,per.m_name);
 } m_age = per.m_age; cout<<m_name<<"的拷贝构造函数"<<endl;
}Cperson::~Cperson()
{
 cout<<"析构姓名:"<<m_name<<endl; if(m_name != NULL)
 {
  delete m_name;
 }
}void Cperson::Print(void)
{
 cout<<"My age is "<<m_age<<",My name is "<<m_name<<endl;
}

Main.cpp

#include"Cperson.h"
#include<iostream.h>

void main(void)
{
    Cperson Tom(10,"Tom");
    Tom.Print();

    Cperson Jim(Tom);
    Jim.Print();
}

可以看到，自己定义了拷贝构造函数后，就没有问题了.在实际中应该避免浅拷贝。