Question

C ++ 11给了我们很棒的std::array，这需要在编译时知道大小：

std::array<int, 3> myarray = {1, 2, 3};

现在，我碰巧有一些旧的short*缓冲区要包装，其大小将在运行时才知道（当然它将是。）

C ++ 14将定义std::dynarray来涵盖这种情况，但{G} 4.7和Clang 3.2中尚未提供dynarray。

那么，有没有人知道一个与std::array相当的容器（就效率而言）但是不需要在编译时指定大小？我怀疑Boost已经为我准备好了，虽然我找不到任何东西。

Answer 1

我认为std::vector是您在dynarray可用之前所寻找的内容。只需使用分配构造函数或reserve，您就可以避免重新分配开销。

Answer 2

如果您不需要std::unique_ptr<short[]>(new short[n])提供的范围检查访问权限，我会对std::dynarray<T>::at()进行投票。您甚至可以使用初始化列表：

#include <iostream>
#include <memory>

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

Answer 3

你可以（ab）使用std::valarray<short>。

int main() {
    short* raw_array = (short*) malloc(12 * sizeof(short));
    size_t length = 12;
    for (size_t i = 0; i < length; ++ i) {
        raw_array[i] = (short) i;
    }

    // ...

    std::valarray<short> dyn_array (raw_array, length);
    for (short elem : dyn_array) {
        std::cout << elem << std::endl;
    }

    // ...

    free(raw_array);
}

valarray支持dynarray的大部分功能，但以下情况除外：

分配器
反向迭代器
.at()
.data()

请注意，标准（自n3690起）不需要valarray存储连续，但没有理由不这样做：）。

（对于一些实现细节，在libstdc ++中它实现为（长度，数据）对，在libc ++中它实现为（begin，end）。）

Answer 4

缓冲区和大小以及一些基本方法可以为您提供所需的大部分内容。

很多样板，但是像这样：

template<typename T>
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<iterator>       reverse_iterator;
  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
  typedef size_t                                size_type;
  typedef ptrdiff_t                             difference_type;

  std::size_t length;
  std::unique_ptr<T[]> 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<T[]> tmp( new T[o.length] );
    std::copy( o.begin(), o.end(), tmp.get() );
    length = o.length;
    buffer = std::move(tmp);
    return *this;
  }
};

at()和分配器一样缺失。

operator=与dyn_array提案不同 - 提案会阻止operator=，我给它赋予价值语义。一些方法效率较低（如copy构造）。我允许空fixed_buffer。

这可能会阻止能够使用堆栈存储dyn_array，这可能是它不允许的原因。如果您想要更接近dyn_array的行为，只需删除我的operator=和简单的构造函数。

Answer 5

C ++ 14还添加了可变长度数组，类似于C99中的数组，并且已经被一些编译器支持：

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

它不是容器，因为它不支持begin()和end()等，但可能是一个可行的解决方案。

Answer 6

dynarray很容易在没有堆栈分配组件的情况下实现自己 - 这显然是不可能的，直到或许 C ++ 14 - 所以我只是推了一个{ {1}} inverse-backport（forwardport？）作为我的库的一部分，从那时起就开始使用它。在C ++ 03中工作到目前为止没有任何“内布拉斯加州的空白”条款，因为它并不完全取决于任何特定于C ++ 11的能力，并且它很好用于这样，当C ++ 1y / 2z dynarray出现在我的代码中时，大部分仍然是兼容的。

（这也是许多显而易见的“为什么C ++没有这个更快？”的事情之一，所以最好有它）。

这是在我了解到显然C ++ 1y - dynarray和C ++ 1y-runtime-size-arrays是完全相同的提议（一个只是另一个的语法糖）而不是两个不同但我首先想到的是补充建议。因此，如果我现在必须解决同样的问题，我可能会根据@ Yakk的解决方案切换到正确的解决方案。

目前有什么替代std :: dynarray吗？

6 个答案: