C语言中二维数组以及多维数组往往令C的初学者迷惑不已 (也包括我)。本文中搜集了各位大神资料中的讲解，小小的对二维数组的用法总结了下，希望对C的初学者有所帮助。高手请直接忽略
二维数组的定义
DataType arrayName[len0][len1];其中，DataType为数据类型，len0为第一维下标长度，len1为第二维下标长度。
可以把二维数组看成一个矩阵，则len0是行的个数，len1是列的个数。
整个数据中的长度是 sizeof(Datatype)*len0*len1。
内存排布上，按行排列，即放完一行后再放第二行。示例：int a[2][3]的内存排布如下;
| a[0][0] | a[0][1] | a[0][2] | a[1][0] | a[1][1] | a[1][2] |
二维数组的元素访问
1. 最简单的方式直接采用变量名+中括号方式: a[x][y]；
2. 指针方式：
1) 通过定义一维指针指向数组的首地址，转换为一维指针的访问
int a[2][3] = {{1,2,3},{4,5,6}};
int *p = &a[0][0];
printf("%d",*(p+1*3+2)); /* 对应a[1][2]:6*/2) 二维数组可以看作是由一维数组嵌套而成的；二维数组a[2][3]可分解为二个一维数组，它们的数组首地址分别为 a[0]、a[1]，类型为Int *。 如下示例：
int a[2][3] = {{1,2,3},{4,5,6}};
int *p = a[1];
printf("%d",p[1]); /* 对应a[1][1]:5*/3) 定义一个int(*)[len1]指针指向数组首元素
int a[2][3] = {{1,2,3},{4,5,6}};
int (*p)[3] = a;
printf("%d",p[1][2]); /* 对应a[1][2]:6*/注意：
a. a[2][3]中，数值名a的类型是个指针 int(*)[3]。
b. int *p[3] 和 int (*p)[3]是不一样的。
前者是定义了一个指针数组，数组长度为3，数组中的元素是指向int类型的指针；
后者是定义了一个指向数组的指针，该指针指向一个长度为3的数组。后者p+1会整体偏移一个数组长度。如上例中： int (*p)[3] = a后， p指向a[0][0]地址，p+1则指向a[1][0]地址。
| p指向 | a[0][0] | a[0][1] | a[0][2] |
| p+1指向 | a[1][0] | a[1][1] | a[1][2] |
二维数组的初始化
二维数组的初始化存在如下几种形式：
1. 用{}分段初始化
int a[2][3] = {{1,2,3},{3,4,5}};大括号包含的元素个数如果超过维度的话，会编译报错
//err： int a[2][3] = {{1,2},{3,4,5}，{1}};
//err: int a[2][3] = {{1,2},{3,4,5,6}}; 2. 按照1维数组方式初始化
int a[2][3] = {1,2,3,3,4,5};3. 部分初始化：未赋值的元素的值为0
int a[2][3] = {{1,2},{3,4}};
/* the value of a:
1 2 0
3 4 0 */
int b[2][4] = {1,2,3,4,5};
/* the value of b:
1 2 3 4
5 0 0 0 */4. 分段初始化时第一个维度可以不用给。按照1维数组方式初始化时，如果对全部元素赋值，第一个维度可以不用给。
例如
int a[][3] = {{1,2,3},{3,4,5}}; //与a[2][3]是一样的
int a[2][3] = {{1,2},{3,4}}; //与a[2][3]是一样的
int a[][3] = {1,2,3,3,4,5}; //与a[2][3]是一样的—小小吐槽一下：C的这种灵活性 让纠结于“回"字的几种写法 的人 大呼过瘾
二维数组作为函数入参
三种方式：
1. 数组名：数组名[.] [.]。第一个维度可以省略。
函数如果sizof(数组名）,会按照指针类型int （*)[]返回大小。一般的，32位返回4，64位返回8。
void Output1(int a[2][3]) /*行数可以省略，a[][3]也是一样的*/
{
a[1][2] = 3;
printf("%d\n",a[1][2]); /* 对应a[1][2]:3*/
}
int main()
{
int a[2][3] = {{1,2,3},{4,5,6}};
Output1(a);
printf("%d\n",a[1][2]); /* a[1][2]已修改:3*/
return 0;
}2. 数组指针：数组指针, 入参的类型与第一种实际上是一致的。
void Output2(int (*a)[3])
{
a[1][2] = 3;
printf("%d",a[1][2]); /* 对应a[1][2]:3*/
}
int main()
{
int a[2][3] = {{1,2,3},{4,5,6}};
Output2(a);
printf("%d\n",a[1][2]); /* 对应a[1][2]:3*/
return 0;
}3. 二维指针：二维指针，一般需要对该二维指针赋值
a. 指针数组
int Output3(int** p, int line, int column)
{
p[1][2] = 3;
}
int main()
{
int a[2][3] = {{1,2,3},{4,5,6}};
int *p[3];
for (int i = 0; i < 2; i++) {
p[i] = a[i];
}
Output3(p,2,3);
printf("%d\n",a[1][2]); /* 对应a[1][2]:3*/
return 0;
}b. 配合动态内存申请
int Output3(int** p, int line, int column)
{
p[1][2] = 3;
}
#define ROW 2
#define COL 3
int main()
{
int a[ROW][COL] = {{1,2,3},{4,5,6}};
int **p;
p = (int**) malloc (ROW*sizeof(int*));
for (int i = 0; i < ROW; i++) {
p[i] = a[i];
}
Output3(p,ROW,COL);
free(p);
printf("%d\n",a[1][2]); /* 对应a[1][2]:3*/
return 0;
}二维数组的动态内存申请
二维数组采用动态内存申请方式，可以不同在定义时就固定行和列。
二维数组[ROW][COL]的动态内存申请：实际上是先申请一个维度为ROW的指针数组，然后再将指针数组的每一个元素指向一个维度为COL的一维数组。
这种方式下，数组的每一行和每一行之间在内存上已经不是地址连续的了！
#define ROW 2
#define COL 3
int main()
{
int **array;
array = (int**) malloc (ROW*sizeof(int*));
for (int i = 0; i < ROW; i++) {
array[i] = (int*) malloc(COL*sizeof(int));
}
array[1][2] = 3;
printf("%d\n",array[1][2]); /* 对应a[1][2]:3*/
for (int i = 0; i < ROW; i++) {
free(array[i]);
}
free(array);
return 0;
}
注意：malloc和free实际上都需要2个步骤，第一个是指针数组的，第二个是每个指针数组指向的一维数组。特别是free时。
二维数组的qsort使用
对于数组方式array[][]和malloc出来的二维数组的方式有区别
动态malloc出来的二维数组
这也是笔者在刷leetcode时碰到的问题
/*from leetcode 56. 合并区间*/
int cmpare(const void *a, const void *b) {
int *ap = *(int **)a;
int *bp = *(int **)b;
if(ap[0] == bp[0]) {
return ap[1] - bp[1];
}
else {
return ap[0] - bp[0];
}
}
/**
* Return an array of arrays of size *returnSize.
* The sizes of the arrays are returned as *returnColumnSizes array.
* Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
*/
int** merge(int** intervals, int intervalsSize, int* intervalsColSize, int* returnSize,
int** returnColumnSizes) {
if (intervals == NULL || intervalsSize == 0) {
*returnSize = 0;
return NULL;
}
qsort(intervals, intervalsSize, sizeof(intervals[0]), cmpare);
/*后面代码就不贴了*/
}
静态定义方式的二维数组
#include <stdlib.h>
int cmp(const void *a, const void *b) {
int *ap = (int *)a;
int *bp = (int *)b;
if(ap[0] == bp[0]) {
return ap[1] - bp[1];
}
else {
return ap[0] - bp[0];
}
}
int main()
{
int a[3][2] = {{2,3},{2,4},{1,2}};
printf("%d\n",sizeof(a[0]));
qsort(a,3, sizeof(a[0]), cmp);
for(int i = 0; i < 3; i++) {
for(int j = 0; j < 2; j++) {
printf("%d ", a[i][j]);
}
printf("\n");
}
return 0;
}处理方式有区别的原因
第一个例子中：
intverals[0]是个指向一维数组的指针，sizeof(intverval[0]) = sizeof(int*) = 8 or 4;
cmpare传递的是intverals[i]的地址，类型是int**，取指向的一维数组的指针需要*(int**)
？qsort调整的是指针数组的位置？
第二个例子中:
第一个入参int（*）[3]。第三个入参中：size[0]是个一维数组，sizeof(a[0]) = 2*sizeof(int) = 8;
cmp传入的直接是一维数组的地址，类型为int *
2418
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
