C++ 浅析深浅拷贝

Posted Readtears

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了C++ 浅析深浅拷贝相关的知识,希望对你有一定的参考价值。

  C++中深拷贝和浅拷贝的问题是很值得我们注意的知识点,如果编程中不注意,可能会出现疏忽,导致bug。本文就详细讲讲C++深浅拷贝的种种。

  我们知道,对于一般对象:

    int a = 1;
    int b = 2;

  这样的赋值,复制很简单,但对于类对象来说并不一般,因为其内部包含各种类型的成员变量,在拷贝过程中就会出现问题

例如:

#include <iostream>
using namespace std;

class String

public:

    String(char str = "")
        :_str(new char[strlen(str) + 1]) // +1是为了避免空字符串导致出错
    
        strcpy(_str , str);
    
    
    // 浅拷贝
    String(const String& s)
        :_str(s._str)
    
    
    ~String()
    
        if(_str)
        
            delete[] _str;
            _str = NULL;
        
        cout<<"~String()"<<endl;
    
    
    void Display()
    
        cout<<_str<<endl;
    
    
private:
    char *_str;
;

void Test()

    String s1("hello");
    String s2(s1);
    String.Display();
    


int main()

    Test();
    
    return 0;

运行结果:

我们发现,编译通过了,但是崩溃了 =  =ll ,这就是浅拷贝带来的问题。


   事实是,在对象拷贝过程中,如果没有自定义拷贝构造函数,系统会提供一个缺省的拷贝构造函数,缺省的拷贝构造函数对于基本类型的成员变量,按字节复制,对于类类型成员变量,调用其相应类型的拷贝构造函数。原型如下:

String(const String& s)
     

但是,编译器提供的缺省函数并不是十全十美的。


      缺省拷贝构造函数在拷贝过程中是按字节复制的,对于指针型成员变量只复制指针本身,而不复制指针所指向的目标--浅拷贝。


用图形象化为:


  在进行对象复制后,事实上s1、s2里的成员指针 _str 都指向了一块内存空间(即内存空间共享了),在s1析构时,delete了成员指针 _str 所指向的内存空间,而s2析构时同样指向(此时已变成野指针)并且要释放这片已经被s1析构函数释放的内存空间,这就让同样一片内存空间出现了 “double free” ,从而出错。而浅拷贝还存在着一个问题,因为一片空间被两个不同的子对象共享了,只要其中的一个子对象改变了其中的值,那另一个对象的值也跟着改变。所以这不是我们想要的结果,同事也不是真正意义上的复制。


为了解决浅拷贝问题,我们引出深拷贝,即自定义拷贝构造函数,如下:

String(const String& s)
        :_str(new char[strlen(s._str) + 1])
    
        strcpy(_str , s._str);
    

这样在运行就没问题了。


那么,程序中还有没有其他地方用到拷贝构造函数呢?

答案:当函数存在对象型的参数(即拷贝构造)或对象型的返回值(赋值时的返回值)时都会用到拷贝构造函数。


而拷贝赋值的情况基本上与拷贝复制是一样的。只是拷贝赋值是属于操作符重载问题。例如在主函数若有:String s3; s3 = s2; 这样系统在执行时会调用系统提供的缺省的拷贝赋值函数,原型如下:


void operator = (const String& s) 
    

我们自定义的赋值函数如下:

void operator=(const String& s)
   
      if(_str != s._str)
      
        strcpy(_str,s._str);
      
      return *this;
   


  但是这只是新手级别的写法,考虑的问题太少。我们知道对于普通变量来讲a=b返回的是左值a的引用,所以它可以作为左值继续接收其他值(a=b)=30,这样来讲我们操作符重载后返回的应该是类对象的引用(否则返回值将不能作为左值来进行运算),如下:

String& operator=(const String& s)
    
        if(_str != s._str)
        
            strcpy(_str,s._str);
        
        return *this;
    

 

  而上面这种写法其实也有问题,因为在执行语句时,_str 已经被构造已经分 配了内存空间,但是如此进行指针赋值,_str 直接转而指向另一片新new出来的内存空间,而丢弃了原来的内存,这样便造成了内存泄露。应更改为:

String& operator=(const String& s)
    
        if(_str != s._str)  
        
            delete[] _str;
            _str = new char[strlen(s._str) + 1];
            strcpy(_str,s._str);
        
        return *this;
    

同时,也考虑到了自己给自己赋值的情况。


  可是这样写就完善了吗?是否要再仔细思索一下,还存在问题吗?!其实我可以告诉你,这样的写法也顶多算个初级工程师的写法。前面说过,为了保证内存不泄露,我们前面 delete[]  _str,然后我们在把new出来的空间给了_str,但是这样的问题是,你有考虑过万一 new 失败了呢?!内存分配失败,m_psz没有指向新的内存空间,但是它却已经把旧的空间给扔掉了,所以显然这样的写法依旧存在着问题。一般高级工程师的写法会是这样的:

String& operator=(const String& s)
    
        if(_str != s._str)
        
            char *tmp = new char[strlen(s._str) + 1];
            strcpy(tmp , s._str);
            delete[] _str;
            _str = tmp;
        
        return *this;
    

这样写就比较全面了。


但是!!!还有元老级别的大师写的更加简便的拷贝构造和赋值函数,我们一睹为快:

<元老级拷贝构造函数>

    String(const String& s)
        :_str(NULL)
    
        String tmp = s._str;
        swap(_str , tmp._str);
    

<元老级赋值函数>

// 1.
   String& operator=(const String& s)
   
     if(_str != s._str)
     
       String tmp = s._str;
       swap(_str , tmp._str);
     
     return *this;
   
// 2.
    String& operator=(String& s)//在此会拷贝构造一个临时的对象s
   
     if(_str != s._str)
     
       swap(_str ,s._str);// 交换this->_str和临时生成的对象数据成员s._str,离开作用域会自动析构释放
     
     return *this;
   

看出端倪了么?


  事实上,这是借助了以上自定义的拷贝构造函数。定义了局部对象 tmp,在拷贝构造中已经为 tmp 的成员指针分配了一块内存,所以只需要将 tmp._str 与this->_str交换指针即可,简化了程序的设计,因为 tmp 是局部对象,离开作用域会调用析构函数释放交换给 tmp._str 的内存,避免了内存泄露。

这是非常值得我们学习和借鉴的。


这是本人对C++深浅拷贝的理解,若有纰漏,欢迎留言指正 ^_^


附注整体代码:

#include <iostream>
using namespace std;

class String

public:

    String(char *str = "")
        :_str(new char[strlen(str) + 1])
    
        strcpy(_str , str);
    
    
    // 浅拷贝
    String(const String& s)
        :_str(s._str)
    


    //赋值运算符重载
    //有问题,会造成内存泄露。。。
    String& operator=(const String& s)
    
        if(_str != s._str)
        
            strcpy(_str,s._str);
        
        return *this;
    

    // 深拷贝  <传统写法>
    String(const String& s)
        :_str(new char[strlen(s._str) + 1])
    
        strcpy(_str , s._str);
    
    
    //赋值运算符重载
    //一.  这种写法有问题,万一new失败了。。
    String& operator=(const String& s)
    
        if(_str != s._str)
        
            delete[] _str;
            _str = new char[strlen(s._str) + 1];
            strcpy(_str,s._str);
        
        return *this;
    

    //二.  对上面的方法改进,先new后delete,如果new失败也不会影响到_str原来的内容
    String& operator=(const String& s)
    
        if(_str != s._str)
        
            char *tmp = new char[strlen(s._str) + 1];
            strcpy(tmp , s._str);
            delete[] _str;
            _str = tmp;
        
    

    // 深拷贝  <现代写法>
    String(const String& s)
        :_str(NULL)
    
        String tmp = s._str;
        swap(_str , tmp._str);
    
    
    //赋值运算符的现代写法一:
    String& operator=(const String& s)
    
        if(_str != s._str)
        
            String tmp = s._str;
            swap(_str , tmp._str);
        
        return *this;
    
    //赋值运算符的现代写法二:
    String& operator=(String& s) //在此会拷贝构造一个临时的对象s
    
        if(_str != s._str)
        
            swap(_str ,s._str);//交换this->_str和临时生成的对象数据成员s._str,离开作用域会自动析构释放
        
        return *this;
    

    ~String()
    
        if(_str)
        
            delete[] _str;
            _str = NULL;
        
        cout<<"~String()"<<endl;
    

    void Display()
    
        cout<<_str<<endl;
    

private:
    char *_str;
;

void Test()

    String s1;
    String s2("hello");
    String s3(s2);
    String s4 = s3;

    s1.Display();
    s2.Display();
    s3.Display();
    s4.Display();



int main()

    Test();

    return 0;


本文出自 “Vs吕小布” 博客,请务必保留此出处http://survive.blog.51cto.com/10728490/1752144

以上是关于C++ 浅析深浅拷贝的主要内容,如果未能解决你的问题,请参考以下文章

浅析Python的深浅拷贝

C++中的深浅拷贝问题

C++ 深浅拷贝写时拷贝

C++ 深浅拷贝写时拷贝

深浅拷贝,赋值

深浅拷贝,深浅赋值语句