Question

我有4个int数组。它们都具有相同数量的元素。像这样：

int  ar1[] = {1,2,3,4};
int  ar2[] = {10,12,13,14};
int  ar3[] = {8,9,15,16};
int  ar4[] = {17,18,19,20};
int  big[][] ={ar1,ar2,ar3,ar4};  // I know this is messed up but here is where the question lies

当我运行for循环时，有没有办法：

int i;
for(i =0; i<4; i++){
    int x;
    for(x = 0; x<4; x++){
       printf(big[i][x]); // something like this   
    }
}

这样当执行此操作时，它会打印出来：

阵列1：1 2 3 4 阵列2：10 12 13 14 等.....

感谢。

Answer 1

检查一下：Multidimensional arrays in C和this Wikipedia page以获取有关C中多维数组的一般信息。

您的代码应该可以使用：

int* big[] = {ar1, ar2, ar3, ar4};

Answer 2

C二维数组不过是一个数组数组。这样的2-d阵列不能“粗糙”，即每行必须具有相同数量的元素。对于您的特定情况，您可以将其声明为：

int big[4][4] =
    { { 1, 2, 3, 4 },
      { 10, 12, 13, 14 },
      { 8, 9, 15, 16 },
      { 17, 18, 19, 20 } };

您可以省略第一个维度：int big[][4] = ...，长度将由初始化程序确定，但您不能省略第二个维度。

这种方法的一个优点是它是一个单独的对象，您可以使用sizeof来确定它有多少元素：

sizeof big == 16 * sizeof (int)
sizeof big[0] == sizeof *big == 4 * sizeof (int)
sizeof big[0][0] == sizeof (int)

但缺点是尺寸是固定的。

另一种方法是使用指针数组，其中每个指针指向数组的第一个元素：

int row0[] = { 1, 2, 3, 4 };
int row1[] = { 10, 12, 13, 14 };
int row2[] = { 8, 9, 15, 16 };
int row3[] = { 17, 18, 19, 20 };

int *big[4] = { row0, row1, row2, row3 };

（在初始值设定项中，row0是一个数组名称，但它会衰减到指向第一个元素的指针;同样适用于row1，row2和row3）。这更灵活，但您必须跟踪每行中的元素数量; sizeof big[0]将给出指针的大小，而不是行本身的大小。

另一种方法是使big指向指针：

int row0[] = { 1, 2, 3, 4 };
int row1[] = { 10, 12, 13, 14 };
int row2[] = { 8, 9, 15, 16 };
int row3[] = { 17, 18, 19, 20 };

int *rows[] = { row0, row1, row2, row3 };

int **big = rows;

这更灵活（实际上，您可能会使用malloc()分配所有内容。

第四种方法，可能不是非常有用，是使big指向数组的指针数组;我不会详细介绍。

由于数组到指针的衰减规则，即使big在4种不同的情况下有4种不同的类型，您也可以使用相同的语法来引用int元素：{ {1}}。

推荐阅读，一如既往：comp.lang.c FAQ的第6部分。

Answer 3

当然，你已经非常接近了。在C中，你所做的是构造（总是）一堆地址，你或者编译器做必要的算术来处理你想要的许多维度。

所以，让我们说我们制作一个一维数组，一个矢量：

int vec[] = {0, 1, 2, 3 };

在内存中，它将成为名为vec

的位置

vec:
     DS  0
     DS  1
     DS  2
     DS  3

其中DS只是说“定义存储并初始化为”。

当你编写一个for循环来迭代它时：

int ix;
for(ix=0; ix < 4; ix++){
   printf("%d\n", vec[ix]);
}

它变成了一个有点像

的循环

ix:    DS 0
loop:  CMP ix, 4
       JGE end     ; jump if comparison is >=
       PUSH vec+ix ; address arithmetic
       JSR PRINTF  ; call the printf routing using value on the stack
       INC ix      ; ix := ix+1
       JUMP loop   ; goto top
end:

（这不是特定的汇编程序，只是伪代码。）

现在，让我们制作一个二维数组

int ary2[][] = {{0,1,2,3},{4,5,6,7});
int ix, jx;
for(ix=0; ix<4;ix++){
   for(jx=0; jx<4; jx++){
      printf("%d\n", ary2[ix][jx]);
   }
}

在记忆中，那就是

ary2:
     DS 0
     DS 1
     DS 2
     DS 3
     DS 4
     DS 5
     DS 6
     DS 7

换句话说，只是另一个记忆。我们的循环成为

ix:   DS  0
jx:   DS  0
;; Now, the compiler helps us a little bit: it "remembers" that
;; the inner array is 4 long.  We'll keep that around as 'len'
len:  DS  4
ofst: DS  0   ; and we'll keep a convenient variable for the "offset"
;; here's out loop
loop1:
      CMP ix, 4
      JGE end1
loop2:
      CMP  jx, 4
      JGE  end2
;; I'm going to cheat here.  ASSUME I've got a little
;; routine that multiplies ix*len and puts it in offset
      MLTOFFSET  ix,len
      ADD  jx, ofst
;; so what this all did was make ofst == (ix*len)+jx
      PUSH ary2+ofst
      INC  jx
      JUMP loop2
end2:
      INC ix
      JUMP loop1
end1:

如果你走过那条路，你会发现ary2[ix][jx]变成了什么 ary2+0，ary2+1，ary2+2，... ary2+6，ary2+7 - 这些正是您制作一块内存所需的值< em> act 就像一个二维数组。

当然，同样的技巧可以根据您的需要进行多种维度;编译器必须“记住”步骤的大小。

Answer 4

因为你知道每个数组中的元素（即4），你可以很容易地构造出具有16个元素的更大的数组.... arr1，arr2，arr3，arr4和arr5（所有4个数组都将存储在其中）你可以遍历更大的数组，并填写更小数组的内容

arr5 - ＆gt; [4个元素] arr1 ---------- [4个元素] arr2 -------- [4个元素] arr3 ------- [4元素] arr4 ========== [16个元素]

for（i = 0; i＆lt; 16; i ++）//遍历更大的数组） {

//对于第一个数组，填充内容并递增i，这将填满更大的数组对于（j = 0; J＆LT; 4; J ++，我++） arr5 [I] = ARR1 [J]; 同样适用于其他阵列

}

有没有办法让一个数组在c中保存其他数组？

4 个答案: