sizeof下数组名的各种形式的大小及原因

一维数组

一维数组int a[4] = {0}:

1. 上面的一维数组有4个元素，分别为：a[0], a[1], a[2], a[3]
2. 数组名a表示的数组的首元素的地址， 即&a[0], 类型为int *
3. &a 表示的是数组的地址， 即&a+1 跳过整个数组。
4. 数组中的地址关系如下：
   a = &a[0];
   a + 1 = &a[1];
   a + 2 = &a[2];
   a + 3 = &a[4]

int main()
{
	int a[4] = {1, 2, 3, 4};
	printf("%d\n", sizeof(a));  //16   a是数组名，在sizeof中表示的是整个数组的地址
	printf("%d\n", sizeof(a+0));  //4/8    a + 0 后，则a表示的就是首元素地址，是个指针，指针的大小为4（32bit)或者8（64bit)
	printf("%d\n", sizeof(*a));   //4     *a 表示的是a[0], 类型是int 占用4个byte
	printf("%d\n", sizeof(a+1));   //4/8     a +1 中过的a是首元素地址，加1后，则是指向第二个元素的地址，也是个指针，指针的大小为4（32bit)或者8（64bit)
	printf("%d\n", sizeof(a [1]));  //4   a[1]表示数组的第二个元素，其类型为int，占4个字节
	printf("%d\n", sizeof(&a)); //4/8   &a 表示的是数组地址，也是个指针，指针的大小为4（32bit)或者8（64bit)
	printf("%d\n", sizeof(*&a));  //16   &a解引用后，即*&a为数组名a
	printf("%d\n", sizeof(&a+1));  //4/8  &a是地址，加1后，也就是跳过整个数组，但是它也是指针，大小依然是4/8
	printf("%d\n", sizeof(&a[0]));   //4/8  &a[0]表示数组首元素的地址，也是个指针，大小为4/8
	printf("%d\n", sizeof(&a[0] + 1));  //4/8  &a[0]表示数组首元素的地址，加1后为第二个元素的地址，但也是个指针，大小为4/8
}

运行结果如下：

16
4
4
4
4
4
16
4
4
4

二维数组

二维数组 int arr[3][4] = {0};

1. 上面的二维数组的数组名arr表示的是二维数组的首元素地址，在sizeof(arr)中可获取整个二维数组的大小，即3(行）* 4(列）* 4(int 类型）= 48；

2. 二维数组可以分为三个一维数组(即二维数组的3个元素），即第一行arr[0], 第二行arr[1], 第三行arr[2], 而第一行arr[0]为首元素，所以arr也表示第一行一维数组arr[0]的数组地址。

3. 这就类似于一维数组a[3] ,有三个元素a[0], a[1], a[2], 只不过二维数组arr[3][4]的元素是三个一维数组arr[0], arr[1], arr[2]。 一维数组的数组名a表示首元素a[0]的地址，二维数组arr[3][4]数组名arr表示首元素arr0的地址。

4. &arr 表示的是二维数组的地址， 即&arr+1 跳过整个二维数组。

5. 类似于一维数组，二维数组中的地址关系如下：
   arr = &arr[0];
   arr + 1 = &arr[1]
   arr + 2 = &arr[2]

6. 二维数组中的三个一维数组分别为arr[0], arr[1], arr[2], 而arr[0], arr[1], arr[2] 又分别为这三个一维数组的数组名，即分别为这三个一维数组的首元素地址，而这三个一维数组的首元素分别为arr[0][0], arr[1][0], arr[2][0], 其地址关系如下：
   arr[0] = &arr[0][0]; arr[0] + 1 = &arr[0][1]; arr[0] + 2 = &arr[0][2]; arr[0] +3 = &arr[0][3];
   arr[1] = &arr[1][0]; arr[1] + 1 = &arr[1][1]; arr[1] + 2= &arr[1][2]; arr[1] +3 = &arr[1][3];
   arr[2] = &arr[2][0]; arr[2] + 1 = &arr[2][1]; arr[2] + 2= &arr[2][2]; arr[2] +3 = &arr[2][3];

7. 因为arr[0], arr[1], arr[2] 分别为第一行，第二行，第三行的数组名，所以sizeof(arr[0])为第一行整个一维数组的大小，即4(元素个数)*4 （int类型）= 16；sizeof(arr[1]) 和sizeof(arr[2])也都为16；

int main()
{
	int arr[3][4] = { 0 };

	printf("%d\n", sizeof(arr));   //48   arr是数组名，表示整个二维数组的地址
	printf("%d\n", sizeof(arr[0][0]));  //4  arr[0][0]是第一行第一列的元素， 类型为int 占用4个字节
	printf("%d\n", sizeof(arr[0]));    //16   arr[0]表示第一行的数组地址，即第一行的数组名  arr[0]单独放在sizeof中表示的是第一行的整个一维数组
	printf("%d\n", sizeof(arr[0] + 1));   // 4/8     arr[0]没有单独放在sizeof中，所以它部表示第一行整个一维数组的地址， 所以arr[0]+1 表示第一行的第二个元素arr[0][1]的地址， 即为指针
	printf("%d\n", sizeof(*(arr[0] + 1)));   // 4   *(arr[0] + 1)表示第一行的第二个元素，类型为int， 占用4个字节
	printf("%d\n", sizeof(arr + 1));  //4/8   arr虽然是二维数组的地址，但是它并没有单独放到sizeof中，也没有取地址，所以arr表示的是第一行的地址，arr+1表示第二行的地址，即为指针
	printf("%d\n", sizeof(*(arr + 1)));  //16    *(arr+1) 表示的是arr[1], 而arr[1]是第二行的数组名，所以取的是整个第二行的大小
	printf("%d\n", sizeof(&arr[0] + 1));  //4/8   &arr[0] 对第一行的数组名取地址，表示的是第一行的地址，而&arr[0]+1表示的是第二行的地址，既是指针
	printf("%d\n", sizeof(*(&arr[0] + 1)));  //16   &arr[0]+1 取的是第二行的数组地址，即&arr[1] , *(&arr[1])即为arr[1], 是第二行的数组名，所以取得是整个第二行数组的大小
	printf("%d\n", sizeof(*arr));  // 16    arr表示首元素的地址，即第一行的数组地址&arr[0] , *arr即为arr[0], 也就是第一行的数组名，所以取得是整个第一行数组的大小
	printf("%d\n", sizeof(arr[3]));  //16   arr[3]是第四行的数组名，虽然不存在，但是其类型依然是占有整个一行地内存空间
}

执行结果如下：

48
4
16
4
4
4
16
4
16
16
16