字符函数和字符串函数模拟实现（strlen,strcpy,strcat,strcmp,strstr,memcpy,memmove）

库函数的模拟实现我个人认为是十分有必要的，在模拟实现的过程中，我们会更加理解函数的使用及定义，加深我们对库函数的理解并进一步提升编程能力，所以我写了这篇文章。

👨‍🚀求字符串长度

🚴‍♂️strlen模拟实现

🚴‍♂️strlen非递归实现

求字符串的长度，我们只需要用一个循环，找到字符串末尾的’\0’，并创建一个临时变量，记录循环进行了多少次，就计算出了字符串长度。
库函数中strlen函数返回的是一个无符号整形（size_t），在使用时要极其注意。

size_t my_strlen(char*str)
{
	int cpunt=0;
	while(*str--)
	{
		count++;
	}
	return count;
}

🚴‍♂️strlen递归实现

size_t my_strlen(char*str)

{

	if (!*str)

		return 0;

	return my_strlen(str + 1) + 1;

}

👨‍🚀长度不受限制的字符串函数

🚴‍♂️strcpy模拟实现

在C语言的拷贝函数中，不是一下子将一个字符串全部拷贝到另一个字符串中，而是一个字符一个字符进行拷贝，拷贝结束将原字符串的’\0’，拷贝到目标空间。

• 目标空间必须足够大
• 目标空间必须可变

char *my_strcpy(char *dest, const char*src)
{
 char *ret = dest;
 assert(dest != NULL);
 assert(src != NULL);

 while((*dest++ = *src++))
 {
 ;
 }
 return ret;
} 

🚴‍♂️srtcat模拟实现

strcat实现的思路很简单，先找到目标字符的’\0’，从’\0’位置开始追加，追加结束后补’\0’。

• 目标空间必须足够大
• 目标空间必须可变

char* my_strcat(char*dest, const char* src)

{
char *s1 = dest;
while (*dest)
{
dest++;
}
while ((*dest++ = *src++))
{
	;
}
return s1;
}

但是这样实现如果我们想要自己给自己追加就实现不了，想知道为什么的同学可以阅读我的另一篇文章
C语言函数strcat改进https://blog.csdn.net/m0_49622667/article/details/120380415?spm=1001.2014.3001.5501

🚴‍♂️srtcpy模拟实现

此函数实际是比较某个字符编码的大小，比如比较abcde和abc的大小，从第一个字符开始比较，如果相等，比较下一个，直到比到c以后，第二个字符串已经没有字符，那此时第一个字符串大于第二个字符串。strcpy这样规定：

• 第一个字符串大于第二个字符串，返回大于0的数字
• 第一个字符串小于第二个字符串，返回小于0的数字
• 第一个字符串等于第二个字符串，返回0

int my_strcmp(const char*str1, const char*str2)

{

char*dest = str1;

char*src = str2;

while (*dest != '\0' && src != '\0')

{

if (*dest > *src)

return *dest - *src;

else if (*dest < *src)

return *dest - *src;

dest++;

src++;

}

return *dest - *src;

}

👨‍🚀长度受限制的字符串函数

🚴‍♂️strncpy模拟实现

这个函数和strcpy的区别在于可以自己选择拷贝几个字符

如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个

char *my_strncpy(char *dest, const char*src,int num)
{
 char *ret = dest;
 assert(dest != NULL);
 assert(src != NULL);

 while(*src)
 {
 	*dest++ = *src++;
 	num--;
 }
 while(num)
 {
	*dest++='\0';
 }
 return ret;
} 

👨‍🚀字符串查找

🚴‍♂️strstr

此函数我们在这里使用暴力查找，更好的方法可以使用KMP算法，不用指针回溯。
那么暴力查找就是一个一个查找，比如char * dest=“abcd”,char*src=“cd”,比较第一个字符，不相等，那么dest++；直到比较第3次，相等之后，dest++；src++；直到src==’\0’;结束查找，返回一个字符指针，那么返回谁？肯定是指向c的指针，此时我们就需要定义一个指针，记录src++前的dest指向，若 *（dest++）与 *（src++）不相等，则需要dest++后重新查找。

const char * my_strstr2(const char * str1, const char * str2)
{
	assert(str1 != NULL && str2 != NULL);
	char*cp = (char*)str1;
	char *substr = (char*)str2;
	char*s1 = NULL;
	if (*str2 == '\0')
		return NULL;
	while (*cp)
	{
		s1 = cp;
		while (*s1 && *substr && (*s1 == *substr))
		{
			s1++;
			substr++;
		}
		if (*substr == '\0')
			return cp;
		cp++;
	}
}

👨‍🚀内存操作函数

🚴‍♂️memcpy

由于是操作内存的函数，也就是说这个拷贝函数我们不知道要拷贝的是什么类型，参数也就只能设置为void*，返回值也是。所以我们需要将参数强转为char*,一个字节一个字节对其拷贝。

void * my_memcpy(void * destination, const void * source, size_t num)

{

assert(destination);

void*ret = destination;

while (num--)

{

*(char*)destination = *(char*)source;

destination = (char*)destination+1;

source = (char*)source + 1;

}

return source;

}

但是这个函数有个致命的问题，比如我执行以下代码

int main()
{
	char s[100] = "abcdef";
	my_memcpy(s+3, s+1, 3);
	printf("%s", s);
	return 0;
}

我想要把bcd拷贝到def，得到的结果应该是abcdbcd,但结果却是这样

在发生内存重叠的时候这个函数就不行了，在https://cplusplus.com（能查到大部分C/C++库函数）查询，解释说memcpy本就不支持在内存重叠时使用，如果在内存重叠是，请使用memmove函数

那我们来看看memmove函数

🚴‍♂️memmove模拟实现

我们来看拷贝的时候发生内存重叠只可能出现在同一字符串自己给自己拷贝，dest和src表示在字符串中的位置，通过观察分析可知，当dest的位置在src之前时，拷贝一个字符两个同时往后继续拷贝，故不会发生内存重叠，也就是说我们只需要将最后一种处理好，就memmove函数就实现完成了。那么解决的方法就是，在拷贝前进行判断，当dest>src或者（char*）dest<(char*)src+num时（num表示要拷贝的字节），从后往前拷贝，其余情况和memcpy一样，这就轻松解决了内存重叠。

void * my_memmove(void * destination, const void * source, size_t num)

{

void *ret = destination;

assert(destination);

assert(source);



char*dest = (char*)destination;

char*src = (char*)source;

if (dest > src || (char*)dest<((char*)src + num))

{

dest = (char*)dest + num - 1;

src = (char*)src + num - 1;

while (num--)

{

*(char*)dest = *(char*)src;

dest = (char*)dest - 1;

src = (char*)src - 1;

}

}

else

{

while (num--)

{

*(char*)dest = *(char*)src;

dest = (char*)dest + 1;

src = (char*)src +1;

}

}

return ret;

}

喜欢的话点赞收藏哦