Question

如何在c ++中使用动态内存分配创建二维数组？

Maze(int c=10){
   const int m=c;
   a=new int[m][m];
  }

void main(){
  Maze(12);
}

Answer 1

std::vector是在C ++中拥有动态分配数组的典型方法。你可以有一个矢量矢量来使它成为二维的。这是一个例子：

std::vector<std::vector<int>> a(m,std::vector<int>(m));

如果你想在课堂上这样做：

struct Maze {
    std::vector<std::vector<int>> a;

    Maze(int m) : a(m,std::vector<int>(m)) { }
};

Answer 2

轻松 - 使用乘法。另外我建议使用对数组的引用，因为这样你可以更明确地指定类型，然后使用指向它的第一个元素。我真的很惊讶为什么这不是大多数程序员使用的类型。也许是因为他们很懒，而且类型很复杂;）。

void Maze(int c=10) {
   const int m=c;
   int (&a)[0][0] = *(int (*)[0][0])new int[/*numbers of rows*/ m * sizeof(int) * m /* number of colums on each row*/];
}

这里'a'是对新创建的数组的引用。由于类型在'C ++'语言中不是动态的，我们假设它在每个维度上都没有元素。但当然我们可以访问0以上。

现在，如果你有一个带有类型2 dim数组参数的函数，它将如下所示：

void func(int (&_2dimarray)[0][0]) ;

或者，如果您想从“迷宫”中退回，您可以写下：

int (&Maze(int c=10))[0][0] {
   const int m=c;
   int (&a)[0][0] = *(int (*)[0][0])new int[/*numbers of rows*/ m * sizeof(int) * m /* number of colums on each row*/];
   return a;
}

生命example。

但当然最简单的方法是使用'std :: vector'，但是在某些编译器上可能会有性能成本，而内置阵列在任何地方都可以更快地运行。

编辑：解释很简单 - 'new []'可以思考，如下所示：

template<class T>
T *operator new T[] (std::size_t);

你的实例：

a=new int[m][m];

也可以这样（说明性）

a=operator new int[m][](m);

使用'int [m]'来实现'T'。

这是非法的，因为'int [m]'不是有效类型。 'C ++'仅支持静态类型，这不是这样的，因为在编译期间无法确定数组的长度，因为'm'不是常量。最后一个'm'是'operator new []'的函数参数。

是的，我也认为这种结构不是最优雅的，但这就是生活。

Answer 3

有两种方法。如果内部一维子阵列的大小是编译时已知的常量值，那么您可以编写

const size_t N = 10;

int ( * )[N] Maze( size_t n = N )
{
    return new int[n][N];
}

int main()
{
    int ( *a )[N] = Maze( 12 );

    //...

    delete [] a;
}

如果它不是常数，那么你需要为一维数组分配一维指针数组。例如

const size_t N = 10;

int ** Maze( size_t n = N )
{
    int **p = new int *[n];

    for ( size_t i = 0; i < n; i++ ) p[i] = new int[n];

    return p;
}

int main()
{
    int **a = Maze( 12 );

    //...

    for ( size_t i = 0; i < 12; i++ ) delete [] a[i];
    delete [] a;
}

您也可以使用智能指针，例如std::unique_ptr。

另一种方法是使用标准容器std::vector<std::vector<int>>

如何在C ++中动态分配2D数组？

3 个答案: