gnustl 4.9的源码：
https://gcc.gnu.org/onlinedocs/gcc-4.9.4/libstdc++/api/files.html
1. std::string的定义
string是basic_string的一个实例化类，定义在stringfwd.h中
typedef basic_string string;//stringfwd.h
basic_string.h文件定义了basic_string模板类
template class basic_string;//basic_string.h
basic_string.tcc存放了一些模板类的成员的实现。c++里面模板的实现不能放在.cpp文件中，必须写在头文件中，如果模板函数实现较复杂，就会导致头文件臃肿和杂乱，这里可以看到stl里面方法，就是把较复杂的实现放在.tcc文件里面，然后当做头文件来包含，我们在写模板代码的时候也可以以此为参考。
string在栈内存空间上只占用一个指针(_CharT* _M_p)的大小空间，因此sizeof(string)==8。其他信息都存储在堆内存空间上。
问题1：定义一个空的string变量共带来多大的内存开销呢？
string name;
这个问题稍后解答。
2. std::string内存布局
下面通过常见的用法来剖析一下string对象内存布局情况。
例如：
string name(“jack”);
basic_string.h中有很多英文注释，大致介绍了basic_string的特点和优势，其中有一段是这样的：
* A string looks like this:
*
* @code
* [_Rep]
* _M_length
* [basic_string] _M_capacity
* _M_dataplus _M_refcount
* _M_p ----------------> unnamed array of char_type
* @endcode
这里其实是介绍了basic_string的内存布局，从起始地址出开始，_M_length表示字符串的长度、_M_capacity是最大容量、_M_refcount是引用计数，_M_p指向实际的数据。值得注意的是引用计数，说明该版本的string实现采用了copy-on-write的方式来减少无意义的内存拷贝。整体内存布局如下：
根据上图推测，一个空string，没有数据，内部开辟的内存应该是8 3=24字节，而sizeof(string)的值似乎为84=32字节，因为需要存储四个变量的值。而实际上并不是这样。
c++对象的大小(sizeof)由非静态成员变量决定，静态成员变量和成员函数不算在内。通读basic_string.h，非静态成员变量只有一个：
mutable _Alloc_hider _M_dataplus;
_Alloc_hider是个结构体类型，其定义如下：
struct _Alloc_hider : _Alloc
{
_CharT* _M_p; // The actual data.
};
_Alloc是分配器，没有成员变量，其对象大小（sizeof）为0，_M_p是指向实际数据的指针，当调用string::data()或者string::c_str()时返回的也是该值。因此sizeof(string)的大小为8，等于该指针的大小.
basic_string的构造函数定义如下：
basic_string(const _CharT* __s, const _Alloc& __a = _Alloc());
// TBD: DPG annotate
template
basic_string<_CharT, _Traits, _Alloc>::basic_string(const _CharT* __s, const _Alloc& __a)
: _M_dataplus(_S_construct(__s, __s ? __s + traits_type::length(__s) : __s + npos, __a),__a)
{ }
该构造函数直接调用 _S_construct 来构造对象，定义如下：
//basic_string.tcc
template
template
_CharT*
basic_string<_CharT , _Traits, _Alloc>::
_S_construct(_InIterator __beg, _InIterator __end , const _Alloc& __a ,
input_iterator_tag)
{
// Avoid reallocation for common case.
_CharT __buf[128];
size_type __len = 0;
while ( __beg != __end && __len < sizeof(__buf ) / sizeof( _CharT))
{
__buf[__len ++] = *__beg;
++ __beg;
}
//构造一个 _Rep 结构体，同时分配足够的空间，具体见下面内存映像图示
_Rep* __r = _Rep ::_S_create( __len, size_type (0), __a);
//拷贝数据到 string对象内部
_M_copy( __r->_M_refdata (), __buf, __len);
__try
{
while (__beg != __end)
{
if (__len == __r-> _M_capacity)
{
// Allocate more space.
_Rep* __another = _Rep:: _S_create(__len + 1, __len, __a);
_M_copy(__another ->_M_refdata(), __r->_M_refdata (), __len);
__r->_M_destroy (__a);
__r = __another ;
}
__r->_M_refdata ()[__len++] = * __beg;
++ __beg;
}
}
__catch(...)
{
__r->_M_destroy (__a);
__throw_exception_again;
}
//设置字符串长度、引用计数以及赋值最后一个字节为结尾符 char_type()
__r-> _M_set_length_and_sharable(__len );
//最后，返回字符串第一个字符的地址
return __r->_M_refdata ();
}
_Rep ::_S_create的定义：
//basic_string.tcc
template
typename basic_string <_CharT, _Traits, _Alloc >::_Rep*
basic_string<_CharT , _Traits, _Alloc>::_Rep ::
_S_create(size_type __capacity, size_type __old_capacity ,
const _Alloc & __alloc)
{
// 需要分配的空间包括：
// 一个数组 char_type[__capacity]
// 一个额外的结尾符 char_type()
// 一个足以容纳 struct _Rep 空间
// Whew. Seemingly so needy, yet so elemental.
size_type __size = (__capacity + 1) * sizeof( _CharT) + sizeof (_Rep);
void* __place = _Raw_bytes_alloc (__alloc). allocate(__size ); //申请空间
_Rep * __p = new (__place) _Rep;// 在地址__place 空间上直接 new对象( 称为placement new)
__p-> _M_capacity = __capacity ;
__p-> _M_set_sharable();// 设置引用计数为0，标明该对象只为自己所有
return __p;
}
_Rep定义如下：
//basic_string.h
struct _Rep_base
{
size_type _M_length;
size_type _M_capacity;
_Atomic_word _M_refcount;
};
至此，我们可以回答上面“问题1”中提出的问题，
上文中”string name;”这个name对象所占用的总空间为33个字节，具体如下：
sizeof(std::string) + 0 + sizeof('') + sizeof(std::string::_Rep)
其中：sizeof(std::string)为栈空间
上文中的提到的另一条C++语句 string name(“jack”); 定义了一个string变量name，其内存空间布局如下：
3. Copy-On-Write
3.1 程序示例：
请先看一段测试代码：
#include
#include
#include
using namespace std;
int main ()
{
string a = "0123456789abcdef" ;
string b = a ;
cout << "a.data() =" << (void *)a. data() << endl ;
cout << "b.data() =" << (void *)b. data() << endl ;
assert( a.data () == b. data());
cout << endl;
string c = a ;
cout << "a.data() =" << (void *)a. data() << endl ;
cout << "b.data() =" << (void *)b. data() << endl ;
cout << "c.data() =" << (void *)c. data() << endl ;
assert( a.data () == c. data());
cout << endl;
c[0] = '1';
cout << "after write:\n";
cout << "a.data() =" << (void *)a. data() << endl ;
cout << "b.data() =" << (void *)b. data() << endl ;
cout << "c.data() =" << (void *)c. data() << endl ;
assert( a.data () != c. data() && a .data() == b.data ());
return 0;
}
运行之后，输出：
a.data() =0xc22028
b.data() =0xc22028
a.data() =0xc22028
b.data() =0xc22028
c.data() =0xc22028
after write:
a.data() =0xc22028
b.data() =0xc22028
c.data() =0xc22068
上述代码运行的结果输出可看出，在对b、c赋值之后，a、b、c三个string对象的内部数据的内存地址是一样的。只有当我们对c对象进行修改之后，c对象的内部数据的内存地址才不一样，这一点是如何做到的呢？接下来分析源码一看究竟。
3.2 string copy的源码分析
//拷贝构造函数
basic_string(const basic_string& __str)
: _M_dataplus( __str._M_rep ()->_M_grab( _Alloc(__str .get_allocator()),
__str.get_allocator ()),
__str.get_allocator ())
{}
_CharT* _M_grab(const _Alloc& __alloc1, const _Alloc& __alloc2)
{
return (! _M_is_leaked() && __alloc1 == __alloc2)
? _M_refcopy() : _M_clone (__alloc1);
}
_CharT*_M_refcopy() throw ()
{
#ifndef _GLIBCXX_FULLY_DYNAMIC_STRING
if ( __builtin_expect(this != &_S_empty_rep(), false))
#endif
__gnu_cxx::__atomic_add_dispatch (&this-> _M_refcount, 1);
return _M_refdata();
}
先后调用了basic_string (const basic_string& __str )拷贝构造函数、_M_grab、_M_refcopy，
_M_refcopy实际上就是调用原子操作__atomic_add_dispatch (确保线程安全)将引用计数+1，然后返回原对象的数据地址。
由此可以看到，string对象之间的拷贝/赋值代价非常非常小。
几个赋值语句之后，a、b、c对象的内存空间布局如下图所示：
下面再来看”c[0] = ‘1’; “做了些什么：
reference operator []( size_type __pos )
{
_M_leak();
return _M_data ()[__pos ];
}
void _M_leak () // for use in begin() & non-const op[]
{
//前面看到 c 对象在此时实际上与a对象的数据实际上指向同一块内存区域
//因此会调用 _M_leak_hard()
if (! _M_rep ()->_M_is_leaked ())
_M_leak_hard ();
}
void _M_leak_hard ()
{
if ( _M_rep ()->_M_is_shared ())
_M_mutate (0, 0, 0);
_M_rep()-> _M_set_leaked ();
}
void _M_mutate ( size_type __pos , size_type __len1, size_type __len2 )
{
const size_type __old_size = this-> size ();//16
const size_type __new_size = __old_size + __len2 - __len1 ; //16
const size_type __how_much = __old_size - __pos - __len1 ; //16
if ( __new_size > this -> capacity() || _M_rep ()->_M_is_shared ())
{
// 重新构造一个对象
const allocator_type __a = get_allocator ();
_Rep * __r = _Rep:: _S_create (__new_size , this-> capacity (), __a );
// 然后拷贝数据
if (__pos )
_M_copy (__r -> _M_refdata(), _M_data (), __pos );
if (__how_much )
_M_copy (__r -> _M_refdata() + __pos + __len2 ,
_M_data () + __pos + __len1, __how_much );
//将原对象上的引用计数减
_M_rep ()->_M_dispose ( __a);
//绑定到新的对象上
_M_data (__r -> _M_refdata());
}
else if (__how_much && __len1 != __len2 )
{
// Work in-place.
_M_move (_M_data () + __pos + __len2 ,
_M_data () + __pos + __len1, __how_much );
}
//最后设置新对象的长度和引用计数值
_M_rep()-> _M_set_length_and_sharable (__new_size );
}
上面源码稍微复杂点，对c进行修改的过程分为以下两步：
- 判断是否为共享对象，(引用计数大于0)，如果是共享对象，就拷贝一份新的数据，同时将老数据的引用计数值减1。
- 在新的地址空间上进行修改，从而避免了对其他对象的数据污染。
由此可以看出，如果不是通过string提供的接口对string对象强制修改的话，会带来潜在的不安全性和破坏性。例如：
char* p = const_cast(s1.data());
p[0] = 'a';
上述代码对c修改(“c[0] = ‘1’; “)之后，a b c对象的内存空间布局如下：
4.总结
- 即使是一个空string对象，其所占内存空间也达到33字节，因此在内存使用要求比较严格的应用场景，请慎重考虑使用string。
- string由于使用引用计数和Copy-On-Write技术，相对于strcpy，string copy的性能提升非常显著。
- 使用引用计数后，多个string指向同一块内存区域，因此，如果强制修改一个string的内容，会影响其他string。
参考：
- http://blogs.360.cn/360cloud/2012/11/26/linux-gcc-stl-string-in-depth/
- https://blog.csdn.net/ybxuwei/article/details/51326830