0基础C语言积跬步之深入理解指针（5上）

目录

1.sizeof 和 strlen 的对比

2.数组和指针笔试题分析

3.指针运算笔试题分析

---

一、sizeof 和strlen 的对比

1.1sizeof

sizeof操作符是用来计算变量的类型所占的内存空间大小的

sizeof不管内存中存的是什么值，多大的值，只看这个数的类型所占的内存空间的大小

1.2strlen

strlen是一个库函数，使用需要包括头文件#include <string.h>，函数原型是：

size_t strlen(const char* str);

strlen库函数统计的是从str起始位置开始，一直往后找'\0'，统计'\0'之前字符的个数

strlen 不管数组类型，永远是 1 个字节、1 个字节 向后扫描，直到找到 \0 才停止

因为如果没有'\0'，strlen库函数就会一直找，存在越界访问的问题，比如：

#include <stdio.h>
#include <string.h>
int main()
{
	char arr1[3] = { 'a', 'b', 'c' };
	char arr2[] = "abc";
	printf("%d\n", strlen(arr1));
	printf("%d\n", strlen(arr2));

	printf("%d\n", sizeof(arr1));
	printf("%d\n", sizeof(arr2));
	return 0;
}

运行截图：

arr2我们知道，字符串末尾都会自动放入一个隐藏字符'\0'，所以起始字符数组arr2里存的是4个字符，abc和'\0'，所以strlen(arr2)会显示3，sizeof(arr2)会显示4；arr1中，由于存的是单个字符，并没有存'\0'，所以就只有三个字符，sizeof(arr1)的结果为3，但strlen会一直往后找'\0'，一直找到'\0'后才统计'\0'之前字符的个数，终于在查询第36个字符的时候找到了'\0'，我们可以来看看调试中的结果：

可以看到，确实arr1[35]中存的是'\0'，arr[35]对应的是第36个字符，所以'\0'之前有35个字符，strlen(arr1)会打印35

1.3sizeof 和strlen 的对比

特性	sizeof	strlen
本质	运算符	库函数（<string.h>）
作用	求变量 / 类型 / 数组占用内存字节数	求字符串实际字符个数 （不含\0）
结束标志	无，直接算整体空间	遇到 \0 停止
执行时机	编译期	运行时
数组	数组名不退化，求整个数组大小	数组名退化为指针，只测字符串长度
空字符\0	占 1 字节，会被计算	不算长度
返回类型	size_t	size_t

二、数组和指针笔试题分析

2.1一维数组

（1）题一：求运行结果

#include <stdio.h>
int main()
{
    int a[] = { 1,2,3,4 };             //运行结果：
    printf("%d\n", sizeof(a));         //16
    printf("%d\n", sizeof(a + 0));     //8
    printf("%d\n", sizeof(*a));        //4
    printf("%d\n", sizeof(a + 1));     //8
    printf("%d\n", sizeof(a[1]));      //4
    printf("%d\n", sizeof(&a));        //8
    printf("%d\n", sizeof(*&a));       //16
    printf("%d\n", sizeof(&a + 1));    //8
    printf("%d\n", sizeof(&a[0]));     //8
    printf("%d\n", sizeof(&a[0] + 1)); //8
    return 0;
}

我们从上往下来一步步分析一下运行结果：

printf("%d\n", sizeof(a))，我们知道当数组名a单独放在sizeof操作符中，a代表的是整个数组，而a的类型是一个拥有四个类型为int数据的数组，所占内存大小为4*4=16，sizeof(a)就会计算得出结果就是16；

printf("%d\n", sizeof(a + 0))，此时a不是单独出现在sizeof中了，a表示的就是数组的首元素地址，a+0地址没动，依然首元素的地址，而地址也就是指针，我们知道，一个指针的大小，在32位电脑下占四个字节，在64位电脑下占8个字节，所以这里sizeof(a + 0)得出的计算结果是4或者8；

printf("%d\n", sizeof(*a))，a不是单独出现在sizeof中，所以a表示数组首元素地址，*a取出的就是数组的第一个元素的值，而这个值是int类型的，int类型大小为4个字节，所以sizeof(*a)计算出的结果为4；

printf("%d\n", sizeof(a + 1))，a代表的是首元素地址，也就是指针，指针+1还是指针，所以sizeof(a+1)计算出的结果就是指针的大小，为4或者8；

printf("%d\n", sizeof(a[1]))，a[1]代表的就是第一个元素，为int类型，大小为4，结果也为4

printf("%d\n", sizeof(&a))，&a取的是整个数组的地址，类型为int(*)[4]，是一个指针，是指针大小就为4或者8， 所以sizeof(&a)的计算结果也为4或者8

⭐️printf("%d\n", sizeof(*&a))，&a取的是整个数组的地址，对整个数组的地址进行解引用，得到就是整个数组，整个数组的大小也就是16个字节，所以sizeof(*&a)的结果就为16，我们也可以理解为*&a==a，所以计算的就是sizeof(a)的大小

printf("%d\n", sizeof(&a + 1))，&a取的是整个数组的地址，也就是指针，指针+1还是指针，所以大小为4或者8

printf("%d\n", sizeof(&a[0]))，a[0]是第一个元素，&a[0]就是取出第一个元素的地址，是指针，大小而4或者8

sizeof(&a[0] + 1)，上一句分析可知：&a[0]取出的是第一个元素的地址，地址+1还是地址，地址就是指针，所以大小为4或者8

我们来检验一下我们分析的结果：

#include <stdio.h>
int main()
{
    int a[] = { 1,2,3,4 };
    printf("sizeof(a)==%d\n", sizeof(a));         //16
    printf("sizeof(a + 0)==%d\n", sizeof(a + 0));     //8
    printf("sizeof(*a)==%d\n", sizeof(*a));        //4
    printf("sizeof(a + 1)==%d\n", sizeof(a + 1));     //8
    printf("sizeof(a[1])==%d\n", sizeof(a[1]));      //4
    printf("sizeof(&a)==%d\n", sizeof(&a));        //8
    printf("sizeof(*&a)==%d\n", sizeof(*&a));       //16
    printf("sizeof(&a + 1)==%d\n", sizeof(&a + 1));    //8
    printf("sizeof(&a[0])==%d\n", sizeof(&a[0]));     //8
    printf("sizeof(&a[0] + 1)==%d\n", sizeof(&a[0] + 1)); //8
    return 0;
}

运行截图：

2.2字符数组

（1）（2）字符数组中存的是一个个的单个字符

（3）（4）字符数组中存的是字符串

（5）（6）是将字符串存入一个*p指针

（1）题一：求运行结果

#include <stdio.h>
int main()
{
    char arr[] = { 'a','b','c','d','e','f' };
    printf("%d\n", sizeof(arr));         //6
    printf("%d\n", sizeof(arr + 0));       //8
    printf("%d\n", sizeof(*arr));        //1
    printf("%d\n", sizeof(arr[1]));      //1
    printf("%d\n", sizeof(&arr));        //8
    printf("%d\n", sizeof(&arr + 1));      //8
    printf("%d\n", sizeof(&arr[0] + 1));   //8
    return 0;
}

我们从上往下来一步步分析一下运行结果：

sizeof(arr)，因为这个是字符数组，存的是一个一个的字符，不是字符串，末尾不会隐藏'\0'，所以数组写进去了多少个字符，就是多少个字符，这里我们写了六个字符进去，所以数组大小会自动初始化为6，sizeof(arr)计算的就是数组的大小，结果为6

sizeof(arr + 0)，arr不单独存放在sizeof中，为首元素地址，地址+1还是地址，结果为4或者8

sizeof(*arr)，arr代表的是首元素地址，*arr取出的是首元素的值，为char类型，大小为1个字节，所以结果为1

printf("%d\n", sizeof(arr[1]))，arr[1]指的是数组第二个元素的值，也是char类型，占1个字节，所以结果为也为1

printf("%d\n", sizeof(&arr))，&arr取的是整个数组的地址，为int(*)[6]，是一个数组指针类型，但既然是指针，那么大小就是4或者8，所以结果为4或者8

printf("%d\n", sizeof(&arr + 1))，&arr上一句分析出代表的含义是，一个int(*)[6]类型的数组指针，指针+1还是指针，所以结果还是为4或者8

printf("%d\n", sizeof(&arr[0] + 1))，&arr[0]取出arr[0]也就是第一个元素的地址，再加1，还是地址，所以结果为4或者8

我们来检验一下我们分析的结果：

#include <stdio.h>
int main()
{
    char arr[] = {'a','b','c','d','e','f'};
    printf("sizeof(arr)==%d\n", sizeof(arr));          // 6
    printf("sizeof(arr+0)==%d\n", sizeof(arr+0));      // 8
    printf("sizeof(*arr)==%d\n", sizeof(*arr));        // 1
    printf("sizeof(arr[1])==%d\n", sizeof(arr[1]));     // 1
    printf("sizeof(&arr)==%d\n", sizeof(&arr));        // 8
    printf("sizeof(&arr+1)==%d\n", sizeof(&arr+1));     // 8
    printf("sizeof(&arr[0]+1)==%d\n", sizeof(&arr[0]+1)); // 8
    return 0;
}

运行截图：

（2）题二：求运行结果

#include <stdio.h>
#include <string.h>
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;
}

我们从上往下来一步步分析一下运行结果：

strlen(arr)，由于这是个字符数组，没有存'\0'，strlen就会一直向后去找'\0'，直到找到为止，然后返回'\0'之前的字符个数，'\0'的存储位置在哪我们无法的值，所以统计出来的数为随机值

printf("%d\n", strlen(arr + 0))，这个和上一句的结果是一样的，arr是首元素地址，+0依然是首元素地址，就等同于上一句的strlen(arr)，结果为随机值

strlen(*arr)，arr是首元素地址，*arr是取出首元素地址存放的值，也就是首元素的值，是char类型，但strlen要的参数得是指针类型，所以会直接报错，程序崩溃，终止运行

strlen(arr[1])，这里是将字符数组中下标为1的元素的值传给了strlen，而不是地址，所以也会直接报错，程序崩溃，终止运行

strlen(&arr)，&arr取的是整个数组的地址，但是在数值上等同于arr的首元素地址，所以也是从首元素开始往后一个字节一个字节遍历，直到遇到'\0'，但'\0'的存储位置在哪我们无法的值，所以统计出来的数为随机值

strlen(&arr + 1)，&arr+1的意思是跳过了整个数组，然后再从arr[6]的位置开始，往后寻找'\0'，就会比strlen(arr)，少遍历六个字符，所以结果会比strlen(arr)少6个数，如果strlen(arr)==36，那么strlen(&arr + 1)就等于30

strlen(&arr[0] + 1)，&arr[0] + 1的意思是首元素地址+1，那就会找到第二个元素，也就是下标为1的元素，然后再从这个元素开始往后遍历，也就是少遍历一个字符，所以会比比strlen(arr)少1个数，如果strlen(arr)==36，那么strlen(&arr[0] + 1)就等于35

我们来检验一下我们分析的结果：

程序无崩溃的代码：

#include <stdio.h>
#include <string.h>
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[0] + 1));     // 随机值
    return 0;
}

运行截图：

程序崩溃的代码：

#include <stdio.h>
#include <string.h>
int main()
{
    char arr[] = { 'a','b','c','d','e','f' };
    printf("%zu\n", strlen(*arr));          // 报错/崩溃
    printf("%zu\n", strlen(arr[1]));        // 报错/崩溃
    return 0;
}

运行截图：

会出现这个错误，因为strlen参数需要的是char *类型的地址，却传了个char类型的值过去，所以有此报错，程序什么也没有打印出来，直接崩溃，终止执行

（3）题三：求运行结果

#include <stdio.h>
int main()
{
    char arr[] = "abcdef";  
    printf("%d\n", sizeof(arr));       // 7
    printf("%d\n", sizeof(arr + 0));     // 4/8
    printf("%d\n", sizeof(*arr));      // 1
    printf("%d\n", sizeof(arr[1]));    // 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
    return 0;
}

我们从上往下来一步步分析一下运行结果：

sizeof(arr)，计算的是整个字符数组的大小，为7

sizeof(arr + 0)，arr+0指的是数组首元素的地址，大小为4或8

sizeof(*arr)，*arr取的是首字符a，为char类型，大小为1

sizeof(arr[1])，下标为1的元素，是char类型，大小为1

sizeof(&arr)，&arr取的是整个数组的地址，是地址！也就是指针！大小为4或者8！

sizeof(&arr + 1)，整数数组的地址+1，还是地址，所以大小还是为4或8

sizeof(&arr[0] + 1)，首元素地址+1，表示指向第二个元素的地址，仍然是地址，大小为4或8

我们来检验一下我们分析的结果：

运行截图：

（4）题四：求运行结果

#include <stdio.h>
#include <string.h>
int main()
{
    char arr[] = "abcdef"; 
    printf("%d\n", strlen(arr));          // 6
    printf("%d\n", strlen(arr + 0));        // 6
    printf("%d\n", strlen(*arr));         // 崩溃/错误
    printf("%d\n", strlen(arr[1]));       // 崩溃/错误
    printf("%d\n", strlen(&arr));         // 6
    printf("%d\n", strlen(&arr + 1));       // 随机值
    printf("%d\n", strlen(&arr[0] + 1));    // 5
    return 0;
}

我们从上往下来一步步分析一下运行结果：

首先字符串的末尾是自带了一个隐藏的'\0'

strlen(arr)，arr传的是首元素地址，从数组首元素开始，向后遍历，统计'\0'之前的字符个数，为6

strlen(arr+0)，arr+0依然表示首元素地址，同上一句，结果为6

strlen(*arr)，*arr取出的是首元素的值，而不是地址，会直接报错，程序崩溃，终止运行

strlen(arr[1])，arr[1]也是数组的元素，不是地址，直接报错，程序崩溃，终止运行

strlen(&arr)，&arr取的是整个数组的地址，但是在数值上等同于arr的首元素地址，所以也是从首元素开始往后一个字节一个字节遍历，结果为6

strlen(&arr + 1)，&arr+1直接跳过整个数组，跳过了字符串末尾自带的'\0'，然后开始往后一个字节一个字节遍历，但我们已经不知道哪里再会遇到'\0'了，所以结果为随机值

strlen(&arr[0] + 1)，&arr[0] + 1的意思是首元素地址+1，那就会找到第二个元素，也就是下标为1的元素，然后再从这个元素开始往后遍历，就少遍历一个元素，所以结果为少1，结果为5

我们来检验一下我们分析的结果：

程序无崩溃的代码：

#include <stdio.h>
#include <string.h>
int main()
{
    char arr[] = "abcdef"; 
    printf("%d\n", strlen(arr));          // 6
    printf("%d\n", strlen(arr + 0));        // 6
    printf("%d\n", strlen(&arr));         // 6
    printf("%d\n", strlen(&arr + 1));       // 随机值
    printf("%d\n", strlen(&arr[0] + 1));    // 5
    return 0;
}

运行截图：

程序崩溃的代码：

#include <stdio.h>
#include <string.h>
int main()
{
    char arr[] = "abcdef";
    printf("%d\n", strlen(*arr));         // 崩溃/错误
    printf("%d\n", strlen(arr[1]));       // 崩溃/错误
    return 0;
}

运行截图：

strlen参数需要的是char *类型的地址，却传了个char类型的值过去，所以有此报错

（5）题五：求运行结果

#include <stdio.h>
int main()
{
    char* p = "abcdef";
    printf("%d\n", sizeof(p));        // 4/8
    printf("%d\n", sizeof(p + 1));      // 4/8
    printf("%d\n", sizeof(*p));       // 1
    printf("%d\n", sizeof(p[0]));     // 1
    printf("%d\n", sizeof(&p));       // 4/8
    printf("%d\n", sizeof(&p + 1));     // 4/8
    printf("%d\n", sizeof(&p[0] + 1));  // 4/8
    return 0;
}

我们从上往下来一步步分析一下运行结果：

首先字符串的末尾是自带了一个隐藏的'\0'

sizeof(p)，p中存的是字符串首元素的地址，是指针，大小为4或8

sizeof(p+1)，p+1指向的是第二个元素的地址，也是指针，大小为4或8

sizeof(*p)，*p取出的是首元素地址对应元素的值，是char类型，大小为1

sizeof(p[0])，p[0]取出的是首元素地址对应元素的值，是char类型，大小为1

sizeof(&p)，&p取的是字符指针变量p本身的地址，类型是二级指针类型（char**），是指针，所以大小为4或8

sizeof(&p + 1)，&p取出的是指针变量p本身的地址，类型是二级指针类型（char**），地址+1还是地址，大小为4或8

sizeof(&p[0] + 1)，&p[0]取出的是字符串首元素的地址，+1之后还是地址，大小为4或8

我们来检验一下我们分析的结果：

运行截图：

（6）题六：求运行结果

#include <stdio.h>
#include <string.h>
int main() {
    char* p = "abcdef";
    printf("%d\n", strlen(p));       // 6
    printf("%d\n", strlen(p + 1));     // 5
    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)); // 5
    return 0;
}

我们从上往下来一步步分析一下运行结果：

strlen(p)，p存的是首元素地址，表示从首元素开始往后遍历，统计'\0'之前的字符个数，为6

strlen(p+1)，p+1指向的是第二个元素的地址，从第二个元素开始往后遍历，少遍历一个首元素，所以'\0'之前的字符个数会少一个，为5

strlen(*p)，*p取出的是首元素地址对应元素的值，是char类型，不是地址，程序会直接报错，程序崩溃，终止运行

strlen(p[0])，p[0]取出的是首元素地址对应元素的值，是char类型，不是地址，程序会直接报错，程序崩溃，终止运行

strlen(&p)，&p取的是字符指针变量p本身的地址，类型是二级指针类型（char**），但它不指向字符串，从这个地址开始往后遍历，我们无法得知'\0'的位置，结果为随机值

strlen(&p + 1)，&p + 1和上一句一样，char**类型指针+1会跳过1个字节，所以会比strlen(&p)少遍历一个字符，随机值的大小会比strlen(&p)的结果少1

strlen(&p[0] + 1)，&p[0]可以写成(&*(p+0))+1，&和*抵消，也就是(p+0)+1，p代表首元素地址，+0还是首元素地址，+1后指向第二个元素的地址，所以从第二个元素开始往后遍历，结果为5

我们来检验一下我们分析的结果：

程序无崩溃的代码：

#include <stdio.h>
#include <string.h>
int main() {
    char* p = "abcdef";
    printf("%d\n", strlen(p));       // 6
    printf("%d\n", strlen(p + 1));     // 5
    printf("%d\n", strlen(&p));      // 随机值
    printf("%d\n", strlen(&p + 1));    // 随机值
    printf("%d\n", strlen(&p[0] + 1)); // 5
    return 0;
}

运行截图：

程序崩溃的代码：

#include <stdio.h>
#include <string.h>
int main() {
    char* p = "abcdef";
    printf("%d\n", strlen(*p));      // 错误/崩溃
    printf("%d\n", strlen(p[0]));    // 错误/崩溃
    return 0;
}

运行截图：

strlen参数需要的是char *类型的地址，却传了个char类型的值过去，所以有此报错

2.3二维数组

（1）题一：求运行结果

#include <stdio.h>
int main() 
{
    int a[3][4] = { 0 };
    printf("%d\n", sizeof(a));          // 48
    printf("%d\n", sizeof(a[0][0]));    // 4
    printf("%d\n", sizeof(a[0]));       // 16
    printf("%d\n", sizeof(a[0] + 1));     // 8
    printf("%d\n", sizeof(*(a[0] + 1)));  // 4
    printf("%d\n", sizeof(a + 1));        // 8
    printf("%d\n", sizeof(*(a + 1)));     // 16
    printf("%d\n", sizeof(&a[0] + 1));    // 8
    printf("%d\n", sizeof(*(&a[0] + 1))); // 16
    printf("%d\n", sizeof(*a));         // 16
    printf("%d\n", sizeof(a[3]));       // 16
    return 0;
}

我们从上往下来一步步分析一下运行结果：

sizeof(a)，数组名单独放在sizeof中时，计算的是整个二维数组的地址，为48

sizeof(a[0][0])，a[0][0]表示二维数组第一个元素的值，大小是int类型，为4

sizeof(a[0])，a[0]表示二维数组首行的地址，也就是第一行一整行的地址，一行有4个int类型的元素，所以大小为4个整型的大小，为16

sizeof(a[0] + 1)，我们知道，a[0]表示二维数组首行的地址，那么a[0] + 1，也可以写成*(a+0)+1，表示这一行中第一个元素的地址，是个地址，大小为4或者8

sizeof(*(a[0] + 1))，这个就是对我们上一句分析的a[0] + 1，进行了解引用操作，也就是*(*(a+0)+1),表示对第一行中第一个元素的地址进行了解引用，找到的是二维数组第一行第一个元素的值，为int类型，大小为4

sizeof(a + 1)，此时数组名a不是单独放在sizeof里面，所以a表示二维数组首元素的地址，也就是首行一整行的地址，+1跳过的是一整行，指向第二行的起始地址，存的是第二行一整行的地址，但只要是地址，那所占内存空间大小就是4或8

sizeof(*(a + 1))，对第二行一整行的地址解引用，找到的是第二行一整行的4个int类型的元素，总大小为16，sizeof(*(a + 1))的结果就为16

sizeof(&a[0] + 1)，a[0]表示的是首行第一个元素的地址，我们可以理解为一个一维数组的数组名是a[0]，&a[0]表示整个一维数组的地址，+1就会跳过这一整个一维数组，进入下一个一维数组，也就是指向二维数组的第二行整行的地址，数值上等价于第二行首元素的地址位置；也可以这样理解，&a[0] + 1==(&*(a+0))+1==(a+0)+1==a+1;a+1我们就很容易理解知道，a+1表示的时二维数组第二行的起始地址，因为是地址，所以大小为4或者8

*(&a[0] + 1)，上一句分析可知&a[0] + 1指的是，整个第二行的地址，所以对齐进行解引用后，指向的就是第二行一整行的元素，为4个int类型的元素，总占内存空间大小为16，所以*(&a[0] + 1)的结果为16

sizeof(*a)，a代表的是二维数组首元素的地址，也就是首行一整行的地址，再解引用，找到的就是第一行四个int类型元素，所占内存空间大小为16，所以sizeof(*a)的值为16

sizeof(a[3])，a[3]表示的是二维数组第三行整行的地址，解引用后找到的是第三行整行的元素，sizeof计算的就是整行的元素总共所占内存空间的大小，也是四个int类型的元素，所占内存空间大小为16

我们来检验一下我们分析的结果：

运行截图：

感谢大家的观看，佬们互三互三，关注我必回关！下章见！