_S_create()

template<typename _CharT, typename _Traits, typename _Alloc>

basic_string< _CharT, _Traits, _Alloc >::_Rep * std::basic_string< _CharT, _Traits, _Alloc >::_Rep::_S_create ( size_type __capacity, size_type __old_capacity, const _Alloc & __alloc )

static

Definition at line 3723 of file cow_string.h.

    {
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 83.  String::npos vs. string::max_size()
      if (__capacity > _S_max_size)
      __throw_length_error(__N("basic_string::_S_create"));
 
      // The standard places no restriction on allocating more memory
      // than is strictly needed within this layer at the moment or as
      // requested by an explicit application call to reserve(n).
 
      // Many malloc implementations perform quite poorly when an
      // application attempts to allocate memory in a stepwise fashion
      // growing each allocation size by only 1 char.  Additionally,
      // it makes little sense to allocate less linear memory than the
      // natural blocking size of the malloc implementation.
      // Unfortunately, we would need a somewhat low-level calculation
      // with tuned parameters to get this perfect for any particular
      // malloc implementation.  Fortunately, generalizations about
      // common features seen among implementations seems to suffice.
 
      // __pagesize need not match the actual VM page size for good
      // results in practice, thus we pick a common value on the low
      // side.  __malloc_header_size is an estimate of the amount of
      // overhead per memory allocation (in practice seen N * sizeof
      // (void*) where N is 0, 2 or 4).  According to folklore,
      // picking this value on the high side is better than
      // low-balling it (especially when this algorithm is used with
      // malloc implementations that allocate memory blocks rounded up
      // to a size which is a power of 2).
      const size_type __pagesize = 4096;
      const size_type __malloc_header_size = 4 * sizeof(void*);
 
      // The below implements an exponential growth policy, necessary to
      // meet amortized linear time requirements of the library: see
      // http://gcc.gnu.org/ml/libstdc++/2001-07/msg00085.html.
      // It's active for allocations requiring an amount of memory above
      // system pagesize. This is consistent with the requirements of the
      // standard: http://gcc.gnu.org/ml/libstdc++/2001-07/msg00130.html
      if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
      __capacity = 2 * __old_capacity;
 
      // NB: Need an array of char_type[__capacity], plus a terminating
      // null char_type() element, plus enough for the _Rep data structure.
      // Whew. Seemingly so needy, yet so elemental.
      size_type __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
 
      const size_type __adj_size = __size + __malloc_header_size;
      if (__adj_size > __pagesize && __capacity > __old_capacity)
      {
        const size_type __extra = __pagesize - __adj_size % __pagesize;
        __capacity += __extra / sizeof(_CharT);
        // Never allocate a string bigger than _S_max_size.
        if (__capacity > _S_max_size)
          __capacity = _S_max_size;
        __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
      }
 
      // NB: Might throw, but no worries about a leak, mate: _Rep()
      // does not throw.
      void* __place = _Raw_bytes_alloc(__alloc).allocate(__size);
      _Rep *__p = new (__place) _Rep;
      __p->_M_capacity = __capacity;
      // ABI compatibility - 3.4.x set in _S_create both
      // _M_refcount and _M_length.  All callers of _S_create
      // in basic_string.tcc then set just _M_length.
      // In 4.0.x and later both _M_refcount and _M_length
      // are initialized in the callers, unfortunately we can
      // have 3.4.x compiled code with _S_create callers inlined
      // calling 4.0.x+ _S_create.
      __p->_M_set_sharable();
      return __p;
    }

References std::basic_string< _CharT, _Traits, _Alloc >::basic_string(), __N, std::__throw_length_error(), std::basic_string< _CharT, _Traits, _Alloc >::_Rep_base::_M_capacity, _M_set_sharable(), and _S_max_size.

Referenced by _M_clone(), std::basic_string< _CharT, _Traits, _Alloc >::_M_mutate(), std::basic_string< _CharT, _Traits, _Alloc >::_S_construct(), and std::basic_string< _CharT, _Traits, _Alloc >::_S_construct().

Here is the call graph for this function:

Here is the caller graph for this function: