深拷贝与浅拷贝深究

深拷贝与浅拷贝。我们可以通过一个故事来了解一下：甲有一本漫画很好看，这时乙也想看。第一种情况，甲将书借给了乙（浅拷贝：资源重复利用了）；第二种情况，甲因自己还没看完，没有借给乙，乙就自己重新买了一本（深拷贝：重新弄一个相同的）。

在这里，我会从构造函数，拷贝构造函数、=（赋值）重载、析构函数进行深究。

首先我们通过一个例子来了解一下:

#include<iostream>
using namespace std;
class String
{
　　public:
　　　　String(const char *str=""); //构造函数
　　　　String(const String &s);  //拷贝构造函数
　　　　String& operator=(const String &s);  //重载=运算符
　　　　~String();  //析构函数
}
void main()
{
　　String s="Hello";
　　String s1=s;

　　String s2;
　　s2=s1;
}

以上的代码是一个简单String类，一般像较为简单的函数，我们可以将函数实现写在类中，这样形成内联函数，执行效率会大大提高。

1.为什么在函数中要对参数进行const限制？

答：在函数中，我们使用const对参数进行限制，为了保证数据的安全性。

2.给形参设置一个默认值（const char  *str=""）有什么好处？

答：在构造函数中，我们给形参设定一个空的的默认值。避免在函数体内进行空指针判断，提高了代码的简约性。

3.在拷贝构造函数中，为什么对参数要加引用？

答：为了避免产生拷贝构造后，无休止的拷贝构造。

初级程序员标准如下代码：

class String{
public:
    String(const char *str="")    //构造函数
    {
        m_data=new char[strlen(str)+1];
        strcpy(m_data,str);
    }
    String(const String &s)   //拷贝构造函数
    {
        m_data=new char[strlen(s.m_data)+1];
        strcpy(m_data,s.m_data);
    }
    String& operator=(const String &s)    //重载=
    {
        if(this != &s)
        {
            delete []m_data;
            m_data=new char[strlen(s.m_data)+1];   //问题4：异常安全性原则
            strcpy(m_data,s.m_data);
        } 
        return *this;
    }
    ~String()//析构函数
    {
        delete[] m_data;
        m_data=NULL;
    }
private:
    char *m_data;
};

4.当在重载=运算符时，s1=s2，s1存储数据所需要的空间申请不足时，会导致之前s1对象delete的数据丢失，如何避免这一情况？ 这称为“异常安全性原则”。

答：①我们先申请相应的空间，在将复制实例释放空间。 ②我们申请一个局部实例，然后交换临时实例和原来实例。

高级程序员标准如下代码：

  String& operator=(const String &s)    //重载=
    {
        if(this != &s)
        {
            String temp_str(s);
　　　　　　　char *temp_data=temp_str.m_data;
　　　　　　　temp_str.m_data=m_data;
　　　　　　  m_data=temp_data;
        } 
        return *this;
    }

5.当我们用到浅拷贝时，那我们在执行析构函数时，就要注意释放空间的时机。在这里我们通过两种方法过度：①我们引用静态常量（static int count）来记住指向当前数据的实例个数，当count==0时，执行释放空间。

class String
{
public:
    String(const char *str = "")
    {
        m_data = new char[strlen(str)+1];
        strcpy(m_data, str);
        use_count++;
    }

    String(const String &s)
    {
        m_data = s.m_data;
        use_count++;
    }
    //String& operator=(const String &s);

    ~String()
    {
        if(--use_count == 0)
        {
            delete []m_data; 
            m_data = NULL;
        }
    }
private:
    char *m_data;
    static int  use_count;
};

int String::use_count = 0;

void main()
{
    String s("Hello");
    String s1 = s;

    String s2("Linux");
}

 

注意：当我们调试发现，当重新定义一个不一样的实例时，也会改变use_count的值，这是我们不想看到的。由此当我们执行程序完成，继第二次之后执行构造函数所分配的空间不会被释放，造成内存泄漏。

②我们引用技术类将实例，将String对象的初始化和use_count的增减操作分离。

class String;
ostream& operator<<(ostream &out, const String &s);

class String_rep
{
    friend class String;
    friend ostream& operator<<(ostream &out, const String &s);
public:
    String_rep(const char *str="") : use_count(0)
    {
        m_data = new char[strlen(str)+1];
        strcpy(m_data, str);
    }

    String_rep(const String_rep &rep)
    {
        m_data=new char[strlen(rep.m_data)+1];
        strcpy(m_data,rep.m_data);
    }
    String_rep& operator=(const String_rep &rep)
    {
        if(this!=&rep)
        {
            /*  同问题4：会发生异常 
            delete m_data;
            m_data=new char[strlen(rep.m_data)+1];
            strcpy(m_data,rep.m_data)*/
            String_rep temp_rep(rep);
            char *temp_data=temp_rep.m_data;
            temp_rep.m_data=m_data;
            m_data=temp_data;
        }
        return *this;
    }
    ~String_rep()
    {
        delete []m_data;
        m_data = NULL;
    }
public:
    void increment()
    {++use_count;}
    void decrement()
    {
　　　　if（--use_count==0）
　　　　　　delete this;
　　}
private:
    char *m_data;
    int   use_count;
};
////
class String
{
    friend ostream& operator<<(ostream &out, const String &s);
public:
    String(const char *str = "") : rep(new String_rep(str))
    {
        rep->increment();
    }
    String(const String &s)
    {
        rep = s.rep;
        rep->increment();
    }
    String& operator=(const String &s);
    ~String()
    {
        rep->decrement();
    }
public:
　　//当完成写实拷贝，如若用户想要对数据进行修改，则需要发生深拷贝，将原类的实例引用常量-1，将新生实例的引用常量+1.
    void to_upper()
　　{
        rep->decrement();
        rep=new String_rep(rep->m_data);
        rep->increment();

        char *ch = rep->m_data;
        while(*ch++ != '\0')
            *ch = toupper(*ch);
    }
private:
    String_rep *rep;
};

ostream& operator<<(ostream &out, const String &s)
{
    out<<(s.rep)->m_data;
    return out;
}

void main()
{
    String s("Hello");
    String s1 = s;

    
    cout<<"s  = "<<s<<endl;
    cout<<"s1 = "<<s1<<endl;

    s.to_upper(); //写实拷贝

    cout<<"s  = "<<s<<endl;
    cout<<"s1 = "<<s1<<endl;

}

对s进行写实拷贝，执行结果如下：

 

 

转载于:https://www.cnblogs.com/single-dont/p/10415838.html