如果你想要一个2d的整数数组，它的元素在内存中是按顺序分配的，你必须像这样声明它

int (*intPtr)[n] = new int[x][n]

你可以用任何维数来代替x，但是n在两个地方必须相等。例子

int (*intPtr)[8] = new int[75][8];
intPtr[5][5] = 6;
cout<<intPtr[0][45]<<endl;

必须打印6。

如果你的项目是CLI(公共语言运行时支持)，那么:

你可以使用数组类，而不是你写的那个:

#include <array>
using namespace std;

换句话说，不是使用std名称空间和包含数组头时获得的非托管数组类，不是std名称空间和数组头中定义的非托管数组类，而是CLI的托管类数组。

使用这个类，您可以创建任意级别的数组。

下面的代码创建了一个2行3列的二维数组，类型为int，并命名为“arr”:

array<int, 2>^ arr = gcnew array<int, 2>(2, 3);

现在您可以访问数组中的元素，通过命名它并只写一个平方括号[]，并在其中添加行和列，并用逗号分隔它们。

下面的代码访问我已经在上面的代码中创建的数组的第2行和第1列中的一个元素:

arr[0, 1]

只写这一行是为了读取该单元格中的值，即获取该单元格中的值，但如果添加等号，则要写入该单元格中的值，即设置该单元格中的值。 当然，你也可以使用+=，-=，*=和/=运算符，仅用于数字(int, float, double， __int16， __int32， __int64等)，但你肯定已经知道了。

如果您的项目不是CLI，那么您可以使用std名称空间的非托管数组类，当然，如果您使用#include <array>，但是问题是这个数组类与CLI数组不同。创建这种类型的数组与CLI相同，除了必须删除^符号和gcnew关键字。但不幸的是，<>括号中的第二个int参数指定了数组的长度(即大小)，而不是它的秩!

没有办法在这类数组中指定rank, rank是CLI数组的特性。

STD数组的行为类似于c++中的普通数组，使用指针定义，例如int*，然后:new int[size]，或者不使用指针:int arr[size]，但与c++中的普通数组不同，STD数组提供了可以与数组元素一起使用的函数，如fill, begin, end, size等，但普通数组什么也没有提供。

但是std数组仍然是一维数组，就像普通的c++数组一样。 但是多亏了其他人提出的关于如何将普通的c++一维数组转换为二维数组的解决方案，我们可以将同样的想法应用到std数组中，例如，根据Mehrdad Afshari的想法，我们可以编写以下代码:

array<array<int, 3>, 2> array2d = array<array<int, 3>, 2>();

这一行代码创建了一个“罐子数组”，这是一个一维数组，它的每个单元格都是或指向另一个一维数组。

如果一维数组中所有一维数组的长度/大小都相等，那么你可以将array2d变量视为一个真正的二维数组，另外你可以使用特殊的方法来处理行或列，这取决于你如何看待它，在二维数组中，std数组支持。

你也可以使用Kevin Loney的解决方案:

int *ary = new int[sizeX*sizeY];

// ary[i][j] is then rewritten as
ary[i*sizeY+j]

但如果你使用STD数组，代码必须看起来不同:

array<int, sizeX*sizeY> ary = array<int, sizeX*sizeY>();
ary.at(i*sizeY+j);

并且仍然具有std数组的独特功能。

请注意，您仍然可以使用[]括号访问std数组的元素，并且不必调用at函数。 您还可以定义并赋值一个新的int变量，该变量将计算并保持std数组中元素的总数，并使用它的值，而不是重复sizeX* sizeey

You can define your own two dimensional array generic class, and define the constructor of the two dimensional array class to receive two integers to specify the number of rows and columns in the new two dimensional array, and define get function that receive two parameters of integer that access an element in the two dimensional array and returns its value, and set function that receives three parameters, that the two first are integers that specify the row and column in the two dimensional array, and the third parameter is the new value of the element. Its type depends on the type you chose in the generic class.

你将能够通过使用普通的c++数组(指针或不指针)或std数组来实现所有这些，并使用其他人建议的想法之一，并使其易于使用，如cli数组，或像你可以在c#中定义、赋值和使用的二维数组。

这个问题一直困扰着我——这是一个很常见的问题，应该已经有了一个好的解决方案，比向量的向量或滚动你自己的数组索引更好的解决方案。

当c++中应该存在一些东西，但却不存在时，第一个地方是boost.org。在那里我找到了Boost多维数组库，multi_array。它甚至包括一个multi_array_ref类，可用于包装您自己的一维数组缓冲区。

这个答案的目的不是添加其他答案没有涵盖的新内容，而是扩展@Kevin Loney的答案。

你可以使用轻量级声明:

int *ary = new int[SizeX*SizeY]

访问语法将是:

ary[i*SizeY+j]     // ary[i][j]

但这对大多数人来说都很麻烦，可能会导致混乱。所以，你可以这样定义宏:

#define ary(i, j)   ary[(i)*SizeY + (j)]

现在可以使用非常相似的语法ary(i, j) //表示ary[i][j]。 这具有简单美观的优点，同时，使用表达式代替索引也更简单，不那么令人困惑。

要访问，比如说，ary[2+5][3+8]，你可以写ary(2+ 5,3 +8)，而不是看起来复杂的ary[(2+5)*SizeY +(3+8)]，也就是说，它节省了括号，有助于可读性。

警告:

尽管语法非常相似，但并不相同。 如果将数组传递给其他函数，则必须以相同的名称传递SizeY(或者声明为全局变量)。

或者，如果你需要在多个函数中使用数组，那么你可以在宏定义中添加SizeY作为另一个参数，如下所示:

#define ary(i, j, SizeY)  ary[(i)*(SizeY)+(j)]

你懂的。当然，这会变得太长而没有用处，但它仍然可以防止+和*的混淆。

当然不推荐这样做，大多数有经验的用户会谴责这是一种糟糕的做法，但我还是忍不住要分享它，因为它很优雅。

编辑: 如果你想要一个适用于任意数量数组的可移植解决方案，你可以使用以下语法:

#define access(ar, i, j, SizeY) ar[(i)*(SizeY)+(j)]

然后你可以使用访问语法将任意大小的数组传递给调用:

access(ary, i, j, SizeY)      // ary[i][j]

附注:我已经测试了这些，在g++14和g++11编译器上可以使用相同的语法(作为左值和右值)。

尽管这个流行的答案将为您提供所需的索引语法，但它的效率是双重的:在空间和时间上都大而慢。有更好的办法。

为什么答案又大又慢

建议的解决方案是创建一个指针的动态数组，然后将每个指针初始化到它自己的独立动态数组。这种方法的优点是它提供了你习惯的索引语法，所以如果你想找到矩阵在x,y位置的值，你说:

int val = matrix[ x ][ y ];

这是因为矩阵[x]返回一个指向数组的指针，然后用[y]作为索引。分解一下:

int* row = matrix[ x ];
int  val = row[ y ];

方便,是吗?我们喜欢[x][y]语法。

但是这个解决方案有一个很大的缺点，那就是它既胖又慢。

Why?

The reason that it's both fat and slow is actually the same. Each "row" in the matrix is a separately allocated dynamic array. Making a heap allocation is expensive both in time and space. The allocator takes time to make the allocation, sometimes running O(n) algorithms to do it. And the allocator "pads" each of your row arrays with extra bytes for bookkeeping and alignment. That extra space costs...well...extra space. The deallocator will also take extra time when you go to deallocate the matrix, painstakingly free-ing up each individual row allocation. Gets me in a sweat just thinking about it.

它慢还有另一个原因。这些单独的分配往往位于内存的不连续部分。一行的地址可能是1000，另一行的地址可能是100000——你可以理解。这意味着当你在穿越矩阵时，你就像一个狂野的人一样在记忆中跳跃。这往往会导致缓存丢失，从而大大降低处理时间。

所以，如果你绝对必须有你可爱的[x][y]索引语法，使用这个解决方案。如果你想要快速和小巧(如果你不关心这些，为什么要用c++ ?)，你需要一个不同的解决方案。

不同的解决方案

更好的解决方案是将整个矩阵分配为单个动态数组，然后使用自己的(稍微)聪明的索引数学来访问单元格。索引的数学运算非常巧妙;不，这一点也不聪明:这是显而易见的。

class Matrix
{
    ...
    size_t index( int x, int y ) const { return x + m_width * y; }
};

给定这个index()函数(我想象它是一个类的成员，因为它需要知道矩阵的m_width)，您可以访问矩阵数组中的单元格。矩阵数组是这样分配的:

array = new int[ width * height ];

所以在缓慢的，高脂肪的溶液中

array[ x ][ y ]

.．.这是一个快速，小的解决方案:

array[ index( x, y )]

很难过，我知道。但你会习惯的。你的CPU会感谢你的。

在c++ 11及以上版本中，我推荐两种通用技术，一种用于编译时维度，另一种用于运行时维度。这两个答案都假设您需要统一的二维数组(而不是锯齿状数组)。

编译时维度

使用std::array的std::array，然后使用new把它放到堆上:

// the alias helps cut down on the noise:
using grid = std::array<std::array<int, sizeX>, sizeY>;
grid * ary = new grid;

同样，这仅适用于在编译时已知维度大小的情况。

运行时维度

实现只有在运行时才知道大小的二维数组的最佳方法是将其包装到一个类中。该类将分配一个1d数组，然后重载操作符[]来为第一个维度提供索引。 这是因为在c++中，2D数组是行为主的:

(摘自http://eli.thegreenplace.net/2015/memory-layout-of-multi-dimensional-arrays/)

连续的内存序列有利于提高性能，而且易于清理。下面是一个示例类，省略了很多有用的方法，但显示了基本思想:

#include <memory>

class Grid {
  size_t _rows;
  size_t _columns;
  std::unique_ptr<int[]> data;

public:
  Grid(size_t rows, size_t columns)
      : _rows{rows},
        _columns{columns},
        data{std::make_unique<int[]>(rows * columns)} {}

  size_t rows() const { return _rows; }

  size_t columns() const { return _columns; }

  int *operator[](size_t row) { return row * _columns + data.get(); }

  int &operator()(size_t row, size_t column) {
    return data[row * _columns + column];
  }
}

因此，我们用std::make_unique<int[]>(行*列)项创建一个数组。我们重载操作符[]，它将为我们索引行。它返回一个int *，指向该行的开头，然后可以像对列一样对该行进行解引用。注意，make_unique在c++ 14中首次发布，但如果需要，可以在c++ 11中填充它。

对于这些类型的结构，重载operator()也是很常见的:

  int &operator()(size_t row, size_t column) {
    return data[row * _columns + column];
  }

从技术上讲，我在这里没有使用new，但是从std::unique_ptr<int[]>移动到int *并使用new/delete是很简单的。