C ++ 11内部std ::字符串表示（libstdc ++） [英] C++11 internal std::string representation (libstdc++)

问题描述

如何在c ++ 11（libstdc ++）中内部表示std :: string？

How std::string is internally represented in c++11 (libstdc++)?

在实现过程中，我发现：

While digging inside the implementation, I found:

/*  A string looks like this:
 *
 *                                        [_Rep]
 *                                        _M_length
 *   [basic_string<char_type>]            _M_capacity
 *   _M_dataplus                          _M_refcount
 *   _M_p ---------------->               unnamed array of char_type
 *
 *  Where the _M_p points to the first character in the string, and
 *  you cast it to a pointer-to-_Rep and subtract 1 to get a
 *  pointer to the header.
 *
 *  This approach has the enormous advantage that a string object
 *  requires only one allocation.  All the ugliness is confined
 *  within a single %pair of inline functions, which each compile to
 *  a single @a add instruction: _Rep::_M_data(), and
 *  string::_M_rep(); and the allocation function which gets a
 *  block of raw bytes and with room enough and constructs a _Rep
 *  object at the front.
 *
 *  The reason you want _M_data pointing to the character %array and
 *  not the _Rep is so that the debugger can see the string
 *  contents. (Probably we should add a non-inline member to get
 *  the _Rep for the debugger to use, so users can check the actual
 *  string length.)
 *
 *  Note that the _Rep object is a POD so that you can have a
 *  static <em>empty string</em> _Rep object already @a constructed before
 *  static constructors have run.  The reference-count encoding is
 *  chosen so that a 0 indicates one reference, so you never try to
 *  destroy the empty-string _Rep object.
 */
  // _Rep: string representation
  //   Invariants:
  //   1. String really contains _M_length + 1 characters: due to 21.3.4
  //      must be kept null-terminated.
  //   2. _M_capacity >= _M_length
  //      Allocated memory is always (_M_capacity + 1) * sizeof(_CharT).
  //   3. _M_refcount has three states:
  //      -1: leaked, one reference, no ref-copies allowed, non-const.
  //       0: one reference, non-const.
  //     n>0: n + 1 references, operations require a lock, const.
  //   4. All fields==0 is an empty string, given the extra storage
  //      beyond-the-end for a null terminator; thus, the shared
  //      empty string representation needs no constructor.
  struct _Rep_base
  {
    size_type       _M_length;
    size_type       _M_capacity;
    _Atomic_word    _M_refcount;
  };

我不太明白这些意见：

• 是std :: string ref么？怎么样？我的意思是_M_refcount不是指针，所以如果一个字符串修改它，其他人看不到它。


• 缓冲区紧接在标题后面？如果是这样，我真的不明白为什么。

推荐答案

引用计数的字符串遵循c ++ 11标准，但请注意，您的程序可能会将其用作ABI兼容性实现的一部分。

GCC did move away from the refcounted string to follow the c++11 standard, but note that it is possible that your program will use it as part of the ABI compatibility implementation.

std :: string 没有 _Rep_Base 成员，但指向 _Rep 与 _Rep 的指针 c>继承 _Rep_Base

std::string doesn't have a _Rep_Base member but a pointer to _Rep with _Rep inheriting from _Rep_Base

这里解释的是：

 *  Where the _M_p points to the first character in the string, and
 *  you cast it to a pointer-to-_Rep and subtract 1 to get a
 *  pointer to the header.

缓冲区位于标题...之后

是的，但是在_Rep对象的头之后，你的字符串只有一个指向它的指针。

The buffer lies after the header...

Yes, but after the header of the _Rep object, and your string only has a pointer to it.

这篇关于C ++ 11内部std ::字符串表示（libstdc ++）的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！