Question

锯齿状数组和多维数组之间有什么区别。彼此之间有什么好处吗？
为什么Visual Studio不允许我做
```
MyClass[][] abc = new MyClass[10][20];
```
（我们曾经在C ++中这样做，但是在C＃中它用红色蠕动线强调[20] ..说无效的等级说明符）

但很满意
```
MyClass[,] abc = new MyClass[10,20];
```
最后，如何在一行中初始化它（就像我们在{new xxx...}{new xxx....}的简单数组中一样）
```
MyClass[][,][,] itemscollection;
```

Answer 1

锯齿状数组是一个数组数组，因此int[][]是一个int[]数组，每个数组的长度可以不同，并占用内存中自己的块。多维数组（int[,]）是一个单独的内存块（基本上是一个矩阵）。
您无法创建MyClass[10][20]因为每个子数组必须单独初始化，因为它们是单独的对象：
```
MyClass[][] abc = new MyClass[10][];

for (int i=0; i<abc.Length; i++) {
    abc[i] = new MyClass[20];
}
```
MyClass[10,20]没问题，因为它正在将一个对象初始化为一个包含10行和20列的矩阵

可以像这样初始化MyClass[][,][,]（不进行编译测试）：

MyClass[][,][,] abc = new MyClass[10][,][,];

for (int i=0; i<abc.Length; i++) {
    abc[i] = new MyClass[20,30][,];

    for (int j=0; j<abc[i].GetLength(0); j++) {
        for (int k=0; k<abc[i].GetLength(1); k++) {
            abc[i][j,k] = new MyClass[40,50];
        }
    }
}

请记住，CLR针对单维数组访问进行了大量优化，因此使用锯齿状数组可能会比同样大小的多维数组更快。

Answer 2

锯齿状数组是一个数组数组。不保证每个阵列的大小相同。你可能有

int[][] jaggedArray = new int[5][];
jaggedArray[0] = { 1, 2, 3 }; // 3 item array
jaggedArray[1] = new int[10]; // 10 item array
// etc.

这是相关数组的 set 。

另一方面，多维数组更像是一个有凝聚力的分组，如盒子，桌子，立方体等，没有不规则的长度。也就是说

int i = array[1,10];
int j = array[2,10]; // 10 will be available at 2 if available at 1

Answer 3

矩形数组的每一行总是具有相同的列数。

MyClass[,] x = new MyClass[10,30]

每行有30列，而在锯齿状数组中，这不是必需的。因此，我认为您必须分别初始化锯齿状阵列中的每个“行”：

MyClass[][] x = new MyClass[10][];

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

实际上，这意味着并非锯齿状数组中的每一行都必须包含相同数量的元素。（在我的例子中，它确实具有相同数量的元素，但这不是必需的。）

你可以完美地做到这一点，例如：

MyClass[][] x = new MyClass[10][];

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

This可能是一篇有趣的文章。

Answer 4

广告3）要初始化像[][,][,]这样的怪物，你可以这样做：

        int [,][,] multiArr1 = { { new int[,] { { 2, 2 }, { 1, 1 } },
                                     new int[,] { { 2, 2 }, { 1, 1 } } },
                                     { new int[,] { { 2, 2 }, { 1, 1 } },
                                         new int[,] { { 2, 2 }, { 1, 1 } } } };
        int [,][,] multiArr2 = { { new int[,] { { 2, 2 }, { 1, 1 } },
                                     new int[,] { { 2, 2 }, { 1, 1 } } },
                                     { new int[,] { { 2, 2 }, { 1, 1 } },
                                         new int[,] { { 2, 2 }, { 1, 1 } } } };

        int [][,][,] superMultiArray = { multiArr1, multiArr2 };

Answer 5

如果您正在寻找具有设置边界的多维数组，请始终使用[,]样式语法。这将确保每个部分的大小相同。

当你使用[][]时，实际上你正在创建一个数组数组。这意味着每个阵列的大小可以不同。例如：

int[][] jaggedArray = new int[5][]
for(int index = 0; index < jaggedArray.Length ; ++index)
{
    jaggedArray[index] = new int[index + 1];
}

Answer 6

内联声明看起来像这样：

int[,] numbers = { {1, 2}, {3, 4}, {5, 6} };

Answer 7

对于＃1，请参阅this SO question

对于锯齿状或多维内联数组，请参阅此programming guide：

// Three-dimensional array.
int[, ,] array3D = new int[,,] { { { 1, 2, 3 }, { 4, 5, 6 } }, { { 7, 8, 9 }, { 10, 11, 12 } } };
// Same array with dimensions specified.
int[, ,] array3Da = new int[2, 2, 3] { { { 1, 2, 3 }, { 4, 5, 6 } }, { { 7, 8, 9 }, { 10, 11, 12 } } };

您不必指定尺寸（array3D），但如果您知道它们永远不会改变，那么了解您正在使用的尺寸（array3Da）会很有帮助。

Answer 8

您需要了解阵列的内部工作原理除了将双索引转换为单个索引之外，多维数组充当单维数组。

c＃中的Jagged数组是一个对象数组，它们是数组。

Answer 9

我认为C＃中的2d锯齿状数组内存分配就像C ++和C中的2d数组一样。因为2d锯齿状数组具有指向指针数组的指针，每个指针都指向一个元素数组（例如整数元素）;就像C ++中的这段代码一样，

int** 2DArr {new int* [number1]};
for (int i = 0; i < number1; i++)
{
   2DArr[i] = new int[number2];
}

代码的内存分配与C＃中的2d锯齿状数组相同。但我怀疑，如果我以错误的方式思考，请你解释一下。

Answer 10

这篇文章很旧，但是我对此有何看法。

锯齿状数组是多维数组。多维数组有两种：矩形和锯齿状。矩形数组代表内存的n维块，锯齿状数组是数组的数组。

矩形数组

使用逗号分隔矩形数组，以分隔每个维。以下语句声明一个矩形二维数组，其尺寸为3×3：

@text = Text.new("Score: #{@score}")
update do
    ...
    @text.remove # At a time you want to stop displaying that text.
    ...
end

锯齿状的阵列

锯齿状数组使用连续的方括号声明，以表示每个维。这是声明一个锯齿状二维数组的示例，其中最外面的维是3：

int[,] matrix = new int [3, 3];

Answer 11

对于多维数组，请考虑一个方框或矩形。每行长度相同，每列长度相同。

在锯齿状数组中，行和列的大小可能不同。例如，列或行可以具有不同的大小。这将导致形状可能不是矩形下方的直线。取而代之的是，侧面可能是<锯齿状。

现在，在此示例中，我使用了2维/ 2个数组，但这适用于更多数组。

为什么我们都有锯齿状数组和多维数组？

11 个答案: