目录
思维导图：
指针和数组笔试题
只有多刷题，才能巩固提高所学的知识。
例1：
#include <stdio.h>
int main()
{
//一维数组
int a[] = { 1,2,3,4 };
//求出下列打印结果及原因
printf("%d\n", sizeof(a));
//sizeof(数组名)数组名代表整个数组，数组每个元素是整形，整形大小4个字节，所以打印16
printf("%d\n", sizeof(a + 0));
//数组名表示首元素地址，+0还是首元素地址，指针大小4/8，x86环境打印4
//我使用的是x86环境
printf("%d\n", sizeof(*a));
//a是首元素地址，*a是首元素，整形大小4个字节，打印4
printf("%d\n", sizeof(a + 1));
//a是首元素地址，+1跳过一个整形，代表第二个元素地址，指针大小4/8，打印4
printf("%d\n", sizeof(a[1]));
//a[1]是数组第二个元素，就是*(a+1)，整形大小4个字节，打印4
printf("%d\n", sizeof(&a));
//&a取出的是整个数组的地址，指针大小4/8，打印4
printf("%d\n", sizeof(*&a));
//&a取出的是整个数组的地址，*&a解引用出的是整个数组，数组四个整形元素，打印16
printf("%d\n", sizeof(&a + 1));
//&a取出整个数组的地址,+1跳过一整个数组，但他还是指针，指针大小4/8，打印4
printf("%d\n", sizeof(&a[0]));
//&a[0]取出数组首元素地址，指针大小4/8，打印4
printf("%d\n", sizeof(&a[0] + 1));
//&a[0]取出数组首元素地址，+1跳过一个整形，是数组第二个元素的地址，指针大小4/8，打印4
return 0;
}输出：
输出：
16
4
4
4
4
4
16
4
4
4学完上述题目，我们发现了一些特点：
1.sizeof(数组名)，数组名表示整个数组，
2.&数组名，取出的是整个数组，
3.除上述两种情况外，数组名都表示数组首元素地址。
例2:
#include <stdio.h>
int main()
{
//字符数组
char arr[] = { 'a','b','c','d','e','f' };
//求出下列打印结果及原因
printf("%d\n", sizeof(arr));
//sizeof(arr)，arr代表整个数组，数组每个元素是字符，打印6
printf("%d\n", sizeof(arr + 0));
//arr是首元素地址，+0后还是地址，指针大小4/8，打印4
printf("%d\n", sizeof(*arr));
//arr是首元素地址，*arr解引用后得到首元素，数组元素是字符，打印1
printf("%d\n", sizeof(arr[1]));
//arr[1]是数组的第二个元素，数组每个元素是字符，打印1
printf("%d\n", sizeof(&arr));
//&arr取出的是整个元素的地址，指针大小4/8，打印4
printf("%d\n", sizeof(&arr + 1));
//&arr取出的是整个元素的地址，+1跳过一整个数组，但还是地址，指针大小4/8，打印4
printf("%d\n", sizeof(&arr[0] + 1));
//&arr[0]取出的数组首元素地址，+1跳过一个字节指向数组第二个元素地址，指针大小4/8，打印4
return 0;
}输出：
输出：
6
4
1
1
4
4
4例三：
#include <stdio.h>
#include <string.h>
int main()
{
//字符数组
char arr[] = "abcdef";//该字符串在内存中存储的是:"abcdef\0"
//求出下列打印结果及原因
//sizeof
printf("%d\n", sizeof(arr));
//sizeof(arr)代表整个数组，数组有七个元素，类型是字符，打印7
printf("%d\n", sizeof(arr + 0));
//arr是首元素地址，+0后还是首元素地址，指针大小4/8，打印4
printf("%d\n", sizeof(*arr));
//arr是首元素地址,*解引用后得到首元素，类型是字符，打印1
printf("%d\n", sizeof(arr[1]));
//arr[1]是首元素，类型是字符，打印1
printf("%d\n", sizeof(&arr));
//&arr取出的整个数组的地址，指针大小4/8，打印4
printf("%d\n", sizeof(&arr + 1));
//&arr取出的整个数组的地址，+1跳过一整个数组，但还是地址，指针大小4/8，打印4
printf("%d\n", sizeof(&arr[0] + 1));
//&arr[0]取出的数组首元素地址，+1跳过一个字节指向数组第二个元素地址，指针大小4/8，打印4
printf("\n");
//strlen
printf("%d\n", strlen(arr));
//arr是首元素地址，strlen通过首元素地址查找整个字符串，遇到\0停下，求出字符长度，打印6
printf("%d\n", strlen(arr + 0));
//arr是首元素地址,+0还是首元素地址，打印6
//printf("%d\n", strlen(*arr));//错误代码
//arr是首元素地址，*解引用后得到首元素‘a’,‘a’不是地址，程序非法访问内存空间
//printf("%d\n", strlen(arr[1]));//错误代码
//arr[1]是数组第二个元素'b'，'b'不是地址,程序非法访问内存空间
printf("%d\n", strlen(&arr));
//&arr取出的是整个数组的地址，但内存中保存的是首元素地址，所以打印6
printf("%d\n", strlen(&arr + 1));
//&arr取出整个数组的地址，+1跳过整个数组，指针指向数组后的空间，
//strlen只有找到\0才会停下，所以程序打印结果是随机值
printf("%d\n", strlen(&arr[0] + 1));
//&arr[0]取出的数组首元素地址，+1跳过一个字节指向数组第二个元素地址，
//strlen将数组第二个元素的地址作为数组的首元素地址，打印5
return 0;
}输出：
输出：
7
4
1
1
4
4
4
6
6
6
12
5tips：
1.strlen 函数将传来的地址作为起始地址。
2.strlen 函数只有遇到'\0'时才会停下来。
例4：
#include <stdio.h>
#include <string.h>
int main()
{
//字符指针
char* p = "abcdef";
//求出下列打印结果及原因
//sizeof
printf("%d\n", sizeof(p));
//p是个指针变量，指针大小4/8，打印4
printf("%d\n", sizeof(p + 1));
//p是个字符类型的指针变量，+1跳过一个字节，指针大小4/8，打印4
printf("%d\n", sizeof(*p));
//p是个指向字符串首字符的指针，*解引用得到字符串首字符，打印1
printf("%d\n", sizeof(p[0]));
//p[0]其实也能写成*(p+0),得到字符串首字符，打印1
printf("%d\n", sizeof(&p));
//p是个指针变量，&p是取p的地址，指针大小4/8，打印4
printf("%d\n", sizeof(&p + 1));
//p是个指针变量，&p+1还是地址，指针大小4/8，打印4
printf("%d\n", sizeof(&p[0] + 1));
//&p[0]取出的是个地址，+1还是地址，指针大小4/8，打印4
printf("\n");
//strlen
printf("%d\n", strlen(p));
//p是个指向字符串首字符的指针，字符串有6个字符，打印6
printf("%d\n", strlen(p + 1));
//p是个指向字符串首字符的指针，+1跳过一个字节，指向字符串第二个字符的地址，打印5
//printf("%d\n", strlen(*p));//错误代码
//p是个指向字符串首字符的指针，*解引用得到字符‘a’,'a'不是地址，程序非法访问内存
//printf("%d\n", strlen(p[0]));//错误代码
//p[0]代表字符串首字符‘a’，‘a’不是地址，程序非法访问内存
printf("%d\n", strlen(&p));
//p是个指针变量，&p取出p的地址，strlen找到\0才停下，打印随机值
printf("%d\n", strlen(&p + 1));
//和上一个类似，只是地址+1，打印随机值
printf("%d\n", strlen(&p[0] + 1));
//&p[0]取出的字符串首字符地址，+1跳过一个字节，打印5
return 0;
}输出：
输出：
4
4
1
1
4
4
4
6
5
15
11
5接下来是一道有关二维数组的题目：
例5：
#include <stdio.h>
#include <string.h>
int main()
{
//二维数组
int a[3][4] = { 0 };
//求出下列打印结果及原因
printf("%d\n", sizeof(a));
//sizeof(a)表示的是整个数组，数组大小是3*4*每个元素4个字节=48，打印48
printf("%d\n", sizeof(a[0][0]));
//arr[0][0]代表的是数组首元素，元素类型是整形，打印4
printf("%d\n", sizeof(a[0]));
//arr[0]是a[3][4]数组第一行的元素，也就是第一行的数组名，代表整个第一行数组，打印16
printf("%d\n", sizeof(a[0] + 1));
//arr[0]是数组第一行的元素,+1跳过一行，所以arr[0]+1是数组第二行的数组名，
//数组名表示首元素地址，指针大小4/8，打印4
printf("%d\n", sizeof(*(a[0] + 1)));
//arr[0]+1是数组第二行的首元素地址，*解引用的到首元素，类型是整形，打印4
printf("%d\n", sizeof(a + 1));
//a代表数组首行地址，+1跳过一行，代表数组第二行地址，指针大小4/8，打印4
printf("%d\n", sizeof(*(a + 1)));
//a + 1代表数组第二行的地址，*解引用得到第二行，打印16
printf("%d\n", sizeof(&a[0] + 1));
//&a[0]取出数组第一行地址，+1跳过一行，代表数组第二行地址，指针大小4/8，打印4
printf("%d\n", sizeof(*(&a[0] + 1)));
//&a[0] + 1代表数组第二行地址，*解引用得到得到第二行，打印16
printf("%d\n", sizeof(*a));
//a是首行的地址，*解引用后得到第一行，打印16
printf("%d\n", sizeof(a[3]));
//arr[3]不在数组内，但是sizeof判断大小不会真的去访问内存，他会通过类型判断
//arr[3]看起来像数组的一行，所以sizeof默认他为数组一行的大小，打印16
return 0;
}输出：
输出：
48
4
16
4
4
4
16
4
16
16
16总结：
二维数组的数组名代表首行地址。
做完上面的题目，相信你一定对数组有了更深层次的理解，
也对sizeof 和strlen 的理解更透彻了，
那么我们接下来就要尝试做一做指针的题目了。
指针笔试题
例1：
#include <stdio.h>
int main()
{
int a[5] = { 1, 2, 3, 4, 5 };
int* ptr = (int*)(&a + 1);
//&a + 1跳过一整个数组，然后强制类型转换成（int*）
//所以指针变量ptr存放的是数组往后一个元素
printf("%d,%d", *(a + 1), *(ptr - 1));
//a时首元素地址，+1得到第二个元素的地址，*解引用得到2，打印2
//(ptr-1)想前跳一个整形的大小，*解引用得到5，打印5
return 0;
}输出：
输出：2,5例2：
#include <stdio.h>
//已知，结构体Test类型的变量大小是20个字节
struct Test
{
int Num;
char* pcName;
short sDate;
char cha[2];
short sBa[4];
}*p;
int main()
{
p = (struct Test*)0x100000;
printf("%p\n", p + 0x1);
//结构体Test的指针+1，跳过20个字节，转换成十六进制是0x00100014
printf("%p\n", (unsigned long)p + 0x1);
//p被强制类型转换成(unsigned long)，整形+1，结果是0x00100001
printf("%p\n", (unsigned int*)p + 0x1);
//p被强制类型转换成(unsigned int*),无符号整形指针+1，跳过4个字节，结果是0x00100004
return 0;
}输出：
输出：
00100014
00100001
00100004注：
指针+1才是跳过类型所占的字节大小，
整形加整形科是直接相加的，可别被绕进去了哦。
例3：
#include <stdio.h>
int main()
{
int a[4] = { 1, 2, 3, 4 };
int* ptr1 = (int*)(&a + 1);
//(&a + 1)跳过整个数组，ptr1指向的是数组后一个元素
int* ptr2 = (int*)((int)a + 1);
//a是首元素地址，强制类型转换成整形后+1，代表整形1的地址从起始位置往后跳了一个字节
//所以ptr2指针指向的是整形1的地址从起始位置往后跳了一个字节的位置
printf("%x,%x", ptr1[-1], *ptr2);
//prt1[-1]就是*(ptr1-1),向前跳一个整形，指向数组最后一个元素，*解引用后，打印4
//我是小端环境，数据在内存中是倒着放的，指针指向整形1往后一个字节，访问的时候
//指针访问四个字节，就将数组下一个元素整形2的第一个字节也包含了，所以打印20000000
return 0;
}
输出：
输出：4,2000000例4：
#include <stdio.h>
int main()
{
int a[3][2] = { (0, 1), (2, 3), (4, 5) };
//(0,1),看清楚，这是个逗号表达式，所以
//数组a其实存放的是{ 1, 3, 5 }
int* p;
p = a[0];
//指针p中存储的是数组第一行地址
printf("%d", p[0]);
//p[0]是第一行的首元素，所以打印1
return 0;
}输出：
输出：1例5：
#include <stdio.h>
int main()
{
int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
//数组第一行：1 2 3 4 5
//数组第二行：6 7 8 9 10
int* ptr1 = (int*)(&aa + 1);
//&aa+1跳过整个数组
int* ptr2 = (int*)(*(aa + 1));
//aa是数组首行地址，+1得到第二行地址
printf("%d,%d", *(ptr1 - 1), *(ptr2 - 1));
//ptr-1向前跳一个整形，得到数组最后一个元素地址，*解引用得到10
//ptr2-1向前跳一个整形，得到数组第一行最后一个元素地址，*解引用得到5
return 0;
}
输出：
输出：10,5例6：
#include <stdio.h>
int main()
{
char* a[] = { "work","at","alibaba" };
//这个指针数组里存放的是三个字符串的首元素地址
char** pa = a;
//二级指针pa接收了数组a首元素地址
pa++;
//指针++，跳过4个字节,
printf("%s\n", *pa);
//*pa指向第二个字符串的首元素地址，打印at
return 0;
}输出：
输出：at例7：
#include <stdio.h>
int main()
{
char* c[] = { "ENTER","NEW","POINT","FIRST" };
//数组中存放四个字符串的首元素地址
char** cp[] = { c + 3,c + 2,c + 1,c };
//这个二级指针数组存放的字符串数组分别是：
//{ "FIRST", "POINT", "NEW", "ENTER" }
char*** cpp = cp;
//三级指针cpp指向cp数组的首元素地址
printf("%s\n", **++cpp);
//cpp++,cpp指向cp数组第二个元素地址，*第一次解引用得到cp数组第二个元素(c+2)
//*第二次解引用cp数组第二个元素，得到c数组第三个元素,打印 POINT
printf("%s\n", *-- * ++cpp + 3);
//cpp++,cpp指向cp数组第三个元素地址，*第一次解引用得到cp数组第三个元素(c+1)
//(c+1)--后等于c,再解引用得到c数组第一个元素，然后+3跳过三个字节，打印 ER
printf("%s\n", *cpp[-2] + 3);
//*cpp[-2]就是**(cpp-2),cpp-2得到cp数组首元素地址，*第一次解引用得到cp数组第二个元素(c+3)
//*第二次解引用cp数组第一个元素，得到c数组第四个元素，+3跳过三个字节，打印 ST
printf("%s\n", cpp[-1][-1] + 1);
//cpp[-1][-1]就是*(*(cpp-1)-1),cpp-1指向cp数组第二个元素地址,*得到cp数组第二个元素(c+2)
//然后-1等于(c+1)，*得到c数组第二个元素，+1跳过一个字节，打印 EW
return 0;
}输出：
输出：
POINT
ER
ST
EW学到这里，相信你对指针的理解一定更上一层楼了！
写在最后：
以上就是本篇文章的内容了，感谢你的阅读。
如果喜欢本文的话，欢迎点赞和评论，写下你的见解。
如果想和我一起学习编程，不妨点个关注，我们一起学习，一同成长。
之后我还会输出更多高质量内容，欢迎收看。
309
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
