1.一维数组

#include 
int main()
{
	int a[] = { 1,2,3,4 };
	printf(\"%d\\n\", sizeof(a));//1
	printf(\"%d\\n\", sizeof(a + 0));//2
	printf(\"%d\\n\", sizeof(*a));//3
	printf(\"%d\\n\", sizeof(a + 1));//4
	printf(\"%d\\n\", sizeof(a[1]));//5
	printf(\"%d\\n\", sizeof(&a));//6
	printf(\"%d\\n\", sizeof(*&a));//7
	printf(\"%d\\n\", sizeof(&a + 1));//8
	printf(\"%d\\n\", sizeof(&a[0]));//9
	printf(\"%d\\n\", sizeof(&a[0] + 1));//10
	return 0;
}

1.sizeof操作符内放数组名，表整个数组。数组大小为4(int类型)*4(数组大小)=16。

2.sizeof操作符内并不是单纯的数组名。故a表示数组首元素地址，首元素地址+0表首元素地址。故地址大小为4/8。

3.sizeof操作符内并不是单纯的数组名，故a表示数组首元素地址，首元素地址解引用得数组第一个元素整型数字1，故大小为4。

4.sizeof操作符内并不是单纯的数组名，故a表示数组首元素地址，首元素地址+1表数组第二个元素地址，故地址大小为4/8。

5.sizeof操作符内是数组第二个元素整型数字2，故大小为4。

6.sizeof操作符内放的是&a，即数组地址，故地址大小为4/8。

7.sizeof操作符内放的是*&a，表取出数组的地址并解引用，即表数组名，故表数组大小(int类型)*4(数组大小)=16。

8.sizeof操作符内放的是&a+1，表数组的地址往后跳一个数组的地址。故地址的大小为4/8。

9.sizeof操作符内放的是&a[0]，表取出数组首元素的地址，故地址大小为4/8。

10.sizeof操作符内放的是&a[0]+1，表取出数组首元素的地址，并向后跳一个整型大小的地址，故地址大小为4/8。

输出：

2.字符数组一

#include 
#include 
int main()
{
	char arr[] = { \'a\',\'b\',\'c\',\'d\',\'e\',\'f\' };
	printf(\"%d\\n\", sizeof(arr));//1
	printf(\"%d\\n\", sizeof(arr + 0));//2
	printf(\"%d\\n\", sizeof(*arr));//3
	printf(\"%d\\n\", sizeof(arr[1]));//4
	printf(\"%d\\n\", sizeof(&arr));//5
	printf(\"%d\\n\", sizeof(&arr + 1));//6;
	printf(\"%d\\n\", sizeof(&arr[0] + 1));//7
	printf(\"%d\\n\", strlen(arr));//8
	printf(\"%d\\n\", strlen(arr + 0));//9
	printf(\"%d\\n\", strlen(*arr));//10
	printf(\"%d\\n\", strlen(arr[1]));//11
	printf(\"%d\\n\", strlen(&arr));//12
	printf(\"%d\\n\", strlen(&arr + 1));//13
	printf(\"%d\\n\", strlen(&arr[0] + 1));//14
	return 0;
}

1.sizeof操作符内单独放数组名，表整个数组，故大小为1(char类型)*6(数组大小)=6。

2.sizeof操作符内放的是arr+0，表首元素地址，故地址大小为4/8。

3.sizeof操作符内放的是*arr，表首元素地址解引用得数组首元素字符型元素\'a\',故大小为1。

4.sizeof操作符内放的是arr[0],表数组首元素字符型元素\'a\'，故大小为1。 

5.sizeof操作符内放的是&arr,表整个数组的地址，故地址大小为4/8。

6.sizeof操作符内放的是&arr+1，表整个数组的地址再向后跳一个数组的地址，故地址大小为4/8。

7.sizeof操作符内放的是&arr[0]+1，表取数组首元素地址在往后跳一个字符类型的地址，故地址大小为4/8。

8.strlen函数内放的是arr，表数组首元素地址，strlen函数会一直往后寻找\'\\0\'便停止，但此数组并没有\'\\0\'，故strle的返回值是一个随机值。

9.strlen函数内放的是arr+0，表数组首元素地址，与8同理，函数的返回值也是一个随机值。

10.strlen函数内放的是*arr，表数组首元素地址解引用，得到字符\'a\'，但因字符\'a\'的ASCLL码为97，故strlen会把97当成地址，所以此处会报错。

11.strlen函数内放的是arr[1]，表数组第二个元素地址解引用，与10同理，此处也会报错。

12.strlen函数内放的是&arr，表整个数组的地址，strlen会以这个地址为基准向后寻找\'\\0\'，但因没有\'\\0\'的具体位置，所以strlen函数的返回值也是一个随机值。

13.与12同理，函数的返回值也是一个随机值。

14.strlen函数内放的是&arr[0]+1，表取出数组首元素地址并往后跳一个字符类型大小的地址，以此地址为基准向后寻找\'\\0\'，但因数组内没有\'\\0\'，所以函数返回值会是随机值。

当没有注释掉错误的两条语句时：

 当注释掉两条错误的语句时：

2.2字符数组二

#include 
#include 
int main()
{
	char arr[] = \"abcdef\";
	printf(\"%d\\n\", sizeof(arr));//1
	printf(\"%d\\n\", sizeof(arr + 0));//2
	printf(\"%d\\n\", sizeof(*arr));//3
	printf(\"%d\\n\", sizeof(arr[1]));//4
	printf(\"%d\\n\", sizeof(&arr));//5
	printf(\"%d\\n\", sizeof(&arr + 1));//6
	printf(\"%d\\n\", sizeof(&arr[0] + 1));//7
	printf(\"%d\\n\", strlen(arr));//8
	printf(\"%d\\n\", strlen(arr + 0));//9
	printf(\"%d\\n\", strlen(*arr));//10
	printf(\"%d\\n\", strlen(arr[1]));//11
	printf(\"%d\\n\", strlen(&arr));//12
	printf(\"%d\\n\", strlen(&arr + 1));//13
	printf(\"%d\\n\", strlen(&arr[0] + 1));//14
	return 0;
}

1.sizeof操作符内放的是arr，表整个数组，数组内存放的是字符串常量，所以为包含\'\\0\'，故大小为7.

2.与1同理，大小也为7。

3.sizeof操作符内放的是*arr，表数组首元素地址解引用，得到字符\'a\'，故大小为1(字符类型)。

4.sizeof操作符内放的是arr[1]，表数组第二个元素字符\'b\'，故大小为1(字符类型)。

5.sizeof操作符内放的是&arr，表取整个数组的地址，故地址大小为4/8。

6.sizeof操作符放的是&arr+1，表取整个数组的地址并向后跳一个数组大小的地址，故地址大小为4/8。

7.sizeof操作符内放的是&arr[0]+1，表取数组首元素地址并向后跳一个字符类型大小的地址，故地址大小为4/8。

8.strlen函数内放的是arr，表数组首元素地址，并以此地址为基准向后寻找\'\\0\'，因为数组存放的是字符串常量包含\'\\0\'，故函数的返回值为6。

9.与8同理，函数的返回值也是6。

10.strlen函数内放的是*arr，表数组首元素字符\'a\'，此处会引发错误。

11.与10同理此处也会引发错误。

12.strlen函数内放的&arr，表取整个数组的地址，但因数组的地址以首元素地址表示，并在strlen函数中会把数组指针强制类型转换为字符指针，故函数的返回值为6。

13.与12同理，函数也会返回一个随机值。

14.strlen函数内放的是&arr[0]+1，表取数组首元素地址并向后跳一个字符类型大小的地址，并以此地址为基准向后寻找\'\\0\'，故函数的返回值为5。

 当没有注释掉错误的两条语句时：

 当注释掉两条错误的语句时：

 2.3字符数组三

#include 
#include 
int main()
{
	char* p = \"abcdef\";
	printf(\"%d\\n\", sizeof(p));//1
	printf(\"%d\\n\", sizeof(p + 1));//2
	printf(\"%d\\n\", sizeof(*p));//3
	printf(\"%d\\n\", sizeof(p[0]));//4
	printf(\"%d\\n\", sizeof(&p));//5
	printf(\"%d\\n\", sizeof(&p + 1));//6
	printf(\"%d\\n\", sizeof(&p[0] + 1));//7
	printf(\"%d\\n\", strlen(p));//8
	printf(\"%d\\n\", strlen(p + 1));//9
	printf(\"%d\\n\", strlen(*p));//10
	printf(\"%d\\n\", strlen(p[0]));//11
	printf(\"%d\\n\", strlen(&p));//12
	printf(\"%d\\n\", strlen(&p + 1));//13
	printf(\"%d\\n\", strlen(&p[0] + 1));//14
	return 0;
}

1.sizeof操作符内放的是指针变量p，故指针的大小为4/8。

2.sizeof操作符内放的是p+1，表第二个元素\'b\'的地址，故地址大小为4/8。

3.sizeof操作符内放的是*p，表第一个元素‘a’，故大小为1(字符类型)。

4.sizeof操作符内放的是p[0]，表第一个元素\'a\'，故大小为1(字符类型)。

5.sizeof操作符内放的是&p，表对指针变量p取地址，故地址大小为4/8。

6.sizeof操作符内放的是&p+1，表对指针变量p取地址并向后跳一个字符类型大小的地址，故地址大小为4/8。

7.sizeof操作符内放的是&p[0]+1，表对元素\'a\'取地址并向后向一个字符类型的地址，即\'b\'的地址，故地址大小为4/8。

8.strlen函数内放的是p，表\'a\'的地址，并以此地址为基准向后寻找\'\\0\'，故函数的返回值为6。

9.strlen函数内放的是p+1，表元素\'b\'的地址，并以此地址为基准向后寻炸\'\\0\'，故函数的返回值为5。

10.strlen函数内放的是*p，表元素\'a\'，故这里会发生错误。

11.与10同理，此处也会发生错误。

12.strlen函数内放的是&p，表取整个数组的地址，但在strlen函数中会把数组指针强制类型转换为字符指针，并向后寻找\'\\0\'，故函数的返回值为6。

13.strlen函数内放的是&p+1，表整个数组的地址并向后跳一个数组大小的地址，因无准确的\'\\0\'位置，故函数返回一个随机值。

14.strlen函数内放的是&p[0]+1，表对元素\'a\'取地址并向后跳一个字符类型大小的地址，即\'b\'的地址，并以此地址为基准向后寻找\'\\0\'，故函数的返回值为5。

当没有注释掉错误的两条语句时：

  当注释掉两条错误的语句时：

3.二维数组

#include 
#include 
int main()
{
	int a[3][4] = { 0 };
	printf(\"%d\\n\", sizeof(a));//1
	printf(\"%d\\n\", sizeof(a[0][0]));//2
	printf(\"%d\\n\", sizeof(a[0]));//3
	printf(\"%d\\n\", sizeof(a[0] + 1));//4
	printf(\"%d\\n\", sizeof(*(a[0] + 1)));//5
	printf(\"%d\\n\", sizeof(a + 1));//6
	printf(\"%d\\n\", sizeof(*(a + 1)));//7
	printf(\"%d\\n\", sizeof(&a[0] + 1));//8
	printf(\"%d\\n\", sizeof(*(&a[0] + 1)));//9
	printf(\"%d\\n\", sizeof(*a));//10
	printf(\"%d\\n\", sizeof(a[3]));//11
	return 0;
}

1.sizeof操作符内放的是a，表整个数组的大小，故大小为3*4(数组元素个数)*4(整型类型)=48。

2.sizeof操作符内放的是a[0][0]，表二维数组的第一个数组元素的第一个元素，故大小为4。

3.sizeof操作符内放的是a[0]，表二维数组的第一个数组元素，故大小为4(元素个数)*4(整型类型)=16。

4.sizeof操作符内放的是a[0]+1，表二维数组的第一个数组元素的第一个元素的地址，故大小为4/8。

 5.sizeof操作符内放的是*(a[0]+1)，此表达式可转换为*(*(a+0)+1)，表二维数组的第一个数组元素的第二个元素，故大小为4。

6.sizeof操作符内放的是a+1，表二维数组首元素地址并向后跳一个数组元素大小的地址，故地址大小为4/8。

7.sizeof操作符内放的是*(a+1)，表二维数组首元素地址并向后跳一个数组元素大小的地址的解引用，即得到二维数组的第二个数组元素，故大小为4(元素个数)*4(整型类型)=16。

8.sizeof操作符内放的是&a[0]+1,表取二维数组的第一个数组元素的地址并向后跳一个数组元素大小的地址，故地址大小为4/8。

9.sizeof操作符内放的是*(&a[0]+1)，表取二维数组的第一个数组元素的地址并向后跳一个数组元素大小的地址并解引用，即得到二维数组的第二个数组元素，故大小为4(元素个数)*4(整型类型)=16。

10.sizeof操作符内放的是*a，表对二维数组的第一个数组元素解引用，故大小为4(元素个数)*4(整型类型)=16。

11.sizeof操作符内放的是a[3]，表二维数组的第四个数组元素，但二维数组没有第四个数组元素，但有第四个数组元素的类型，故大小也为4(元素个数)*4(整型类型)=16。

输出：