Question

我一直在尝试创建一个可变长度的多维数组。据我了解，您不能在堆栈上创建可变长度数组，但您可以使用动态分配在C ++中创建1D可变长度数组。如果这是一个编译器扩展，请更正我，但它似乎在使用--pedantic set的clang和gcc上正常工作。

int size = 10;
int *ary = new int[size]();

我试图将概念扩展到多维数组。这是我的结果。可能性1和2的问题在于它们需要constexpr并且不适用于可变大小。是否可以使其中任何一个接受变量作为其大小？我把可能性3放在我知道的地方，但它没有[] []访问权限，这正是我正在寻找的。

constexpr int constSize = 10;

//Possibility 1: Only works in C++11
//Creates CONTIGUOUS 2D array equivalent to array[n*n], but with [][] access

int (*ary1)[constSize] = new int[constSize][constSize]();
delete [] ary1;

//Possibility 2:
//Really horrible as it does NOT create a contiguous 2D array
//Instead creates n seperate arrays that are each themselves contiguous
//Also requires a lot of deletes, quite messy

int **ary2 = new int*[constSize];
for (int i = 0; i < n; ++i)
    ary2[i] = new int[constSize];
for (int i = 0; i < n; ++i)
    delete [] ary2;
delete [] ary2;

//Possibility 3:
//This DOES work with non-constexpr variable
//However it does not offer [][] access, need to access element using ary[i*n+j]

int *ary3 = new int[size*size];
delete [] ary3;

Answer 1

这将创建一个动态分配的2D可变长度数组，其维度为w和h：

std::vector<std::vector<int>> ary4(w, std::vector<int>(h));

可以使用[][]：

访问它

ary4[x][y] = 0;

然而，它不是连续分配的。要获得一个连续的数组，这里有一个解决方案：

template<typename E>
class Contiguous2DArray
{
public:
    Contiguous2DArray(std::size_t width, std::size_t height)
    : array(width * height), width(width) {}

    E& operator()(std::size_t x, std::size_t y)
    { return array[x + width * y]; }

private:
    std::vector<E> array;
    std::size_t width;
}

可以像这样使用：

Contiguous2DArray<int> ary5(w, h);
ary5(x, y) = 0;

Answer 2

维度数量是固定的，因为[]返回的类型会根据维度数进行更改。通过重复[]和(...)进行访问。第一个模仿C风格的数组查找。 (...)语法必须完整（必须将N args传递给N维数组。支持两者都需要适度的效率成本。

使用C ++ 14功能来节省冗长。没有必要。

使用n_dim_array 0尺寸会产生不良结果。

template<class T, size_t N>
struct array_index {
  size_t const* dimensions;
  size_t offset;
  T* buffer;
  array_index<T,N-1> operator[](size_t i)&&{
    return {dimensions+1, (offset+i)* *dimensions, buffer};
  }
  template<class...Is, std::enable_if_t<sizeof...(Is) == N>>
  T& operator()(size_t i, Is...is)&&{
    return std::move(*this)[i](is...);
  }
};
template<class T>
struct array_index<T,0> {
  size_t const* dimension;
  size_t offset;
  T* buffer;
  T& operator[](size_t i)&&{
    return buffer[i+offset];
  }
  T& operator()(size_t i)&&{
    return std::move(*this)[i];
  }
};

template<class T, size_t N>
struct n_dim_array {
  template<class...Szs, class=std::enable_if_t<sizeof...(Szs)==N>>
  explicit n_dim_array( Szs... sizes ):
    szs{ { static_cast<size_t>(sizes)... } }
  {
    size_t sz = 1;
    for( size_t s : szs )
      sz *= s;
    buffer.resize(sz);
  }
  n_dim_array( n_dim_array const& o ) = default;
  n_dim_array& operator=( n_dim_array const& o ) = default;


  using top_level_index = array_index<T,N-1>;
  top_level_index index(){return {szs.data(),0,buffer.data()};}
  auto operator[]( size_t i ) {
    return index()[i];
  }
  using const_top_level_index = array_index<const T,N-1>;
  const_top_level_index index()const{return {szs.data(),0,buffer.data()};}
  auto operator[]( size_t i ) const {
    return index()[i];
  }
  template<class...Is,class=std::enable_if_t<sizeof...(Is)==N>>
  T& operator()(Is...is){
    return index()(is...);
  }
  template<class...Is,class=std::enable_if_t<sizeof...(Is)==N>>
  T const& operator()(Is...is) const {
    return index()(is...);
  }
private:
  n_dim_array() = delete;
  std::array<size_t,N> szs;
  std::vector<T> buffer;
};

live example

不支持for(:)循环迭代。编写迭代器并不难：我会在array_index中完成。

C ++ 11动态分配了可变长度的多维数组

2 个答案: