string类的简单实现（写时拷贝Copy-on-write）

前言：上一篇文章实现了string的深拷贝写法；那我们能不能用浅拷贝写string类呢？当然可以；
一、
（1）
当我们需要对拷贝之后的对象进行修改时，采用深拷贝的方式； 如果不需要修改，只是输出字符串的内容时，或者是当偶尔修改的的时候，我们再采用深拷贝的方法；对于这两种情况，我们在实现拷贝构造函数时采用浅拷贝的方式。在采用浅拷贝的方式以后，那么两个对象的成员变量指针指向同一块字符串空间；根据上一篇的文章，我们知道这样的话，析构时必然会发生错误；那么怎么避免析构时出错；请看下文；

（2）
写之前，还是先说一下，为什么要实现string类的写时拷贝

原理：浅拷贝+引用计数；

因为在现实生活中，我们有很多情况下用一个对象来拷贝构造另一个对象的之后，我们只是把拷贝构造来的对象用一下而已，不会对他的字符串进行修改操作；那么这样的话，我们其实不用深拷贝那么麻烦。按照上一篇的深拷贝，如果我们要用一万个对象，那我们开辟一万个对象空间，但是得到之后只是用对象里面保存的字符串，并没有其他的操作；这样的话会很浪费空间；而且还要拷贝字符串，程序效率也会降低，所以我们想到了一种实现方式；就是说

，只有当我们要对拷贝来的字符串进行修改时，才采用深拷贝的方式，其余情况都采用浅拷贝；这种只有写的时候才进行深拷贝的方式叫做写时拷贝；

（3）实现写时拷贝的时候，因为采用了浅拷贝的方式，所以，为了避免析构的时候出现错误，上篇文章的析构函数就用不了；要在其基础上修改；我们可以在成员变量中添加一个变量count，用来记录拷贝的次数；每拷贝一次，我们就count++；然后在析构函数内部也加上if的判断语句；当我们每次析构一个对象的时候，就–count;当count等于0的时候，再进入if语句内部；释放空间；将变量置空；

再此，我给出了三种方案，其中有二个是错的；但都是经典的错误写法。所以把三种方法都说一下

二、两种经典的错误实现方法：

（1）方案一：错误写法

方案一：（错误）
#include<iostream>
using namespace std;
class String
{
public:
    String(const char* str="")//构造函数
        :_str(new char[strlen(str)+1])
        ,_count(1)
    {
        strcpy(_str,str);
    }
    String( String& s)//拷贝构造---浅拷贝
        :_str(s._str)
    {
        _count=++(s._count);
    }

    String& operator=(String s)//赋值操作符重载---现代写法
    {
        std::swap(_str,s._str);
        return *this;
    }
    ~String()//析构函数
    {
        if (--_count==0)
        {
            delete[] _str;
            _str=NULL;
        }
    }
private:
    char* _str;
    int   _count;
};
int main()
{
    String s1("abcdef");
    String s2(s1);
    return 0;
}

分析：
分析：首先这种方案是不对的，为什么呢？我们确实是添加了一个计数器_count；在构造函数里面；每次构造一个对象；_count赋值为1；在析构函数内部也加入了if（–_count=0)的判断机制，避免一块空间被多次释放；但是真的达到这个效果了吗？其实没有，因为在拷贝构造函数当中，我们每次++被拷贝的_count然后赋给要接受拷贝的对象的_count;当程序走完，此时两个_count都变为2；

当析构各自的对象时，这时，这两个对象的_conut各自都为2；当调用析构函数时，–_count以后，都不能够释放空间；这里的意思就是，当S2调用析构函数后，他没有释放空间，自己的_count变为了1；

但是接下来，当s1掉用析构函数时，它的_count不是1，仍然是2，–_count以后仍然不能够进入if语句释放空间；

所以，这种方法不对；那我们能不能定义一个_count使其能够被所有对象共用；当一个对象调用析构函数时，–_count;等到下一次另一个对象调用时，在上一次减了基础上再减呢；当然可以；我们把_count定义为局部静态变量；

（2）方案二：错误写法

在类中数据成员的声明前加上static,该成员是类的静态数据成员,必须在类外进行定义；

★★类中静态数据成员和非静态数据成员的区别：★★

①对于非静态数据成员,每个类对象都有自己的拷贝.

②而静态数据成员被当做是类的成员,无论这个类被定义了多少个,静态数据成员都只有一份拷贝， 为该类型的所有对象所共享(包括其派生类).所以,静态数据成员的值对每个对象都是一样的,它的值可以更新. 静态数据成员不属于某个类对象所私有，所以不能再在初始化列表中初始化

#include<iostream>
using namespace std;
#include<cassert>
class String
{

public:
    String(const char* str="")//构造函数
        :_str(new char[strlen(str)+1])
    {
        _count=1;
        strcpy(_str,str);
    }
    String(const String& s)//拷贝构造---浅拷贝
        :_str(s._str)
    {
        ++_count;
    }

    String& operator=(String s)//赋值操作符重载---现代写法
    {
        std::swap(_str,s._str);
        return *this;
    }
    ~String()//析构函数
    {
        if (--_count==0)
        {
            delete[] _str;
            _str=NULL;
        }
    }
private:
    char* _str;
    static int  _count;
};

int String:: _count=1;
int main()
{
    String s1("abcdef");
    String s2(s1);
    String s3("HELLO");
    return 0;
}

分析： 这种写法表面上看上去好像是对的；其实也存在问题；如过只看我上面的两行测试代码；好像没有错误；当s1创建时，静态成员变量_count变为了1；然后构造S2之后，_count++;变为2；这时这个_count是两个对象的共用成员变量，

然后s2先调用析构函数，–_count变为1，

然后s1再调用类的析构函数，此时的_count为1，–_count以后，_count 变为0；这时，才将s1和s2共同指向的空间释放掉，避免一块空间，被多次释放；

but，当我们在这后面，再创建一个对象s3时，这就不对了，创建s3的时候，调用构造函数，将静态变量_count变为1；

此时类的共用成员变量_count变为了1；当从后往前析构时；

S3调用析构函数_conut变为0；s3的空间成功释放；

但是当s2调用析构函数时，此时计数器_count=0;–count之后变为-1，不会进入if判断语句内部释放空间；

S1调用析构函数时，_count变为-2；更不会析构s1和S2共同指向的空间。所以错误

三、正确的写时拷贝写法

（1）方案三：正确写法

#include<iostream>
using namespace std;
#include<cstring>
class String
{
public:
    String(const char* str="")//构造
        :_str(new char[strlen(str)+1])
        ,_PCount(new int(1))
    {
        strcpy(_str,str);

    }
    String(const String& s)//拷贝构造----浅拷贝
        :_str(s._str)
        ,_PCount(s._PCount)
    {
        ++_PCount[0];

    }
    String& operator=(const String& s)//赋值运算符重载
    {
        if (this!=&s)
        {
            delete[] _str;
            delete _PCount;
            _str=s._str;
            _PCount=s._PCount;
            ++_PCount[0];
        }
        return *this;
    }
    ~String()//析构
    {
        if (--_PCount[0]==0)
        {
            delete[] _str;
            delete _PCount;
            _str=NULL;
            _PCount=NULL;
        }
    }
private:
    char* _str;
    int* _PCount;
};
void Test()
{
    String s1("abcdef");
    String s2(s1);
    String s3("ABCEDF");
    String s4;
    s4=s1;
}
int main()
{
    Test();
    return 0;
}

分析：
正确写法（每段字符串内存加上属于自己的计数器指针,这样的话，只有当拷贝构造的时候，两个对象的计数器指针才会指向同一个计数器内存，让其++，如果构建新的对象，那么他的计数器为构造函数1，析构时，是自己的1变为0，不会影响拷贝构造的两个对象的计数器变化，这样就能到达：没有拷贝构造的对象，一次把自己的空间释放掉，而拷贝构造的对象，所有对象的计数器都指向同一个计数器空间，释放该计数器的字符串内存；也不会出错）



图示说明：
①

    String s1("abcdef");
    String s2(s1);
    String s3("ABCEDF");

②赋值运算符重载详解

String& operator=(const String& s)//赋值运算符重载
    {
        if (this!=&s)
        {
            delete[] _str;
            delete _PCount;
            _str=s._str;
            _PCount=s._PCount;
            ++_PCount[0];
        }
        return *this;
    }

测试

    String s1("abcdef");
    String s2(s1);
    String s3;
    s3=s1;

（2）方案三写时拷贝的改进

前面的方案三，我们是用两个指针，分别管理内存和计数器，这样每次构造函数的时候，要分别开辟空间给各自的指针;这样做降低效率；我们可以只开辟一次空间；里面既存计数器又存字符串；在开辟的空间的前四个字节存储计数器，后面存储字符串；

#include<iostream>
using namespace std;
#include<cstring>
#include<cassert>
class String
{
public:
    String(const char* str="")//构造
        :_str(new char[strlen(str)+1+4])
    {
        cout<<"构造"<<endl;   
        _str+=4;//走到数据区首地址
        strcpy(_str,str);
        GetCount()=1;//计数器区域赋值为1
    }

    String(const String& s)//拷贝构造
        :_str(s._str)
    {
        cout<<"拷贝构造"<<endl;   
        ++GetCount();//将所指向的共同内存的计数器加+
    }

    String& operator=(String& s)//赋值运算符重载---赋值的对象计数器要++;被赋值的对象计数器要++
    {
        if (this!=&s)
        {
            cout<<"构赋值运算符重载"<<endl;   
            /*判断被赋值的对象的计数器--，是否为0；如果为0，就要释放他的（计数区+数据区）
              如果没有到达0；则只是给计数器减1；*/
            if (--GetCount()==0)
            {
                delete[] (_str-4);//回到内存的首位置
            }
            ++(s.GetCount());
            _str=s._str;

        }
        return *this;
    }

    ~String()//析构
    {
        cout<<"析构"<<endl;   
        if (--GetCount()==0)
        {
            cout<<"释放"<<endl;   
            delete[] (_str-4);
            _str=NULL;
        }
    }

    char& operator[](size_t index)//  写时拷贝
    {
        cout<<"重载[]"<<endl;
        assert(index>=0 && index<(int)strlen(_str));
        if (GetCount()=1)//如果该对象的计数器为1
        {
            return _str[index];//直接返回index位置的值，进行修改
        }
        如果不为1
        --GetCount();//先给对象的计数器--
        char* tmp=new char[strlen(_str)+1+4];//然后开辟一个同样大小的空间；用指针指着
        strcpy(tmp+4,_str);//给这块空间字符串区域拷贝原空间的字符串
        _str=tmp+4;//将指针指向新开辟字符串的首位置
        GetCount()=1;//将指针的计算器置为1
        return _str[index];//返回index位置的值
    }
private:
    int& GetCount()//取计数器的值
    {
        return  *((int*)_str-1);
    }
private:
    char* _str;
};

void Test()
{
   String s1("abcdef");
   String s2(s1);
   String s3(s2);
   s3[3]='q';
}

int main()
{
    Test();
    return 0;
}

部分函数过程图示：
①拷贝构造函数

②赋值运算符重载

四、写时拷贝比普通拷贝的效率高

#include<iostream>
using namespace std;
#include<cstring>
#include<cassert>
#include<Windows.h>
namespace WriteCopy
{

class String
{
public:
    String(const char* str="")//构造
        :_str(new char[strlen(str)+1+4])
    {
        _str+=4;
        strcpy(_str,str);
        GetCount()=1;
    }
    String(const String& s)
        :_str(s._str)
    {
        ++GetCount();
    }
    ~String()//析构
    {
        if (--GetCount()==0)
        {
            delete[] (_str-4);
            _str=NULL;
        }
    }

private:
    int& GetCount()//取计数器的值
    {
        return  *((int*)_str-1);
    }
private:
    char* _str;
};
}

namespace MyString
{
    class String
    {   
    public:
        String(const char* str="")
            :_str(new char[strlen(str)+1])
        {
            strcpy(_str,str);
        }
        String(const String& s)
            :_str(new char[strlen(s._str)+1])
        {
            strcpy(_str,s._str);
        }

        ~String()
        {
            if (NULL!=_str)
            {
                delete[] _str;
                _str=NULL;
            }
        }
    private:
        char* _str;
    };
}
void Test()
{
    int start=GetTickCount();
    WriteCopy::String s1("abcdef");
    for (int i=0;i<10000000;i++)
    {
        WriteCopy::String s2(s1);
    }
    int end=GetTickCount();
    cout<<"写时拷贝"<<end-start<<endl;


    start=GetTickCount();

    MyString::String s3("abcdef");
    for (int i=0;i<10000000;i++)
    {
        MyString::String s4(s3);
    }
    end=GetTickCount();
    cout<<"普通拷贝"<<end-start<<endl;
}

int main()
{
    Test();
    return 0;
}

end!!!

接下来模拟实现c++库中的string类；