一、二维数组元素由其行、列下标决定

以float a[3][4];为例：

1.引用a[2][3] — 行、列下标均是整数

2.引用a[2-1][2*2-1] — 行、列下标可以是整型表达式

3.a[1][2]=3.14/2; — 数组元素作为赋值表达式的左值

4.a[3][4]=15; — 错误！最后一个元素是a[2][3],“越界”

二、输入输出二维数组元素

1.二维数组行序优先输出

#include <stdio.h>
int main()
{
	int a[3][5]; //定义3行5列的二维数组
	int i; //循环中用于记录行数变化
	int j; //循环中用于记录列数变化
	
	//嵌套循环方式输入数组元素
	for (i = 0; i < 3; ++i) 
	{
		for (j = 0; j < 5; ++j)
		{
			scanf_s("%d", &a[i][j]);
		}
	}
	//嵌套循环方式输出数组元素：常规操作
	for (i = 0; i < 3; ++i)
	{
		for (j = 0; j < 5; ++j)
		{
			printf("%d\t", a[i][j]);
		}
		putchar('\n');
	}
}
运行结果：
85 78 99 96 88
76 89 75 97 74
64 92 90 73 56
85      78      99      96      88
76      89      75      97      74
64      92      90      73      56

2.二维数组列序优先输出

#include <stdio.h>
int main()
{
	int a[3][5];
	int i;
	int j;
	for (i = 0; i < 3; ++i)
	{
		for (j = 0; j < 5; ++j)
		{
			scanf_s("%d", &a[i][j]);
		}
	}
	//循环嵌套方式输出数组元素：列序优先
	for (i = 0; i < 5; ++i)
	{
		for (j = 0; j < 3; ++j)
		{
			printf("%d\t", a[j][i]); //注意i,j顺序
		}
		putchar('\n');
	}
}
运行结果：
85 78 99 96 88
76 89 75 97 74
64 92 90 73 56
85      76      64
78      89      92
99      75      90
96      97      73
88      74      56

3.二维数组元素倒序输出

#include <stdio.h>
int main()
{
	int a[3][5];
	int i;
	int j;
	for (i = 0; i < 3; ++i)
	{
		for (j = 0; j < 5; ++j)
		{
			scanf_s("%d", &a[i][j]);
		}
	}
	for (i = 2; i >=0; --i)
	{
		for (j = 4; j >=0; --j)
		{
			printf("%d\t", a[i][j]);
		}
		putchar('\n');
	}
}
运行结果：
85 78 99 96 88
76 89 75 97 74
64 92 90 73 56
56      73      90      92      64
74      97      75      89      76
88      96      99      78      85

三、实例：二维数组行列互换后存入另一个二维数组

#include <stdio.h>
int main()
{
	int a[2][3] ={{1,2,3},{4,5,6}};
	int b[3][2];
	int i;
	int j;
	printf("array a: \n");
	for (i = 0; i < 2; ++i)
	{
		for (j = 0; j < 3; ++j)
		{
			printf("%d\t", a[i][j]);
		}
		putchar('\n');
	}
	for (i = 0; i < 2; ++i)
	{
		for (j = 0; j < 3; ++j)
		{
			b[j][i] = a[i][j];
		}
	}
	printf("array b: \n");
	for (i = 0; i < 3; ++i)
	{
		for (j = 0; j < 2; ++j)
		{
			printf("%d\t", b[i][j]);
		}
		putchar('\n');
	}
}
运行结果：
array a:
1       2       3
4       5       6
array b:
1       4
2       5
3       6

二维数组元素指针引用

1.定义
2.数组指针和指针数组的区别
1.二维数组可以理解为是一个一维数组，不过每个数组元素又是一个一维数组
int a[2][3]={{1,2,3},{4,5,6}};
可以理解为，二维数组只有两个元素，即a[0]和a[1]，只不过元素类型为一维数组
指向二维数组的指针（行指针）
格式：类型 (*指针名) [N]
N为数组的第二维长度

2.二维数组指针与指针型数组的区别

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

int *p0[3] = a;    //错误，将一个二维数组赋给指针型数组

int(*p1)[3] = a;   //正确

数组指针（也称行指针）
定义 int (*p)[n];
()优先级高，首先说明p是一个指针，指向一个整型的一维数组，这个一维数组的长度是n，也可以说是p的步长。也就是说执行p+1时，p要跨过n个整型数据的长度。

如要将**二维数组**赋给一指针，应这样赋值：
int a[3][4];
int (*p)[4]; //该语句是定义一个数组指针，指向含4个元素的一维数组。
 p=a;        //将该二维数组的首地址赋给p，也就是a[0]或&a[0][0]
 p++;       //该语句执行过后，也就是p=p+1;p跨过行a[0][]指向了行a[1][  ]

比如要表示数组中i行j列一个元素：

*(p[i]+j)、*(*(p+i)+j)、(*(p+i))[j]、p[i][j]

优先级：()>[]>*
出处：
https://www.cnblogs.com/hongcha717/archive/2010/10/24/1859780.html

3.实现一个3*4阶矩阵转置 指针为形参

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<stdlib.h>
//定义一个3行4列的二维数组arr。
//定义一个函数func()完成矩阵转置，以数组指针作为参数。
//在func()函数内部，使用for循环完成矩阵转置
void func(int(*pa)[4], int(*pb)[3], int x, int y)
{
    int i, j;
    /*-------------------------begin------------------*/
    for(i=0;i<x;i++)
       for(j=0;j<y;j++){      	
       	 *(pb[j]+i)=*(pa[i]+j);
       	 // *(*(pb+j)+i)=*(*(pa+i)+j);
       	 // pb[j][i]=pa[i][j];
       	 // (*(pb+j))[i]=(*(pa+i))[j];
	   }
    /*--------------------------end-------------------*/
    printf("转置：\n");
    for (i = 0; i < y; i++)
    {
        for (j = 0; j < x; j++)
        {
            printf("%d\t", pb[i][j]);
        }
        printf("\n");
    }
}
int main()
{
    int i, j;
    int arr[3][4], brr[4][3];
    printf("输入二维数组的元素：\n");
    for (i = 0; i < 3; i++)
    {
        for (j = 0; j < 4; j++)
        {
            scanf("%d", &arr[i][j]);
        }
    }
    func(arr,brr,3,4);
    return 0;
}

另有:

数组元素访问 方法总结