C++17剖析:string在Modern C++中的实现

C++17剖析:string在Modern C++中的实现

2019-01-26 19:17  猴子顶呱呱  阅读(388)  评论(0)  编辑  收藏

概述

GCC 8.2提供了两个版本的std::string:一个是基于Copy On Write的,另一个直接字符串拷贝的。前者针对C++11以前的,那时候没有移动构造,一切以效率为先,需要使用COW这种奇技淫巧。后者针对C++11,也就是_GLIBCXX_USE_CXX11_ABI宏被设置为非零时会被用到,并没有COW的功能,更简单,用户可以在必要时使用移动构造。如果不使用移动构造,字符串的频繁拷贝将会是异常灾难,这一点,在我的项目中已经踩过坑。
本文主要研究Modern C++中的string实现,因为使用C++11以后的标准都使用它。

数据组织:16字节的栈上存储,如果超出16字节则在堆上分配

数据的组织很简单,如果字符串长度不超过15字节(加上后缀0一共16字节),则在栈上保存,否则会在堆上分配内存。


      // Use empty-base optimization: http://www.cantrip.org/emptyopt.html
      struct _Alloc_hider : allocator_type // TODO check __is_final
      {
#if __cplusplus < 201103L
        _Alloc_hider(pointer __dat, const _Alloc& __a = _Alloc())
        : allocator_type(__a), _M_p(__dat) { }
#else
        _Alloc_hider(pointer __dat, const _Alloc& __a)
        : allocator_type(__a), _M_p(__dat) { }

        _Alloc_hider(pointer __dat, _Alloc&& __a = _Alloc())
        : allocator_type(std::move(__a)), _M_p(__dat) { }
#endif

        pointer _M_p; // The actual data.
      };

      _Alloc_hider      _M_dataplus;       ////数据指针,指向本地或者堆内存
      size_type         _M_string_length;  ////实际长度,如果大于_S_local_capacity则是堆内存,否则,是栈内存

      enum { _S_local_capacity = 15 / sizeof(_CharT) };

      ////注意这是Union,16字节的栈内存和整个堆的容量(Capacity)共用一块存储
      union
      {
        _CharT           _M_local_buf[_S_local_capacity + 1];
        size_type        _M_allocated_capacity;
      };

里面那个union挺有意思,如果_M_string_length>=_S_local_capacity,那么_M_allocated_capacity保存了整块缓冲区的大小(注意不是字符串的大小);如果_M_string_length<_S_local_capacity则_M_dataplus._M_p指针指向_M_local_buf这块栈上内存区。union的特性是全部元素共用一块空间,根据程序的语义只使用其中一个变量,在这里_M_local_buf有效的时候_M_allocated_capacity无效,反之亦然,巧妙地运用空间,减少内存浪费。

对象的构造:第一组,不带参数的构造函数(默认构造函数)

  • 始化长度为0,数据指针指向栈内存_M_local_buf,包括以下函数:
    • basic_string()
    • basic_string(const _Alloc& __a)

对象的构造:第二组,根据字符串构造

  • 调用_M_construct()构造对象,也就是把字符串拷贝一个(而不是增加引用计数);关于_M_construct()的细节,在下面会分析。包括以下函数:
  • 2.1 基于basic_string构建字符串拷贝
    • basic_string(const basic_string& __str):拷贝__str的完整字符串;
    • basic_string(const basic_string& __str, const _Alloc& __a):同上,指定构造器;
    • basic_string(const basic_string& __str, size_type __pos, const _Alloc& __a = _Alloc()):拷贝__str从__pos位置到末尾的所有字符;
    • basic_string(const basic_string& __str, size_type __pos, size_type __n):拷贝__str从__pos位置开始的N个字符(或者到末尾);
    • basic_string(const basic_string& __str, size_type __pos, size_type __n, const _Alloc& __a):同上,指定构造器;
  • 2.2 基于指针构建字符串拷贝,指针可以是字符串指针,也可以是其他指针,只要编译器不抱怨
    • basic_string(const _CharT* __s, const _Alloc& __a = _Alloc()):拷贝__s的全部字符串,构造时会计算__s的长度,使用char_traits<char>::length()内联函数;
    • basic_string(const _CharT* __s, size_type __n, const _Alloc& __a = _Alloc()):拷贝__s字符串的前__n个字符,不检测越界问题,留给调用方保证
    • basic_string(const _Tp& __t, size_type __pos, size_type __n, const _Alloc& __a = _Alloc()):这个比上面两个构造函数更加宽泛,可以是任意数据指针,编译器会对数据能否正确转换进行检测(warnning或者error);
  • 2.3 其他
    • basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc()):使用初始化列表构造;
    • basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc()):以n个相同的字符填充缓冲区:调用_M_construct()初始化缓冲区并填充字符。

对象的构造:第三组:移动构造函数

  • 对于栈上保存的字符串,会拷贝到目标字符串(最多16Bytes);如果是堆上分配的字符串,则把指针转到目标字符串。完成这些拷贝和转移后,右值字符串回归到默认构造的状态(长度为0,字符串指针指向栈缓冲区的起始位置);
    • basic_string(basic_string&& __str)
    • basic_string(basic_string&& __str, const _Alloc& __a)

对象的构造:第四组:基于迭代器构造

  • 调用_M_construct(),根据迭代器的类型进行分类处理:
    • basic_string(_InputIterator __beg, _InputIterator __end, const _Alloc& __a = _Alloc()):把迭代器区间内的数据(允许不是char/wchar_t,只要编译器不抱怨);

对象的构造:第五组:根据std::string_view构造

  • 可以轻量级使用std::string_view构造一个std::string,同样是使用字符串拷贝
    • basic_string(const _Tp& __t, const _Alloc& __a = _Alloc()):需要__t是std::string_view类型,取整个std::string_view字符串构建std::string;
    • basic_string(const _Tp& __t, size_type __pos, size_type __n, const _Alloc& __a = _Alloc()):需要__t是std::string_view类型,并且取它的字符串一部分构建新的字符串,调用上面的构造函数完成构造。
    • basic_string(__sv_wrapper __svw, const _Alloc& __a):允许某个类型,如果可以转换成std::string_view,则使用此构造函数,类似于basic_string(sv.data(), sv.size(), alloc)

对象的构造:第六组:赋值

  • 调用assign()函数,进而调用_M_assign()系列函数,这部分下面会详细分析
    • operator=(const basic_string& __str) :代码相对比较复杂,其实就是字符串拷贝,没有COW。
    • operator=(const _CharT* __s):同上
    • operator=(_CharT __c):只插入一个字符

先谈谈构造时的调用流程

上面大部分版本的构造函数都是给定一个起始区间,调用_M_construct(_InIterator __beg, _InIterator __end)函数。下面分析这个函数的来龙去脉。

  • _M_construct(_InIterator __beg, _InIterator __end):根据std::__is_integer<_InIterator>::__type分析这个“迭代器”是否数值类型;
    • 如果是数值类型,则表示调用方是basic_string(size_type __n, _CharT __c)这一组的函数,那么就调用_M_construct_aux(_Integer __beg, _Integer __end, std::__true_type)去生成,最终调用_M_construct(size_type __req, _CharT __c)函数;
    • 如果不是数值类型,则表示调用方是上面第二组的调用方式,则调用_M_construct_aux(_Integer __beg, _Integer __end, std::__true_type),继而调用_M_construct(_InIterator __beg, _InIterator __end)函数;

现在回到_M_construct()函数

_M_construct()函数执行字符串的实际构造操作。它按照迭代器/参数的类型,有两种实现:

  • _M_construct(size_type __req, _CharT __c):实现的算法很简单,申请一段__req的内存空间(如果小于15字节则直接写在栈上),并拷贝__req个__c字符;
  • _M_construct(_InIterator __beg, _InIterator __end, std::forward_iterator_tag):只有当迭代器类型是forward_iterator或者比它更宽的迭代器时使用,它会根据迭代器之间的长度来确定字符串的长度,并逐字符拷贝。关于迭代器的“更宽”,可以参考迭代器类型
  • _M_construct(_InIterator __beg, _InIterator __end, std::input_iterator_tag):用于input_iterator迭代器,如输入迭代器等。这个构造比较低效,每次输入一个字符,会检测是否达到缓冲区的末尾,如果是,则把缓冲区的大小加1,重新分配空间并拷贝字符串。
  • 讲完了

字符串赋值专用的_M_assign()函数

  • 赋值类的函数都会在预分配足够内存后,调用_M_assign()函数,该函数的逻辑很简单,只是单纯的字符串拷贝,拷贝到需要的位置。

结论:std::string在程序在使用的注意事项(划重点)

  • 两个字符串连接:根据std::string的实现代码,字符串的连接一定会引起内存的重新分配和字符串拷贝。很遗憾,C++没有使用C的realloc()函数。如果使用realloc()函数,有可能在扩大内存的同时,不需要拷贝字符串(也就是原来分配的内存区域末尾还有足够的字符串)。C++很单纯地分配一块新内存,再把就内存拷贝过去。这一点在效率上会比较低下。个人认为解决办法是,使用std::deque代替std::string。在字符串不断变动的时候,字符数组可以写入std::deque,因为它的插入、追加操作比std::string高效。等字符串稳定后,再使用basic_string(_InputIterator __beg, _InputIterator __end)构造函数生成std::string
    • google的abseil提供了一个可用的办法:也就是先计算多个字符串的长度,预分配一大块内存来存放,然后分别拷贝字符串,这样避免反复分配内存和拷贝字符串,请参考abseil中的string库。但是这种方法只适用于已知固定个数的字符串连接。
    • 有人测试出C++拼接字符串的比较中,std::string::append和operator+的效率是最高的,同样的代码,我用C++98和C++11、C++17分别测试过,O3级别优化,最终结果类似。代码和测试结果见这里
  • 字符串的赋值:C++11下,因为有移动构造,所以std::string的复杂性比之前的版本有所降低,但是如果直接使用赋值,而不使用移动赋值,效率反而较“史前”版本慢,因为C++11以前,使用基于引用计数的COW,拷贝更加轻量级,而C++11出现以后,移动赋值成为提升效率几乎唯一的途径了,因此C++11以后的程序尽可能使用移动赋值
  • 另外,字符串的中间插入,也是需要重新分配内存,并完整拷贝整个字符串,这一点需要在使用中注意。
  • 如果只是需要字符串的只读操作,可以使用std::string_view代替。
  • 最后说一个地方,虽然比较少用,就是基于std::input_iterator的构造,它每次重新分配内存只会分配“刚刚适合需要的大小”,而不会如std::vector那样分配2倍,所以将会有频繁分配内存和拷贝的操作。解决的办法还是用std::deque,等字符足够之后再写入std::string
  • 总结上述几条:任何对已有字符串的插入、追加操作,都很可能造成内存的重新分配和整个字符串拷贝,这种重新分配和拷贝,并不是realloc(),而是new+memcpy,这是必须注意的。解决的办法,一是使用reserver()函数申请足够的内存,二是使用std::deque临时代替。
posted @ 2020-11-26 17:47  Bigben  阅读(231)  评论(0编辑  收藏  举报