进阶指针(3)——指针与数组笔试题的解析
在讲解之前我们先回顾一下，以下将要涉及的重要知识点：
1、数组名是什么？
①sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节；
②&数组名，这里的数组名表示整个数组，取出的是整个数组的地址；
③除此之外，所有的数组名都是数组首元素的地址。
2、sizeof
①sizeof是关键字(如变量名不能和关键字一样)也是操作符(功能:计算操作数的类型长度)；
②sizeof的特点：sizeof内部的表达式是不计算的；
③sizeof不是函数，因为函数调用的时候，要写括号，但是sizeof后边的括号可以省略(注:变量名可以，类型不可以)。
④sizeof的计算结果是无符号的整形unsigned int。
3、strlen
①strlen是C语言提供的库函数，可以计算字符串的长度，统计的是'\0'之前的字符个数。
②函数原型：size_t strlen(const char *str)，从中我们可知strlen的参数是一个地址，返回类型是无符号的整形。
总结：
①除了两种特殊情况数组名单独放在sizeof()里和&数组名，其他情况数组名都表示数组的首元素地址。
②sizeof作为操作符：计算的是操作数的类型长度，sizeof内部的表达式是不计算的。
③strlen的形参是一个地址，所以实参也要是地址。
接下来我们开始练习：
一维数组
分析代码运行后的结果：
1、整形数组
（1）sizeof——计算的是操作数的类型大小，单位字节
#include
int main()
{
int a[] = { 1,2,3,4 };
printf("%d\n", sizeof(a));
printf("%d\n", sizeof(a + 0));
printf("%d\n", sizeof(*a));
printf("%d\n", sizeof(a + 1));
printf("%d\n", sizeof(a[1]));
printf("%d\n", sizeof(&a));
printf("%d\n", sizeof(*&a));
printf("%d\n", sizeof(&a + 1));
printf("%d\n", sizeof(&a[0]));
printf("%d\n", sizeof(&a[0] + 1));
return 0;
}
答案分析：
#include
int main()
{
int a[] = { 1,2,3,4 };
printf("%d\n", sizeof(a));//16字节，单独的数组名，计算的是整个数组的大小
printf("%d\n", sizeof(a + 0));//4/8字节，不是单独的数组名，a+0是首元素的地址
printf("%d\n", sizeof(*a));//4字节，*a相当于a[0]，计算的是首元素的大小
printf("%d\n", sizeof(a + 1));//4/8字节，不是单独的数组名，a+1是第二个元素的地址
printf("%d\n", sizeof(a[1]));//4字节，a[1]是第二个元素，计算的是第二个元素的大小
printf("%d\n", sizeof(&a));//4/8字节，&数组名，取的是整个数组的地址，类型是数组指针int (*)[4]
printf("%d\n", sizeof(*&a));//16个字节，&数组名，取出整个数组的地址，解引用得到整个数组(*&a<-->a)
printf("%d\n", sizeof(&a + 1));//4/8字节,&a+1跳过整个数组，还是数组指针(不管是否越界，只操作数关注类型)
printf("%d\n", sizeof(&a[0]));//4/8字节，&a[0]取的是第一个元素的地址
printf("%d\n", sizeof(&a[0] + 1));//4/8字节，&a[0]+1是第二个元素的地址
return 0;
} 2.字符数组
情景1：
例如：char arr[] = {'a','b','c','d','e','f'};
（1）sizeof——计算的是操作数的类型大小
#include
int main()
{
char arr[] = {'a','b','c','d','e','f'};
printf("%d\n", sizeof(arr));
printf("%d\n", sizeof(arr+0));
printf("%d\n", sizeof(*arr));
printf("%d\n", sizeof(arr[1]));
printf("%d\n", sizeof(&arr));
printf("%d\n", sizeof(&arr+1));
printf("%d\n", sizeof(&arr[0]+1));
return 0;
} 答案分析：
#include
int main()
{
char arr[] = { 'a','b','c','d','e','f' };
printf("%d\n", sizeof(arr));//6字节，数组名单独放在sizeof内部，计算的是整个数组的大小
printf("%d\n", sizeof(arr + 0));//4/8字节，数组名没有单独放，arr+0是数组首元素的地址
printf("%d\n", sizeof(*arr));//1字节，*arr相当于arr[0]是数组首元素，计算的是首元素的大小
printf("%d\n", sizeof(arr[1]));//1字节，arr[1]是第二个元素，计算的是第二个元素的大小
printf("%d\n", sizeof(&arr));//4/8字节，&数组名，取出的整个数组的地址，类型是数组指针char (*)[6]
printf("%d\n", sizeof(&arr + 1));//4/8字节，&arr+1，向后跳过整个数组，指向后面的空间地址，但类型不变
printf("%d\n", sizeof(&arr[0] + 1));//4/8字节，&arr[0]+1是数组第二个元素的地址
return 0;
} （2）strlen——注意实参是地址，计算字符串的长度，统计的是‘\0’之前的字符个数
#include
int main()
{
char arr[] = { 'a','b','c','d','e','f' };
printf("%d\n", strlen(arr));
printf("%d\n", strlen(arr + 0));
printf("%d\n", strlen(*arr));
printf("%d\n", strlen(arr[1]));
printf("%d\n", strlen(&arr));
printf("%d\n", strlen(&arr + 1));
printf("%d\n", strlen(&arr[0] + 1));
return 0;
} 答案解析：
#include
#include
int main()
{
char arr[] = { 'a','b','c','d','e','f' };//没有'\0',不知道'\0'在哪
printf("%d\n", strlen(arr));//随机数，传的是数组首元素地址，类型char*
printf("%d\n", strlen(arr + 0));//随机数，传的是数组首元素地址，类型char*
//printf("%d\n", strlen(*arr));//err,strlen('a')-->str(97),非法访问
//printf("%d\n", strlen(arr[1]));//err,'b'-98,和上面代码类似，非法访问
printf("%d\n", strlen(&arr));//随机值，传的是数组指针的地址，数组指针的地址也是从数组起始地址开始的，类型char (*)[6]
printf("%d\n", strlen(&arr + 1));//随机值-6，&arr+1向后跳过整个数组的地址，类型char (*)[6]
printf("%d\n", strlen(&arr[0] + 1));//随机值-1，&arr[0]+1是数组第二个元素的地址，类型char*
return 0;
} 情景2：
例如：char arr[] = "abcdef";
（1）sizeof——计算的是操作数类型的大小
#include
int main()
{
char arr[] = "abcdef";
printf("%d\n", sizeof(arr));
printf("%d\n", sizeof(arr + 0));
printf("%d\n", sizeof(*arr));
printf("%d\n", sizeof(arr[1]));
printf("%d\n", sizeof(&arr));
printf("%d\n", sizeof(&arr + 1));
printf("%d\n", sizeof(&arr[0] + 1));
return 0;
} 答案分析：
#include
int main()
{
char arr[] = "abcdef";
printf("%d\n", sizeof(arr));//7字节，数组名单独放在sizeof内部，计算的是整个数组的大小
printf("%d\n", sizeof(arr + 0));//4/8字节，arr+0<-->&arr[0]是数组首元素的地址，类型是char*
printf("%d\n", sizeof(*arr));//1字节，*arr<-->arr[0]是数组首元素，计算的是首元素大小
printf("%d\n", sizeof(arr[1]));//1字节，arr[1]是第二个元素，计算的是第二个元素的大小
printf("%d\n", sizeof(&arr));//4/8字节，&arr是取出整个数组的地址，类型数组指针char (*)[7]
printf("%d\n", sizeof(&arr + 1));//4/8字节，&arr+1是跳过整个数组的地址，类型还是数组指针char (*)[7]
printf("%d\n", sizeof(&arr[0] + 1));//4/8字节，&arr[0]+1是数组第二个元素的地址，类型char*
return 0;
} （2）strlen——注意实参是地址，计算字符串的长度，统计的是‘\0’之前的字符个数
#include
#include
int main()
{
char arr[] = "abcdef";
printf("%d\n", strlen(arr));
printf("%d\n", strlen(arr + 0));
printf("%d\n", strlen(*arr));
printf("%d\n", strlen(arr[1]));
printf("%d\n", strlen(&arr));
printf("%d\n", strlen(&arr + 1));
printf("%d\n", strlen(&arr[0] + 1));
return 0;
} 答案解析：
#include
#include
int main()
{
char arr[] = "abcdef";//字符串后默认'\0'为结束标志
//a b c d e f \0
printf("%d\n", strlen(arr));//6字节，传的是数组首元素的地址，strlen从数组首元素地址开始统计\0之前的字符个数类型char*
printf("%d\n", strlen(arr + 0));//6字节,传的是数组首元素的地址，strlen从数组首元素地址开始统计\0之前的字符个数，类型char*
//printf("%d\n", strlen(*arr));//err,*arr-->a,strlen(a)-->strlen(97),传给strlen是一个非法的地址，造成非法访问
//printf("%d\n", strlen(arr[1]));//err，arr[1]-->b-->98,同上，传给strlen是一个非法的地址，造成非法访问
printf("%d\n", strlen(&arr));//6字节，传的是整个数组的地址，整个数组的地址也是从数组起始地址开始统计\0之前的字符个数，类型char (*)[7]
printf("%d\n", strlen(&arr + 1));//随机值,&arr+1跳过整个数组的地址，类型char (*)[7]
printf("%d\n", strlen(&arr[0] + 1));//5字节,传的是第二个元素的地址
return 0;
} 字符指针——指向一个常量字符串的首元素地址
（1）sizeof操作符——计算操作数类型的大小
#include
int main()
{
char* p = "abcdef";
printf("%d\n", sizeof(p));
printf("%d\n", sizeof(p + 1));
printf("%d\n", sizeof(*p));
printf("%d\n", sizeof(p[0]));
printf("%d\n", sizeof(&p));
printf("%d\n", sizeof(&p + 1));
printf("%d\n", sizeof(&p[0] + 1));
return 0;
} 答案解析：
#include
int main()
{
char* p = "abcdef";//p指针变量，指向字符串首元素的地址
printf("%d\n", sizeof(p));//4/8字节，p指针变量
printf("%d\n", sizeof(p + 1));//4/8字节，p+1是b的地址
printf("%d\n", sizeof(*p));//1字节，*p-->a-->字符，计算的是字符的大小
printf("%d\n", sizeof(p[0]));//1字节，p[0]<-->*(p+0)-->a,同上
printf("%d\n", sizeof(&p));//4/8字节，&p是二级指针，指向变量p的地址
printf("%d\n", sizeof(&p + 1));//4/8字节，&p+1是跳过p变量后的地址
printf("%d\n", sizeof(&p[0] + 1));//4/8字节，p[0]-->a,&p[0]就是a的地址，+1就是b的地址
return 0;
} （2）strlen——注意实参是地址，计算字符串的长度，统计的是‘\0’之前的字符个数
#include
#include
int main()
{
char* p = "abcdef";
printf("%d\n", strlen(p));
printf("%d\n", strlen(p + 1));
printf("%d\n", strlen(*p));
printf("%d\n", strlen(p[0]));
printf("%d\n", strlen(&p));
printf("%d\n", strlen(&p + 1));
printf("%d\n", strlen(&p[0] + 1));
return 0;
} 答案解析：
#include
#include
int main()
{
char* p = "abcdef";//p是指针变量，指向字符串的首元素地址
printf("%d\n", strlen(p));//6字节，传的是a的地址
printf("%d\n", strlen(p + 1));//5字节，传的b的地址
//printf("%d\n", strlen(*p));//err,*p-->a-->97,传给strlen一个非法地址，造成非法访问
//printf("%d\n", strlen(p[0]));//err,同上
printf("%d\n", strlen(&p));//随机值，&p拿到的是p变量的起始地址，从这开始求字符串长度不知道\0
printf("%d\n", strlen(&p + 1));//随机值，&p+1是跳过p变量的地址，从这开始求字符串长度也不知道\0位置
printf("%d\n", strlen(&p[0] + 1));//5字节，&p[0]+1-->是b的地址，从b开始数字符串长度
return 0;
}
二维数组
深入了解二维数组：
二维数组可以看成一维数组的数组，即一行就是是一个元素。
所以二维数组的首元素地址即第一行的地址。
例如：下图
（1）sizeof操作符——计算操作数类型的大小
#include
int main()
{
int a[3][4] = { 0 };
printf("%d\n", sizeof(a));
printf("%d\n", sizeof(a[0][0]));
printf("%d\n", sizeof(a[0]));
printf("%d\n", sizeof(a[0] + 1));
printf("%d\n", sizeof(*(a[0] + 1)));
printf("%d\n", sizeof(a + 1));
printf("%d\n", sizeof(*(a + 1)));
printf("%d\n", sizeof(&a[0] + 1));
printf("%d\n", sizeof(*(&a[0] + 1)));
printf("%d\n", sizeof(*a));
printf("%d\n", sizeof(a[3]));
return 0;
}
答案分析：
#include
int main()
{
int a[3][4] = { 0 };
printf("%d\n", sizeof(a));//48字节，二维数组名单独放在sizeof内部，计算的是整个数组的大小
printf("%d\n", sizeof(a[0][0]));//4字节，a[0][0]是第一行第一个元素
printf("%d\n", sizeof(a[0]));//16字节，a[0]是第一行的数组名，数组名单独放在sizeof内部，
//计算的就是数组(第一行)的大小
printf("%d\n", sizeof(a[0] + 1));//4/8字节,a[0]作为第一行的数组名，没有单独放在sizeof内部，没有取地址，
//表示的就是数组的首元素地址，a[0]即a[0][0]的地址，a[0]+1就是第一行第二个元素的地址
printf("%d\n", sizeof(*(a[0] + 1)));//4字节，a[0]+1是第一行第二个元素的地址，解引用得到元素
printf("%d\n", sizeof(a + 1));//4/8字节，a是二维数组的数组名，没有单独放在sizeof内部，数组名就是二维数组首元素地址，
//就是第一行的地址，那a+1就是第二行的地址，类型数组指针int (*)[4]
printf("%d\n", sizeof(*(a + 1)));//16字节，(a+1)是第二行的地址，解引用得到第二行
printf("%d\n", sizeof(&a[0] + 1));//4/8字节，&a[0]是第一行的地址，+1是第二行的地址
printf("%d\n", sizeof(*(&a[0] + 1)));//16字节，&a[0]+1是第二行的地址，解引用得到第二行，计算的就是第二行的大小
printf("%d\n", sizeof(*a));//16字节，a没有单独放在sizeof内部，表示二维数组首元素的地址，就是第一行的地址，
//解引用得到第一行，计算的是第一行的大小
printf("%d\n", sizeof(a[3]));//16个字节，如果存在第四行，a[3]就是第四行的数组名，单独放在sizeof，计算的是第四行的大小
return 0;
} 总结：
sizeof是操作符
（1）sizeof内部的表达式是不计算的。
#include
int main()
{
int a = 2;
short s = 3;
printf("%d\n", sizeof(s = a + 3));
printf("%d\n", s);
return 0;
} 运行结果：
tip：①sizeof在编译时就执行了，而表达式求值在运行时才执行；
②表达式求值的两个属性：值属性和类型属性。
（2）sizeof只关注操作数占用内存空间的大小，单位是字节，不关心内存中存放的是什么。
strlen是库函数
（1）strlen是求字符串长度的，统计的是'\0'之前出现的字符个数，一定要找到'\0'才算结束，所以可能存在越界访问的。