目录
一、主要作用介绍
1、求字符串长度
strlen->求出字符串到 \0 前的字符的数量
2、长度不受限制的字符串函数
strcpy->将源地址到结束符 \0 的字符都复制到目标地址中
strcat->将源字符串的副本追加到目标字符串后面
strcmp->比较两个字符串 第一个字符串大于第二个字符串，则返回大于0的数字，第一个字符串等于第二个字符串，则返回0，第一个字符串小于第二个字符串，则返回小于0的数字
3、长度受限制的字符串函数介绍
strncpy->拷贝
num
个字符从源字符串到目标空间
strncat->将源字符串中指定的字符数量追加到目标字符串后面
strncmp->比较两个字符串，但此处指定了第二个字符串比较的数量，比较的规则同上strcmp
4、字符串查找
strstr->查找子字符串
strtok->将字符串拆分为标记
5、错误信息报告
strerror->返回错误码，所对应的错误信息。
6、字符操作
内存操作函数
memcpy->从源地址
的位置开始向后复制
num
个字节的数据到目标地址
的内存位置。
memmove->和memcpy作用效果相同，但是和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的
memset->填充内存块
memcmp->比较从ptr1和ptr2指针开始的num个字节
二、函数详解
1、strlen
原型：size_t strlen ( const char * str );
字符串已经 '\0'
作为结束标志，
strlen
函数返回的是在字符串中
'\0'
前面出现的字符个数（不包 含 '\0'
)
。
参数指向的字符串必须要以 '\0' 结束。
注意函数的返回值为size_t
，是无符号的（
易错
）
2、strcpy
原型：char* strcpy(char * destination, const char * source );
将source指向的C字符串复制到destination指向的数组中，包括终止空字符(并在该点停止)。
源字符串必须以 '\0' 结束。
会将源字符串中的 '\0' 拷贝到目标空间，并且他会返回将 destination指向的数组的地址。
目标空间必须足够大，以确保能存放源字符串。
目标空间必须可变。
3、 strcat
原型：char * strcat ( char * destination, const char * source );
将源字符串的副本追加到目标字符串。结束的空字符 destination被source的第一个字符覆盖，并包含一个空字符 在由两者在destination中串联而成的新字符串的末尾。并且返回destination的地址。
源字符串必须以 '\0' 结束。
目标空间必须有足够的大，能容纳下源字符串的内容。
目标空间必须可修改。
4、strcmp
原型：int strcmp ( const char * str1, const char * str2 );这个函数开始比较每个字符串的第一个字符。如果它们是相等的 否则，它继续使用以下对，直到字符不同或直到结束 达到空字符。
标准规定：
第一个字符串大于第二个字符串，则返回大于0
的数字
第一个字符串等于第二个字符串，则返回0
第一个字符串小于第二个字符串，则返回小于0的数字
5、strncpy
原型：char * strncpy ( char * destination, const char * source, size_t num );
将源的第一个num字符复制到目标。如果源C字符串的结束 (由空字符表示)在复制num个字符之前找到， 目标将用零填充，直到向其写入总数为num个字符为止。
并且他会返回将 destination指向的数组的地址。
拷贝num个字符从源字符串到目标空间。
如果源字符串的长度小于num
，则拷贝完源字符串之后，在目标的后边追加
0
，直到
num
个。
6、strncat
原型：char * strncat ( char * destination, const char * source, size_t num );将源的从第一个数的num字符附加到目标，加上一个结束的空字符。返回destination指向的数组的地址。
如果source中的C字符串的长度小于num，则只包含直到结束的内容复制空字符。
7、strncmp
原型：int strncmp ( const char * str1, const char * str2, size_t num );
比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。
8、strstr
原型：char * strstr ( const char *str1, const char * str2); 返回指向 str2 中第一次出现的 str1 的指针，如果 str2 不是 str1 的一部分，则返回一个空指针。
匹配过程不包括终止空字符，但它到此为止。
9、strstok
原型：char * strtok ( char * str, const char * sep );
sep参数是个字符串，定义了用作分隔符的字符集合
第一个参数指定一个字符串，它包含了0
个或者多个由
sep
字符串中一个或者多个分隔符分割的标记。
strtok函数找到
str
中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注： strtok函数会改变被操作的字符串，所以在使用
strtok
函数切分的字符串一般都是临时拷贝的内容 并且可修改。）
strtok函数的第一个参数不为
NULL
，函数将找到
str
中第一个标记，
strtok
函数将保存它在字符串 中的位置。
strtok函数的第一个参数为
NULL
，函数将在同一个字符串中被保存的位置开始，查找下一个标 记。
如果字符串中不存在更多的标记，则返回 NULL
指针。
10、 strerror
原型：char * strerror ( int errnum );解释 errnum 的值，生成一个字符串，其中包含描述错误条件的消息，就像由库的函数设置为 errno 一样。 返回的指针指向静态分配的字符串，程序不应修改该字符串。对此函数的进一步调用可能会覆盖其内容（不需要特定的库实现来避免数据争用）。 strerror 生成的错误字符串可能特定于每个系统和库实现。
11、 memcpy
原型：void * memcpy ( void * destination, const void * source, size_t num );
函数memcpy
从
source
的位置开始向后复制
num
个字节的数据到
destination
的内存位置。
这个函数在遇到 '\0'
的时候并不会停下来。
如果source
和
destination
有任何的重叠，复制的结果都是未定义的。
12、memove
原型：void * memmove ( void * destination, const void * source, size_t num );
和memcpy
的差别就是
memmove
函数处理的源内存块和目标内存块是可以重叠的。
如果源空间和目标空间出现重叠，就得使用memmove
函数处理。
13、 memcmp
原型：int memcmp ( const void * ptr1, const void * ptr2, size_t num );
比较从ptr1
和
ptr2
指针开始的
num
个字节
返回值如下：
第一个字符串大于第二个字符串，则返回大于0的数字
第一个字符串等于第二个字符串，则返回0
第一个字符串小于第二个字符串，则返回小于0的数字
三、其中最常用函数的模拟实现
1、 strlen
int my_len(const char* s)
{
int re = 0;
while (*s)
{
re++;
s++;
}
return re;
}
2、strcpy
char* my_strcpy(char* dest, const char* src)
{
char* ret = dest;
assert(dest != NULL);
while ((*dest++ = *src++));
return ret;
}
3、strcat
char* my_strcat(char* s1, char* s2)
{
assert(s1);
assert(s2);
char* re = s1;
while (*s1)
{
s1++;
}
while (*s2)
{
*s1 = *s2;
s1++;
s2++;
}
*s1 = '\0';
return re;
}
4、strstr
char* my_strstr(const char* s1, const char* s2)
{
char *q1, *q2;
char* cp = (char*)s1;
if (!*s2)
return (char*)s1;
while (*cp)
{
q1 = cp;
q2 = (char*)s2;
while (*q1&&*q2&&!(*q1-*q2))
{
q1++;
q2++;
}
if (!*q2)
return cp;
cp++;
}
return NULL;
}
5、strcmp
int my_strcmp(const char* s1, const char* s2)
{
while (*s1 || *s2)
{
if (*s1 > *s2)
return 0;
else if (*s1 == *s2)
{
s1++;
s2++;
}
else
return -1;
}
return 1;
}
6、memcpy
void* my_memcpy(void* st1, const void* st2,size_t num)
{
assert(st1 != NULL);
assert(st2 != NULL);
void* re = st1;
while (num--)
{
*(char *)st1 = *(char *)st2;
st1 = (char*)st1 + 1;
st2 = (char*)st2 + 1;
}
return re;
} 
7、memmove
void* my_memmove(void* s1, void* s2, size_t num)
{
void* re = s1;
if (s1 <= s2 || (char*)s1 >= ((char*)s2 + num))
{
while (num--) {
*(char*)s1 = *(char*)s2;
s1 = (char*)s1 + 1;
s2 = (char*)s2 + 1;
}
}
else
{
s1 = (char*)s1 + num - 1;
s2 = (char*)s2 + num - 1;
while (num--) {
*(char*)s1 = *(char*)s2;
s1 = (char*)s1 - 1;
s2 = (char*)s2 - 1;
}
}
return re;
}