Будь-яка альтернатива std :: dynarray наразі доступна?

Я думаю, що std :: vector це те, що ви шукаєте, перш ніж dynarray стане доступним. Просто скористайтеся конструктором, що розподіляє, або reserve , щоб уникнути перерозподілу накладних витрат.

I’ll put in a vote for std::unique_ptr(new short[n]) if you don’t need the range-checked access provided by std::dynarray::at(). You can even use an initializer list:

#include 
#include 

int main(int argc, char** argv) {
  const size_t n = 3;
  std::unique_ptr myarray(new short[n]{ 1, 2, 3 });
  for (size_t i = 0; i < n; ++i)
    std::cout << myarray[i] << '\n';
}

Буфер і розмір, а також деякі основні методи дають вам більшу частину того, що ви хочете.

Багато боліплата, але щось на зразок цього:

template
struct fixed_buffer {
  typedef       T                               value_type;
  typedef       T&                              reference;
  typedef const T&                              const_reference;
  typedef       T*                              iterator;
  typedef const T*                              const_iterator;
  typedef std::reverse_iterator       reverse_iterator;
  typedef std::reverse_iterator const_reverse_iterator;
  typedef size_t                                size_type;
  typedef ptrdiff_t                             difference_type;

  std::size_t length;
  std::unique_ptr buffer;

  std::size_t size() const { return length; }

  iterator begin() { return data(); }
  const_iterator begin() const { return data(); }
  const_iterator cbegin() const { return data(); }
  iterator end() { return data()+size(); }
  const_iterator end() const { return data()+size(); }
  const_iterator cend() const { return data()+size(); }

  reverse_iterator rbegin() { return {end()}; }
  const_reverse_iterator rbegin() const { return {end()}; }
  const_reverse_iterator crbegin() const { return {end()}; }
  reverse_iterator rend() { return {begin()}; }
  const_reverse_iterator rend() const { return {begin()}; }
  const_reverse_iterator crend() const { return {begin()}; }

  T& front() { return *begin(); }
  T const& front() const { return *begin(); }
  T& back() { return *(begin()+size()-1); }
  T const& back() const { return *(begin()+size()-1); }
  T* data() { return buffer.get(); }
  T const* data() const { return buffer.get(); }
  T& operator[]( std::size_t i ) { return data()[i]; }
  T const& operator[]( std::size_t i ) const { return data()[i]; }
  fixed_buffer& operator=(fixed_buffer &&) = default;
  fixed_buffer(fixed_buffer &&) = default;

  explicit fixed_buffer(std::size_t N):length(N), buffer( new T[length] ) {}
  fixed_buffer():length(0), buffer() {}

  fixed_buffer(fixed_buffer const& o):length(o.N), buffer( new T[length] )
  {
    std::copy( o.begin(), o.end(), begin() );
  }
  fixed_buffer& operator=(fixed_buffer const& o)
  {
    std::unique_ptr tmp( new T[o.length] );
    std::copy( o.begin(), o.end(), tmp.get() );
    length = o.length;
    buffer = std::move(tmp);
    return *this;
  }
};

at() is missing, as are allocators.

operator= is different than dyn_array proposal -- the proposal blocks operator=, I give it value semantics. A few methods are less efficient (like copy construction). I allow empty fixed_buffer.

Це, ймовірно, заблокує можливість використання стеків для зберігання dyn_array , що, ймовірно, чому це не дозволяє. Просто видаліть мій operator = і тривіальний конструктор, якщо ви хочете ближче до dyn_array поведінки.

C ++ 14 також додає масивів змінної довжини, подібні до тих, що містяться в C99, і це вже підтримується деякими компіляторами:

void foo(int n) {
  int data[n];
 //...
}

Це не контейнер, оскільки він не підтримує begin() і end() тощо, але це може бути дієвим рішенням.

dynarray is very easy to implement oneself without the stack-allocation component -which apparently isn't possible to do until perhaps C++14 anyway- so I just rolled a dynarray inverse-backport (forwardport?) as part of my library and started using it ever since. Works in C++03 without any "void in Nebraska" clauses so far, as it doesn't absolutely depend on any C++11-specific capability, and it's neat to have
That way when C++1y/2z dynarray comes along my code is still for the most part compatible.

(Це також одна з багатьох очевидних "чому не C ++ це було раніше", так що це добре, щоб це навколо).

Це було до того, як я дізнався, що, очевидно, C ++ 1y- dynarray і C ++ 1y-runtime-size-масиви - точно така ж пропозиція (це просто синтаксичний цукор для іншого), а не дві різні - але-додаткові пропозиції, як я спочатку подумав. Отже, якщо б мені довелося вирішити одне й те саме питання, то сьогодні я ймовірно перейду на щось на основі рішення @ Yakk для правильності.