掘金上篇：https://juejin.cn/post/7121858995047890957
掘金下篇：https://juejin.cn/post/7121864919985127431
目录
一、求字符串长度
strlen：专门用来求字符串长度的函数（这里的长度指的是字符串字符的个数）。
1、strlen库函数如何使用？
#include<stdio.h>
#include<string.h>
int main()
{
char arr[] = "abcdef";
int len = strlen(arr);
printf("%d\n", len);
return 0;
}输出结果：
?为什么会输出 6 呢？
解释：
strlen 从arr数组的第一个字符开始计算，遇到一个字符，个数加1，直到计算所有的字符后结束。
注意：字符串的结束标志是?'\0'?，计算字符串长度时不会计算?'\0'?，只会计算?'\0'?之前的字符。
strlen库函数的使用需要引用头文件！
2.如何模拟实现strlen函数
#include<stdio.h>
#include<assert.h>
size_t my_strlen(const char* arr)
{
assert(arr);
size_t count = 0;
while (*arr != '\0')
{
count++;
arr++;
}
return count;
}
int main()
{
char arr[] = "abcdef";
int ret = my_strlen(arr);
printf("%d\n", ret);
return 0;
}
这个代码求的是arr数组的长度，结果是6。
assert(arr);这一句是断言，为的是确保数组首元素的地址传过来的时候不是一个 NULL 。
assert 函数的头文件：
count 记录的是字符个数，所以返回 count 就是返回字符串长度。
二、长度不受限制的字符串函数
strcpy：字符串拷贝函数，专门用来拷贝字符串内容的函数。（将源空间的内容拷贝到目标空间）
1.库函数 strcpy 如何使用？
#include<stdio.h>
#include<string.h>
int main()
{
char arr1[20] = { 0 };
char arr2[] = "I love China!";
strcpy(arr1, arr2);
printf("%s\n", arr1);
return 0;
}strcpy?的第一个参数（arr1）表示目标空间，第二个参数（arr2）表示源空间。
它的头文件是：
代码的作用是将字符串 "I love China!" 拷贝到arr1中并打印出来。
输出结果：
??
?注意：strcpy 只是将目标空间的内容覆盖，自身源空间的内容并不会改变。
2.如何模拟实现 strcpy 函数？
#include<stdio.h>
#include<assert.h>
char* my_strcpy(char* dest, const char* src)
{
assert(dest && src);
char* ret = dest;
while (*src)
{
*dest++ = *src++;
}
*dest = *src;//'\0'
return ret;
}
int main()
{
char arr1[20] = { 0 };
char arr2[] = "I love China!";
my_strcpy(arr1, arr2);
printf("%s\n", arr1);
return 0;
}我们并不会改变源空间，所以加上 const?在我们不小心将其修改的时候对其进行保护。
代码的含义是：
? ? ? ? 先将 dest 最开始指向的内容赋给 ret ，作为目标空间起始地址；*dest++ = *src++;?是将目标空间的字符给改成源空间的字符，直到源空间的字符全部改完。++ 就是指向下一个内容； src 是源空间拷贝结束后会指向 arr2 末尾的 '\0'，*dest = *src; 就是将此时 src 指向的内是('\0')?dest。
3.库函数 strcmp 如何实现？
strcmp:?字符串比较函数，专门用来比较字符串内容的函数。
注意：字符串比较，比的是相同位置字符的 ASCII 码值的大小
例如：
char arr1[] = "abcde";
char arr2[] = "abcfg";a, b, c 的 ASCII 码值一样大，所以前三个字符是相同大小的，比到第4个字符的时候，f 的 ASCII 码值大于 d ，所以 arr2 要大于 arr1 。
这个函数有两个参数，分别是要比较的字符串的地址。返回类型是 int 。
?返回值的解释：
如果第一个字符串小于第二个字符串，就返回?小于0?的数字；如果第一个字符串等于第二个字符串，就返回 0 ；如果第一个字符串大于第二个字符串，就返回?大于0?的数字；
#include<stdio.h>
#include<string.h>
int main()
{
char arr1[] = "abcdef";
char arr2[] = "abc";
int ret = strcmp(arr1, arr2);
if (0 > ret)
{
printf("arr1 < arr2");
}
else if (0 == ret)
{
printf("arr1 == arr2");
}
else
{
printf("arr1 > arr2");
}
return 0;
}strcmp 的头文件
输出结果：
4.strcmp 函数如何模拟实现？
#include<stdio.h>
#include<assert.h>
int my_strcmp(const char* arr1, const char* arr2)
{
assert(arr1 && arr2);
while (*arr1 == *arr2)
{
//等于的情况
if (*arr1 == '\0')
{
return 0;
}
arr1++;
arr2++;
}
return (*arr1 - *arr2);
}
int main()
{
char arr1[] = "abcd";
char arr2[] = "abcd";
int ret = my_strcmp(arr1, arr2);
if (ret < 0)
{
printf("arr2 < arr1");
}
else if (ret == 0)
{
printf("arr2 == arr1");
}
else
{
printf("arr2 > arr1");
}
printf("%d\n", ret);
return 0;
}? ? ? ?当比较的字符相等时而且还未遇到结尾，循环和 ++ 操作符就可以指向下一个字符并比较，直到遇到末尾的 \0 。如果arr1指向了 \0 则说明两个字符串的所有字符都比较过了，结果还是相等，然后返回0。当比较出大小的时候，就返回 arr1 指向的内容减去 arr2 指向的内容。如果 arr1 大于 arr2 ，返回的就是大于 0 的数字，反之就是小于。
? ?
长度不受限制就是再使用的时候，不能限制进行操作的字符个数，一直操作到 \0 为止；长度受限制相反，我们可以限制操作的字符个数。
在使用的时候建议使用长度受限制的字符串函数，因为当目标空间不够的时候，我们进行字符串拷贝、追加会因为空间不够而造成出错。
5. 库函数 strcat 的使用
strcat :?字符串追加函数，专门用来追加字符串内容的函数。（将一段字符追加到目标空间）
strcat 的头文件
#include<stdio.h>
#include<string.h>
int main()
{
char arr[20] = "hello ";
strcat(arr, "world");
printf("%s\n", arr);
return 0;
}代码的作用是将 world 追加到 arr 字符串的末尾。
?输出结果：
6. 如何模拟实现 strcat?
#include<stdio.h>
#include<assert.h>
char* my_strcat(char* dest, const char* src)
{
assert(dest && src);
char* ret = dest;
while (*dest != '\0')
{
dest++;
}
while (*dest++ = *src++)
{
;
}
return ret;
}
int main()
{
char arr[20] = "hello ";
my_strcat(arr, "world");
printf("%s\n", arr);
return 0;
}第一个参数依然是表示目标空间，第二个参数表示源空间，代码的作用是将源空间的每一个字符都拷贝到目标空间，这和 strcpy 有些类似。
第一个循环为的是找到目标字符串的结尾，第二个循环为的是将源空间的字符拷贝到目标字符串的后面。?
三、长度受限制的字符串函数
1. strncpy -?长度受限制的字符串拷贝函数
?这个函数的参数有三个，前两个是要操作的字符串，第三个参数是你要拷贝多少个字节。
#include<stdio.h>
#include<string.h>
int main()
{
char arr1[] = "hello";
char arr2[] = "abcdefg";
strncpy(arr1, arr2, 5);
printf("%s", arr1);
return 0;
}arr1是目标空间， arr2是源空间，5是要拷贝的字节数，因为一个字符是一个字节；所以这段代码的含义是：将 arr2 数组的前5个字符拷贝到 arr1 数组中。
代码结果：
??
注意：当我们要拷贝的字节数大于源空间的字节数时，差几个字节就拷贝几个 '\0' 到目标空间去。
2.strncat - 长度受限制的字符串追加函数
这个函数的参数有三个，前两个是要操作的字符串，第三个参数是你要追加多少个字节。
#include<stdio.h>
#include<string.h>
int main()
{
char arr1[20] = "hello ";
char arr2[] = "world";
strncat(arr1, arr2, 5);
printf("%s", arr1);
return 0;
}?代码结果：
arr1是目标空间， arr2是源空间，5是要追加的字节数，因为一个字符是一个字节；所以这段代码的含义是：将 arr2 数组的5个字符追加到 arr1 数组中。
注意： 值得注意的是在要追加的内容完成后还会追加一个 \0?，因为补上一个 \0 才能是作为一个字符串存在。
?
注意：当我们要拷贝的字节数大于源空间的字节数时，不会像strcpy那样拷贝 \0 过去。?
3.strncmp - 长度受限制的字符串比较函数
?这个函数的参数也有三个，前两个是要比较的字符串，第三个参数是你要比较多少个字节。
#include<stdio.h>
#include<string.h>
int main()
{
char arr1[20] = "abcdef";
char arr2[] = "abcdf";
int ret = strncmp(arr1, arr2, 5);
if (ret > 0)
{
printf("arr1 > arr2");
}
else if (ret < 0)
{
printf("arr1 < arr2");
}
else
{
printf("arr1 == arr2");
}
return 0;
}arr1是要比较的第一个字符串， arr2是要比较的第二个字符串，5是要比较的字节数，因为一个字符是一个字节；所以这段代码的含义是：比较?arr2?和?arr1 数组的前5个字符的大小。
代码结果：
四、字符串查找
strstr?：是一个查找子串的函数，就是在一个字符串中查找了一个字符串存不存在。
1.strstr 如何使用呢？
? ? ? ? 这个函数有两个参数，第一个参数是比较长的串，第二个是子串；函数的目的是要在这个比较长的串中查找子串是否存在。如果找到了子串会返回子串在长串的起始位置，找不到则返回一个空指针
#include<stdio.h>
#include<string.h>
int main()
{
char arr1[] = "abcdefg";
char arr2[] = "cde";
char* ret = strstr(arr1, arr2);
if (ret == NULL)
{
printf("子串不存在\n");
}
else
{
printf("%s\n", ret);
}
return 0;
}子串如果存在，代码会打印从子串起始位置到 \0 的字符。
strstr 的头文件：
代码结果：
2.strstr 模拟实现
可能遇到的两种情况：
情况1
这一种情况是最简单的。
情况2
? ? ? ?值得注意的是，当s2全都对比过后还没有查找到，而且s1还有字符为对比过，则就要把s2重置到起始位置，把s1重置到第一次与s2相等的后面的字符，然后从这里开始对比，直到结束。?
代码实现：
#include<stdio.h>
#include<string.h>
#include<assert.h>
char* my_strstr(const char* str1, const char* str2)
{
assert(str1 && str2);
const char* p = str1;
const char* s1 = str1;
const char* s2 = str2;
while (*p)
{
s1 = p;
s2 = str2;
while (*s1 != '\0' && *s2 != '\0' && *s1 == *s2)
{
s1++;
s2++;
}
if (*s2 == '\0')
{
return (char*)p;
}
p++;
}
return NULL;
}
int main()
{
char arr1[] = "abcdefg";
char arr2[] = "cde";
char* ret = my_strstr(arr1, arr2);
if (ret == NULL)
{
printf("子串不存在\n");
}
else
{
printf("%s\n", ret);
}
return 0;
}
3.strtok 字符串切割函数
字符串切割函数，把你想要的内容给切割出来。
这个函数有两个参数，返回类型是 char*，
- sep 参数是是个字符串，定义了用作分隔符的字符集合。
这一点是什么意思呢？
#include<stdio.h>
#include<string.h>
#include<assert.h>
int main()
{
//假设是这个字符串：abcdefg@lilong.com
char* sep = "@.";//@ 和 . 就是分隔符
return 0;
}- 第一个参数指定一个字符串，它包含了 0 个或者多个由 sep 字符串中的一个或者多个分隔符分割的标记。
- strtok函数找到str中的下一个，并蒋用大学结，的课指向这个标记的指针。?(注：strtok 函数会改变被操作的字符串，所以在使用 strtok 函数切分的字符串一般都是临时拷贝的内容并且可修改。)
这一点是什么意思呢？
?会返回 \0 之前的字符串。
- strtok 函数的第一个参数不为 NULL，函数将找到str中第一个标记，strtok 函数将保存它在字符串中的位置。
- strtok 函数的第一个参数为?NULL，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
- 如果字符串中不存在更多的标记，则返回NULL指针。
头文件是 <string.h>
#include<stdio.h>
#include<string.h>
int main()
{
//假设是这个字符串：abcdefg@lilong.com
const char* sep = "@.";//@ 和 . 就是分隔符
char str[] = "abcdefg@lilong.com";
char cp[30] = { 0 };
strcpy(cp, str);
char* ret = NULL;
for (ret = strtok(cp, sep); ret != NULL; ret = strtok(NULL, sep))
{
printf("%s\n", ret);
}
return 0;
}代码结果：
五、错误信息报告
strerror ：错误信息报告函数，返回错误码，所对应的信息。
函数的参数及返回类型
?
#include<stdio.h>
#include<string.h>
#include<errno.h>
//errno - 是C语言设置的一个全局的错误码存放的变量
int main()
{
//"r" - 以读的形式打开 "test.txt" 这个文件
FILE* pf = fopen("test.txt", "r");
if (NULL == pf)
{
printf("%s\n", strerror(errno));
//使用errno是需要引用头文件<errno.h>
return 1;
}
else
{
printf("haha\n");
}
return 0;
}?因为文件不存在，所以strerror?函数会返回一个错误信息。
代码结果：
六、字符操作
字符分类函数
iscntrl：如何控制字符
isspace：空白字符：空格' '、换页'\f'、换行'\n'、回车'\r'、制表符'\t'或者垂直制表符'\v'
isdigit：十进制数字 0~9
isxdigit：十六进制数字，不搜阔所以十进制数字，小写字母 a~f、大写字母 A~F
islower：小写字母 a~z
isupper：大写字母 A~Z
isalpha：字母a~z 或者 A~Z
isalnum：字母或者数字，a~z、A~Z、0~9
ispunct：标点符号，任何不属于数字或者字母的图形字符（可打印）
isgraph：任何图形字符
isprint：任何可打印字符，包括图形字符和空白字符
因为这些函数使用起来比较简单，这里就不一一介绍了。大家可以去 cplusplus.com 这个网站查看；也可以使用 MSDN 来查看。
字符转换函数：
int tolower(int c);
int toupper(int c);
#include<stdio.h>
#include<ctype.h>
int main()
{
printf("%c\n", tolower('A'));
//将大写字母转化为小写
return 0;
}
七、内存操作函数
1.memcpy内存拷贝函数如何使用呢？
memcpy：内存拷贝函数
? ? ? ? 当不确定要拷贝内容的类型是什么的时候。可以把内存拷贝过去，这样不管是什么类型都可以拷贝。不用 strcpy 是因为它是字符串的拷贝函数，只能用来拷贝字符串。
?num 表示要拷贝多少个字节的内容，source 表示源空间，destination 表示目标空间。
#include<stdio.h>
#include<string.h>
int main()
{
int src[] = { 1,2,3,4,5 };
int dest[10] = { 0 };
memcpy(dest, src, sizeof(src));
return 0;
}代码结果：
?src 里的内容拷贝成功！
为什么这个函数的参数和返回类型是 void* 呢？
因为 void* 是一个泛型指针，它的通用高，当不确定是什么类型的时候使用它更加方便快捷。
2.模拟实现 memcpy
#include<stdio.h>
#include<assert.h>
void* my_memcpy(void* dest, const void* src, size_t num)
{
assert(dest && src);
void* ret = dest;
while (num--)
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
return ret;
}
int main()
{
int src[] = { 5,6,7,8,9 };
int dest[10] = { 0 };
my_memcpy(dest, src, sizeof(src));
return 0;
}拷贝的数据是 int 类型的，但是这里为什么要使用 char* 来强制类型转换呢？
一个整形4个字节，如果强转为 int* 只能一次性拷贝4个字节，但如果要拷贝3个、11个或者是21个的（4的倍数）时候 int* 明显不合适，这个时候就可以使用最细致的 char* ，一次拷贝一个字节，通用型更强。
memcpy 是不用来处理重叠的内存之间的数据拷贝的
3.重叠内存之间的数据拷贝
memmove ：也是一个内存拷贝函数，但是可以拷贝重叠内存之间的数据。
这是他的返回类型、参数和头文件
值得注意的是它与 ，memcpy 的参数一样?。都是目标空间、源空间、和要拷贝的字节数。说明它的用法也是一样的。
下面的代码目的是将?1、2、3、4、5 拷贝到 3、4、5、6、7 上去，但是实际的结果是什么呢？
#include<stdio.h>
#include<assert.h>
void* my_memcpy(void* dest, const void* src, size_t num)
{
assert(dest && src);
void* ret = dest;
while (num--)
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
return ret;
}
void test1()
{
int src[] = { 1,2,3,4,5,6,7,8,9,10 };
int dest[20] = { 0 };
my_memcpy(dest, src, 20);
int i = 0;
for (i = 0; i < 5; i++)
{
printf("%d ", dest[i]);
}
}
void test2()
{
int src[] = { 1,2,3,4,5,6,7,8,9,10 };
my_memcpy(src + 2, src, 20);
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", src[i]);
}
}
int main()
{
test2();
return 0;
}代码结果：
如果拷贝成功了，代码的结果应该是：
1 2 1 2 3 4 5 8 9 10?
那为什么会出错呢？
是因为 memcpy 不能拷贝重叠内存之间的数据，要使用memmove来拷贝
memmove 库函数的使用方法：
#include<stdio.h>
#include<assert.h>
#include<string.h>
void test2()
{
int src[] = { 1,2,3,4,5,6,7,8,9,10 };
memmove(src + 2, src, 20);
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", src[i]);
}
}
int main()
{
test2();
return 0;
}代码结果：
这次拷贝成功了。?
4.memmove 模拟实现
在实现 memmove?会出现三种情况。
第一种：从前往后处理数据
?当 src 的起始地址在 dest 的起始地址左边的时候，就要采用从前往后处理数据的方式（先拷贝4，最后拷贝8）来避免数据重叠而带来的错误。
第二种：从后往前处理数据
?在 dest 的起始位置在 src 的范围内的时候，就要采用从后往前处理数据的方式（先拷贝5，最后拷贝1）来避免数据重叠而带来的错误。
第三种：前往后，后往前任意
??在 dest 的起始位置不在 src 的范围内的时候，采用前往后，后往前任意
如果是第一种情况就采用 前往后，如果是第二、三两种情况就采用 后往前。
代码实现：
#include<stdio.h>
#include<assert.h>
void* my_memmove(void* dest, const void* src, size_t num)
{
assert(dest && src);
void* ret = dest;
if (dest < src)
{
//前 -> 后
while (num--)
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
}
else
{
//后到前
while (num--)
{
*((char*)dest + num) = *((char*)src + num);
}
}
return ret;
}
void test()
{
int src[] = { 1,2,3,4,5,6,7,8,9,10 };
my_memmove(src + 2, src, 20);
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", src[i]);
}
}
int main()
{
test();
return 0;
}5.内存比较
memcmp ：内存比较函数
参数、返回类型和头文件：
buf1 和 buf2 指向两块空间，count 表示向后在 count 个字节内部比较。
?如果要比较两块内存里的数据是否相同，就可以使用 memcmp
#include<stdio.h>
#include<string.h>
int main()
{
int arr1[] = { 1,2,3 };
int arr2[] = { 1,3,2 };
int ret = memcmp(arr1, arr2, 12);
printf("%d\n", ret);
return 0;
}
如果第一块内存大于第二块内存，返回一个大于0的数字；?如果第一块内存等于第二块内存，返回数字0；?如果第一块内存小于第二块内存，返回一个小于0的数字；?
memcmp 也是一对一对比较的。
arr1：01 00 00 00 02 00 00 00 03 00 00 00
arr2：01 00 00 00 03 00 00 00 02 00 00 00
一对比可以很明显的看出 arr1 小于 arr2 ，所以返回小于0的数字。
代码结果：
注意：
- memcmp 可以比较字符串也可以比较任意类型的数据。
- memcmp 只有当参数中所有的字节都比较完后才会结束。
6.内存设置
memset ：内存设置函数
参数、返回类型和头文件：
?如果有一份数据等待着对他初始化，就可以使用 memset 。
dest 参数是设置的填充空间，c 参数是要设置的值，count 参数是要设置的值的字节数
例1：
#include<stdio.h>
#include<string.h>
int main()
{
char arr[] = "hello world";
memset(arr, 'x', 5);
printf("%s\n", arr);
return 0;
}代码的含义是将arr数组中的前5个字节的内容设置为字符x。
代码结果：
例2：
#include<stdio.h>
#include<string.h>
int main()
{
char arr[] = "hello world";
memset(arr + 6, 'x', 5);
printf("%s\n", arr);
return 0;
}代码结果：
