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

朱雀 2022-12-24 00:58 208阅读 0赞

### 字符操作库函数 ###

*  ## 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*)

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70][]

模拟实现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][http_www.ruanyifeng.com_blog_2013_05_Knuth_E2_80_93Morris_E2_80_93Pratt_algorithm.html]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 1][]

### 内存操作库函数 ###

*  ## 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 如图所示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 2][]

解决方案，从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;
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70]: /images/20221120/b42f8c160af14b50925b69be67035a83.png
[http_www.ruanyifeng.com_blog_2013_05_Knuth_E2_80_93Morris_E2_80_93Pratt_algorithm.html]: http://www.ruanyifeng.com/blog/2013/05/Knuth%E2%80%93Morris%E2%80%93Pratt_algorithm.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/2020112614263517.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20201126151442429.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx,size_16,color_FFFFFF,t_70