目录
前言
当我们使用C语言编写程序是，通常会用到<string.h>这个头文件，而这个头文件正是与C语言字符串处理有关的头文件，那么，这些库函数是怎么实现的呢？
一.模拟实现C语言字符串库函数
1.str系列
1.1 模拟实现strlen
strlen是头文件<string.h>中返回给定字符串的长度的函数，具有以下特点：
• 字符串以 '\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前⾯出现的字符个数（不包含 '\0' )。
• 参数指向的字符串必须要以 '\0' 结束。
• 注意函数的返回值为size_t类型，是无符号的（ 易错 ）
• strlen的使用需要包含头文件<string.h>
strlen的函数原型式（为了区别于库函数提供的strlen，前面加上了my）：
size_t mystrlen(const char* str);返回类型：size_t
参数类型：const char* （字符数组首元素地址）
因为计算字符串长度是不需要对字符串作出修改，所以可以加上const进行修饰
1.1.1 使用计数器的方式
size_t mystrlen(const char* str)
{
assert(str);
size_t count = 0;
while (*str != '\0')
{
str++;
count++;
}
return count;
}为了判断传进来的数组指针是否为NULL，我们可以先使用assert断言（需要包含头文件<assert.h>），如果是空指针，就报错。
使用while循环，指针加一，计数器也加一，最后返回计数器的值。
1.1.2 使用指针-指针的方式
size_t mystrlen(const char* str)
{
assert(str);
char* ps = str;
while (*str != '\0')
{
str++;
}
return str - ps;
}创建指针ps，确定字符串初起始位置，通过while循环找到字符串终点位置，最后相减就得到了字符串长度。
1.1.3 使用函数递归的方式（不创建临时变量）
size_t mystrlen(const char* str)
{
assert(str);
if (*str == '\0')
return 0;
else
return 1 + mystrlen(++str);
}使用函数递归的方式，如果*str为'\0'，说明已经到了字符串终点，返回0，如果不是，就1+下一个字符的判断。
1.2 模拟实现strcpy
strcpy是头文件<string.h>中复制一个字符串给另一个的函数，具有以下特点：
• 源字符串必须以 '\0' 结束。
• 会将源字符串中的 '\0' 拷贝到目标空间。
• 目标空间必须足够大，以确保能存放源字符串。
• 目标空间必须可修改。
strcpy函数原型式：
char* mystrcpy(char* destination, const char* source);返回类型：char* (目标字符数组首元素地址)
参数1类型：char* （目标字符数组首元素地址）
参数2类型：const char* （源字符串首元素地址）
char* mystrcpy(char* destination, const char* source)
{
assert(destination);
assert(source);
char* ret = destination;
while (*destination++ = *source++)
{
;
}
return ret;
}首先使用assert断言判断传进来的两个地址非空
创建字符指针ret指向目标字符数组首元素地址，便于返回
使用while循环，在字符逐个复制的同时完成地址的自增
最后返回目标字符数组首元素地址。
1.3 模拟实现strcat
strccat是头文件<string.h>中连接两个字符串的函数，具有以下特点：
• 源字符串必须以 '\0' 结束。
• 目标字符串中也得有 \0 ，否则没办法知道追加从哪里开始。
• 目标空间必须有足够大，能容纳下源字符串的内容。
• 目标空间必须可修改。
函数原型式：
char* mystrcat(char* destination, const char* source);返回类型：char* (目标字符数组首元素地址)
参数1类型：char* （目标字符数组首元素地址）
参数2类型：const char* （源字符串首元素地址）
char* mystrcat(char* destination, const char* source)
{
assert(destination);
assert(source);
char* ret = destination;
while (*destination)
{
destination++;
}
while (*destination++ = *source++)
{
;
}
return ret;
}首先使用assert断言判断传进来的两个地址非空
创建字符指针ret指向目标字符数组首元素地址，便于返回
使用while循环，找到目标字符数组的终点位置
再使用while循环，在字符逐个复制的同时完成地址的自增
最后返回目标字符数组首元素地址。
1.4 模拟实现strcmp
strcmp是头文件<string.h>中比较两个字符串的函数，具有以下特点：
◦ 如果第一个字符串大于第二个字符串，则返回大于0的数字
◦ 如果第一个字符串等于第二个字符串，则返回0
◦ 如果第一个字符串小于第二个字符串，则返回小于0的数字
◦ 如果那么如何判断两个字符串？ 比较两个字符串中对应位置上字符ASCII码值的大小。
strcmp函数原型式：
int mystrcmp(const char* str1, const char* str2);返回类型：int (第一个不同的字符差值，完全相同返回0)
参数1类型：const char* （需要比较的字符串1首元素地址）
参数2类型：const char* （需要比较的字符串2首元素地址）
int mystrcmp(const char* str1, const char* str2)
{
assert(str1);
assert(str2);
while (*str1 == *str2)
{
if (*str1 == '\0')
return 0;
str1++;
str2++;
}
return *str1 - *str2;
}首先使用assert断言判断传进来的两个地址非空
使用while循环，如果两个字符相同就继续循环
如果一个字符串已经达到终点，就返回0
如果存在不同的字符，就返回字符之间的差值。
1.5 模拟实现strstr
strstr是头文件<string.h>中查找子串字符的首次出现的函数，具有以下特点：
• 函数返回字符串str2在字符串str1中第一次出现的位置。
•字符串的比较匹配不包含 \0 字符，以 \0 作为结束标志。
strstr函数原型式：
char* mystrstr(const char* str1, const char* str2);返回类型：char* （被查找的目标字符串首元素地址）
参数1类型：const char* （需要被查找的目标字符串首元素地址）
参数2类型：const char* （需要查找的目标字符串首元素地址）
char* mystrstr(const char* str1, const char* str2)
{
const char* s1 = NULL;
const char* s2 = NULL;
const char* cur = str1;
if (str2 == NULL)
return (char*)str1;
while (*cur)
{
s1 = cur;
s2 = str2;
while ((*s1 != '\0') && (s2 != '\0') && (*s1 == *s2))
{
s1++;
s2++;
}
if (*s2 == '\0')
return (char*)cur;
cur++;
}
return (char*)NULL;
}如果需要查找的字符串为NULL，就直接返回被查找的字符串的首元素地址
创建三个临时字符指针：s1 , s2 , cur
并让字符指针cur指向str1
使用while循环，如果*cur不为0，就继续循环
在循环中让s1指向cur，让s2指向str2的起始位置
如果s1不为0，s2不为0，且s1等于s2，就让s1和s2都自增，在while循环中进行匹配，直到有一个达到字符串终点
在循环结束以后，如果s2为'\0'，说明两个字符串全部匹配上了，就返回cur（此时cur指向的是匹配开始前的位置），如果s2不为'\0'，说明两个字符串存在不匹配的地方，cur就继续自增，进行下一次循环
如果cur指向字符串末端仍然没有匹配上，说明不存在匹配的字段，返回空指针（NULL）
2.strn系列
strn系列和str系列的区别是strn系列可以确定需要操作的元素个数，可以完成指定元素个数的字符串操作
2.1 模拟实现strncpy
strncpy是头文件<string.h>中从一个字符串复制一定数量的字符到另一个的函数，具有以下特点：
• 拷贝num个字符从源字符串到目标空间。
• 如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。
strncpy函数原型式：
char* mystrncpy(char* Destination, const char* Source, size_t Count);返回类型：char* (目标字符数组首元素地址)
参数1类型：char* （目标字符数组首元素地址）
参数2类型：const char* （源字符串首元素地址）
参数3类型：size_t （操作元素个数）
char* mystrncpy(char* Destination, const char* Source, size_t Count)
{
assert(Destination);
assert(Source);
char* ret = Destination;
while (Count--)
{
if (*Source != '\0')
{
*Destination++ = *Source++;
}
else
{
*Destination++ = '\0';
}
}
return ret;
}首先使用assert断言判断传进来的两个地址非空
创建字符指针ret指向目标字符数组首元素地址，便于返回
使用while循环，次数是需要操作的元素个数
如果没到达源字符串终点，就在字符逐个复制的同时完成地址的自增
如果达到了源字符串终点，就填充'\0'
最后返回目标字符数组首元素地址。
2.2 模拟实现strncat
strncat是头文件<string.h>中连接两个字符串的一定数量字符的函数，具有以下特点：
• 将source指向字符串的前num个字符追加到destination指向的字符串末尾，再追加一个 \0 字
符。
•如果source指向的字符串的长度小于num的时候，只会将字符串中到\0 的内容追加到destination指向的字符串末尾。
strncat函数原型式：
char* mystrncat(char* Destination, const char* Source, size_t Count);返回类型：char* (目标字符数组首元素地址)
参数1类型：char* （目标字符数组首元素地址）
参数2类型：const char* （源字符串首元素地址）
参数3类型：size_t （操作元素个数）
char* mystrncat(char* Destination, const char* Source, size_t Count)
{
assert(Destination);
assert(Source);
char* ret = Destination;
while (*Destination)
{
Destination++;
}
while ((Count--) && (*Destination++ = *Source++))
{
;
}
return ret;
}首先使用assert断言判断传进来的两个地址非空
创建字符指针ret指向目标字符数组首元素地址，便于返回
使用while循环，找到目标字符数组的终点位置
再使用while循环，次数是需要操作的元素个数自减并且在字符逐个复制的同时完成地址的自增
最后返回目标字符数组首元素地址。
2.3 模拟实现strncmp
strncmp是头文件<string.h>中比较两个字符串的一定数量字符的函数
比较str1和str2的前num个字符，如果相等就继续往后比较，最多比较num个字母，如果提前发现不一样，就提前结束，返回字符之间的差值。如果num个字符都相等，就是相等返回0.
strncmp函数原型式：
int mystrncmp(const char* str1, const char* str2, size_t MaxCount);返回类型：int (第一个不同的字符差值，完全相同返回0)
参数1类型：const char* （需要比较的字符串1首元素地址）
参数2类型：const char* （需要比较的字符串2首元素地址）
参数类型3：size_t （操作元素个数）
int mystrncmp(const char* str1, const char* str2, size_t MaxCount)
{
assert(str1);
assert(str2);
while ((*str1 == *str2) && (--MaxCount))
{
if (*str1 == '\0')
return 0;
str1++;
str2++;
}
return *str1 - *str2;
}首先使用assert断言判断传进来的两个地址非空
使用while循环，如果两个字符相同就继续循环并且完成对MaxCount的自减
如果一个字符串已经达到终点，就返回0
如果存在不同的字符或者MaxCount为0，就返回字符之间的差值。
二.模拟实现C语言内存库函数
1.模拟实现memcpy
memcpy是头文件<string.h>中将一个缓冲区复制到另一个的函数，具有以下特点：
• 函数memcpy从source的位置开始向后复制num个字节的数据到destination指向的内存位置。
• 这个函数在遇到 '\0' 的时候并不会停下来。
• 如果source和destination有任何的重叠，复制的结果都是未定义的
memcpy函数原型式：
void* mymemcpy(void* Dst, const void* Src, size_t Size);返回类型：void* (目标内存首字节地址)
参数1类型：void* （目标内存首字节地址）
参数2类型：const void* （源内存首字节地址）
参数3类型：size_t （操作字节数）
void* mymemcpy(void* Dst, const void* Src, size_t Size)
{
assert(Dst);
assert(Src);
void* ret = Dst;
while (Size--)
{
*((char*)Dst)++ = *((char*)Src)++;
}
return ret;
}首先使用assert断言判断传进来的两个地址非空
创建字符指针ret指向目标首字节地址，便于返回
使用while循环，在字节逐个复制的同时完成地址的自增
最后返回目标首元素地址。
2.模拟实现memmove
memmove是头文件<string.h>中将一个缓冲区移动到另一个的函数，具有以下特点：
• 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
• 如果源空间和目标空间出现重叠，就得使用memmove函数处理。
memmove函数原型式：
void* mymemmove(void* Dst, const void* Src, size_t Size);返回类型：void* (目标内存首字节地址)
参数1类型：void* （目标内存首字节地址）
参数2类型：const void* （源内存首字节地址）
参数3类型：size_t （操作字节数）
void* mymemmove(void* Dst, const void* Src, size_t Size)
{
assert(Dst);
assert(Src);
void* ret = Dst;
if (Dst < Src)
{
while (Size--)
{
*((char*)Dst)++ = *((char*)Src)++;
}
}
else
{
Dst = (char*)Dst + Size - 1;
Src = (char*)Src + Size - 1;
while (Size--)
{
*((char*)Dst)-- = *((char*)Src)--;
}
}
return ret;
}首先使用assert断言判断传进来的两个地址非空
创建字符指针ret指向目标首字节地址，便于返回
通过if—else语句，判断字节复制方式
如果目标地址在源地址之前，使用while循环，在字节逐个复制的同时完成地址的自增
如果目标地址在源地址之后，先确定最后地址所在的位置，然后使用while循环，在字节逐个复制的同时完成地址的自减
最后返回目标首元素地址。
三.其它字符、字符串和内存库函数用法介绍
1.字符串库函数
1.1 strtok介绍
1.1.1 文字介绍
strtok是头文件<string.h>中查找字节字符串中的下一个记号的函数，具有以下特点：
• sep参数指向一个字符串，定义了用作分隔符的字符集合。
• 第⼀个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标
记。
• strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。
注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串⼀般都是临时拷贝的内容并且可修改。
• strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
• strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
• 如果字符串中不存在更多的标记，则返回 NULL 指针。
strtok函数原型式：
char* strtok(char* String, const char* Delimiter);返回类型：char* (被分割字符串分割后首元素地址)
参数1类型：char* （被分割字符串首元素地址）
参数2类型：const char* （分割符首元素地址）
1.1.2 代码示例
#include <stdio.h>
#include <string.h>
int main()
{
char arr[] = "nice.to@meet#you";
char* sep = ".@#";
char* str = NULL;
for (str = strtok(arr, sep); str != NULL; str = strtok(NULL, sep))
{
printf("%s\n", str);
}
return 0;
}通过for循环，在第一次循环传入被分割的字符串arr和分割字符串sep，如果没有到达arr字符串终点，就反复传入NULL和sep，完成对字符串的逐次分割并打印
运行结果：
1.2 strerror介绍
1.2.1 文字介绍
strerror是头文件<string.h>中返回给定错误码的文本版本的函数，可以把参数部分错误码对应的错误信息的字符串地址返回来。
在不同的系统和C语言标准库的实现中都规定了一些错误码，一般是放在 <errno.h> 这个头文件中说明的，C语言程序启动的时候就会使用一个全局的变量errno来记录程序的当前错误码，只不过程序启动的时候errno是0，表示没有错误，当我们在使用标准库中的函数的时候发生了某种错误，就会将对应的错误码存放在errno中，而一个错误码的数字是整数很难理解是什么意思，所以每一个错误码都是有对应的错误信息的。strerror函数就可以将错误对应的错误信息字符串的地址返回。
strerror函数原型式：
char* strerror(int ErrorMessage);返回类型：char* (错误信息字符串首元素地址)
参数类型：int (错误码)
1.2.2 代码示例1（打印0~10错误码对应的错误信息）
#include <stdio.h>
#include <string.h>
#include <errno.h>
int main()
{
int i = 0;
for (i = 0; i <= 10; i++) {
printf("%s\n", strerror(i));
}
return 0;
}运行结果：
1.2.3 代码示例2（打开文件错误信息打印）
#include <stdio.h>
#include <string.h>
#include <errno.h>
int main()
{
FILE* pFile;
pFile = fopen("test.txt", "r");
if (pFile == NULL)
printf("Error opening file: %s\n", strerror(errno));
return 0;
}运行结果：
1.2.4 相关函数：perror函数介绍
也可以了解一下perror函数，perror函数相当于一次将上述代码中的第10行完成了，直接将错误信息打印出来。perror函数打印完参数部分的字符串后，再打印一个冒号和一个空格，再打印错误信息。
#include <stdio.h>
#include <string.h>
#include <errno.h>
int main()
{
FILE* pFile;
pFile = fopen("test.txt", "r");
if (pFile == NULL)
perror("Error opening file");
return 0;
}运行结果同上：
2.内存库函数
2.1 memset
2.1.1 文字介绍
memset是头文件<string.h>中以字符填充缓冲区的函数，将内存中的值以字节为单位设置成想要的内容
memset函数原型式：
void* memset(void* Dst, int Val, size_t Size);返回类型：void* (目标内存首字节地址)
参数1类型：void* （目标内存首字节地址）
参数2类型：int （设置后的字符）
参数3类型：size_t （操作字节数）
2.1.2 代码示例
#include <stdio.h>
#include <string.h>
int main()
{
char str[] = "hello world";
memset(str, 'x', 6);
printf("%s\n", str);
return 0;
}
运行结果：
2.2 memcmp
2.2.1 文字介绍
memcmp是头文件<string.h>中比较两块缓冲区的函数，具有以下特点：
• 比较从ptr1和ptr2指针指向的位置开始，向后的num个字节
• 返回值如下：
memcmp函数原型式：
int memcmp(const void* Buf1, const void* Buf2, size_t Size);返回类型：int (第一个不同的字符差值，完全相同返回0)
参数1类型：const void* （需要比较的内存1首字节地址）
参数2类型：const void* （需要比较的内存2首字节地址）
参数3类型：size_t （操作字节数）
2.2.2 代码示例
#include <stdio.h>
#include <string.h>
int main()
{
char buffer1[] = "Hello World";
char buffer2[] = "Hello world";
int n = 0;
n = memcmp(buffer1, buffer2, sizeof(buffer1));
if (n > 0)
printf("'%s' is greater than '%s'.\n", buffer1, buffer2);
else if (n < 0)
printf("'%s' is less than '%s'.\n", buffer1, buffer2);
else
printf("'%s' is the same as '%s'.\n", buffer1, buffer2);
return 0;
}运行结果：
3.字符库函数
3.1 字符分类函数
C语言中有一系列的函数是专门做字符分类的，也就是一个字符是属于什么类型的字符的。
这些函数的使用都需要包含一个头文件是 <ctype.h>
| 函数 | 如果他的参数符合下列条件就返回真 |
| 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 | 任何可打印字符,包括图形字符和空白字符 |
这些函数的使用方法非常类似，以islower为例：
islower是头文件<ctype.h>中检查一个字符是否是小写字母的函数
islower函数原型式：
int islower(int C);islower 是能够判断参数部分的 c 是否是小写字母的。
通过返回值来说明是否是小写字母，如果是小写字母就返回非0的整数，如果不是小写字母，则返回0。
代码示例（将字符串中的小写字母转大写，其他字符不变）
#include <stdio.h>
#include <ctype.h>
int main()
{
int i = 0;
char str[] = "Test String.\n";
char c;
while (str[i])
{
c = str[i];
if (islower(c))
c -= 32;
putchar(c);
i++;
}
return 0;
}运行结果：
3.2 字符转换函数
C语言提供了2个字符转换函数
int tolower ( int C ); //将参数传进去的大写字母转小写
int toupper ( int C ); //将参数传进去的小写字母转大写上面islower的代码示例，我们将小写转大写，是-32完成的效果，有了转换函数，就可以直接使用 tolower 函数。如下：
#include <stdio.h>
#include <ctype.h>
int main()
{
int i = 0;
char str[] = "Test String.\n";
char c;
while (str[i])
{
c = str[i];
if (islower(c))
c = toupper(c);
putchar(c);
i++;
}
return 0;
}运行结果：
