目录
前言
前几期的博客已经将有关指针、数组的所以知识都已基本讲解完毕，那么接下来我们就做一些练习巩固，这些练习依据历年来一些公司笔试题进行改编，更有经典笔试题目，如果您想要提高自己的 C 语言编程能力，那么数组和指针练习题是必不可少的。在本文中，我们将为您提供一些有趣且具有挑战性的问题，并附上详细的解析和讲解。
题目列表：
//一维数组
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));
//字符数组
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));
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));
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));
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));
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));
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));
//二维数组
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]));
指针笔试题
笔试题1：
int main()
{
int a[5] = { 1, 2, 3, 4, 5 };
int *ptr = (int *)(&a + 1);
printf( "%d,%d", *(a + 1), *(ptr - 1));
return 0;
}
//程序的结果是什么？
笔试题2：
struct Test
{
int Num;
char *pcName;
short sDate;
char cha[2];
short sBa[4];
}*p;
//假设p 的值为0x100000。 如下表表达式的值分别为多少？
int main()
{
printf("%p\n", p + 0x1);
printf("%p\n", (unsigned long)p + 0x1);
printf("%p\n", (unsigned int*)p + 0x1);
return 0;
}
笔试题3：
int main()
{
int a[4] = { 1, 2, 3, 4 };
int *ptr1 = (int *)(&a + 1);
int *ptr2 = (int *)((int)a + 1);
printf( "%x,%x", ptr1[-1], *ptr2);
return 0;
}
笔试题4：
#include <stdio.h>
int main()
{
int a[3][2] = { (0, 1), (2, 3), (4, 5) };
int *p;
p = a[0];
printf( "%d", p[0]);
return 0;
}
笔试题5；
int main()
{
int a[5][5];
int(*p)[4];
p = a;
printf( "%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
return 0;
}
笔试题6：
int main()
{
int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int *ptr1 = (int *)(&aa + 1);
int *ptr2 = (int *)(*(aa + 1));
printf( "%d,%d", *(ptr1 - 1), *(ptr2 - 1));
return 0;
}
笔试题7：
#include <stdio.h>
int main()
{
char *a[] = {"work","at","alibaba"};
char**pa = a;
pa++;
printf("%s\n", *pa);
return 0;
}
笔试题8：
int main()
{
char *c[] = {"ENTER","NEW","POINT","FIRST"};
char**cp[] = {c+3,c+2,c+1,c};
char***cpp = cp;
printf("%s\n", **++cpp);
printf("%s\n", *--*++cpp+3);
printf("%s\n", *cpp[-2]+3);
printf("%s\n", cpp[-1][-1]+1);
return 0;
}大家可以先尝试自己做，最后与我的解析进行对比，思路是否正确。
题目解析
int a[] = {1,2,3,4};
printf("%d\n",sizeof(a));看到第一题sizeof（数组名），这里提到数组名，那再次强调一次数组名的理解，后边的题目几乎都牵扯到数组名的理解
数组名的理解
数组名指的是数组首元素的地址
2个例外
sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节。
&数组名，这里的数组名表示整个数组，取出的是整个数组的地址
一维数组
我们接着来看第一个
printf("%d\n",sizeof(a));sizeof（a），a是一个整形数组，里边有4个字节，那么输出的结果也就是4*4=16，16个字节
printf("%d\n",sizeof(a+0));sizeof（a+0）括号里不再是数组名，而是数组名+0，这里就不再表示是整个数组了。a是数组首元素的地址+0还是数组首元素地址。是地址所占空间就是4/8个字节。
printf("%d\n",sizeof(*a));sizeof（*a），这里并没有将a单独放在sizeof内部，所以就不能表示为整个数组，所以这里的a表示的是数组首元素的地址，解引用就是数组的首元素。数组为整形所以占4个字节
printf("%d\n",sizeof(a+1));sizeof（a+1），这里也是并没有将a单独放在sizeof内部，所以这里的a表示数组首元素的地址，a+1，跳过一个整形的空间，也就是第二个元素的地址。是地址所占的内存空间就是4/8个字节
printf("%d\n",sizeof(a[1]));这个就简单了，a[1]代表的是数组第二个元素，是一个整形数字，占4个字节。
printf("%d\n",sizeof(&a));sizeof（&a），这里a表示数组首元素的地址，&a取出整个数组的地址，&a也是个地址，是地址就占4/8个字节。
printf("%d\n",sizeof(*&a));sizeof(*&a)，这里可以从两个角度去理解
1.*&相互抵消，sizeof（*&a）等价于sizeof（a），占16个字节。
2.&a取出的是整个数组的地址，那它的数据类型也就是int （*）[4]一个指向4个整形空间大小的指针，解引用也就是4个整形空间的大小。4*4=16，占16个字节
printf("%d\n",sizeof(&a+1));sizeof（&a+1），&a取出的是整个数组的地址，+1跳过一个数组的空间，但它终究还是个地址，是地址就占4/8个字节。
printf("%d\n",sizeof(&a[0]));sizeof（&a[0]），a[0]是数组首元素，那&a[0]就是数组首元素的地址，所以占4/8个字节。
printf("%d\n",sizeof(&a[0]+1));&a[0]是数组首元素的地址，&a[0]+1就是数组第二个元素的地址，占4/8个字节
通过一维数组的练习我们发现了什么规律？
sizeof计算大小时根本就不关心数组的大小，它只关注数据的类型。
字符数组
char arr[] = {'a','b','c','d','e','f'};
printf("%d\n", sizeof(arr));sizeof（arr），数组名单独放在sizeof内部，那就是整个数组的大小，char类型的数组每个元素占1个字节的空间，所以arr数组也就占6个字节
printf("%d\n", sizeof(arr+0));这里并不是将arr（数组名）单独放在sizeof内部，这里的arr表示数组首元素地址，arr+0还是数组首元素的地址，是地址就占4/8个字节。
printf("%d\n", sizeof(*arr));arr没有单独放在sizeof内部，那么arr表示数组首元素地址，*arr就是数组首元素，占1个字节。
printf("%d\n", sizeof(arr[1]));arr[1]表示数组第二个元素，占1个字节
printf("%d\n", sizeof(&arr));arr没有单独放在sizeof内部，所以arr表示数组首元素地址，&arr又表示整个数组的地址。是地址就占4/8个字节的空间
printf("%d\n", sizeof(&arr+1));&arr取的是整个数组的地址，+1跳过整个数组，&arr+1是跳过整个数组后的地址，是地址就占4/8个字节
printf("%d\n", sizeof(&arr[0]+1));&arr[0]+1表示数组第二个元素的地址，是地址就占4/8个字节
char arr[] = {'a','b','c','d','e','f'};
printf("%d\n", strlen(arr));这次我们用的不是sizeof了，使用的是strlen。
arr在内存中存储如下图：
在内存条中，arr前和arr后数据都未知，我们知道strlen求字符串长度是到 '\0' 才会停止计算。
在数组arr中我们存'a','b','c','d','e','f'时是不会在数组是最后补上‘\0’，
所有就会造成在使用strlen求arr字符串长度时会越界访问数组arr后未知区域的数据，直到遇到‘\0’为止。这时计算的strlen就是随机值。
在知道这些的前提下，我们继续来看题目。
strlen（arr），arr是数组首元素的地址，从首元素开始向后遍历，直到\0为止，在遍历完数组后，还会一直向后遍历，直到遇到\0为止，所有输出会是一个随机值。
printf("%d\n", strlen(arr+0));arr+0，还是数组首元素地址，和上一个一样也是一个随机值
printf("%d\n", strlen(*arr));arr是数组首元素地址，*arr就是数组首元素，但这里我们要注意，strlen这个库函数参数部分需要传的是一个地址。当我们传递一个‘a’时，编译器就会将‘a’的ASCII值97当作地址传参，这时strlen就会从97这块空间开始取计算字符串长度，这样就造成了内存的非法访问，我们在运行时程序就会崩溃，出现错误。
printf("%d\n", strlen(arr[1]));arr[1]数组的第二个元素‘b’，传进去一个字符‘b’，结果和上一个一样，出现错误。
printf("%d\n", strlen(&arr));&arr是数组的地址,数组的地址和数组首元素的地址，值是一样的，那么传递给strlen函数后，依然是从数组的第一个元素的位置开始往后统计，所以输出会是一个随机值
printf("%d\n", strlen(&arr+1));&arr+1，跳过了数组arr，那传过去的地址就是arr[7]（已经越界）的地址，从arr[7]的位置开始向后统计，所以输出也是一个随机值。
printf("%d\n", strlen(&arr[0]+1));&arr[0]+1，表示数组第二个元素的地址，从数组第二个元素的位置开始向后统计，所以输出是一个随机值
字符串
char arr[] = "abcdef";
printf("%d\n", sizeof(arr));//7这次我们的数组在初始化时使用的是字符串。有什么不同呢？字符串初始会自动在字符串末尾加上\0作为结束的标志。
这时我们的数组arr里就是{a，b，c，d，e，f，\0}，这时使用sizeof计算arr的大小，结果就是7。
sizeof在计算时不管数组的元素是什么，它只管计算数组的大小，arr默认最后添加了一个\0，于是数组arr就变成了7个元素。
printf("%d\n", sizeof(arr+0))//4/8arr+0，时数组首元素地址，是地址就是占4/8个字节。
printf("%d\n", sizeof(*arr));//1*arr，表示的是数组arr首元素，是一个字符，占1个字节
printf("%d\n", sizeof(arr[1]));//1arr[1]是数组第二个元素，是字符b，占1个字节。
printf("%d\n", sizeof(&arr));//4/8
printf("%d\n", sizeof(&arr+1));//4/8
printf("%d\n", sizeof(&arr[0]+1));//4/8&arr取的是数组的地址，是地址就占4/8个字节
&arr+1跳过一个数组arr的空间，实质还是一个地址，是地址就占4/8个字节
&arr[0]+1，指的是数组第二个元素的地址，占4/8个字节
printf("%d\n", strlen(arr));//6
printf("%d\n", strlen(arr+0));//6这里的arr和arr+0都表示的是数组首元素地址，那么使用strlen函数计算的是\0之前的字符个数，那它们的输出结果都是6.
printf("%d\n", strlen(*arr));//error
printf("%d\n", strlen(arr[1]))//error*arr和arr[1]都表示的是数组arr里的元素，字符当作地址传递给strlen函数会使程序运行时出现错误
printf("%d\n", strlen(&arr));//6
printf("%d\n", strlen(&arr+1));//随机值
printf("%d\n", strlen(&arr[0]+1));//5这里&arr取的是数组的地址，但数组的地址和数组首元素的地址，值是一样的，那么传递给strlen函数后，依然是从数组的第一个元素的位置开始往后统计，所以输出结果是6。
&arr+1，跳过了整个数组arr，从arr数组最后的\0后边开始向后统计字符串长度，所以输出的结果将会是一个随机值。
&arr[0]+1,是数组第二个元素的地址，从第二个元素开始向后统计，所以输出结果是5
字符指针
char *p = "abcdef";
printf("%d\n", sizeof(p));//4/8
printf("%d\n", sizeof(p+1));//4/8这里的指针变量p里边存的是字符a的地址（字符串在内存中存储是连续的），我们前边总结过：
sizeof在计算时，它只在乎数据的类型。
p它是char*类型的指针，是指针那它就占4/8个字节。
那p+1，表示的就是字符b的地址，是指针那它就占4/8个字节
printf("%d\n", sizeof(*p));//1
printf("%d\n", sizeof(p[0]));//1*p就是就是字符a，是char类型，占1个字节。
p[0],就等价于*(p+0)，p+0指向的还是字符a，所以p[0]也是字符a，char类型，占1个字节
printf("%d\n", sizeof(&p));//4/8
printf("%d\n", sizeof(&p+1));//4/8
printf("%d\n", sizeof(&p[0]+1));//4/8p是char*类型，那&p就是char**是一个二级指针，是指针那它就占4/8个字节。
&p+1，也是一个二级指针，也是占4/8个字节，那我们思考一下，&p+1指向的是哪里呢？
如上图，&p+1指向的是&p的后边，且相邻。
&p[0]+1，这个很好理解，&p[0]是首元素a的地址，+1指向的就是字符b的地址，所占空间也是4/8个字节。
printf("%d\n", strlen(p));//6
printf("%d\n", strlen(p+1));//5这次我们换用为strlen，我们知道，字符串在内存中存储时是连续的，且会在字符串的末尾加上\0，作为结束的标志。
p指向的是字符串首元素a的地址，向后统计字符个数，所以strlen（p）的结果是6.
p+1指向的是b的地址，从字符串第二字符的位置开始向后统计字符个数，输出结果是5.
printf("%d\n", strlen(*p));//error
printf("%d\n", strlen(p[0]));//error*p和p[0]都是字符a，我们前边了解到，将字符作为地址传给strlen函数在程序运行时会出现错误。
printf("%d\n", strlen(&p));//随机值
printf("%d\n", strlen(&p+1));//随机值
printf("%d\n", strlen(&p[0]+1));//5&p我们知道是一个二级指针，它存放的只是指针p的地址，并不是字符串abcdef，所以在从&p开始向后统计字符个数时，无法得知字符个数，因此为随机值
&p+1与&p同理，所以输出也是一个随机值
&p[0]+1,p[0]是字符串首元素，&p[0]等价于p，所以&p[0]+1就是指向字符串第二个字符b，从第二个字符开始向后统计字符个数，输出结果就是5
二维数组
int a[3][4] = {0};
printf("%d\n",sizeof(a));//48二维数组也是数组，将数组名单独放在sizeof内部，结果是什么呢？
siaeof（a）表示中a表示整个数组，3行4列，12个元素，一个元素占4个字节，所以数组a的大小就是48个字节
printf("%d\n",sizeof(a[0][0]));//48
printf("%d\n",sizeof(a[0]));//16
printf("%d\n",sizeof(a[0]+1));//4/8a[0][0]，表示的就是1行1列的元素，是一个整形数字，占4个字节
a[0],在对二维数组的理解中，我们可以将二维数组理解为一个存放一维数组的数组。
a[0]代表的是第一行一维数组的数组名，a[1]代表第二行一维数组的数组名，a[2]代表第三行一维数组的数组名。
而每个数组又有4个整形的空间，所以a[0]所占的内存大小就是占16个字节。
我们再来看a[0]+1，首先a[0]作为第一行的数组名没有单独放在sizeof内部，没有&，所以a[0]表示的是第一行数组的首元素地址，那么a[0]+1,指向的就是第一行第二列元素（a[0][1]）的地址。
它是地址，那就占4/8个字节
printf("%d\n",sizeof(*(a[0]+1)));//4理解了a[0]+1指向的是第一行第二列元素（a[0][1]）的地址，这里就很简单了，解引用就是第一行第二列的元素（a[0][1]），占4个字节
printf("%d\n",sizeof(a+1));//4/8
printf("%d\n",sizeof(*(a+1)));//16a+1，我们前边提到可以将a[3][4]理解为一个存放数组的数组，即a[3][4]={ a[0] , a[1] , a[2] };
并且没有单独将a放在sizeof内部，所以a表示的就是第一行的数组的地址（数组首元素的地址），a+1跳到相邻元素，所以a+1就是第二行的地址，占4/8个字节
*(a+1)
两种理解思路
1. *(a+1)等价于a[1]，也表示的是第二行的数组,所以占16个字节
2. a+1表示第二行数组的地址，类型为int (*)[4]，解引用就是一个4个整形空间大小的数组，占16个字节。
printf("%d\n",sizeof(&a[0]+1));//4/8
printf("%d\n",sizeof(*(&a[0]+1)));//16a[0]是第一行的数组，&a[0]就是第一行的地址，&a[0]+1也等价于a+1，表示的就是第二行的地址，占4/8个字节。
将&a[0]+1解引用就是第二行的数组，占16个字节。
printf("%d\n",sizeof(*a));//16
printf("%d\n",sizeof(a[3]));//16sizeof（*a），并没有将a单独放在sizeof内部，所以这里的a表示的就是数组首元素地址，二维数组首元素地址就是第一行数组的地址，再解引用就是第一行的大小，所以占16个字节
sizeof（a[3])，这里我们可以发现数组越界了，但这并不影响，sizeof计算只关注数据类型。
a[3]也就相当于是二维数组中的第四行，不管第四行是否催在，所能存储的类型都只能是int [4](4个元素的整形数组），所以占16个字节。
笔试题
笔试题1：
int main()
{
int a[5] = { 1, 2, 3, 4, 5 };
int *ptr = (int *)(&a + 1);
printf( "%d,%d", *(a + 1), *(ptr - 1));//2，5
return 0;
}
//程序的结果是什么？题目分析：
ptr是一个指针，赋值为（int*）(&a+1）,&a我们知道取出的是整个数组的地址，&a+1指向的位置如图所示：
在将int (*)[5]强制类型转换为int*类型。
输出：
*（a+1)，a表示数组首元素地址，a+1就是数组第二个元素的地址，*（a+1）就是数组第二个元素，也就是2.
*(ptr - 1)，我们已经知道ptr所指向的位置，并且强制转换为int*类型，那ptr+1或-1就只会跳过一个整形的空间。那ptr-1就是数组第五个元素的地址，所以*(ptr - 1)就是数组第五个元素，也就是5.
笔试题2：
struct Test
{
int Num;
char *pcName;
short sDate;
char cha[2];
short sBa[4];
}*p;
//假设p 的值为0x100000。 如下表表达式的值分别为多少？
int main()
{
printf("%p\n", p + 0x1);//0x100014
printf("%p\n", (unsigned long)p + 0x1);//0x100001
printf("%p\n", (unsigned int*)p + 0x1);//0x100004
return 0;
}
由于未向大家详细具体的介绍结构体，这里先告知大家结构体大小是20个字节（32位操作系统）
假设p 的值为0x100000，即p=（struct Test*）0x100000
这道题考察的就是指针+1跳过的空间大小。
输出：
p + 0x1，p是结构体指针，地址+1根据数据类型不同跳过的空间大小不同，我们已知结构体大小是20个字节。所以输出为：0x100014，14转化为10进制就是20。
(unsigned long)p + 0x1，将p转化为无符号长整形，那这里就是正常的整数相加，输出也就是0x100001
(unsigned int*)p + 0x1，将结构体类型的指针转换为无符号整形的指针，+1就变成了一次跳过4个字节，所以输出也就是0x100004
总结
考虑到文章长度问题，本期博客到此结束，预知后事如何，见下期博客，最后感谢阅读！
1531
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
