std::string的Copy-On-Write(写时拷贝)技术原理及其简单实现
以下是基于SGI版本
1、std::string
std::string 其实是模板类std::basic_string的实例化,可以在头文件stringfwd.h中查看
std::basic_string的实现可以在basic_string.h和basic_string.tcc文件中查看
2、Copy-On-Write
basic_string有一个写时拷贝的技术，这样可以极大的优化性能,它通过引用计数实现的，
basic_string类的大致构造如上图所示，对于_Rep对象的构建，是先申请堆空间，空间大小是sizeof(_Rep)+字符串capacity长度, 在申请内存的首地址就地new出 _Rep对象，所以basic_string的_M_p指向的实际内存如下图所示。
例如当string A=string B时，A并没有为_M_p重新申请数据内存，而是A. _M_p = B. _M_p, _M_refcount加一，直到A有写入时，才会重新为A. _M_p申请内存，而_M_refcount也会减一，
_Rep中静态的_S_empty_rep_storage成员，是用来存放每一个默认构造的basic_string前提是宏定义_GLIBCXX_FULLY_DYNAMIC_STRING == 0,也就是说其实所有默认构造对象的_M_p都指向同一处内存，这样可以节省很多内存
3、MyString的简单实现
#include <stdio.h> #include <atomic> class MyString { public: struct Rep_base { uint32_t m_length; uint32_t m_capacity; std::atomic<int32_t> m_refcount; }; struct Rep:Rep_base { static uint32_t s_empty_rep_storage[]; // 用于存放所有默认构造的string static const uint32_t s_max_size; // string所允许的最大长度 static const char s_terminal; // 定义结束符 // static Rep& s_empty_rep() { void* p = reinterpret_cast<void*>(&s_empty_rep_storage); return *reinterpret_cast<Rep*>(p); } // 返回string数据的地址 char* refdata() throw() { // this+1的地址就是偏移一个Rep，也就是12个字节后的地址 char* p = reinterpret_cast<char*>(this + 1); return p; } // 堆空间申请新的内存区域，最前端是Req，后面跟着string字符数据 static Rep* create(uint32_t capacity, uint32_t old_capacity) { if (capacity > s_max_size) { return nullptr; } if (capacity > old_capacity && capacity < 2 * old_capacity) { capacity = 2 * old_capacity; } // 这里省略了源码里的页面对齐 //... uint32_t size = (capacity + 1) * sizeof(char) + sizeof(Rep); void* place = malloc(size); Rep * p = new (place) Rep; p->m_capacity = capacity; p->m_refcount.exchange(0); return p; } // 释放内存，销毁对象 void destroy() throw () { free(reinterpret_cast<char*>(this)); } // 设置string长度和引用计数，并追加结束符 // 因此string的size()是不包含结束符的 void set_length_and_sharable(uint32_t n) { if (this != &Rep::s_empty_rep()) { this->m_refcount.exchange(0); this->m_length = n; this->refdata()[n] = s_terminal; } } // 重新创建空间，拷贝原数据 char* clone(uint32_t res = 0) { const uint32_t requested_cap = this->m_capacity + res; Rep* r = Rep::create(requested_cap, this->m_capacity); if (this->m_length) { memcpy( r->refdata(), this->refdata(), this->m_length); } r->set_length_and_sharable(this->m_length); return r->refdata(); } // 引用计数加1 char* refcopy() throw() { if (this != &Rep::s_empty_rep()) { this->m_refcount++; } return refdata(); } // 如果引用计数>=0,则引用计数++，否则重新申请空间拷贝数据 char* grab() { return (m_refcount.load() >= 0) ? refcopy() : clone(); } // 引用计数减一，如果引用计数小于0，销毁内存 void dispose() { if (this != &Rep::s_empty_rep()) { m_refcount--; if (m_refcount.load() < 0) { destroy(); } } } }; struct Alloc_hider { Alloc_hider(char* dat) : m_p(dat) { } char* m_p; // The actual data. }; public: // 默认构造函数 MyString() : m_dataplus(Rep::s_empty_rep().refdata()) { } // 带入参的构造函数 MyString(const char* s) : m_dataplus(m_construct(s, s ? s + strlen(s) : s)) { } // 拷贝构造 MyString(const MyString& s) : m_dataplus(s.m_rep()->grab()) { } // 移植构造,入参需为右值 MyString(MyString&& s) : m_dataplus(s.m_dataplus) { // s对象m_rep()地址交给了this对象，自己指向了全局的初始化空间 s.m_data(Rep::s_empty_rep().refdata()); } MyString& operator=(const MyString& s) { if (m_rep() != s.m_rep()) { char* tmp = s.m_rep()->grab(); // s的引用计数加一 m_rep()->dispose(); // this的引用计数减一 m_data(tmp); } return *this; } ~MyString() // 析构函数 { m_rep()->dispose(); } MyString& operator=(const char* s) { uint32_t n = strlen(s); // m_data()不包含s字符串或者引用计数大于0,则可能需要调整m_data()内存 if (m_disjunct(s) || m_rep()->m_refcount.load() > 0) { return m_replace_safe(0, this->size(), s, n); } else { // s在m_data()内存中 const uint32_t pos = s - m_data(); if (pos >= n) {// m_data()到s的长度足够容纳s字符串,只需要拷贝进去就行 memcpy(m_data(), s, n); } else if (pos) {// 需要内存移动，如果pos为0，则不用做任何操作，置一个结束符就可以 memmove(m_data(), s, n); } m_rep()->set_length_and_sharable(n); // 该函数会置结束符 return *this; } } MyString& operator=(MyString&& s) { // 交换双方指针 char* tmp = s.m_data(); s.m_data(this->m_data()); this->m_data(tmp); return *this; } //MyString& operator=[]() const char* c_str() const { return this->m_data(); } uint32_t size() const { return this->m_rep()->m_length; } uint32_t capacity() const { return this->m_rep()->m_capacity; } private: // 返回Rep对象后的string字符串首地址 char* m_data() const { return m_dataplus.m_p; } // 重新赋值string字符串首地址 char* m_data(char* p) { return (m_dataplus.m_p = p); } // 返回Rep对象地址 Rep* m_rep() const { return &((reinterpret_cast<Rep*> (m_data()))[-1]); } // 构建一个新的对象，返回字符串首地址 char* m_construct(const char* beg, const char* end) { if (beg == end)// 空字符串不处理 { return Rep::s_empty_rep().refdata(); } // 这里先按128字节申请内存 char buf[128]; uint32_t len = 0; while (beg != end && len < sizeof(buf) / sizeof(char)) { buf[len++] = *beg; ++beg; } Rep* r = Rep::create(len, 0); memcpy(r->refdata(), buf, len); while (beg != end) // 如果128字节不够，再重新申请内存，翻倍扩大 { if (len == r->m_capacity) { // 重新翻倍申请内存 Rep* another = Rep::create(len + 1, len); memcpy(another->refdata(), r->refdata(), len); r->destroy(); // 释放内存 r = another; // 重新赋值 } r->refdata()[len++] = *beg; ++beg; } r->set_length_and_sharable(len); return r->refdata(); } // 判断s首地址是否在m_data()字符串地址内,如果在其内， // 则m_data()字符串必然包含s字符串，因为m_data()字符串必然以‘\0’结尾 bool m_disjunct(const char* s) const { return ((s < m_data()) || ((m_data() + m_rep()->m_length) < s)); } // 调整m_data()内存，因为需要把pos位置开始的len1长度替换为len2长度 void m_mutate(uint32_t pos, uint32_t len1, uint32_t len2) { const uint32_t old_size = this->size(); const uint32_t new_size = old_size + len2 - len1; const uint32_t how_much = old_size - pos - len1; // pos+len1后面的内存数据 if (new_size > this->capacity() || m_rep()->m_capacity > 0) { // m_data()长度不够或者引用计数大于0，m_data()就需要重新申请块内存了 Rep* r = Rep::create(new_size, this->capacity()); if (pos) // 把pos前的内存拷贝到新内存中 { memcpy(r->refdata(), m_data(), pos); } if (how_much) // 把pos+len1后面的内存数据后面的数据拷贝到新内存中 { memcpy(r->refdata() + pos + len2, m_data() + pos + len1, how_much); } m_rep()->dispose(); // 原先的rep引用计数减一 m_data(r->refdata()); // m_data()指向新的内存地址 } else if (how_much && len1 != len2) { // 如果len1==len2,则刚好不需要操作m_data() memmove(m_data() + pos + len2, m_data() + pos + len1, how_much); } m_rep()->set_length_and_sharable(new_size); // 新的引用计数置0,设置length并置结束符 } // 将m_data()数据从pos1位置开始的n1长度数据替换为长度为n2的s字符串 MyString& m_replace_safe(uint32_t pos1, uint32_t n1, const char* s, uint32_t n2) { m_mutate(pos1, n1, n2); if (n2) { memcpy(m_data() + pos1, s, n2); } return *this; } private: mutable Alloc_hider m_dataplus; }; uint32_t MyString::Rep::s_empty_rep_storage[ (sizeof(Rep_base) + sizeof(char) + sizeof(uint32_t) - 1) / sizeof(uint32_t)]; const uint32_t MyString::Rep::s_max_size = (((uint32_t(-1) - sizeof(Rep_base)) / sizeof(char)) - 1) / 4; const char MyString::Rep::s_terminal = '\0';
