STL string源码剖析

vector与string

这个是源码对为什么string类不定义成vector的解释

// There are three reasons why basic_string is not identical to
// vector. First, basic_string always stores a null character at the
// end; this makes it possible for c_str to be a fast operation.
// Second, the C++ standard requires basic_string to copy elements
// using char_traits<>::assign, char_traits<>::copy, and
// char_traits<>::move. This means that all of vector<>’s low-level
// operations must be rewritten. Third, basic_string<> has a lot of
// extra functions in its interface that are convenient but, strictly
// speaking, redundant.
大概上面意思是总共有3个理由
第一string总是要存储一个\0,用来快速调用c_str函数。
第二c++标准需要string类去用char_traits类去拷贝元素和搬移元素.这样就意味着vector的搬移和拷贝操作必须重新设计。
第三string类有大量额外的函数接口可供便利的调用，但是严格的来说……这些接口是多余的。

Basic_string

// Class basic_string.
// Class invariants:
// (1) [start, finish) is a valid range. 在这个范围是可使用变量的范围
// (2) Each iterator in [start, finish) points to a valid object
// of type value_type. 迭代器在这个范围是合法的
// (3) *finish is a valid object of type value_type; in particular,
// it is value_type(). *finish 也是合法的，但返回的只是一个临时变量
// (4) [finish + 1, end_of_storage) is a valid range. 这个范围是合法的
// (5) Each iterator in [finish + 1, end_of_storage) points to
// unininitialized memory. 任何迭代器访问 该区域内存都是合法的但是都是未初始化的内存

// Note one important consequence: a string of length n must manage
// a block of memory whose size is at least n + 1.
需记住一个重要结论，那就是一个长度为n的string 它的大小长度 n+1
npos 它是一个const 类型的静态变量在string中 大小为无符号整形的最大值
通常在拷贝构造中代表直到拷贝到该字符串结尾。

Basic_string类的空间配置器

其实Basic_string有俩个空间配置器的类，但是string默认使用的是如下这个版本，这个string的空间配置器很像SGI_STL中的simple_alloc这个类，这是对STL中的空间配置器的一个转调接口.
template <class _Tp, class _Alloc> class _String_base {  
public:
  typedef _Alloc allocator_type;
  allocator_type get_allocator() const { return allocator_type(); }

protected:
  typedef simple_alloc<_Tp, _Alloc> _Alloc_type;

  _Tp* _M_start;
  _Tp* _M_finish;
  _Tp* _M_end_of_storage;
                                // Precondition: 0 < __n <= max_size().

  _Tp* _M_allocate(size_t __n) { return _Alloc_type::allocate(__n); }
  void _M_deallocate(_Tp* __p, size_t __n) {
    if (__p)
      _Alloc_type::deallocate(__p, __n); 
  }

  void _M_allocate_block(size_t __n) { 
    if (__n <= max_size()) {
      _M_start  = _M_allocate(__n);
      _M_finish = _M_start;
      _M_end_of_storage = _M_start + __n;
    }
    else
      _M_throw_length_error();
  }

  void _M_deallocate_block() 
    { _M_deallocate(_M_start, _M_end_of_storage - _M_start); }

  size_t max_size() const { return (size_t(-1) / sizeof(_Tp)) - 1; }

  _String_base(const allocator_type&)
    : _M_start(0), _M_finish(0), _M_end_of_storage(0) { }

  _String_base(const allocator_type&, size_t __n)
    : _M_start(0), _M_finish(0), _M_end_of_storage(0)
    { _M_allocate_block(__n); }

  ~_String_base() { _M_deallocate_block(); }

  void _M_throw_length_error() const;
  void _M_throw_out_of_range() const;
};

以下由c++手册上的string接口对应的源码分析

string与Basic_string的关系

template <class _CharT, 
          class _Traits = char_traits<_CharT>,   
          class _Alloc = __STL_DEFAULT_ALLOCATOR(_CharT) >
class basic_string;
//这个_Traits参数极为重要string类的copy和assign搬移也是通过它来实现的
typedef basic_string<char>    string;
typedef basic_string<wchar_t> wstring;

1. 要注意上面的声明 string 只是Basic_string的一个实例化类，所以下面所有Basic_string 中有关空配的参数都可以忽视.
2. 这里提醒下，在string中它的迭代器类型就是char * 这个内置类型的指针，所以大家自己下面看这部分源码时在碰见转调其他函数时，直接看对应 const char* 这个参数的函数即可.

Basic_string中所使用的类型声明

  typedef _CharT value_type;  // _CharT 代表 char
  typedef _Traits traits_type;// _Traits 就是char_traits<char>
  typedef value_type* pointer;
  typedef const value_type* const_pointer;
  typedef value_type& reference;
  typedef const value_type& const_reference;
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;   // ptrdiff_t在cstddef头文件中它是c++标准指定的类型表内置类型指针的距离
  typedef const value_type*           const_iterator;
  typedef value_type*                 iterator;

string 之构造初始化

string()

///////////////////////////////////下面是源码所表示的内容/////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
explicit basic_string(const allocator_type& __a = allocator_type()) // 当不指定大小时，编译器默认
    : _Base(__a, 8) { _M_terminate_string(); }//这里默认申请了8个元素的空间，即8个char所以是8字节大小的空间。忽视这个空间配置器参数后就可以看出它是string的默认构造函数。
    /*terminate_string 表示 string字符串结束符的一个构造函数*/
    void _M_terminate_string() {
    __STL_TRY {
      _M_construct_null(_M_finish);//初始化时 finish和start指向同一位置，大家可以从我上面放的空配代码看出
    }
    __STL_UNWIND(destroy(_M_start, _M_finish));
  }

//下面这个函数只是一个初始化 string 结束符的函数，里面只是在已分配的空间上调用了char()来初始化空串
    void _M_construct_null(_CharT* __p) {
    construct(__p);  /* 里面在p所指向的空间上调用了placement new ，就仅仅只是调用了 charT() 的默认构
    造函数来初始化了p所指的空间，所以用char的默认构造函数来初始化空串!!! 所以初始化后第一个元素为\0 */
#   ifdef __STL_DEFAULT_CONSTRUCTOR_BUG 
    __STL_TRY {  
      *__p = (_CharT) 0;
    }
    __STL_UNWIND(destroy(__p));
#   endif
  }
// 所以可以看出string的结束符是有的，为char()的值也是0。

其实如上可以看出，string的默认构造函数，只是申请了8字节大小的空间，并且第一个元素初始化为0，剩下8个元素都是未初始化的状态。

string的拷贝构造

以下的所有string的拷贝构造都用到了这个函数，我给大家在这里先分析以下这个函数的意义
 template <class _ForwardIter>
  void _M_range_initialize(_ForwardIter __f, _ForwardIter __l, 
                           forward_iterator_tag) {
    difference_type __n = 0;
    distance(__f, __l, __n);
    _M_allocate_block(__n + 1);
    _M_finish = uninitialized_copy(__f, __l, _M_start);
    _M_terminate_string(); //最后在把finish所指向元素初始化为 \0
  }
  首先这个distance函数是用来这求俩个迭代器之间的元素个数，然后调用了string的空间配置器申请了从first到last迭代器所指向这么多元素的空间。然后调用了uninitialized_copy。
  ForwardIter uninitialized_copy(InputIter first,InputIter last,ForwardIter result);
  这个函数其实就是用参数first,last所指区间的所有元素来初始化result所指向的空间。然后把result返回出去.
  而且在这个函数中是会先萃取了下，如果是POD类型直接调用了memcpy来初始化，如果不是一个一个调用拷贝构造.

string (const string& str, size_t pos, size_t len = npos)

  basic_string(const basic_string& __s, size_type __pos, size_type __n = npos,
               const allocator_type& __a = allocator_type()) 
    : _Base(__a) {
    if (__pos > __s.size())
      _M_throw_out_of_range();
    else
      _M_range_initialize(__s.begin() + __pos,
                          __s.begin() + __pos + min(__n, __s.size() - __pos)); 
  } // s.size()-pos代表如果 pos 位后直到结尾的长度。所以综上如果这个长度比参数len小选择这个长度，否则选择参数len。所以也就是我们用拷贝构造的方式裁剪字符串时，len如果传的大于剩余字符的长度，string最多从pos位拷贝到字符串的结尾.

string (const char* s)

 basic_string(const basic_string& __s) : _Base(__s.get_allocator()) 
    { _M_range_initialize(__s.begin(), __s.end()); }
    //这个简单的从头拷贝到尾

string (const char* s, size_t n)

 basic_string(const _CharT* __s, size_type __n,
               const allocator_type& __a = allocator_type()) 
    : _Base(__a) 
    { _M_range_initialize(__s, __s + __n); } //其实也就申请了n+1个空间，拷贝了n个有效字符进去。

string (size_t n, char c)

 basic_string(size_type __n, _CharT __c,
               const allocator_type& __a = allocator_type())
    : _Base(__a, __n + 1)
  {
    _M_finish = uninitialized_fill_n(_M_start, __n, __c);
    _M_terminate_string();
  }

string类析构

 ~basic_string() { destroy(_M_start, _M_finish + 1); }
 这里只string的析构函数只对空间进行了析构并未释放空间，当string类的基类的析构函数被调用时，由其基类来释放空间

string类的赋值运算符重载

_Traits ------ class _Traits = char_traits<_CharT>
 static _CharT* copy(_CharT* __s1, const _CharT* __s2, size_t __n) {
    memcpy(__s1, __s2, __n * sizeof(_CharT));
    return __s1;
  } 
template <class _CharT, class _Traits, class _Alloc> 
basic_string<_CharT,_Traits,_Alloc>& 
basic_string<_CharT,_Traits,_Alloc>::assign(const _CharT* __f, 
                                            const _CharT* __l)
{
  const ptrdiff_t __n = __l - __f; //这里的n为有效字符大小不包括\0
  if (static_cast<size_type>(__n) <= size()) {
    _Traits::copy(_M_start, __f, __n);//列如 A=B， B字符串比A字符串短，就把B的有效字符从A的头
    erase(_M_start + __n, _M_finish);//部开始拷贝，一直拷贝到结束。然后把原字符串之后的有效元素全部析构掉
  }//之后新的被赋值的字符串大小为n的大小
  else {
    _Traits::copy(_M_start, __f, size());// 否则先拷贝大小为size个字符在A字符串中
    append(__f + size(), __l);//再调用扩展函数拷贝剩下的...这个里面扩容了
  }
  return *this;
}
/*综上 assign函数，当比原字符串有效大小，小时会裁剪原字符串，比原字符串大时，会扩展原字符串*/
1. basic_string& operator=(const basic_string& __s) {
    if (&__s != this) 
      assign(__s.begin(), __s.end()); 
    return *this;
  }
2.  basic_string& operator=(const _CharT* __s) //处理与1相同
    { return assign(__s, __s + _Traits::length(__s)); }
3.  basic_string& operator=(_CharT __c)    
    { return assign(static_cast<size_type>(1), __c); }
    //把原字符串的第一个字符赋值成C。并且只保留字符C的空间，其余的有效元素的空间全释放掉。
    // eg s1("AAAA")  s1='b'  s1现在结果只有字符b s1=='b' 为True

综上

无论如何都会赋值成功。
假设俩个字符串赋值：
A = B，B串给A串赋值
如果B长度小于A，那么就把B的所有的有效字符拷贝到A字符串中。从A的头部开始拷贝，直到B字符串结束。
如果B长度大于A，那么A字符串释放之前所使用的空间。重新申请一块更大的空间用来存放B的所有有效字符。

string之容量

size_t size()const

size_type请看前面的类型声明
size_type size() const { return _M_finish - _M_start; } //有效字符的个数，finish永远指向\0

size_t length() const

size_type length() const { return size(); }

size_t max_size() const

size_t max_size() const { return (size_t(-1) / sizeof(_Tp)) - 1; } 
其实max_size就是无符号整数的最大值-1。

void resize (size_t n) / void resize (size_t n, char c)

void resize(size_type __n, _CharT __c) {
    if (__n <= size())    // 当扩展大小，小于原大小时只裁剪原字符串，原字符串被裁剪为只有 n个字符
      erase(begin() + __n, end());
    else   //当扩展大小大于原大小时才在原字符串后面扩展，此时原字符串大小变为n,扩展字符个数为n-size()个c。
      append(__n - size(), __c);
  }

  void resize(size_type __n) 
  { resize(__n, _M_null()); }
  //这个跟上面一样只是如果n大于原字符串大小时，扩展字符为\0而已。
  从上可看resize函数会改变原字符串大小。

size_t capacity() const

size_type capacity() const 
{ return (_M_end_of_storage - _M_start) - 1; }
如果容量没变，这个大小为你第一次申请空间时所传的大小

void reserve (size_t n = 0)

用来修改string容量的一个函数大家，不必要纠结这个函数，因为不同版本的STL，string的扩容方式可能不同。
void basic_string<_CharT,_Traits,_Alloc>::reserve(size_type __res_arg) {
  if (__res_arg > max_size())
    _M_throw_length_error();

  size_type __n = max(__res_arg, size()) + 1;//设n为重新扩容的大小和原有效字符中的最大值
  pointer __new_start = _M_allocate(__n);//然后释放之前空间。再重新申请大小为n的空间，并把之前的元素拷贝过来
  pointer __new_finish = __new_start;

  __STL_TRY {
    __new_finish = uninitialized_copy(_M_start, _M_finish, __new_start);
    _M_construct_null(__new_finish);
  }
  __STL_UNWIND((destroy(__new_start, __new_finish), 
                _M_deallocate(__new_start, __n)));

  destroy(_M_start, _M_finish + 1);
  _M_deallocate_block();
  _M_start = __new_start;
  _M_finish = __new_finish;
  _M_end_of_storage = __new_start + __n;
}
所以该函数肯定会发生迭代器失效.... 
其次原字符串内容不变，有效字符个数不变，但是容量改变了。
如果重新设置的容量大小比原字符串的有效字符个数小，容量改变为原字符串有效字符大小，否则改变为重设容量大小.
特别强调：vs 和 sgi 的string类的扩容方式不同且reserve实现也不同需要注意下。

void clear()

  void clear() {
    if (!empty()) {
      _Traits::assign(*_M_start, _M_null());//原字符串的第一个字符赋值成\0,然后析构之后的有效字符
      destroy(_M_start+1, _M_finish+1);//再让finish指向start,此时size==0
      _M_finish = _M_start;
    }
  } 

bool empty() const

bool empty() const { return _M_start == _M_finish; }    

所有容量函数结束，下面是string的模型

append — 扩展string对象的函数

string& append (const char* s)

 basic_string& append(const _CharT* __s) 
 { return append(__s, __s + _Traits::length(__s)); } 
 这个length求的只是有效字符长度，所以它把第一个字符的位置和\0的位置传了过去，然后转调了 
 append(const char*first,const * last) 这个函数，关于这个函数在下面有详细的分析。

string& append (const char* s, size_t n)

  basic_string& append(const _CharT* __s, size_type __n) 
    { return append(__s, __s+__n); } 
     其实跟上面这个函数基本一样，只不过一个拷贝全部字符串，一个拷贝字符串的子串到string中

string& append (size_t n, char c)

basic_string<_CharT,_Traits,_Alloc>::append(size_type __n, _CharT __c) {
  if (__n > max_size() || size() > max_size() - __n)
    _M_throw_length_error();
  if (size() + __n > capacity())
    reserve(size() + max(size(), __n));
  if (__n > 0) {
    uninitialized_fill_n(_M_finish + 1, __n - 1, __c);// 这里先拷贝n-1个跟下面的先start++再拷贝一个道理
    __STL_TRY {//都是防止这里抛出异常又把原先的\0给覆盖掉导致原字符串无效.
      _M_construct_null(_M_finish + __n);
    }
    __STL_UNWIND(destroy(_M_finish + 1, _M_finish + __n));
    _Traits::assign(*_M_finish, __c);
    _M_finish += __n;
  }
  return *this;
}

string& append (const string& str)

首先 begin end 都返回的是一个 iter 类型 ，这个类型是 charT* 的一个别名，所以就是char*
 basic_string& append(const basic_string& __s) 
    { return append(__s.begin(), __s.end()); } 
    // 故这里就相当转调append(const char*,cosnt char*)的一个函数

string& append (const string& str, size_t subpos, size_t sublen)

  该函数表示从pos位置开始拷贝n个元素到dest string 中.
  basic_string& append(const basic_string& __s, size_type __pos, size_type __n)
  { //pos指在字符串中的下标 n指从该下标开始拷贝多少个元素
    if (__pos > __s.size()) //当pos大于src字符串的有元素个数时抛出异常
      _M_throw_out_of_range();
    return append(__s.begin() + __pos,__s.begin() + __pos + min(__n, __s.size() - __pos));
  }
   然后转调 append(const char * first,const char* last)这个函数
   这里注意下只要pos合法无论n是否合法都可以调用成功，如果n个数大于从pos到finish这个[）区间的有效元素个数的话，最多就把pos到\0这个区间的所有有效元素拷贝到dest string中。如果小于就拷贝从pos开始拷贝相应大小的字符串过去.

append(const char* first,cosnt char*last) 该函数并没有暴露给外层基本上所有append的函数都是转调它

 basic_string<_Tp, _Traits, _Alloc>::append(const _Tp* __first,
                                           const _Tp* __last)
{
  if (__first != __last) { //先看是不是空串
    const size_type __old_size = size();
    ptrdiff_t __n = __last - __first; //这个 n 代表有效元素的个数
    if (__n > max_size() || __old_size > max_size() - __n)
      _M_throw_length_error();
    if (__old_size + __n > capacity()) {//如果原先容量不足进入这个代码块
      const size_type __len = __old_size + max(__old_size, (size_t) __n) + 1;
      pointer __new_start = _M_allocate(__len);
      pointer __new_finish = __new_start;
      __STL_TRY {
        __new_finish = uninitialized_copy(_M_start, _M_finish, __new_start);
        __new_finish = uninitialized_copy(__first, __last, __new_finish);
        _M_construct_null(__new_finish);
      }// 这里其实就申请了段满足新的大小的空间，然后把老的元素拷贝进去，再把要赋值的元素拷贝进去
      __STL_UNWIND((destroy(__new_start,__new_finish),
                    _M_deallocate(__new_start,__len)));
      destroy(_M_start, _M_finish + 1);
      _M_deallocate_block();
      _M_start = __new_start;
      _M_finish = __new_finish;
      _M_end_of_storage = __new_start + __len; 
    } /*上面是当之前的字符串容量不足以容纳新的字符串的处理*/
    else {
      const _Tp* __f1 = __first;
      ++__f1;// 这个first ++ 是正确的，之前我思考了好久在这里,终于想通了，这里先++的原因如下,先++的操作如下图
      uninitialized_copy(__f1, __last, _M_finish + 1);
      __STL_TRY {
        _M_construct_null(_M_finish + __n);//这里先拷贝start+1后面元素，在回头用start在覆盖掉原先的\0
      }//主要是因为这里的 try 中的构造\0的这个函数，如果它抛出异常，刚拷贝的元素都会析构掉，所以原字符串还是有效的
      __STL_UNWIND(destroy(_M_finish + 1, _M_finish + __n));//如果我们直接从finish处赋值的话抛出异常后
      _Traits::assign(*_M_finish, *__first);//原字符串的\0就被覆盖掉了，原字符串就不再是有效字符串就会显示热热热
      _M_finish += __n;
    }
  }

解释上面如何要先start++一下再赋值

string 运算符重载函数

string& operator+= (const string& str); —> string

 basic_string& operator+=(const basic_string& __s) 
            { return append(__s); }

string& operator+= (const char* s); —> c-string

 basic_string& operator+=(const _CharT* __s) 
            { return append(__s); }

string& operator+= (char c); —>character

 basic_string& operator+=(_CharT __c) 
            { push_back(__c); return *this; }