标准库string原理与实现

设计一个完美的String是不可能的，但是无论如何，这个string为许多需要提供了很好的服务。

字符集就是在字符和整数值之间的一种映射。C++的方式就是允许程序员使用任何字符集作为串的字符类型。原则上讲，串能以任何带有正确的复制操作的类型作为其字符类型，然而对于那些没有用户自定义复制操作的类型，他可以改进效率并简化实现。因此标准库string要求作为其字符类型的类型不包含用户定义复制操作。

一个字符类型的性质由其char_traits定义。

char_traits就是模板的一个专门特化：

// Class __char_traits_base.

template <class _CharT, class _IntT> class __char_traits_base {
public:
  typedef _CharT char_type; // 字符类型
  typedef _IntT int_type;   // 字符的整数值类型

  static void assign(char_type& __c1, const char_type& __c2) { __c1 = __c2; } // char_type的复制操作 =
  
  // 字符的整数表示
  static char_type to_char_type(const int_type& __c) { // int_type 到 char_type 的转化
    return static_cast<char_type>(__c);  
  }
  static int_type to_int_type(const char_type& __c) {  // char_type 到 int_type 的转化
    return static_cast<int_type>(__c);
  }
  static bool eq_int_type(const int_type& __c1, const int_type& __c2) {
    return __c1 == __c2;
  }
  
  // char_type单字符比较操作
  static bool eq(const _CharT& __c1, const _CharT& __c2)
    { return __c1 == __c2; }
  static bool lt(const _CharT& __c1, const _CharT& __c2) 
    { return __c1 < __c2; }

  // char_type字符序列s[n]的比较操作
  static int compare(const _CharT* __s1, const _CharT* __s2, size_t __n) {
    for (size_t __i = 0; __i < __n; ++__i)
      if (!eq(__s1[__i], __s2[__i]))
        return __s1[__i] < __s2[__i] ? -1 : 1;
    return 0;
  }
  static size_t length(const _CharT* __s) {
    const _CharT __nullchar = _CharT();
    size_t __i;
    for (__i = 0; !eq(__s[__i], __nullchar); ++__i)
      {}
    return __i;
  }
  static const _CharT* find(const _CharT* __s, size_t __n, const _CharT& __c)
  {
    for ( ; __n > 0 ; ++__s, --__n)
      if (eq(*__s, __c))
        return __s;
    return 0;
  }
  // 使用标准C库的memmove和memcpy提高了效率
  static _CharT* move(_CharT* __s1, const _CharT* __s2, size_t __n) {
    memmove(__s1, __s2, __n * sizeof(_CharT));
    return __s1;
  }    
  static _CharT* copy(_CharT* __s1, const _CharT* __s2, size_t __n) {
    memcpy(__s1, __s2, __n * sizeof(_CharT));
    return __s1;
  } 
  static _CharT* assign(_CharT* __s, size_t __n, _CharT __c) {
    for (size_t __i = 0; __i < __n; ++__i)
      __s[__i] = __c;
    return __s;
  }

  // I/O相关操作
#ifdef __STL_USE_NEW_IOSTREAMS
  typedef streamoff off_type; // 流中的偏移量
  typedef streampos pos_type; // 流中位置 
  typedef mbstate_t state_type;  // 多字节流状态
#endif /* __STL_USE_NEW_IOSTREAMS */
 
  static int_type eof() {  // 文件结束
    return static_cast<int_type>(-1);
  }
  static int_type not_eof(const int_type& __c) { // __c不等于eof()则为__c；否则返回0
    return !eq_int_type(__c, eof()) ? __c : 0;
  }
};

// Generic char_traits class.  Note that this class is provided only
//  as a base for explicit specialization; it is unlikely to be useful
//  as is for any particular user-defined type.  In particular, it 
//  *will not work* for a non-POD type.

template <class _CharT> class char_traits
  : public __char_traits_base<_CharT, _CharT>
{};

从SGI标准库的代码中可以看出：通用的char_traits本身没有任何属性（除了一些字符之间的操作和类型定义），只有针对特定字符类型的专门char_traits具有属性。

任何一个类想要作为basic_string的字符类型，必须支持上述功能的专门化的char_traits。

下面我们分析针对char类型的特化版本：

// Specialization for char.

__STL_TEMPLATE_NULL class char_traits<char> 
  : public __char_traits_base<char, int>
{
public:
  static char_type to_char_type(const int_type& __c) {
    return static_cast<char_type>(static_cast<unsigned char>(__c));
  }

  static int_type to_int_type(const char_type& __c) {
    return static_cast<unsigned char>(__c);
  }
  // 使用mencmp提高效率
  static int compare(const char* __s1, const char* __s2, size_t __n) { 
    return memcmp(__s1, __s2, __n); 
  }    
  static size_t length(const char* __s) { 
    return strlen(__s); 
  }  
  static void assign(char& __c1, const char& __c2) {
    __c1 = __c2; 
  }  
  // 使用menset提高效率  
  static char* assign(char* __s, size_t __n, char __c) { 
    memset(__s, __c, __n); return __s; 
  }
  };

宽字符很像char，除了它占用两个或者多个字节之外。wchar_t通常用于保存16位字符集，如Unicode。

// Specialization for wchar_t.

__STL_TEMPLATE_NULL class char_traits<wchar_t>
  : public __char_traits_base<wchar_t, wint_t>
{};

基础串类basic_string

basic_string很像vector，但是不会直接用数组或者vector实现，为了支持string的许多常见应用，实现中需要尽量减少复制，对短的字符串不适用自由存储空间，允许对长串简单修改等。首先，basic_string总是在字符末尾存储一个null字符，这有助于执行c_str操作；其次，标准库定义了一些basic_string特有的操作，比如：char_traits<>::assign, char_traits<>::copy和char_traits<>::move；最后，虽然basic_string增加了一些很方便的接口，但严格上将是多余的。

虽然C++标准强加了一个限制：_charT必须是一个POD类型，但是sgi的实现弱化了限制，只要_charT有个默认构造函数就行。

basic_string和其它标准库容器一样，首先是类型的定义：

template <class _CharT, class _Traits, class _Alloc> 
class basic_string : private _String_base<_CharT,_Alloc> {
public:
  typedef _CharT value_type;
  typedef _Traits traits_type;

  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;

  typedef const value_type*                const_iterator;
  typedef value_type*                      iterator;

#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
  typedef reverse_iterator<const_iterator> const_reverse_iterator;
  typedef reverse_iterator<iterator>       reverse_iterator;
#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  typedef reverse_iterator<const_iterator, value_type, const_reference, 
                           difference_type>  
          const_reverse_iterator;
  typedef reverse_iterator<iterator, value_type, reference, difference_type>
          reverse_iterator; 
#endif /* __STL_PARTIAL_SPECIALIZATION */
  // ...
};

只要_charT提供与char相同的语义，相应的串就可以像char的串一样使用。

与其他容器一样，一个string也提供了常规额和反向的迭代器：

template <class _CharT, class _Traits, class _Alloc> 
class basic_string : private _String_base<_CharT,_Alloc> {
public:                         // Iterators.
  iterator begin()             { return _M_start; }
  iterator end()               { return _M_finish; }
  const_iterator begin() const { return _M_start; }
  const_iterator end()   const { return _M_finish; }  

  reverse_iterator rbegin()             
    { return reverse_iterator(_M_finish); }
  reverse_iterator rend()               
    { return reverse_iterator(_M_start); }
  const_reverse_iterator rbegin() const 
    { return const_reverse_iterator(_M_finish); }
  const_reverse_iterator rend()   const 
    { return const_reverse_iterator(_M_start); }

};