寫時拷貝 引用計數(shù)器模型

1、深淺拷貝的使用時機：

  淺拷貝：對只讀數(shù)據(jù)共用一份空間，且只釋放一次空間；

  深拷貝：數(shù)據(jù)的修改，的不同空間；

2、引用計數(shù)器模型

  使用變量use_count，來記載初始化對象個數(shù)；

  static模型(此處只用淺拷貝與淺賦值)

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

class String{
public:
    String(const char *str = ""){
        if(str == NULL){
            data = new char;
            data[0] = 0;
        }else{
            data = new char[strlen(str) + 1];
            strcpy(data,str);
        }
        use_count++;     //每新創(chuàng)建一個對象，對引用計數(shù)器++；
    }
    String(const String &s){
        data = s.data;
        use_count++;      //創(chuàng)建出新的對象，use_count++；
    }
 //此處先不寫賦值語句
    ~String(){
        if(--use_count == 0){  //當引用計數(shù)器減為0時，就是每次行析構對象時，都對它減一次，直到為0才釋放空間，
            delete []data;
            data = NULL;
        }
    }
public:
    char* GetString()const{
        return data;
    }
private:
    char *data;
    static int use_count;   //此處use_count只有一份，負責記載創(chuàng)建了多少個對象；
};

int String::use_count = 0;  //C++中的靜態(tài)變量全局只有一份，可以再類外進行初始化；

int main(void)
{
    String s1("hello");
    cout<<s1.GetString()<<endl;
    String s2;
    s2 = s1;  //淺賦值，調用默認的；
    cout<<s2.GetString()<<endl;
    String s3("xyz"); //創(chuàng)建t3對象，要出問題了；(對其就只創(chuàng)建出來，不在進行賦值語句等操作)；此時的情況是：已經(jīng)有兩個對象，其成員data指向同一空間，此時又有一個data指向另一個空
                      //間，但是use_count為0才釋放空間，只釋放一份，所以肯定有內存泄漏?。?！
    return 0;
}

  上面的static淺拷貝其實存在很大的問題，當t3對象創(chuàng)建時，use_count會加1；

  當調用析構函數(shù)時，每次減1，為0時，釋放空間，

3、寫時拷貝

  淺拷貝與深拷貝聯(lián)合使用，看實際需求對其編寫，此時我希望，對數(shù)據(jù)讀時共用一份數(shù)據(jù)，需要修改時，在單獨開辟空間進行修改，在進行改寫，并且對象(初始化)應該有自己的data和use_count，賦值語句時共用一份就行，此時就需要句柄了，這就是寫時拷貝；

  具體完整代碼如下：

#include<iostream>
#include<malloc.h>
#include<string.h>
using namespace std;
class String;
class String_rep{        // 這個類是封裝在內部供我們程序員自己使用的。
    friend class String;  //友元類，可以訪問私有數(shù)據(jù)。
public:
    String_rep(const char *str = ""):use_count(0){  //構造函數(shù)的初始化
        if(str == NULL){
            data = new char[1];
            data[0] = 0;
        }else{
            data = new char[strlen(str)+1];
            strcpy(data,str);
        }
    }
    String_rep(const String_rep &rep);
    String_rep& operator=(const String_rep &rep);
    ~String_rep(){
        delete []data;
        data = NULL;
    }
public:
    void increment(){  
        use_count++;
    }
    void decrement(){   //這個函數(shù)至關重要，寫了一個釋放空間的函數(shù)，要在其后賦值語句中使用；
        if(--use_count == 0)
            delete this;
    }
    int use_count_()const{
        return use_count;
    }
public:
    char *getdata()const{
        return data;
    }
private:
    char *data;
    int use_count;
};
class String{
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){
        if(this != &s){
            rep->decrement();
            rep = s.rep;
            rep->increment();
        }
        return *this;
    }
    ~String(){
        rep->decrement();
    }
public:
    int use_count()const{
        return rep->use_count_();
    }
    void print()const{
        cout<<rep->data<<endl;
    }
    void toupper(){      //這個函數(shù)提供的意義：對其要改的對象重新申請空間，進行改寫，使相互之間不影響。     
        if(rep->use_count_() > 1){ //對象個數(shù)大于1才進行拷貝出來重新寫，只有一個就直接在其上進行修改。
            String_rep *new_rep = new String_rep(rep->data);
            this->rep->decrement();
            rep = new_rep;
            rep->increment();
        }
        char *pch = rep->data;
        while(*pch){
            *pch -= 32;
            pch++;
        }
    }
private:
    String_rep *rep; // 句柄
};
int main(){
    String s1("hello");
    String s2 = s1;
    String s3("xyz");
    s3 = s2;
    s1.toupper();
    s1.print();
    cout<<"s1 count = "<<s1.use_count()<<endl;
    s2.print();
    cout<<"s2 count = "<<s2.use_count()<<endl;
    s3.print();
    cout<<"s3 count = "<<s3.use_count()<<endl;
    return 0;
}

以上的代碼就可以達到目的，每次創(chuàng)建對象都有自己的data和use_count(調用構造函數(shù)),在賦值語句時先釋放原有空間，在進行淺拷貝，構造函數(shù)時也是淺拷貝，對其進行了各自空間的管理與釋放，并且在修改數(shù)據(jù)時拷貝出來一份即可。

分析如下：

關于以上還有個問題：就是：

void decrement(){   
  if(--use_count == 0)
   delete this;
}

為什么不在String類的析構函數(shù)中寫delete呢？

原因：析構函數(shù)只有在對象釋放是才調用，而在此時，通過賦值語句要釋放空間，析構函數(shù)此時就不能及時釋放原有空間，會造成內存泄漏，所以寫一個釋放空間的函數(shù)，內部有delete，會先調用析構函數(shù)，達到了及時釋放空間的目的！

以上只是對寫時拷貝的粗淺理解。