字符操作库函数以及内存操作库函数 C语言实现

字符操作库函数

strlen

strlen判断结束的标志为找到字符串中的'\0',也就是说如果字符串中间出现'\0'将会导致strlen停止即strlen的返回值是'\0'前所出现的字符个数然而此时字符串长度并非真实长度，但一般很少出现字符串中间会有‘\0’

size_t strlen(const char* str)

模拟实现my_strlen：

方式1：直接计数遍历整个字符串直至找到“\0”为止否则计算器实现加一操作

int my_strlen(const char* str)
{int count=0;while(*str){count++;str++；}return count;
}

方式2：不引入整型计数变量，利用递归实现计数

int my_strlen(const char* str)
{if(*str=='\0'){return 0;}return 1+my_strlen(str+1);
}

方式3：指针方式实现计数,遍历不为‘\0’则向右移动指针，直至指针p移动至‘\0’前一位置，p-str即为中间不为'\0'的字符个数

int my_strlen(const char* str)
{char* p=(char*)str;while(*p!='\0'){p++;}return p-str;
}

strcpy

源字符串必须以'\0'结束，同时，目标空间必须足够大，以免源字符串拷贝空间不足，通过实际代码调试查看内存空间注意到，拷贝过程中会将源字符串结尾的‘\0’拷贝至目标地址空间中

char* strcpy(char* destination,const char* source)

my_strcpy模拟实现：

当判断源字符串不为空，以及目标空间存在的情况下，实现从源字符串到目标空间的逐个字符拷贝，直至源字符串遇到'\0'结束拷贝

注意：while(*dest++=*src++); 当src遇到'\0'，赋值给dest后，表达式结果为0，为false，则循环结束，暂停拷贝

char* my_strcpy(char* dest,const char* src)
{char* ret=dest;assert(dest!=NULL)assert(src!=NULL)while(*dest++=*src++)；return ret;
}

strcat

char* strcat(char* destination,const char* source)

strcat模拟实现，可以在strcpy基础上进行，即在目标空间末尾(不包括‘\0’)进行一次strcpy即可实现，具体参见代码

char* my_strcat(char* dest,const char* src)
{char* ret=dest;assert(dest!=NULL)assert(src!=NULL)while(*dest!=NULL){dest++;}while(*dest++=*src++)；return ret;
}

考虑：strcat自己给自己追加会发生什么？

自己给自己追加的过程中，源字符串末尾的‘\0’被覆盖，导致while循环进入死循环，无法再找到‘\0’停止，此时starcat将一直拷贝连接直至目标空间溢出报错

strcmp

strcmp实现字符串比较，通过对应字符ASCll码比较大小

int strcmp(const char* src1,const char* src2)

如果第一个字符串大于第二个字符串，返回大于0的数

如果第一个字符串等于第二个字符串，返回等于0的数

如果第一个字符串小于第二个字符串，返回小于0的数

strcmp的模拟实现：

int my_strcmp(const char* src1,const char* src2)
{int ret=0;assert(src1!=NULL);assert(src2!=NULL);while(!(ret=*(unsigned char*)src1-*(unsigned char*)src2)&&*src2)//相等字符则后移比较，直至遇到‘\0’{src1++;src2++;}if(ret<0)ret=-1;else if(ret>0)ret=1;return ret;
}

strstr

strstr实现子串查找，返回子串首元素地址

char* strstr(const char*,const char*)

模拟实现my_strstr():主要难点在于一个字符一个字符逐一匹配，需要一个指针记录起始位置，每次匹配失败需要退回起始位置的下一位置处开始在次匹配

#include<stdio.h>
#include<string.h>
#include<assert.h>char* my_strstr(const char* str1,const char* str2)
{assert(str1);assert(str2);const char* s1 = str1;const char* s2 = str2;const char* cp = str1;//该指针记录每一次进行匹配的起始位置if (*str2 == '\0'){return (char*)str1;}while (*cp){//一次匹配查找的过程s1 = cp;s2 = str2;while (*s1 && *s2 && *s1 == *s2)//逐个匹配{s1++;s2++;}if (*s2 == '\0')//只有s2走完才能说明找到真正的子串  返回起始查找位置cp  s1走完还没有找到匹配的子串，则返回null{return (char*)cp;}cp++;}return NULL;
}int main()
{char* str1 = "abcdef";char* str2 = "cde";char* ret = my_strstr(str1,str2);printf("%s",ret);return 0;
}

kmp算法实现字符串匹配详细可参考http://www.ruanyifeng.com/blog/2013/05/Knuth%E2%80%93Morris%E2%80%93Pratt_algorithm.html

内存操作库函数

memcpy

函数从source拷贝nums个字节到destination中，此时拷贝字节，遇到'\0'并不会停止

void* memcpy(void* destination,const void* source,size_t nums)

memcpy拷贝过程中源内存块和目标内存块不可以重叠

由于类型不确定，为void*类型，为了实现一字节一字节拷贝，需要强制类型转换为char*类型具体代码如下：

void* my_memcpy(void* dest,const void* str,size_t count)
{void* ret = dest;//一字节一字节拷贝,一字节一字节后移while (count--){*(char*)dest = *(char*)str;dest = (char*)dest + 1;str = (char*)str + 1;}return ret;
}

memmove

memmove与memcpy功能基本类似，都是实现内存块数据拷贝，memmove可以实现重叠内存拷贝

重叠内存拷贝不同的拷贝方向会导致尚未拷贝的内存空间 cd被覆盖为bb 导致后续拷贝也只拷贝了bb 如图所示：

解决方案，从source后面开始拷贝，从后向前拷贝，则不会被覆盖，但情况不一定，如果红色框为dest，绿色框为source，从后向前拷贝又会被覆盖

考虑是否存在一个分界条件，使得分情况处理即可

如果拷贝的目的地址在源地址前面则源地址从前向后拷贝到目的地址

如果拷贝的目的地址在源地址后面则源地址从后向前拷贝到目的地址

void* my_memmove(void* dest, const void* str, size_t count)
{//避免拷贝重叠  需要分情况讨论void* ret = dest;if (dest < str)//如果拷贝的目的地址在源地址前面  则源地址从前向后拷贝到目的地址{while (count--){//依然遵循一字节一字节拷贝*(char*)dest = *(char*)str;dest = (char*)dest + 1;str = (char*)str + 1;}}else//如果拷贝的目的地址在源地址后面  则源地址从后向前拷贝到目的地址{while (count--){*((char*)dest + count) = *((char*)str + count);}}return ret;
}