前言
来到第二章，继续学习指针和数组笔试题
第一组题
#include<stdio.h>
int main()
{
char arr[] = "abcdef";//里面的放的是[a b c d e f \0]
printf("%d\n", strlen(arr));
没有单独放在sizeof内部，所以表示首元素地址，strlen统计的是在字符串中\0之前的字符的个数，所以结果是6
2.
printf("%d\n", strlen(arr+0));
arr表示首元素地址，arr+0也表示首元素地址，结果仍是6
3.
//printf("%d\n", strlen(*arr));
arr表示首元素地址，*arr表示首元素，就是字符a，传的是ASCII码值，非法访问内存，是错误代码
4.
printf("%d\n", strlen(arr[1]));
arr[1]是数组第二个元素，也是非法访问内存，是错误代码
5.
printf("%d\n", strlen(&arr));
&arr是数组的地址，但strlen是从首元素地址开始访问的，遇到\0停下，结果是6
6.
printf("%d\n", strlen(&arr+1));
&arr是数组地址，&arr+1跳过整个数组，从\0后面向后访问，后面是未知的，所以是随机值
如下图：
7.
printf("%d\n", strlen(&arr[0]+1));
&arr[0]表示数组首元素地址，&arr[0]+1表示第二个元素地址，意思是从第二个元素地址向后访问，统计了bcdef，5个字符
return 0;
}
总结：strlen访问的是地址，统计的是在字符串中\0之前的字符的个数。如果访问的是元素本身，就会造成非法访问内存。
第二组题
int main()
{
char* p = "abcdef";//[a b c d e f \0]
1.
printf("%d\n", sizeof(p));
p是char类型的指针变量
p是指针变量，大小是4/8个字节
2.
printf("%d\n", sizeof(p + 1));
p是从首元素地址访问的，p+1就是第二个元素地址，就是’b’的地址，是地址就是4/8个字节
如下图：
3.
printf("%d\n", sizeof(*p));
p是首元素地址，*p就是首元素，就是字符’a’,访问的不是地址，是元素本身，计算的是大小，char类型是一个字节
4.
printf("%d\n", sizeof(p[0]));//p[0]=*(p+0)
p[0]是首元素，大小是一个字节
5.
printf("%d\n", sizeof(&p));
p存放的是字符串的地址，&p是char**类型，存放的是p的地址，不是字符串的地址，是地址就是4/8个字节
6.
printf("%d\n", sizeof(&p + 1));
&p是从p的地址开始的，存的是p的整个地址，&p + 1,跳过整个地址，从p的地址后面往后访问地址，是地址就是4/8个字节。
要区分好p+1和&p+1的区别。
如下图：
7.
printf("%d\n", sizeof(&p[0] + 1));
&p[0]指向数组首元素地址，&p[0] + 1指向数组第二个元素地址，得到’b’的地址，是地址就是4/8个字节
return 0;
}
总结：p是指针变量，本身就是一个地址，&p也是一个地址，但它们存放的不是同一个地址。p存放的是某个数组的地址，&p存放的是p的地址。
第三组题
int main()
{
char* p = "abcdef";//[a b c d e f \0]
printf("%d\n", strlen(p));
p是一个指针，存放a b c d e f \0的地址，strlen从a开始访问，遇到\0停下，所以访问了a b c d e f6个字节
2.
printf("%d\n", strlen(p + 1));
p+1是’b’的地址，意思是从p[1]开始向后访问，访问了b c d e f 5个字节3.
// printf("%d\n", strlen(*p));
p是a的地址，*p是字符’a’，非法访问内存
4.
// printf("%d\n", strlen(p[0]));
p[0]=*p=‘a’,所以也是非法访问内存
5.
printf("%d\n", strlen(&p));
p存放的是字符串的地址，&p=char**,存放的是p的地址，但是编译器并不知道p的地址是什么，所以strlen访问到的是一个随机值
6.
printf("%d\n", strlen(&p + 1));
&p+1f跳过了p的地址，从p的地址后面往后访问地址，p后面的地址编译器更不知道了，所以也是随机值
7.
printf("%d\n", strlen(&p[0] + 1));
&p[0]是从’a’的地址向后访问，&p[0] + 1是从’b’的地址向后访问，访问了b c d e f 5个字节
return 0;
}
二维数组（难点）
int main()
{
int a[3][4] = {
0 };
三行四列的数组，元素都是0
2.
printf("%d\n", sizeof(a));
数组名单独放在sizeof内部，表示整个数组大小，每个元素是整型，344=48
3.
printf("%d\n", sizeof(a[0][0]));
0行0列的元素，大小是4个字节
4.
printf("%d\n", sizeof(a[0]));
把二维数组的每一行看作是一个元素，三行就是三个元素，a[0]就是二维数组的第一行的数组名，注意不是首元素，数组名单独放在sizeof内部，计算整个数组大小，是4*4=16
5.
printf("%d\n", sizeof(a[0]+1));
a[0]没有单独放在sizeof内部，是第一行的首元素地址，a[0]+1是第一行第二个元素的地址，是地址就是4/8个字节
6.
printf("%d\n", sizeof(*(a[0] + 1)));
a[0]+1是第一行第二个元素的地址，*(a[0] + 1)就是第一行第二个元素，大小是4个字节
7.
printf("%d\n", sizeof(a+1));
a是数组首元素的地址，是二维数组第一行的地址，a+1就是二维数组第二行的地址，是地址就是4/8个字节
8.
printf("%d\n", sizeof(*(a + 1)));
a+1是二维数组第二行的地址,(a + 1)是二维数组第二行的元素大小，大小是44=16
9.
printf("%d\n", sizeof(&a[0] + 1));
注意不要把a[0]看作是数组首元素，在二位数组这里，a[0]是数组名，&数组名+1跳过整个数组，表示的是二维数组第二行的地址，是地址就是4/8个字节
10.
printf("%d\n", sizeof(*(&a[0] + 1)));
&a[0] + 1表示的是二维数组第二行的地址，(&a[0] + 1)表示二维数组第二行的元素，计算大小，44=16
11.
printf("%d\n", sizeof(*a));
没有单独放在sizeof内部，没有&修饰，这里的a是二维数组首元素地址，就是第一行的地址，a就是第一行，大小是44=16
12.
printf("%d\n", sizeof(a[3]));
a[3]表示二维数组第四行的数组名，大小是4*4=16
return0；
}
总结
以上就是今天的指针和数组笔试题，二维数组是难点，需要花时间多理解。