数组名的意义

1. sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小。
2. &数组名，这里的数组名表示的是整个数组，取出的是整个数组的地址。
3. 除了上述两种情况之外，所有的数组名表示的都是数组首元素的地址。

Ⅰ 一维数组

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

printf("%zd\n", sizeof(a));			//16		
//sizeof(数组名)，计算的是整个数组的大小
	
printf("%zd\n", sizeof(a + 0));		//4/8	
//此处的 a + 0 表示数组首元素的地址，是地址就是 4/8 个字节
	
printf("%zd\n", sizeof(*a));		//4
//*a 中的 a 是数组首元素的地址，*a 就是对首元素的地址解引用;
//找到的就是首元素，首元素的大小就是 4 个字节
	
printf("%zd\n", sizeof(a + 1));		//4/8
//a + 1 表示数组第二个元素（2）的地址，所以计算结果是 4/8 个字节
	
printf("%zd\n", sizeof(a[1]));		//4
//计算第二个元素的大小
	
printf("%zd\n", sizeof(&a));		//4/8
//&a 取出的是整个数组的地址，数组的地址它还是个地址，是地址就是 4/8 个字节
	
printf("%zd\n", sizeof(*&a));		//16
//* 与 & 相互抵消，就成了 sizeof(a) 计算整个数组的大小
	
printf("%zd\n", sizeof(&a + 1));	//4/8
//&a 取出整个数组的地址，&a 的类型 是 int(*)[4];
//&a + 1是从数组 a 的地址向后，跳过了一个 4 个整型元素的数组的大小；
//&a + 1 还是地址，是地址就是 4/8 个字节
	
printf("%zd\n", sizeof(&a[0]));		//4/8
//计算的是第一个元素的地址
	
printf("%zd\n", sizeof(&a[0] + 1));	//4/8
//&a[0] + 1 是第二个元素的地址

Ⅱ 字符数组

题型 1

char arr[] = { 'a','b','c','d','e','f' };//整个数组 6 个元素

1. 用 sizeof 求结果

char arr[] = { 'a','b','c','d','e','f' };

printf("%zd\n", sizeof(arr));			//6
//整个数组的大小为 6 个字节

printf("%zd\n", sizeof(arr + 0));		//4/8
//不是 sizeof(单个数组名)这种情况，arr + 0 表示首元素地址，地址都是 4/8 个字节

printf("%zd\n", sizeof(*arr));			//1
//*arr 就是数组的首元素，大小事 1 字节

printf("%zd\n", sizeof(arr[1]));		//1
//计算的是数组第二个元素的大小，'b' 的大小为 1 字节

printf("%zd\n", sizeof(&arr));			//4/8
//计算整个数组的地址，是地址就是 4/8 字节

printf("%zd\n", sizeof(&arr + 1));		//4/8
//&arr + 1 指向了 'f' 的后面，但它还是个地址

printf("%zd\n", sizeof(&arr[0] + 1));	//4/8
//计算第二个元素的地址，地址的大小都是 4/8 个字节

2. 用 strlen 求结果

char arr[] = { 'a','b','c','d','e','f' };

printf("%d\n", strlen(arr));			随机值
//strlen 会计算 '\0' 之前有几个字符，arr 里面并没有 '\0'；
//strlen 会一直往后找 '\0'，直到碰巧碰到 '\0' 才停止工作。

printf("%d\n", strlen(arr + 0));		随机值
//arr 还是首元素地址，指向 'a'，这玩意不是 '\0'，strlen 自然要往后猛找 '\0'

printf("%d\n", strlen(*arr));			程序报错（野指针问题）
//站在 strlen 这个函数的角度看，传给它的都应该是地址，然而 *arr 是 'a'（97）；
//相当于 strlen(97)，把 97 作为一个地址传给 strlen，那肯定会出 BUG

printf("%d\n", strlen(arr[1]));			程序报错（野指针问题）
//和上面类似，相当于 strlen(98)，把 98 当做地址传给 strlen，不出 BUG 才有问题

printf("%d\n", strlen(&arr));			随机值
//数组的地址从 'a' 开始，还是没有 '\0'，strlen 又要吭哧吭哧往后找了

printf("%d\n", strlen(&arr + 1));		随机值 - 6
//传过去的地址指向 'f' 后面，从 'f' 后面开始往后找 '\0'，那必定是个随机值了。
//又因为是从 'f' 后面开始往后找，没有算入 arr 数组内的 6 个字符所以随机值会少 6

printf("%d\n", strlen(&arr[0] + 1));	随机值 -1
//从 'b' 的地址处开始往后找，没有算入 'a' 这一个字符的个数

题型 2

char arr[] = "abcdef";//这个数组有 a b c d e f \0 7 个元素

1. 用 sizeof 求结果

char arr[] = "abcdef";

printf("%zd\n", sizeof(arr));			//7
//'f' 的后面藏了个 '\0'，所以整个数组的大小是 7 个字节

printf("%zd\n", sizeof(arr + 0));		//4/8
//sizeof 内不是单个数组名这种情况，所以 arr + 0 表示的首元素的地址，地址就是 4/8 字节
printf("%zd\n", sizeof(*arr));			//1
//arr 是首元素地址，对首元素地址解引用就得到了 'a'，这个字符的大小就是 1 字节

printf("%zd\n", sizeof(arr[1]));		//1
//arr[1] 是字符 'b'，'b' 的大小位 1 字节

printf("%zd\n", sizeof(&arr));			//4/8
//这个数组的地址还是地址，是地址就是 4/8 字节

printf("%zd\n", sizeof(&arr + 1));		//4/8
//&arr + 1 指向了 '\0' 的后面，即使指向 '\0' 后面它还是个地址

printf("%zd\n", sizeof(&arr[0] + 1));	//4/8
//&arr[0] 是 a 的地址，a 的地址 + 1，成了 b 的地址，来来去去算的还是地址

2. 用 strlen 求结果

char arr[] = "abcdef";

printf("%d\n", strlen(arr));			//6
//这个数组里 '\f' 的后面就有 '\0' 了

printf("%d\n", strlen(arr + 0));		//6
//从首元素地址开始往后找 '\0'

printf("%d\n", strlen(*arr));			程序错误
//strlen(*arr) -> strlen ('a') -> strlen(97)，把 97 作为地址肯定出问题

printf("%d\n", strlen(arr[1]));			程序错误
//strlen(98)，将 98 作为地址传给 strlen

printf("%d\n", strlen(&arr));			//6
//&arr 整个数组的地址也是从 'a' 的地址开始的；
//还是传了 'a' 的地址给 strlen，往后找 '\0' 的结果是一样的

printf("%d\n", strlen(&arr + 1));		随机值
//从 '\0' 后面开始找 '\0'，那什么时候碰到 '\0' 就全看运气了

printf("%d\n", strlen(&arr[0] + 1));	//5
//从 'b' 开始往后找 '\0'

题型 3

char* p = "abcdef";//将常量字符串首字符 a 的地址赋给 p

1. 用 sizeof 求结果

char* p = "abcdef";

printf("%zd\n", sizeof(p));			//4/8
//p 是个指针，指针不管指向的是什么东西，指针本身的大小都是 4/8 字节

printf("%zd\n", sizeof(p + 1));		//4/8
//让指针 + 1 指向了 'b' ，p + 1 他还是个指针

printf("%zd\n", sizeof(*p));		//1
//计算 p 指向的字符 'a' 的大小

printf("%zd\n", sizeof(p[0]));		//1
//p[0] <--> *(p + 0) <--> *p

printf("%zd\n", sizeof(&p));		//4/8
//虽然是取出 p 的地址，相当于二级指针，二级指针也是个指针，

printf("%zd\n", sizeof(&p + 1));	//4/8
//&p + 1 还是个地址，不过这个地址指向了 '\0' 的后面

printf("%zd\n", sizeof(&p[0] + 1));	//4/8
//计算的是 'b' 的地址

2. 用 strlen 求结果

char* p = "abcdef";

printf("%d\n", strlen(p));			//6
//p 里存着的是 'a' 的地址，从 'a' 开始往后找 '\0'

printf("%d\n", strlen(p + 1));		//5
//p + 1 是 'b' 的地址，从 'b' 开始找 '\0'

printf("%d\n", strlen(*p));			程序错误
//*p == 'a'，strlen(*p) <--> strlen('a') <--> strlen(97)

printf("%d\n", strlen(p[0]));		程序错误
//p[0] <--> *p，和上面情况一样

printf("%d\n", strlen(&p));			随机值
//&p 是 p 本身的地址，和常量字符串的地址完全不是一码事，从 p 的地址开始往后随机找 '\0'

printf("%d\n", strlen(&p + 1));		随机值
//从 p 之后往后找 '\0'，

printf("%d\n", strlen(&p[0] + 1));	//5
//&p[0] + 1 指向 'b'，从 'b' 开始往后找 '\0'

Ⅲ 二维数组

int a[3][4] = { 0 };					//该二维数组有 12 个元素

int a[3][4] = { 0 };					//该二维数组有 12 个元素

printf("%zd\n", sizeof(a));				//48
//数组名单独放在 sizeof 内部，计算的是整个数组的大小，为 3 * 4 * 4 = 48 字节

printf("%zd\n", sizeof(a[0][0]));		//4
//计算第一行第一列的元素的大小，

printf("%zd\n", sizeof(a[0]));			//16
//a[0] 表示的是二维数组的第一行，第一行的大小为 4 * 4 = 16 个字节 

printf("%zd\n", sizeof(a[0] + 1));		//4/8
//此处的 a[0] 不是单独放在 sizeof 内部，此时 a[0] 表示的是首行首列的地址
//所以 a[0] + 1 <--> &a[0][0] + 1 <--> &a[0][1]，这玩意就是个地址

printf("%zd\n", sizeof(*(a[0] + 1)));	//4
//*(a[0] + 1) <--> *&a[0][1]，* 和 & 相互抵消，就是计算 a[0][1] 的大小

printf("%zd\n", sizeof(a + 1));			//4/8
//a 虽然是二维数组的地址，但是并没有单独放在 sizeof 内部，也没取地址；
//此时 a 表示首元素的地址，二维数组的首元素是它的第一行，a 就是第一行的地址；
//a + 1 就是跳过第 1 行，表示的是第二行的地址，是地址就是 4/8 字节

printf("%zd\n", sizeof(*(a + 1)));		//16
//对第二行的地址解引用，相当于访问整个第二行，第二行的大小当然是 16 个字节了

printf("%zd\n", sizeof(&a[0] + 1));		//4/8
//&a[0] 表示整个第一行的地址，&a[0] + 1 表示第二行的地址，与sizeof(a + 1) 等同

printf("%zd\n", sizeof(*(&a[0] + 1)));	//16
//对第二行的地址解引用，访问整个第二行，与 sizeof(*(a + 1)) 等同

printf("%zd\n", sizeof(*a));			//16
//a 没有单独放在 sizeof 内部，所以此时的 a 表示的是首元素（第一行）的地址
//*a 相当于访问整个第一行，第一行的大小为 4 * 4 = 16 字节

printf("%zd\n", sizeof(a[3]));			//16
//虽然第 4 行不存在，但第 4 行的类型和前 3 行也没什么区别；
//对于 sizeof 来说，只要知道类型就能计算大小，不会真的去访问越界得内容