大家好，我是安然无虞。
文章目录
每篇前言
博客主页：安然无虞
作者介绍：2021年博客新星Top2
咱的口号：🌹小比特，大梦想🌹
作者请求：由于博主水平有限，难免会有错误和不准之处，我也非常渴望知道这些错误，恳请铁汁批评斧正。
火爆专栏：蓝桥杯基础算法剖析
首先回顾一个知识点：
传统上，数组名表示首元素的地址
有两个例外：
- sizeof(数组名)：单单一个数组名放到sizeof里面，此时的数组名表示的不再是首元素的地址，而是整个数组，计算的是整个数组的大小，单位是字节（注意这个单单！）；
- &数组名：取出的是整个数组的地址。
好，介绍完这个知识点，那么请看下面一系列笔试题：
一、一维数组
//一维数组 #include<stdio.h> int main() { int a[] = { 1,2,3,4 }; printf("%d\n", sizeof(a));//16 //单单一个数组名a放到sizeof里面，此时的数组名表示的是整个数组，计算的是整个数组的大小（注意这个单单！） printf("%d\n", sizeof(a + 0));//4/8 - 在32位平台占4个字节，64位平台占8个字节 //此时不止数组名a一个放在sizeof里，所以a表示的是首元素的地址，类型是int*，a+0跳过0个整型，表示的还是首元素的地址 //地址就是指针，指针在32位平台占4个字节，在64位平台占8个字节 printf("%d\n", sizeof(*a));//4 //此时a表示的是首元素的地址，对其进行解引用操作，拿到的是首元素，所以这里计算的是首元素的大小 printf("%d\n", sizeof(a + 1));//4/8 //此时a表示的是首元素的地址，类型是int*，a+1跳过一个整型，所以a+1表示的是第二个元素的地址，也就是2的地址 printf("%d\n", sizeof(a[1]));//4 //计算的是第二个元素的大小 printf("%d\n", sizeof(&a));//4/8 //&a取出的是整个数组的地址，类型是int(*)[4]，属于数组指针，数组指针依然是指针 printf("%d\n", sizeof(*&a));//16 //理解1：可认为*和&操作抵消了，此时只剩下sizeof(a),a表示的是整个数组，计算的是整个数组的大小； //理解2：&a，取出整个数组的地址，类型是int(*)[4]数组指针类型，然后对其解引用，此时访问到的是整个数组，大小是16字节 printf("%d\n", sizeof(&a + 1));//4/8 //&a取出的是整个数组的地址，类型是int(*)[4]数组指针，&a+1跳过了整个数组的地址，是地址就是4/8个字节 printf("%d\n", sizeof(&a[0]));//4/8 //&a[0]，取出的是首元素的地址 printf("%d\n", sizeof(&a[0] + 1));//4/8 //&a[0]+1，跳过1个整型，所以&a[0]+1访问的是第二个元素的地址 return 0; }
二、字符数组
1.题型一
注意这样的一个概念：
sizeof：
- sizeof只关注占用空间的大小；
- sizeof不关注类型；
- sizeof是操作符
strlen()：
- strlen()关注的是字符串中’\0’之前字符的个数；
- strlen()只针对于字符串；
- strlen()是库函数
好，请看下面的代码：
代码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));//4/8 //计算的是首元素的地址 printf("%d\n", sizeof(*arr));//1 //计算的是首元素的大小 printf("%d\n", sizeof(arr[1]));//1 //计算的是第二个字符的大小 printf("%d\n", sizeof(&arr));//4/8 //&arr，取出的是整个数组的地址，地址就是指针 printf("%d\n", sizeof(&arr + 1));//4/8 //&arr+1,跳过了整个数组，不过依然是地址 printf("%d\n", sizeof(&arr[0] + 1));//4/8 //&arr[0]表示首字符的地址，类型是char*,所以&arr[0]+1跳过一个字符，指向第二个字符的地址 return 0; }
代码2：
#include<stdio.h> int main() { char arr[] = { 'a','b','c','d','e','f' }; printf("%d\n", strlen(arr));//随机值 //strlen()遇到'\0'结束，统计的是'\0'之前字符的个数，但是arr中没有'\0'，所以不知道在具体哪里结束，故而这里是随机值 printf("%d\n", strlen(arr + 0));//随机值 //同上 printf("%d\n", strlen(*arr));//内存访问冲突 //strlen()里面的参数是指针类型（可认为里面存放的是地址），*arr表示的是首元素，也就是'a'，'a'的ACSII值是97， //所以strlen(*arr)将'97'当作内存地址去访问了，这里就会导致内存访问冲突 printf("%d\n", strlen(arr[1]));//内存访问冲突 //同上，arr[1]表示的是'b',ACSII值是98，strlen(arr[1])表示将'98'当作内存地址去访问了 printf("%d\n", strlen(&arr));//随机值 //&arr，取出的是整个数组的地址，由于数组中没有'\0'，所以不知道会具体在哪里结束 printf("%d\n", strlen(&arr + 1));//随机值 printf("%d\n", strlen(&arr[0] + 1));//随机值 return 0; }
这里再重点强调一下这行代码：
printf("%d\n", strlen(*arr));
strlen()需要的是一个地址，从这个地址开始向后找字符直到’\0’，统计的是’\0’之前字符的个数，但是*arr表示的是首元素，也就是’a’，这时传递给strlen()的就是’a’的ACSII值97，strlen()会把97作为起始地址来统计字符串，这样的话也就会形成内存访问冲突。
2.题型二
代码1：
#include<stdio.h> int main() { char arr[] = "abcdef"; printf("%d\n", sizeof(arr));//7 //注意哦，sizeof(arr)计算的是arr数组所占内存空间的大小，包括'\0'在内 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; }
代码2：
有了上面的经验，那么下面一定难不到你啦！
#include<stdio.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; }
3.题型三
代码1：
#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; }
代码2：
#include<stdio.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));//随机值（注意哦，这里是特别容易出错的地方，特别容易错写成6） //这里要说的是，p指的是常量字符串，和字符数组是不一样的，p有自己的一块空间 printf("%d\n", strlen(&p + 1));//随机值 printf("%d\n", strlen(&p[0] + 1));//5 return 0; }
补充常量字符串
在指针类型中我们知道有一种指针类型是char*，它有两种使用方法：
一般使用：
#include<stdio.h> int main() { char ch = 'w'; char* pc = &ch; *pc = 'a'; printf("%c\n", ch); return 0; }
这种使用方法比较简单，我就不过多阐述了，看看下面这种使用方法：
#include<stdio.h> int main() { char* p = "abcdef"; printf("%s\n", p); return 0; }
- 注意上面的 abcdef 是常量字符串，存储在内存的只读数据区（只读不可写）
- 特别容易让我们以为是把字符串 abcdef 放到字符指针 p 里了，其实本质上是把字符串 abcdef 首字符的地址放到 p 中
所以下面代码是有问题的：
#include<stdio.h> int main() { char* p = "abcdef"; *p = 'w';//目的是将'a'改成'w'（bug） return 0; }
上面的第6行代码是错误的，因为常量字符串不可以修改，所以为避免上述错误，可将第5行代码修改为：
const char* p = "abcdef";
这样的话就会避免上述错误。
面试题：
#include <stdio.h> int main() { char str1[] = "hello bit."; char str2[] = "hello bit."; char* str3 = "hello bit."; char* str4 = "hello bit."; if (str1 == str2) printf("str1 and str2 are same\n"); else printf("str1 and str2 are not same\n"); if (str3 == str4) printf("str3 and str4 are same\n"); else printf("str3 and str4 are not same\n"); return 0; }
解题思路：
- str1 和 str2 是两个字符数组，数组的操作方式是将右边的常量字符串拷贝到数组的空间中，所以它们是两块空间，只是内容相同，而作为数组名，str1 和 str2 是数组首元素的地址，所以 str1 != str2
- str3 和 str4 是两个字符指针，指向的是同一个常量字符串，而常量字符串存储在单独的一个内存区域（只读数据区），当几个指针指向同一个常量字符串的时候，它们实际上会指向同一块内存
三、二维数组
#include<stdio.h> int main() { int arr[3][4] = { 0 }; printf("%d\n", sizeof(arr));//12*4=48 //sizeof(数组名)，计算的是整个数组的大小，单位是字节 printf("%d\n", sizeof(arr[0][0]));//4 printf("%d\n", sizeof(arr[0]));//4*4=16 //arr[0]相当于第一行的数组名，由于是单独放在sizeof内部，所以计算的是第一行数组的大小，单位是字节 printf("%d\n", sizeof(arr[0] + 1));//4/8 //arr[0]相当于第一行的数组名，由于不是单独放在sizeof内部，所以此时的arr[0]表示的是第一行首元素的地址 printf("%d\n", sizeof(*(arr[0] + 1)));//4 //前面提到arr[0]表示的是第一行首元素的地址，所以*(arr[0] + 1)表示的是arr[0][1]这个元素本身 printf("%d\n", sizeof(arr + 1));//4/8 //arr数组名表示的是首元素的地址，也就是第一行数组的地址，所以arr+1表示的是第二行数组的地址 printf("%d\n", sizeof(*(arr + 1)));//4*4=16 //前面提到arr+1表示的是第二行数组的地址，对其进行解引用操作，访问到的是第二行数组，单独放到sizeof内部，计算的是第二行数组的大小 printf("%d\n", sizeof(&arr[0] + 1));//4/8 //&arr[0]表示取出第一行数组的地址，那么&arr+1表示取出第二行数组的地址，地址就是指针 printf("%d\n", sizeof(*(&arr[0] + 1)));//4*4=16 //前面提到，&arr[0]+1表示的是第二行数组的地址，所以对其解引用表示的是第二行数组，单独放到sizeof内部，计算的是第二行数组的大小 printf("%d\n", sizeof(*arr));//4*4=16 //arr表示的是首元素的地址，也就是第一行数组的地址，对其进行解引用表示的是第一行数组，单独放到sizeof内部，计算的是第一行数组的大小 printf("%d\n", sizeof(arr[3]));//4*4=16 //这里我们可能会觉得arr[3]越界了，但是对于本题不影响，sizeof内部会推导出arr[3]类型是int[4] return 0; }
四、模拟实现字符串库函数
1.strlen()
函数原型：
函数功能：
求字符串的长度
注意：返回值类型是 size_t，这 size_t 到底是什么？
其实 size_t 是为 sizeof 操作符返回值设计的，可以浅显的认为 size_t 就是我们熟知的 unsigned int ，因为是求长度，所以肯定不会是负数，故而使用无符号整型，但是由此也容易产生 bug，请看下面代码：
解读下面代码，请问输出结果是什么：
#include<stdio.h> #include<string.h> int main() { if (strlen("abc") - strlen("abcdef") > 0) printf(">"); else printf("<="); return 0; }
没错，答案是输出 “>”，为什么呢？3 - 6 = -3鸭，这是怎么回事？
这是因为strlen的返回值是 size_t ，属于无符号数，所以两个无符号数相减，答案一定是无符号数。
那怎么修改呢？
方案一：强制类型转换
#include<stdio.h> #include<string.h> int main() { if ((int)strlen("abc") - (int)strlen("abcdef") > 0 ) printf(">"); else printf("<="); return 0; }
方案二：直接比较
#include<stdio.h> #include<string.h> int main() { if (strlen("abc") > strlen("abcdef")) printf(">"); else printf("<="); return 0; }
注意：
- 字符串以 ‘\0’ 作为结束标志，strlen 返回的是在字符串中 ‘\0’ 之前的字符个数（不包括’\0’）;
- 参数中指向的字符串必须以 ‘\0’ 结束；
- 注意strlen函数的返回值是 size_t 类型，属于无符号类型（特易错）
代码示例：
#include<stdio.h> #include<string> int main() { int len = strlen("abcdef"); printf("%d\n", len); return 0; }
自定义函数模拟实现strlen():
方法：
- 计数器的方法
- 递归的方法
- 指针 - 指针
方法一：计数器的方法
int my_strlen(const char* str) { assert(str);//断言str非空 int count = 0; while (*str != '\0') { count++; str++; } return count; }
方法二：递归的方法
int my_strlen(const char* str) { assert(str);//断言str非空 //找边界 if (*str == '\0') { return 0; } int count = my_strlen(str + 1); //注意str++和str+1是不同的概念 count++; return count; }
这里需要注意的是，str++ 和 str+1 不是一个概念，str++是先使用后++，本题可以写成++str的形式，先++再使用。
方法三：指针 - 指针
指针-指针其实表示的是两个指针中间的元素个数，注意哦，不是中间有几个字节。
int my_strlen(const char* str) { assert(str); const char* cur = str; while (*cur != '\0') { cur++; } return cur - str; }
2.strcpy()
函数原型：
函数功能：
将源字符串拷贝到目标字符串，返回目标字符串首元素的地址。
解读下列代码：
#include<stdio.h> #include<string.h> int main() { char arr1[] = "abcdef"; char arr2[20] = { 0 }; printf("%s\n", strcpy(arr2, arr1)); return 0; }
本题是将字符串 arr2 拷贝给字符串 arr1 ，返回的是 arrr2 首元素的地址（目标字符串首元素的地址）。所以上面代码输出的是：abcdef，那么这里的问题是，会不会将字符串arr1中的 ‘\0’ 拷贝给字符串 arr2 ，所以这里用以下代码验证这个问题：
#include<stdio.h> #include<string.h> int main() { char arr1[] = "abcdef"; char arr2[20] = "XXXXXXXXXX"; printf("%s\n", strcpy(arr2, arr1)); return 0; }
首先，还没有将字符串 arr1 拷贝给 arr2 时，它们存放的数据是这样的：
当执行 strcpy(arr2, arr1) 完后，此时 arr2 中存放的数据是这样的：
可以看到，将字符串 arr1（源字符串） 拷贝给字符串 arr2（目标字符串） 时会自动将源字符串末尾的 ‘\0’ 拷贝过去，返回的是目标字符串起始位置的地址。
这里又有一个问题是：如果源字符串末尾没有加上 ‘\0’ （这里用字符数组的形式演示，正常的字符串末尾会自动填充 ‘\0’），请看如下代码：
#include<stdio.h> #include<string.h> int main() { char arr1[] = { 'a','b','c','d','e','f' }; char arr2[20] = "XXXXXXXXXX"; printf("%s\n", strcpy(arr2, arr1)); return 0; }
代码执行结果：
所以需要注意的是：如果想将源字符串拷贝给目标字符串，那么就要保证源字符串中是包含 ‘\0’ 的，否则会拷贝失败。
所以，使用 strcpy 拷贝字符串是需要注意以下几点：
- 源字符串必须以 ‘\0’ 结束；
- 拷贝时会将源字符串中的 ‘\0’ 一同拷贝给目标字符串；
- 目标字符串（目标空间）必须足够大，以确保能存放源字符串 ；
- 还有一点就是，目标字符串必须是可以改变的
请看下面的代码：
#include<stdio.h> #include<string.h> int main() { char arr1[] = "abcdef"; const char* p = "XXXXXXXXXX"; printf("%s\n", strcpy(p, arr1)); return 0; }
执行程序是错误的，因为此时的目标字符串是被 const 修饰的，是不可以修改的。
自定义函数模拟实现strcpy()
代码执行：
char* my_strcpy(char* dest, const char* src) { char* ret = dest; assert(dest && src); while (*dest++ = *src++)//很妙 { ; } return ret; }
3.strcat()
函数原型：
函数功能：
将源字符串追加到目标字符串的后面，返回目标字符串首字符的地址
解读下列代码：
#include<stdio.h> #include<string.h> int main() { char arr1[30] = "hello"; char arr2[] = "world"; strcat(arr1, arr2); printf("%s\n", arr1); return 0; }
以上代码是将 “world” 拼接到 “hello” 的后面，所以打印结果如下：
其实，使用 strcat 库函数的注意事项与 strcpy 是十分相似的，在这里的话我就不重复解释了：
- 源字符串必须以 ‘\0’ 结束；
- 目标空间必须足够大，能容纳下源字符串的内容;
- 目标空间必须可变。
那么试想：如果让我们自己实现 strcat 函数，该怎么做呢？先想一下大致思路，我们首先要找到目标字符串的结束标志’\0’，然后将源字符串拼接到目标字符串的后面，最后返回目标字符串的首字符的地址，看起来好像挺简单的，那我们实现一下：
自定义函数模拟实现strcat()
代码执行：
char* my_strcat(char* dest, const char* src) { char* ret = dest; assert(dest && src); //1、找到目标字符串的\0 while (*dest)//注意循环条件写成*dest++是错误的，因为会跳过\0，请细品 { dest++; } //2、拷贝源字符串 while (*dest++ = *src++) { ; } return ret; }
4.strcmp()
函数原型：
函数功能：
比较对应位置上字符的字典序
标准规定：
- 第一个字符串 > 第二个字符串，则返回大于0的数字；
- 第一个字符串 == 第二个字符串，则返回0；
- 第一个字符串 < 第二个字符串，则返回小于0的数字。
敲黑板：
两个字符串不能直接进行比较，也不能直接进行相加相减运算，因为字符串表示的是首字符的地址。也就是说，如果直接进行比较的话，比的不是字符串的内容，而是地址，所以是错误的。
自定义函数模拟实现strcmp()
代码执行：
int my_strcmp(const char* str1, const char* str2) { assert(str1 && str2); while (*str1 == *str2)//注意是在循环体中判断相等的情况，想想为什么 { if (*str1 == '\0') return 0; str1++; str2++; } if (*str1 > *str2)//return *str1 - *str2; return 1; else return -1; }
五、模拟实现内存函数
1.memcpy()
函数原型：
注意哦，内存操作函数中的第三个参数单位是字节。
想想为什么是void*类型？
因为设计者在设计这个库函数的时候不知道会用来拷贝何种类型，所以只有设计成void*最合适。
看下面一段代码：
#include<stdio.h> #include<string.h> int main() { int arr1[] = { 1,2,3,4,5,6,7,8,9,10 }; int arr2[5] = { 0 }; memcpy(arr2, arr1 + 5, 5 * sizeof(arr1[0])); int i = 0; for (i = 0; i < 5; i++) { printf("%d ", arr2[i]); } return 0; }
自定义函数模拟实现memcpy()
代码执行：
void* my_memcpy(void* dest, const void* src, size_t num) { void* ret = dest;//注意返回类型是void*,而不是void， assert(dest && src); while (num--)//先使用，后-- { *(char*)dest = *(char*)src;//想想为什么强制类型转换成char*，因为只有它最合适 dest = (char*)dest + 1;//注意直接进行dest++,src++是错误的，因为它是空类型 src = (char*)src + 1; } return ret; }
2.memmove()
函数原型：
其实C语言只要求：
memcpy能拷贝不重叠的内存空间就可以了，memmove去处理那些重叠的内存拷贝，也就是说，如果记memcpy的功能是A，那么memmove的功能就是A+B
那么何为重叠的内存拷贝呢，请看下面一段代码：
#include<stdio.h> #include<string.h> int main() { int arr1[] = { 1,2,3,4,5,6,7,8,9,10 }; memmove(arr1 + 2, arr1, 5 * sizeof(arr1[0]));//处理同一块空间时会发生重叠内存拷贝 int i = 0; for (i = 0; i < 10; i++) { printf("%d ", arr1[i]); } return 0; }
自定义函数模拟实现memmove
代码执行：
void* my_memmove(void* dest, const void* src, size_t num) { void* ret = dest; assert(dest && src); if (dest < src)//从前向后拷贝 { while (num--) { *(char*)dest = *(char*)src; dest = (char*)dest + 1; src = (char*)src + 1; } } else//从后向前拷贝 { //src = (char*)src + num - 1;//注意一定要-1 //dest = (char*)dest + num - 1; //while (num--) //{ // *(char*)dest = *(char*)src; // dest = (char*)dest - 1; // src = (char*)src - 1; //} while (num--)//先使用，后--，在循环体中是--后的num（真的妙） { *((char*)dest + num) = *((char*)src + num); } } return ret; }
六、遇见安然遇见你，不负代码不负卿。
今天的面试题就到这里咯，有所收获的老铁麻烦动动小手来个三连🌹。
