目录
[1. sizeof和strlen的对⽐](#1. sizeof和strlen的对⽐)
[2. 数组和指针笔试题解析](#2. 数组和指针笔试题解析)
[3. 指针运算笔试题解析](#3. 指针运算笔试题解析)
1. sizeof和strlen的对⽐
1.1 sizeof(单目操作符）
注意：sizeof不是函数，它只是操作符 ,以字节为单位
在学习操作符的时候，我们学习了 sizeof ， sizeof 计算变量所占内存空间⼤⼩的，单位是字 节，如果操作数是类型的话，计算的是使⽤类型创建的变量所占内存空间的⼤⼩
sizeof 只关注占⽤内存空间的⼤⼩，不在乎内存中存放什么数据
cpp
int main()
{
int a = 0;
printf("%zd\n", sizeof(a));
printf("%zd\n", sizeof a); //证明了sizeof不是函数，因为函数后面必须加括号
printf("%zd\n", sizeof(int));
return 0;
}输出结果：
注意：证明了sizeof不是函数，因为函数后面必须加括号
cpp
printf("%zd\n", sizeof a)1.2 strlen
注意：它是一个库函数,用来求字符串的长度,它还要一个头文件<string.h>
strlen 是C语⾔库函数，功能是求字符串⻓度。函数原型如下：
cpp
size_t strlen (const char* str);统计的是从 strlen 函数的参数 str 中这个地址开始向后， \0 之前字符串中字符的个数。
strlen 函数会⼀直向后找 \0 字符，直到找到为⽌，所以可能存在越界查找。
cpp
int main()
{
size_t len1 = strlen("abcdef\n");
size_t len2 = strlen("abc\0def\n"); //strlen计算的是\0之前的数字，所以这里是3
printf("%zd\n", len1); //输出7
printf("%zd\n", len2); //输出3
return 0;
}输出结果：
注意：strlen计算的是\0之前的数字，所以这里是3
cpp
size_t len2 = strlen("abc\0def\n"); //strlen计算的是\0之前的数字，所以这里是3
printf("%zd\n", len2); //输出31.3 sizeof 和strlen的对⽐
|------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------|
| sizeof | strlen |
| 1. sizeof是操作符 2. sizeof计算操作数所占内存的 ⼤⼩，单位是字节 3. 不关注内存中存放什么数据 | 1. strlen是库函数，使⽤需要包含头⽂件 string.h 2. srtlen是求字符串⻓度的，统计的是 \0 之前字符的个数 3. 关注内存中是否有 \0 ，如果没有 \0 ，就会持续往后找，可能 会越界 |
| | |
strlen函数有多种写法
cpp
int main()
{
const char* str = "abcdef";
printf("%zd\n", strlen(str)); //输出6
return 0;
}输出结果：
还有一个写法
cpp
int main()
{
char str[] = "abcdef";
printf("%zd\n", strlen(str)); //输出6
return 0;
}输出结果：
2. 数组和指针笔试题解析
2.1 ⼀维数组
数组名的理解
数组名是数组首元素（第一个元素）的地址
但是有两个例外
1.sizeof（数组名） -----数组名表示的是整个数组，计算的是整个数组的大小，单位是字节
2.&数组名 ----数组名表示的是整个数组，取出的是整个数的地址除了上面两个例外，其他的数组名都是数组首元素（第一个元素）的地址
代码如下：
cpp
int main()
{
int a[] = { 1,2,3,4 };//4个元素
printf("%zd\n", sizeof(a)); //16 ----sizeof（数组名）的情况
printf("%zd\n", sizeof(a + 0)); //x64坏境是8，x86的坏境是4 ---a是首元素的地址，它的类型是int* ，所以a+0还是首元素的地址，是地址的话，它的大小就是4或者8，根据x64和x86坏境决定的
printf("%zd\n", sizeof(a+1));//8或者4 ---a是数组首元素的地址，它的类型是int* ,所以a+1会跳过1个整型，即a+1就是第二个元素的地址
printf("%zd\n", sizeof(a[1]));//4 ---a[1] 就是第二个元素，int是4个字节，所以这里是4
printf("%zd\n", sizeof(*a)); //4 ---a是首元素的地址，*a就是首元素，首元素是int，所以是4个字节，这里的 *a == a[0]
printf("%zd\n", sizeof(*&a));//16 ---这里的*和&互相抵消了，所以 sizeof(*&a) == sizeof(a)
printf("%zd\n", sizeof(&a));//4或者8 ---&a是数组的地址，数组的地址也是地址，所以地址大小就是4或者8
printf("%zd\n", sizeof(&a+1));//4或者8 ---&a+1它是跳过了整个数组后的那个位置的地址，是地址，大小就是4或者8
printf("%zd\n", sizeof(&a[0]));//4或者8 ---&a[0]是首元素的地址，是地址大小就是4或者8
printf("%zd\n", sizeof(&a[0]+1));//4或者8 ---&a[0]+1是数组第二个元素的地址，是地址，大小就是4或者8
return 0;
}输出结果：
现在我们来一一解析一下上面的代码：
输出16 ----sizeof（数组名）的情况，int型为4个字节，总共有4个元素，
cpp
printf("%zd\n", sizeof(a)); x64坏境是8，x86的坏境是4 ---a是首元素的地址，它的类型是int* ，所以a+0还是首元素的地址，是地址的话，它的大小就是4或者8，根据x64和x86坏境决定的
cpp
printf("%zd\n", sizeof(a + 0)); 输出8或者4 ---a是数组首元素的地址，它的类型是int* ,所以a+1会跳过1个整型，即a+1就是第二个元素的地址
cpp
printf("%zd\n", sizeof(a+1));输出4 ---a[1] 就是第二个元素，int是4个字节，所以这里是4
cpp
printf("%zd\n", sizeof(a[1]));输出4 ---a是首元素的地址，*a就是首元素，首元素是int，所以是4个字节，这里的 *a == a[0]
cpp
printf("%zd\n", sizeof(*a)); 16 ---这里的*和&互相抵消了，所以 sizeof(*&a) == sizeof(a)
cpp
printf("%zd\n", sizeof(*&a));4或者8 ---&a是数组的地址，数组的地址也是地址，所以地址大小就是4或者8
4或者8 ---&a+1它是跳过了整个数组后的那个位置的地址，是地址，大小就是4或者8
4或者8 ---&a[0]是首元素的地址，是地址大小就是4或者8
4或者8 ---&a[0]+1是数组第二个元素的地址，是地址，大小就是4或者8
cpp
printf("%zd\n", sizeof(&a))
printf("%zd\n", sizeof(&a+1));
printf("%zd\n", sizeof(&a[0]));
printf("%zd\n", sizeof(&a[0]+1));2.2 字符数组
代码如下：
cpp
int main()
{
char arr[] = { 'a','b','c','d','e','f' };//后面没有省略的\0
printf("%zd\n", sizeof(arr));//6 ---数组名单独放在了sizeof内部了，计算的是数组的大小，单位是字节
printf("%zd\n", sizeof(arr+0));//4或者8 ---arr是数组名，表示的是首元素的地址，arr+0还是首元素的地址，地址的大小就是4或者8
printf("%zd\n", sizeof(*arr));//1 ---arr是首元素的地址，*arr==arr[0]就是首元素a，char字符是1个字节
printf("%zd\n", sizeof(arr[1]));//1 ---arr[1]就是第二个元素b，字符大小是1个字节
printf("%zd\n", sizeof(&arr));//4或者8 ---&arr是数组地址，数组的地址也是地址，所以大小是4或者8
printf("%zd\n", sizeof(&arr+1));//4或者8 ---&arr+1，是跳过了整个数组后的那个位置的地址，是地址，大小就是4或者8
printf("%zd\n", sizeof(&arr[0]+1));//4或者8 ---&arr[0]+1是第二个元素的地址，是地址就是4或者8
return 0;
}输出结果：
解析：
6 ---数组名单独放在了sizeof内部了，计算的是数组的大小，单位是字节
4或者8 ---arr是数组名，表示的是首元素的地址，arr+0还是首元素的地址，地址的大小就是4或者8
cpp
printf("%zd\n", sizeof(arr));
printf("%zd\n", sizeof(arr+0));1 ---arr是首元素的地址，*arr==arr[0]就是首元素a，char字符是1个字节
1 ---arr[1]就是第二个元素b，字符大小是1个字节
cpp
printf("%zd\n", sizeof(*arr));
printf("%zd\n", sizeof(arr[1]));4或者8 ---&arr是数组地址，数组的地址也是地址，所以大小是4或者8
4或者8 ---&arr+1，是跳过了整个数组后的那个位置的地址，是地址，大小就是4或者8
4或者8 ---&arr[0]+1是第二个元素的地址，是地址就是4或者8
cpp
printf("%zd\n", sizeof(&arr));
printf("%zd\n", sizeof(&arr+1));
printf("%zd\n", sizeof(&arr[0]+1));把数组的初始化改一下
cpp
int main()
{
char arr[] = "abcdef"; //7个元素，最后省略的\0也是一个元素
printf("%zd\n", sizeof(arr));//7 ---arr是数组名，单独放在了sizeof内部，计算的是数组的总大小
printf("%zd\n", sizeof(arr + 0));//4或者8 ---arr表示的是首元素的地址，arr+0还是首元素的地址，地址的大小就是4或者8
printf("%zd\n", sizeof(*arr));//1 ---*arr就是首元素a ，char类型字节为1
printf("%zd\n", sizeof(arr[1]));//1 ---arr[1]就是第二个元素b，字节是1
printf("%zd\n", sizeof(&arr));//4或者8 ---&arr是数组地址
printf("%zd\n", sizeof(&arr + 1));//4或者8 --- +1跳过整个地址，结果还是地址
printf("%zd\n", sizeof(&arr[0] + 1));//4或者8 --- +1就是第二个元素的地址，结果还是地址
return 0;
}输出结果：
解析：
7 ---arr是数组名，单独放在了sizeof内部，计算的是数组的总大小
4或者8 ---arr表示的是首元素的地址，arr+0还是首元素的地址，地址的大小就是4或者8
cpp
printf("%zd\n", sizeof(arr));
printf("%zd\n", sizeof(arr + 0));1 ---*arr就是首元素a ，char类型字节为1
1 ---arr[1]就是第二个元素b，字节是1
cpp
printf("%zd\n", sizeof(*arr));
printf("%zd\n", sizeof(arr[1]));4或者8 ---&arr是数组地址
4或者8 --- +1跳过整个地址，结果还是地址
4或者8 --- +1就是第二个元素的地址，结果还是地址
cpp
printf("%zd\n", sizeof(&arr));
printf("%zd\n", sizeof(&arr + 1));
printf("%zd\n", sizeof(&arr[0] + 1));初始化的创建换成指针
代码如下：
cpp
int main()
{
const char* p = "abcdef";
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的类型是const char* ，而*p就是char类型
printf("%d\n", sizeof(p[0]));//1 ---p[0] == *(p+0) == *p == 'a'
printf("%d\n", sizeof(&p));//4或者8 ---取出的是p的地址
printf("%d\n", sizeof(&p+1));//4或者8 ---它跳过的是p指针变量后的地址
printf("%d\n", sizeof(&p[0]+1));//4或者8 ---&p[0] 取出的是首元素的地址，+1就是第二个元素的地址
return 0;
}输出结果：
计算换成strlen
cpp
int main()
{
char arr[] = { 'a','b','c','d','e','f' };
printf("%d\n", strlen(arr));//结果是随机的---arr是首元素的地址，但是数组里面没有\0，所以strlen在计算的时候会导致越界访问
printf("%d\n", strlen(arr+0));//同上
//printf("%d\n", strlen(*arr));//arr首元素的地址，*arr是数组的首元素，即'a'，它的ASCII的值是97，相当于把97传给了strlen，所以strlen得到的就是野指针，代码有问题
//printf("%d\n", strlen(arr[1]));//arr[1]=='b'，代码错误，原因同上
printf("%d\n", strlen(&arr));//随机值 ---&arr是数组的地址，起始位置是数组的第一个元素的位置，假如是随机值是x
printf("%d\n", strlen(&arr+1));//随机值 ---也是找不到\0 ，则值x-6
printf("%d\n", strlen(&arr[0]+1));//随机值 ---它是从第二个元素开始往后计算的 , 则值x-1
return 0;
}输出结果：
把数组的初始化改一下
cpp
int main()
{
char arr[] = "abcdef"; //后面有个省略的\0
printf("%d\n", strlen(arr));//6
printf("%d\n", strlen(arr + 0));//6 ---arr+0是首元素的地址，往后一直计算到\0之前的数为6个字符
//printf("%d\n", strlen(*arr));//错误代码 ---strlen得到的是'a'，为97，野指针
//printf("%d\n", strlen(arr[1]));//错误代码 ---得到的是'b'
printf("%d\n", strlen(&arr));//6 ---&arr是数组的地址，也是从数组第一个元素往后找\0之前的数，为6
printf("%d\n", strlen(&arr + 1));//随机值
printf("%d\n", strlen(&arr[0] + 1));//5 ---&arr[0] + 1相当于从'b'开始往后面找\0之前的数，为5
return 0;
}输出结果：
初始化的创建换成指针
cpp
int main()
{
char* p = "abcdef";
printf("%d\n", strlen(p));//6
printf("%d\n", strlen(p+1));//5
//printf("%d\n", strlen(*p));//错误代码 ---*就是'a',是97，野指针
//printf("%d\n", strlen(p[0]));//错误代码 ---p[0] == *(p+0) == *p 即'a',97野指针
printf("%d\n", strlen(&p));//随机值 ---&p是指针变量p的地址，和字符串没什么关系，因为它是从p这个指针变量的起始位置开始往后计算的，又因为p变量存放的地址是什么？我们不知道，所以是随机值
printf("%d\n", strlen(&p+1));//随机值 ---同上
printf("%d\n", strlen(&p[0]+1 ));//5 ---&p[0] 取出的是首元素的地址，+1就是第二个元素的地址
return 0;
}输出结果：
2.3二维数组
代码如下：
cpp
int main()
{
int a[3][4] = { 0 };
printf("%d\n", sizeof(a));//48 ---a是数组名，并且单独放在sizeof内部，计算的是数组的大小，单位是字节
printf("%d\n", sizeof(a[0][0]));//4 ---a[0][0]就是第一行第一个元素，为int型 即4个字节
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], +1后就是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表示二维数组首元素的地址，也就是第一行的地址，a+1会跳过一行，即第二行的地址
printf("%d\n", sizeof(*(a + 1)));//16 ---a + 1是第二行的地址，*(a + 1)就是第二行，计算的是第二行的大小，即16
//还有一个思路：*(a + 1) == a[1] ，它就是第二行的数组名，也就是把a[1]单独放在了sizeof里面，然后单独计算第二行的大小
printf("%d\n", sizeof(&a[0] + 1));//4或者8 ---a[0]是第一行的数组名，&a[0]取出的是第一行数组的地址，+1就是第二行的地址
printf("%d\n", sizeof(*(&a[0] + 1)));//16 ---*(&a[0] + 1)就是第二行数组
printf("%d\n", sizeof(*a));//16 ---a是数组名，没有单独放在sizeof内部，所以a表示二维数组首元素的地址，*a就是第二行数组，计算第二行数组的大小，即16
//还有一个思路：*a == *（a+1）== a[0]
printf("%d\n", sizeof(a[3]));//16 ---虽然我们没有四行数组，但是sizeof并不会去访问第四行的值，a[3]单独放在sizeof内部，计算的是第四行的数组的大小，为16
return 0;
}输出结果：
3.指针运算笔试题
3.1 题目1
代码如下：
cpp
int main()
{
int a[5] = { 1, 2, 3, 4, 5 };
int* ptr = (int*)(&a + 1); // (int*)强制转换为int* ，因为后面取的是地址
printf("%d,%d", *(a + 1), *(ptr - 1)); // 2 5
return 0;
}输出结果：
3.2 题目2
在X86（32bit）环境下
假设结构体的⼤⼩是20个字节
程序输出的结果是啥？
cpp
struct Test
{
int Num;
char* pcName;
short sDate;
char cha[2];
short sBa[4];
}*p = (struct Test*)0x100000; // 强制转换为(struct Test*) p是指针变量，这里我们存放的是地址0x100000（随便取的）
int main()
{
printf("%p\n", p + 0x1);//0x1是16进制的1
printf("%p\n", (unsigned long)p + 0x1);//unsigned long是无符号的整型 ，这里按整型+1来计算就行了
printf("%p\n", (unsigned int*)p + 0x1);//unsigned int*无符号的整型指针，这里的+1相当于+4
return 0;
}输出结果：
3.3 题目3
cpp
int main()
{
int a[3][2] = { (0, 1), (2, 3), (4, 5) }; //注意这里是小括号，(0, 1)是一个逗号表达式，按照从左往右来计算
//正真的数组 = {1 ,3 ,5}
int* p;
p = a[0]; //a[0]是第一行的数组名，没有单独放在sizeof内部，所以表示的是首元素的地址，即&a[0][0]的地址,
printf("%d", p[0]); //输出为1， p[0] == *(p+0) == *p
return 0;
}输出结果：
3.4 题目4
假设环境是x86环境，程序输出的结果是啥？
cpp
int main()
{
int a[5][5];
int(*p)[4]; //p是一个数组指针，p指向的数组是4个整型元素的
p = a;
printf("%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
return 0;
}3.5 题目5
cpp
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;
}3.6 题目6
cpp
int main()
{
char* a[] = { "work","at","alibaba" };
char** pa = a;
pa++;
printf("%s\n", *pa);
return 0;
}3.7 题目7
cpp
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;
}以上就是我们的全部内容了，谢谢大家