C++中的位拷贝和值拷贝（深拷贝和浅拷贝）

拷贝构造是确确实实构造一个新的对象，并给新对象的私有成员赋上参数对象的私有成员的值，新构造的对象和参数对象地址是不一样的，所以如果该类中有一个私有成员是指向堆中某一块内存，如果仅仅对该私有成员进行浅拷贝，那么会出现多个指针指向堆中同一块内存，这是会出现问题，如果那块内存被释放了，就会出现其他指针指向一块被释放的内存，出现未定义的值的问题，如果深拷贝，就不会出现问题，因为深拷贝，不会出现指向堆中同一块内存的问题，因为每一次拷贝，都会开辟新的内存供对象存放其值。

下面是浅拷贝构造函数的代码：

#include <iostream>

using namespace std;

class A
{
private:
    int* n;

public:
    A()
    {
        n = new int[10];
        n[0] = 1;
        cout<<"constructor is called\n";
    }

    A(const A& a)
    {
        n = a.n;
        cout<<"copy constructor is called\n";
    }

    ~A()
    {
        cout<<"destructor is called\n";
        delete n;
    }

    void get()
    {
        cout<<"n[0]: "<<n[0]<<endl;
    }
};


int main()
{
    A* a = new A();
    A b = *a;
    delete a;

    b.get();

    return 0;
}

运行结果如下：

下面是深拷贝构造函数的代码：

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

class A
{
private:
    int* n;

public:
    A()
    {
        n = new int[10];
        n[0] = 1;
        cout<<"constructor is called\n";
    }

    A(const A& a)
    {
        n = new int[10];
        memcpy(n, a.n, 10);  //通过按字节拷贝，将堆中一块内存存储到另一块内存
        cout<<"copy constructor is called\n";
    }

    ~A()
    {
        cout<<"destructor is called\n";
        delete n;
    }

    void get()
    {
        cout<<"n[0]: "<<n[0]<<endl;
    }
};


int main()
{
    A* a = new A();
    A b = *a;
    delete a;

    b.get();

    return 0;
}

运行截图如下：

但是赋值构造函数是将一个参数对象中私有成员赋给一个已经在内存中占据内存的对象的私有成员，赋值构造函数被赋值的对象必须已经在内存中，否则调用的将是拷贝构造函数，当然赋值构造函数也有深拷贝和浅拷贝的问题。当然赋值构造函数必须能够处理自我赋值的问题，因为自我赋值会出现指针指向一个已经释放的内存。还有赋值构造函数必须注意它的函数原型，参数必须是引用类型，返回值也必须是引用类型，否则在传参和返回的时候都会再次调用一次拷贝构造函数。

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

class A
{
private:
    int* n;

public:
    A()
    {
        n = new int[10];
        n[0] = 1;
        cout<<"constructor is called\n";
    }

    A(const A& a) //拷贝构造函数的参数一定是引用，不能不是引用，不然会出现无限递归
    {
        n = new int[10];
        memcpy(n, a.n, 10);  //通过按字节拷贝，将堆中一块内存存储到另一块内存
        cout<<"copy constructor is called\n";
    }

    A& operator=(const A& a)  //记住形参和返回值一定要是引用类型，否则传参和返回时会自动调用拷贝构造函数
    {
        if(this == &a)     //为什么需要进行自我赋值判断呢？因为下面要进行释放n的操作，如果是自我赋值，而没有进行判断的话，那么就会出现讲一个释放了的内存赋给一个指针
            return *this;
        if(n != NULL)
        {
            delete n;
            n == NULL;   //记住释放完内存将指针赋为NULL
        }

        n = new int[10];
        memcpy(n, a.n, 10);
        cout<<"assign constructor is called\n";
        return *this;
    }

    ~A()
    {
        cout<<"destructor is called\n";
        delete n;
　　　　　n = NULL;  //记住释放完内存将指针赋为NULL
    }

    void get()
    {
        cout<<"n[0]: "<<n[0]<<endl;
    }
};


int main()
{
    A* a = new A();
    A* b =  new A();

    *b = *a;

    delete a;

    b->get();
return 0;
}

运行截图如下：

如果我们在赋值构造函数的形参和返回值不用引用类型，代码如下：

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

class A
{
private:
    int* n;

public:
    A()
    {
        n = new int[10];
        n[0] = 1;
        cout<<"constructor is called\n";
    }

    A(const A& a) //拷贝构造函数的参数一定是引用，不能不是引用，不然会出现无限递归
    {
        n = new int[10];
        memcpy(n, a.n, 10);  //通过按字节拷贝，将堆中一块内存存储到另一块内存
        cout<<"copy constructor is called\n";
    }

    A operator=(const A a)   //传参和返回值设置错误
    {
        if(this == &a)
            return *this;
        if(n != NULL)
        {
            delete n;
            n == NULL;
        }

        n = new int[10];
        memcpy(n, a.n, 10);
        cout<<"assign constructor is called\n";
        return *this;
    }

    ~A()
    {
        cout<<"destructor is called\n";
        delete n;
    }

    void get()
    {
        cout<<"n[0]: "<<n[0]<<endl;
    }
};


int main()
{
    A* a = new A();
    A* b =  new A();

    *b = *a;

    delete a;

    b->get();

    while(1)
    {}

    return 0;
}

多了两次的拷贝构造函数的调用和两次析构函数的调用。

为了便于说明我们以String类为例：

首先定义String类，而并不实现其成员函数。

 

Class String{
public:
    String(const char *ch=NULL);//默认构造函数
    String(const String &str);//拷贝构造函数
   ~String(void);
   String &operator=(const String &str);//赋值函数
private:
   char *m_data;
};

 

位拷贝拷贝的是地址，而值拷贝则拷贝的是内容。如果定义两个String对象A和B。A.m_data和B.m_data分别指向一段区域，A.m_data="windows",B.m_data=“linux";

如果未重写赋值函数，将B赋给A;则编译器会默认进行位拷贝，A.m_data=B.m_data

则A.m_data和B.m_data指向同一块区域，虽然A.m_data指向的内容会改变成"linux",但是这样容易出现这些问题：

(1):A.m_data原来指向的内存区域未释放，造成内存泄露。

(2):A.m_data和B.m_data指向同一块区域，任何一方改变都会影响另一方

 (3)：当对象被析构时，B.m_data被释放两次。

对于编译器，如果不主动编写拷贝函数和赋值函数，它会以“位拷贝”的方式自动生成缺省的函数。

如果重写赋值函数和拷贝构造函数后，

A.m_data=B.m_data，进行的是值拷贝，会将B.m_data的内容赋给A.m_data,A.m_data还是指向原来的内存区域，但是其内容改变。

�