标准C＋＋类std::string的内存共享和Copy-On-Write（写时拷贝）

标准C＋＋类std::string的内存共享，值得体会：

详见大牛：https://www.douban.com/group/topic/19621165/

顾名思义，内存共享，就是两个乃至更多的对象，共同使用一块内存；

1.关于string的内存共享问题：

通常，string类中必有一个私有成员，其是一个char*，用户记录从堆上分配内存的地址，其在构造时分配内存，在析构时释放内存。

因为是从堆上分配内存，所以string类在维护这块内存上是格外小心的，string类在返回这块内存地址时，只返回const char*，也就是只读的，

如果你要写，也只能通过string提供的方法进行数据的改写。

#include<iostream>
#include<string>
#include<cstdio>
using namespace std;

main()
{
       string str1 = "hello world";
       string str2 = str1;
       string str3 = str2;

       printf ("内存共享:
");
       printf ("	str1 的地址: %x
", (unsigned int)str1.c_str() );
       printf ("	str2 的地址: %x
", (unsigned int)str2.c_str() );
       printf ("	str3 的地址: %x
", (unsigned int)str3.c_str() );

       return 0;
}

如上例子中，str1,str2,str3共享同一块内存，如图：

基本就是内存string类内存共享的最底层展现了，既然内存是一样的了，如果需要改写某个对象怎么办？由此引出写时拷贝Copy-On-Write

2.关于Copy-On-Write（原理）

顾名思义,写的时候在拷贝，（读的时候就不用了，哈哈）

还是以上边的例子为例：

#include<iostream>
#include<string>
#include<cstdio>
using namespace std;

main()
{
       string str1 = "hello world";
       string str2 = str1;
       string str3 = str2;

       printf ("内存共享:
");
       printf ("	str1 的地址: %x
", (unsigned int)str1.c_str() );
       printf ("	str2 的地址: %x
", (unsigned int)str2.c_str() );
       printf ("	str3 的地址: %x
", (unsigned int)str3.c_str() );

       str3[1]='a';
       str2[1]='w';
       str1[1]='q';

       printf ("通过写时拷贝之后:
");
       printf ("	str1 的地址: %x
", (unsigned int)str1.c_str() );
       printf ("	str2 的地址: %x
", (unsigned int)str2.c_str() );
       printf ("	str3 的地址: %x
", (unsigned int)str3.c_str() );

       return 0;
}

//输出结果：
内存共享:
　　str1 的地址: 83f9017
　　str2 的地址: 83f9017
　　str3 的地址: 83f9017
通过写时拷贝之后:
　　str1 的地址: 83f9017
　　str2 的地址: 83f9054
　　str3 的地址: 83f9034

很明显可以看出来，一开始，str1,str2,str3共享同一块内存，地址都是一样的；

当开始修改是这些内存是，先不说如何实现，先表征是如何写时拷贝的，看图，咱还是看图：

图中依然说明了str3的内容修改是怎么回事，str2的内容修改，也是同样的道理，重新给str2在堆上开辟空间，原空间只是str1一个人用，修改最后一个str1的内容时，

当然就不用在和前两种一样啦，因为，这个时候，原空间只有str1一个人用，这个时候，对此空间操作，没有任何问题。都写都可以；

写时拷贝在此例中的体现，主要是str2,和str3内容的修改；但是有没有发现，我每次开辟空间的同时，会在新开辟的空间开头多分配一个空间，存放的是count；

原因就和写时拷贝的具体操作有关了：

3.写时拷贝（Copy-On-Write）的实现：

Copy-On-Write使用了“引用计数”，有一个变量count来计数，而且计数就放在没开辟一段空间的开头几个字节。

当第一个类构造时，string的构造函数会根据传入的参数从堆上分配内存，当有其它类需要这块内存时，这个计数为自动累加，

当有类析构时，这个计数会减一，直到最后一个类析构时，此时的count为1或是0，此时，程序才会真正的Free这块从堆上分配的内存。 

下面是我写的一个简单的例子：

#include<iostream>
using namespace std;

class String
{
public:
    String(const char* str)
        //初始时字符创有一个外加4个字节的引用计数空间
        :_str(new char[strlen(str)+5])
    {
        (*((int*)_str)) = 1;//申请的空间赋值为1
        _str += 4; //让_str还是指向字符创的第一个字符
                   //而不是引用计数的头上
        strcpy(_str,str);
    }

    String(const String& s)
        :_str(s._str)
    {
        (*(((int*)_str) - 1)) += 1;
    }

    String& operator=(const String& s)
    {
        if(_str != s._str)
        {
            if(*(((int*)_str) - 1) == 0)
            {
                delete[] (_str-4);
            }
            _str = s._str;
            *(((int*)_str) - 1) += 1;
        }
        return *this;


    }
    ~String()
    {
        if(*(((int*)_str) - 1) == 0)
        {
            _str -= 4;
            delete[] _str;
        }
    }
private:
    char *_str;
};

void Test()
{
    String s1("11111111111111111111111111");
    String s2(s1);
}

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

在内存开头开辟引用计数空间；

到此，string类的内存共享和写时拷贝，就算是告一段落了，个人拙见，跪求赐教！