C++ C++；二维动态阵列

我试图动态地将2d数组分配给构造函数中的指针

FooBar::FooBar()
    : _array( new int[10][10] )
{ }
int **_array;

然而，这不起作用。我知道多维数组的分配有点不同。有人能详细解释一下吗

提前感谢。

int**array=new int*[10]；
int **array  = new int *[10];

for(int i= 0; i< 10;i++)
{
    array[i] = new int[10];
}

对于（int i=0；i<10；i++）
{
数组[i]=新整数[10]；
}

如果使用new，则需要分别分配第二维度的每个部分

int **Array;
Array = new int*[10];
for (int i = 0; i < 10; i++) {
    Array[i] = new int[10];
}

int**数组；
数组=新整数*[10]；
对于（int i=0；i<10；i++）{
数组[i]=新整数[10]；
}

C中的二维数组是指向其他数组的指针数组

假设我们有3x3数组

a

（键入

int**

）：

这意味着需要两个分配过程，一个用于指针数组（int**），其余用于该数组的每个元素

第一步，分配指针数组：

int** a = new int*[10];

第二步，为

a

的每个元素分配一个新数组：

for(int i=0; i<10; ++i)
    a[i] = new int[10];

---

这里的一些答案说，二维数组是指向其他数组的指针数组。这不是真的（如果您只分配数组的数据，那么在哪里存储指针！？）。相反，二维数组是其他数组的数组。因此，您必须更改成员的类型：

FooBar::FooBar()
    : _array( new int[10][10] )
{ }
int (*_array)[10];

这是因为

new[]

返回指向所创建数组的第一个元素的指针。这个元素是一个由10个整数组成的数组，因此成员类型会发生变化。如果语法吓跑了你，用temlate简化它（这个模板相当于

boost:：identity

）

模板结构标识{typedef T type；}；
FooBar：：FooBar（）
：_数组（新整数[10][10]）
{ }
identity:：type*\u数组；

这与就地typedef一样有效。当然，与任何

new[]

的使用一样，它需要一个适当的

delete[]

，放置在析构函数中，并在对象被销毁时调用

由于

new[]

分配的元素数组的类型在编译时已知，因此只能将第一个（最外层）维度设置为运行时值-所有其他维度的值必须在编译时已知。如果这不是您想要的，您将不得不分配一个指针数组，就像其他一些答案所说的那样

---

但请注意，为了避免进一步混淆，这些不是多维数组。它们是指针的一维数组，恰好指向其他一维数组

如果您不太关心性能，可以使用以下方法：

//vec2d.h
#include<vector>

template<class T>
void init2DVect(std::vector< std::vector<T> >& _T, size_t sx, size_t sy)
{
  _T.resize( sx );
  for(size_t i =0; i < sx; ++i)
  {
    std::vector<T> ins_v(sy);
    _T[i] = ins_v;
  }
}

//vec2d.h
#包括
模板
void init2DVect（std:：vector和大小sx，大小sy）
{
_T.resize（sx）；
对于（尺寸i=0；i

示例用例：

//file: vec2d_test.cpp
#include "vec2D.h"

#include<cassert>

int main()
{
  std::vector< std::vector<int> > vi;
  size_t sx = 5;
  size_t sy = 7;
  init2DVect(vi, sx, sy);

  for(size_t i = 0; i < sx; ++i)
  {
    for(size_t j = 0; j < sy; ++j)
    {
      vi.at(i).at(j) = i*j;
    }
  }

  for(size_t i = 0; i < sx; ++i)
  {
    for(size_t j = 0; j < sy; ++j)
    {
      assert( vi.at(i).at(j) == i*j );
      assert( vi[i][j] == i*j );
    }
  }   

  return 0;
}

//文件：vec2d\u test.cpp
#包括“vec2D.h”
#包括
int main（）
{
std:：vectorvi；
尺寸_t sx=5；
尺寸sy=7；
init2DVect（vi，sx，sy）；
对于（尺寸i=0；i

这样做的好处是，您不必担心内存问题，并且可以使用vector:：at（）函数在超出范围时抛出异常。。。好的C++作业，但是STD的向量：向量不一定是最快的方法。< /P>

---

其他人也会这么做。

哦，有人先到了。嗨。C++中动态多维数组很难看。如果您实际正在使用它们（与学习/家庭作业相反），请查看boost多数组类型。-1-C/C++中的2D数组与指向数组的指针数组不同，也没有指针类型。-1 LiraNuna的回答不正确。C/C++中的2D（或n维）数组由编译器展平。维[n][m]的二维数组实际上是维[nm]的线性数组，[i][j]的存取实际上是[im+j]的存取。

template<typename T> struct identity { typedef T type; };

FooBar::FooBar()
    : _array( new int[10][10] )
{ }
identity<int[10]>::type *_array;

//vec2d.h
#include<vector>

template<class T>
void init2DVect(std::vector< std::vector<T> >& _T, size_t sx, size_t sy)
{
  _T.resize( sx );
  for(size_t i =0; i < sx; ++i)
  {
    std::vector<T> ins_v(sy);
    _T[i] = ins_v;
  }
}

//file: vec2d_test.cpp
#include "vec2D.h"

#include<cassert>

int main()
{
  std::vector< std::vector<int> > vi;
  size_t sx = 5;
  size_t sy = 7;
  init2DVect(vi, sx, sy);

  for(size_t i = 0; i < sx; ++i)
  {
    for(size_t j = 0; j < sy; ++j)
    {
      vi.at(i).at(j) = i*j;
    }
  }

  for(size_t i = 0; i < sx; ++i)
  {
    for(size_t j = 0; j < sy; ++j)
    {
      assert( vi.at(i).at(j) == i*j );
      assert( vi[i][j] == i*j );
    }
  }   

  return 0;
}