深入理解C++中的深拷贝与浅拷贝

最新推荐文章于 2024-09-13 17:43:09 发布

南宫小仙僧

最新推荐文章于 2024-09-13 17:43:09 发布

阅读量476

点赞数 1

分类专栏： c++ 深拷贝浅拷贝文章标签： c++ 深拷贝浅拷贝

c++ 同时被 2 个专栏收录

17 篇文章 0 订阅

订阅专栏

深拷贝浅拷贝

2 篇文章 0 订阅

订阅专栏

   先说下自己的理解吧，浅拷贝，即在定义一个类A，使用类似A obj;  A obj1(obj);或者A obj1 = obj; 时候，由于没有自定义拷贝构造函数，C++编译器自动会产生一个默认的拷贝构造函数。这个默认的拷贝构造函数采用的是“位拷贝”（浅拷贝），而非“值拷贝”（深拷贝）的方式，如果类中含有指针变量，默认的拷贝构造函数必定出错。
   用一句简单的话来说就是浅拷贝，只是对指针的拷贝，拷贝后两个指针指向同一个内存空间，深拷贝不但对指针进行拷贝，而且对指针指向的内容进行拷贝，经深拷贝后的指针是指向两个不同地址的指针。

浅拷贝会出现什么问题呢？
假如有一个成员变量的指针，char *m_data;
其一，浅拷贝只是拷贝了指针，使得两个指针指向同一个地址，这样在对象块结束，调用函数析构的时，会造成同一份资源析构2次，即delete同一块内存2次，造成程序崩溃。

其二，浅拷贝使得obj.m_data和obj1.m_data指向同一块内存，任何一方的变动都会影响到另一方。

其三，在释放内存的时候，会造成obj1.m_data原有的内存没有被释放（这句话，刚开始我不太理解，如果没有走自定义的拷贝构造函数，申请内存空间，A obj1(obj);也不走默认构造函数，走的是默认的拷贝构造函数，何来分配空间直说，更不会造成obj1.m_data原有的内存没有被释放，这里刚开始我一直有疑问），造成内存泄露。
事实是这样的，当delete obj.m_data, obj.m_data内存被释放后，由于之前obj.m_data和obj1.m_data指向的是同一个内存空间，obj1.m_data所指的空间不能在被利用了，delete obj1.m_data也不会成功，一致已经无法操作该空间，所以导致内存泄露。
深拷贝采用了在堆内存中申请新的空间来存储数据，这样每个可以避免指针悬挂。
下面来看看类string的拷贝构造函数

class String
{
  public:
       String(const Stirng &other);//拷贝构造函数
  private:
       char *m_data;//用于保存字符串
};

String(const String &other)
{
  int length=strlen(other.m_data);
  m_data=new char[length+1];
  strcpy(m_data,other.m_data);
}

可以看到在拷贝构造函数中为成员变量申请了新的内存空间，这就使得两个对象的成员变量不指向同一个内存空间，除非你的确需要这样做，用于实现一些其他的用途。
浅拷贝：也就是在对象复制时，只是对对象中的数据成员进行简单的赋值，如果对象中存在动态成员，即指针，浅拷贝就会出现问题，下面代码：

#include <stdio.h>  

class A  
{  
    public:  
        A()      // 构造函数，p指向堆中分配的一空间  
        {  
            m_data = new char(100);  
            printf("默认构造函数\n");  
        }  
        ~A()     // 析构函数，释放动态分配的空间  
        {  
            if(m_data != NULL)  
            {  
                delete m_data;  
                m_data = NULL;  
                printf("析构函数\n");  
            }  
        }  
    private:  
        char *m_data;     // 一指针成员  
};  

int main()  
{  
    A a;  
    A b(a);   // 复制对象  
    return 0;  
}

运行结果：
* glibc detected ./simple: double free or corruption (fasttop): 0x000000000c62a010 **
分析：由于没有拷贝构造函数，走编译器默认的拷贝构造函数，A b(a); 进行对象析构时，会造成释放同一内存空间2次，导致内存泄露。

深拷贝：对于深拷贝，针对成员变量存在指针的情况，不仅仅是简单的指针赋值，而是重新分配内存空间，如下：

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

class A  
{  
    public:  
        A()      // 构造函数，p指向堆中分配的一空间  
        {  
            m_pdata = new char(100);  
            printf("默认构造函数\n");  
        }  

        A(const A& r)  
        {  
            m_pdata = new char(100);    // 为新对象重新动态分配空间  
            memcpy(m_pdata, r.m_pdata, strlen(r.m_pdata));  
            printf("copy构造函数\n");  
        }  

        ~A()     // 析构函数，释放动态分配的空间  
        {  
            if(m_pdata != NULL)  
            {  
                delete m_pdata;  
                printf("析构函数\n");  
            }  
        }  

    private:  
        char *m_pdata;     // 一指针成员  
};  

int main()  
{  
    A a;  
    A b(a);   // 复制对象  
    return 0;  
}

下面是我在具体的应用中使用深拷贝的情况，现在把这个demo贴出来:

#include <iostream>  
#include <errno.h>  
#include <vector>  
#include <stdio.h>  

using namespace std;  

/*存储记录信息的结构体*/  
typedef struct _RECODER_VALUE_STRU  
{  
        int Id;  
        int Age;  
}RECODER_VALUE_STRU;  

class recorder  
{  
        public:  
                recorder()  
                {  
                        m_stru_RecValue.Id = -1;  
                        m_stru_RecValue.Age = -1;  
                        m_pRecValue = &m_stru_RecValue;  

                        m_paddr = new char[100];  
                        memset(m_paddr,0x00 ,100);  

                        printf("默认 construct recorder->&m_stru_RecValue: %x,\t m_pRecValue: %x\t m_paddr: %x\n", &m_stru_RecValue, m_pRecVa  
lue, m_paddr);  
                }  

                //拷贝构造函数  
/*              recorder(const recorder &recorder) 
                { 
                        m_stru_RecValue.Id = -1;        
                        m_stru_RecValue.Age = -1; 
                        m_stru_RecValue = recorder.m_stru_RecValue; 
                        m_pRecValue = &m_stru_RecValue; 

                        m_paddr = new char[100]; 
                        memset(m_paddr, 0x00 ,100); 
                        memcpy(m_paddr, recorder.m_paddr, strlen(recorder.m_paddr)); 

                        printf("拷贝 construct recorder->&m_stru_RecValue: %x\t m_pRecValue: %x\t m_paddr: %x\n",&m_stru_RecValue, m_pRecValu 
e, m_paddr); 
                } 
*/  
                //构造函数  
                recorder(int iId, int iAge)  
                {  
                        m_stru_RecValue.Id = iId;  
                        m_stru_RecValue.Age = iAge;  
                        m_pRecValue = &m_stru_RecValue;  

                        m_paddr = new char[100];  
                        memset(m_paddr, 0x00 ,100);  
                        memcpy(m_paddr, &iAge, sizeof(int));  

                        printf("construct recorder->&m_stru_RecValue: %x \t m_pRecValue: %x\t m_paddr: %x\n", &m_stru_RecValue, m_pRecValue,  
m_paddr);  
                }  

                ~recorder()  
                {  
                //      cout<<"recorder 析构"<<endl;  
                        /*if(m_paddr != NULL) 
                        { 
                                delete m_paddr; 
                                m_paddr =NULL; 
                        }*/  
                }  

        public:  
                RECODER_VALUE_STRU m_stru_RecValue;//存储记录信息的结构体   
                void* m_pRecValue;//每条记录的值  
                char *m_paddr;  
};  

int main()  
{  
        cout <<"测试默认构造函数"<<endl<<endl;  
        recorder btest;  
        recorder btest1(btest);  

        printf("非参：btest ->&m_stru_RecValue: %x\t addr: %x\t m_paddr: %x\n",  &btest.m_stru_RecValue, btest.m_pRecValue,  btest.m_paddr);  
        printf("非参：btest1->&m_stru_RecValue: %x\t addr: %x\t m_paddr: %x\n", &btest1.m_stru_RecValue, btest1.m_pRecValue, btest1.m_paddr);  


        cout << endl<<"测试带参数的构造函数"<<endl<<endl;  


        recorder btest2(1, 100);  
        recorder btest3(btest2);  
        printf("带参：btest2->m_stru_RecValue: %x\t m_pRecValue: %x\t, m_paddr: %x\n", &btest2.m_stru_RecValue, btest2.m_pRecValue, btest2.m_  
paddr);  
        printf("带参：btest3->m_stru_RecValue: %x\t m_pRecValue: %x\t, m_paddr: %x\n", &btest3.m_stru_RecValue, btest3.m_pRecValue, btest3.m_  
paddr);  


        return 0;  
}

对比结果：
注释掉自定义拷贝构造函数,运行结果：
测试默认构造函数
默认 construct recorder->&m_stru_RecValue: ddbb8de0, m_pRecValue: ddbb8de0 m_paddr: 1b8a0010
非参：btest ->&m_stru_RecValue: ddbb8de0 addr: ddbb8de0 m_paddr: 1b8a0010
非参：btest1->&m_stru_RecValue: ddbb8dc0 addr: ddbb8de0 m_paddr: 1b8a0010
测试带参数的构造函数
construct recorder->&m_stru_RecValue: ddbb8da0 m_pRecValue: ddbb8da0 m_paddr: 1b8a0080
带参：btest2->m_stru_RecValue: ddbb8da0 m_pRecValue: ddbb8da0 , m_paddr: 1b8a0080
带参：btest3->m_stru_RecValue: ddbb8d80 m_pRecValue: ddbb8da0 , m_paddr: 1b8a0080
默认拷贝构造函数结果分析：
通过结果可以看出，当成员变量为指针变量的时候，指针成员变量指向的地址都是同一个地址，无论是申请空间的成员变量m_pRecValue，和仅仅作为指针赋值的成员变量m_paddr；结构体的地址是变化的，除了指针浅拷贝与深拷贝没什么区别。
打开自定义拷贝构造函数，运行结果：
测试默认构造函数
默认 construct recorder->&m_stru_RecValue: 58bb9e20, m_pRecValue: 58bb9e20 m_paddr: 7a2c010
拷贝 construct recorder->&m_stru_RecValue: 58bb9e00 m_pRecValue: 58bb9e00 m_paddr: 7a2c080
非参：btest ->&m_stru_RecValue: 58bb9e20 addr: 58bb9e20 m_paddr: 7a2c010
非参：btest1->&m_stru_RecValue: 58bb9e00 addr: 58bb9e00 m_paddr: 7a2c080
测试带参数的构造函数
construct recorder->&m_stru_RecValue: 58bb9de0 m_pRecValue: 58bb9de0 m_paddr: 7a2c0f0
拷贝 construct recorder->&m_stru_RecValue: 58bb9dc0 m_pRecValue: 58bb9dc0 m_paddr: 7a2c160
带参：btest2->m_stru_RecValue: 58bb9de0 m_pRecValue: 58bb9de0 , m_paddr: 7a2c0f0
带参：btest3->m_stru_RecValue: 58bb9dc0 m_pRecValue: 58bb9dc0 , m_paddr: 7a2c160
自定义深拷贝构造函数结果分析：
从结果可以看出，所有成员变量的地址都不相同。
其他：
1. 有时候为了防止默认拷贝发生，可以声明一个私有的拷贝构造函数（不用写代码），这样的话，如果试图调用 A b(a); 就调用了私有的拷贝构造函数，编译器会报错。
2.
Effective C++ 条款06：若不想使用编译期自动生成的函数，就应该明确拒绝
地产中介商卖的是房子，一个中介系统自然而然想必有一个class用来描述待售房屋：
class HomeForSale{……};
每一个真正的地产中介商都会说，任何一笔资产都是天上地下独一无二的，没有两笔完全相像。因此，我们认为，为HomeForSale对象做一个副本有点没道理。你怎么可以复制某些独一无二的东西呢？因此，你应该乐意看到HomeForSale的对象拷贝动作以失败收场。

HomeForSale h1;
HomeForSale h2;
HomeForSale h3(h1);//企图拷贝h1，不应该通过编译
h1=h2;//企图拷贝h2，不该通过编译

你看，阻止这一类的戴拿的编译并不是很直观。通常，如果你不希望class支持某一特定机能，只要不声明对应函数就行了。但是该策略对copy构造函数和copy assignmnet 操作符却不起作用。因为如果你不声明它们，而某些人尝试调用它们，那么编译期会为你声明它们。
这就把你逼入绝境了啊，如果你不声明copy构造函数或copy assignment 操作符，编译期可能为你产出了一份，于是你的class支持copying。如果你声明它们，你的class还是支持copying，但这里的目标确实要阻止copying。
答案的关键是，所有编译期产出的函数都是public。为了阻止这些函数被创建出来，你得自行声明它们，但这里并没有像需求使你必须将它们声明为public。因此你可以将copy构造函数或copy assignment 操作符声明为private。籍由明确声明一个成员函数，你组织了编译期暗自创建其专属版本，二令这些函数为private，使你得以成功阻止人们调用它。

一个类中可以存在多个拷贝构造函数，例如：

class A  
{  
Public:  
X(const X&);//const拷贝构造  
X(X &);//非const拷贝构造  
X(X& , int  iData);  
}

下面贴上知乎上一位大神的见解，蛮有趣的
这里写图片描述

这里写图片描述
本文为转载。原出处：
http://blog.csdn.net/feitianxuxue/article/details/9275979

南宫小仙僧

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录