пользовательский распределитель STL приводит к удалению первого символа

Question

По предложению @BenVoigt в ответ на мой вопрос, касающийся стекового хранилища с выделенным потоком , я разработал stack_allocator (код следует ниже) и объявил тип basic_ostringstream с его использованием.

IЯ испытываю странную ошибку, хотя.Первый символ, который я помещаю в поток, пропускается, когда я печатаю полученную строку!

Вот пример:

template<typename T, size_t capacity, size_t arr_size>
__thread bool stack_allocator<T, capacity, arr_size>::_used[arr_size] = {};

template<typename T, size_t capacity, size_t arr_size>
__thread T stack_allocator<T, capacity, arr_size>::_buf[capacity][arr_size] = {};

typedef std::basic_ostringstream<char, 
                                 std::char_traits<char>, 
                                 stack_allocator<char, 1024, 5> > stack_ostringstream;  
int main()
{
  stack_ostringstream _os;
  _os << "hello world";
  std::cout << _os.str() << std::endl;
  return 0;
}

В результате получается:

ello world

Может кто-нибудь уточнить, что происходит с первым персонажем?

Отсюда подразумевается: stack_allocator: Это довольно упрощенно, и я уверен, что есть много возможностей для улучшения(не выдерживает исправления ошибки!)

#include <cstddef>
#include <limits>
#include <bits/allocator.h>

template<typename T, size_t capacity = 1024, size_t arr_size = 5>
class stack_allocator 
{
 public: 
  typedef T value_type;
  typedef value_type* pointer;
  typedef const value_type* const_pointer;
  typedef value_type& reference;
  typedef const value_type& const_reference;
  typedef std::size_t size_type;
  typedef std::ptrdiff_t difference_type;

  inline explicit stack_allocator() { }
  template<typename U>
  inline explicit stack_allocator(const stack_allocator<U, capacity, arr_size>& that) { }
  inline ~stack_allocator() {}

  template<typename U>
  struct rebind 
  {
    typedef stack_allocator<U, capacity, arr_size> other;
  };

  inline pointer allocate(size_type cnt, typename std::allocator<void>::const_pointer = 0) 
  {
    if (cnt > capacity)
      return reinterpret_cast<pointer>(::operator new(cnt * sizeof (T))); 
    for (size_t i = 0; i < arr_size; ++i)
    {
      if (!_used[i])
      {
        _used[i] = true;
        return reinterpret_cast<pointer>(_buf[i]); 
      }
    }
  }

  inline void deallocate(pointer p, size_type) 
  {
    for (size_t i = 0; i < arr_size; ++i) 
    {
      if (p != _buf[i])
        continue;
      _used[i] = false;
      return;
    }
    ::operator delete(p); 
  }

  inline pointer address(reference r) { return &r; }
  inline const_pointer address(const_reference r) { return &r; }

  inline size_type max_size() const 
  { 
    return std::numeric_limits<size_type>::max() / sizeof(T);
  }

  inline void construct(pointer p, const T& t) { new(p) T(t); }
  inline void destroy(pointer p) { p->~T(); }

  inline bool operator==(const stack_allocator&) const { return true; }
  inline bool operator!=(const stack_allocator& a) const { return !operator==(a); }

 private:
  static __thread bool _used[arr_size];
  static __thread T    _buf[capacity][arr_size];
};

Answer 1

Ваша функция allocate может упасть до конца, если вы выделите более arr_size элементов. Если вы используете g++ -Wall, он предупредит вас о подобных вещах.

Другая проблема заключается в том, что ваши _buf индексы массива обратные. Это должно быть static T _buf[arr_size][capacity];, которое имеет arr_size в качестве строки, а не тот другой порядок, в котором вы используете его в исходном коде, что делает емкость первым индексом.

Также, как примечание, просто избегайте идентификаторов, которые начинаются с начального _, потому что некоторые такие идентификаторы зарезервированы для реализации, и их легче никогда не использовать, чем запоминать точные правила. Наконец, никогда не включайте заголовки bits/ напрямую, просто используйте настоящие заголовки. В этом случае memory. Мне также пришлось добавить include для <iostream> и <sstream>, чтобы заставить его компилироваться.