C语言中存在许多处理字符与字符串的函数，本文将着重介绍这些库函数的使用方式及其模拟实现
strlen
size_t strlen ( const char * str );
strlen是常用的计算字符串长度的库函数，由于字符串以'\0'结尾，strlen将返回第一个'\0'出现之前的字符个数
如参数中的字符串不以'\0'结尾，将返回随机值
同时函数的返回值类型为size_t，属于无符号整型，在使用时容易出现错误，如使用两个字符串长度的差值作为判断条件，由于为size_t类型，因此无法出现负值
strlen函数的模拟实现：
#include <stdio.h>
#include <assert.h>
size_t myStrlen(const char* str)
{
assert(str);
size_t count = 0;
while (*str)
{
count++;
str++;
}
return count;
}strcpy
char * strcpy ( char * destination, const char * source );
strcpy用于拷贝字符串，参数中的destination为目标空间的起始地址，source为源字符串的起始地址
strcpy将拷贝至源字符串的第一个'\0',源字符串必须以'\0'结束
在拷贝的过程中，源字符串的'\0'也会被拷贝至目标空间
目标空间必须足够大，否则将越界访问
strcpy函数的模拟实现：
#include <stdio.h>
#include <assert.h>
char* myStrcpy(char* dest, const char* src)
{
char* tmp = dest;
assert(dest && src);
while (*dest++ = *src++)
;
return tmp;
}
strcat
char * strcat ( char * destination, const char * source );
strcat用于字符串链接/追加，参数中的destination为目标空间的起始地址，source为源字符串的起始地址，返回值为目标空间的起始地址
strcat将追加至源字符串的第一个'\0',源字符串必须以'\0'结束
目标空间需要能够容纳下源字符串的内容
模拟实现：
1.找到目标字符串的末尾
2.追加源字符串直到'\0'
#include <stdio.h>
#include <assert.h>
char* myStrncat(char* des, const char* src, size_t num)
{
assert(des && src);
char* s1 = des;
char* s2 = src;
int i = 0;
while (*s1)
s1++;
for (i = 0; i < num; i++)
{
*s1 = *s2;
s1++;
s2++;
if (*s2 == 0)
{
*s1 = 0;
break;
}
}
return des;
}strcmp
int strcmp ( const char * str1, const char * str2 );
strcmp用于字符串比较，需要注意比较的是字符串中的内容，而非长度
标准规定：
? ? ? ? 第一个字符串大于第二个字符串，则返回大于0的数字
? ? ? ? 第一个字符串等于第二个字符串，则返回0
? ? ? ? 第一个字符串小于第二个字符串，则返回小于0的数字
????????（返回值只规定范围，不规定具体的值）
模拟实现：
#include <stdio.h>
#include <assert.h>
int myStrcmp(const char* str1, const char* str2)
{
int ret = 0;
assert(str1 && str2);
while (!(ret = *(unsigned char*)str1 - *(unsigned char*)str2) && *str1)
{
str1++;
str2++;
}
if (ret < 0)
return -1;
else if (ret > 0)
return 1;
return ret;
}strncpy
char * strncpy ( char * destination, const char * source, size_t num );
strncpy用于拷贝num个字符串从源字符串到目标空间
如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个
模拟实现：
#include <stdio.h>
#include <assert.h>
#include <string.h>
char* myStrncpy(char* des, const char* src, size_t num)
{
assert(des && src);
char* s1 = des;
char* s2 = src;
int i = 0;
for (i = 0; i < num; i++)
{
*s1 = *s2;
s1++;
s2++;
if (*s2 == 0)
{
*s1 = 0;
break;
}
}
return des;
}strncat
char * strncat ( char * destination, const char * source, size_t num );
strncat用于追加源字符串中的num个字符
如源字符串中的字符不住num个，则只追加到'\0'
#include <stdio.h>
#include <assert.h>
#include <string.h>
char* myStrncpy(char* des, const char* src, size_t num)
{
assert(des && src);
char* s1 = des;
char* s2 = src;
int i = 0;
for (i = 0; i < num; i++)
{
*s1 = *s2;
s1++;
s2++;
if (*s2 == 0)
{
*s1 = 0;
break;
}
}
return des;
}strncmp
int strncmp ( const char * str1, const char * str2, size_t num );
strncmp比较到出现一个字符不一样或则一个字符串结束或则num个字符全部比较完
strstr
const char * strstr ( const char * str1, const char * str2 );
strstr为字符串查找函数，在一个字符串str1中查找子字符串str2
模拟实现：（可采用BF算法与KMP算法，这里只展现BF算法的模拟实现）
#include <stdio.h>
#include <assert.h>
char* myStrstr(const char* str1, const char* str2)
{
assert(str1 && str2);
if (*str2 == '\0')
return str1;
char* s1;
char* s2;
char* cp = str1;
while (*cp)
{
s1 = cp;
s2 = str2;
while ((*s1 != '\0') && (*s2 != '\0') && (*s1 == *s2))
{
s1++;
s2++;
}
if (*s2 == '\0')
return cp;
cp++;
}
return NULL;
}strtok
char * strtok ( char * str, const char * delimiters );
strtok用于切割字符串
参数delimiters为一个字符串，定义了用作分隔符的字符集合
第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记
strtok函数找到str中的下一个标记，并将其用\0结尾，返回一个指向这个标记的指针
strtok函数的第一个参数不为NULL，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置
strtok函数的第一个参数为NULL，函数将在同一个字符串中被保存的位置开始，查找下一个标记
如果字符串中不存在更多的标记，则返回NULL指针
strerror
char * strerror ( int errnum );
strerror用于返回错误码所对应的错误信息（C语言内置的，C语言库函数调用失败时，会把错误码存入到errno变量中）
memcpy
void * memcpy ( void * destination, const void * source, size_t num);
函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
该函数在遇到' 0 '的时候不会停下来。
如果source和destination有任何的重叠，复制的结果都是未定义的。
void* myMemcpy(void* dest, void* src, size_t cnt)
{
assert(dest && src);
void* ret = dest;
while (cnt--)
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
return ret;
}memmove
void * memmove ( void * destination, const void * source, size_t num );
和memcpy的差别是mommove函数处理的源内存块和目标内存块是可以重叠的。
如果源空间和目标空间出现重叠，就得使用memmove函数处理。
模拟实现需要分类讨论：向前拷贝或向后拷贝
void* myMemmove(void* dest, const void* src, size_t cnt)
{
assert(dest && src);
void* ret = dest;
if (dest < src)//从前向后拷贝
{
while (cnt--)
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
}
else//从后向前拷贝
{
while (cnt--)
{
*((char*)dest + cnt) = *((char*)src + cnt);
}
}
return ret;
}memcmp
int memcmp ( const void * ptr1, const void * ptr2, size_t num );
比较从ptr1和ptr2指针开始的num个字节
?