Why is sizeof(std::string) only eight bytes?

Question

Why is std::string\'s size, as determined by sizeof(std::string), yield 8?
I thought it should be more than 8 as it h

Answer 1

Because all your implementation of std::string stores is a pointer to the heap where all of it's data is stored.

Answer 2

The implementation of std::string is not specified by the C++ standard. It only describes the classes behaviour. However, I would expect there to be more than one pointer's worth of information in the class. In particular:

• A pointer to the actual string.
• The size available.
• The actual size used.

It MAY of course store all these in a dynamically allocated location, and thus take up exactly the same amount of space as char* [in most architectures].

In fact looking at the C++ header that comes with my Linux machine, the implementation is quite clear when you look at (which, as per comments, is "pre-C++11", but I think roughly representative either way):

  size_type
  length() const _GLIBCXX_NOEXCEPT
  { return _M_rep()->_M_length; }

and then follow that to:

  _Rep*
  _M_rep() const _GLIBCXX_NOEXCEPT
  { return &((reinterpret_cast<_Rep*> (_M_data()))[-1]); }

which in turn leads to:

  _CharT*
  _M_data() const _GLIBCXX_NOEXCEPT
  { return  _M_dataplus._M_p; }

Which leads to

  // Data Members (private):
  mutable _Alloc_hider  _M_dataplus;

and then we get to:

  struct _Alloc_hider : _Alloc
  {
    _Alloc_hider(_CharT* __dat, const _Alloc& __a) _GLIBCXX_NOEXCEPT
    : _Alloc(__a), _M_p(__dat) { }

    _CharT* _M_p; // The actual data.
  };

The actual data about the string is:

  struct _Rep_base
  {
    size_type       _M_length;
    size_type       _M_capacity;
    _Atomic_word        _M_refcount;
  };

So, it's all a simple pointer called _M_p hidden inside several layers of getters and a bit of casting...