一些库函数的模拟实现

大家好，这次的博客我想介绍一下我正在学的一些库函数，包括如何使用和模拟实现：

1.strlen：这个函数是来计算字符串大小的也就是'\0'的之前的字符串大小，这里我就直接模拟实现来代替例子了：

模拟实现strlen函数
size_t My_strlen1(char* str)
{
	int count = 0;
	while (*str)
	{
		count++;
		str++;
	}
	return count;
}
size_t My_strlen2(char* str)
{
	if (*str)
	{
		return 1 + My_strlen2(str + 1);
	}
	else
		return 0;
	
}
size_t My_strlen3(char* str)
{
	char* ret = str;
	while (*str)
	{
		str++;
	}
	return str - ret;
}
int main()
{
	char arr[] = "abcdef";
	size_t ret1 = My_strlen1(arr);
	size_t ret2 = My_strlen2(arr);
	size_t ret3 = My_strlen3(arr);
	printf("%zd\n", ret1);
	printf("%zd\n", ret2);
	printf("%zd\n", ret3);
	return 0;
}

这里我给出了三种模拟实现strlen函数的方法，大家参考就可以了，3种方法很显然：

（1）我们可以把它叫做计数器，因为count就相当于一个计数器，*str!='\0'的时候count就一直++，直到遇到'\0'为止，然后返回count

（2）递归的方式，至于为什么是1+My_strlen(str+1)因为我们知道str+1就会跳过一个比特位，刚好是下一个元素的地址，那么+1就相当于把跳过的那个元素的大小加了进来，总大小就可以递归出来了。

（3）这个方法是指针减指针的形式，我们由原理可以知道，其实高地址的指针-低地址的指针得到的就元素个数，所以这个方法也可以实现

2.strcmp函数：这个函数的功能是进行字符串大小的比较，比较的是ASCll码值，如果第一个字符串小于第二个字符串，则返回一个小于0的数；如果第一个字符串等于第二个字符串，那么就返回0，如果第一个字符串大于第二个字符串，则返回一个大于0的数。

模拟实现strcmp函数
int My_strcmp(const char* str1, const char* str2)
{
	while (*str1 == *str2)
	{
		if (*str1 == '\0')
			return 0;
		str1++;
		str2++;
	}
	
	if (*str1 < *str2)
		return (int)(*str1 - *str2);
	else
		return (int)(*str1 - *str2);

}
int main()
{
	char arr1[] = "abc";
	char arr2[] = "abd";
	int ret = My_strcmp(arr1, arr2);//arr1<arr2 返回一个小于0的数，arr1>arr2 返回一个大于0的数， arr1=arr2 返回0
	if (ret > 0)
	{
		printf("arr1>arr2\n");
	}
	else if (ret == 0)
		printf("arr1=arr2\n");
	else
		printf("arr1<arr2\n");
	return 0;
}

这里我们可以看到这个函数已经模拟实现成功了，大家可以下去试一试，用用其他的例子，看能不能满足，如果出错的话，记得提醒我哦！！谢谢各位啦！

3.strcpy函数：这个函数是进行字符串拷贝的函数，话不多说直接上实例

模拟实现strcpy函数
char* My_strcpy(char* str1, const char* str2)
{
	assert(str1 && str2);
	int i = 0;
	char* ret = str1;
	size_t len = strlen(str2);
	for (i = 0; i < len ; i++)
	{
		str1[i] = str2[i];
	}
	return ret;
}
int main()
{
	char arr1[] = "xxxxxxxxx";
	char arr2[] = "abcdef";
	char* ret=My_strcpy(arr1, arr2);
	printf("%s\n", ret);
	return 0;
}

这个函数主要就是进行字符串的拷贝，我给你们提个问题，就是进行字符串拷贝的时候，'\0'是否也一起拷贝了？这个问题大家下去探讨一下。

4.strcat函数：字符串追加函数，直接上实例：

char* My_strcat(char* dest, const char* src)
{
	assert(dest && src);
	char* ret = dest;
	while (*dest)
	{
		dest++;
	}
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}
int main()
{
	char arr1[20] = "abcdef";
	char arr2[] = "ghijklm";
	char* ret = My_strcat(arr1, arr2);
	printf("%s\n", ret);
	return 0;
}

这里我们可以看到这个代码的实现是非常巧妙的，特别是*dest++=*src++,因为++的优先级高，所以先执行++，但是这是后置++，先使用再++，是不是很巧秒，如果不这样做，那么就会多写几行代码。大家可以进行用例测试。

5.strstr函数：这个函数是用来寻找字符串的，再arr1中寻找arr2第一次出现的地方，如果arr1中存在arr2，那么就返回在arr1中第一次出现的字符串的地址，否则返回NULL。实例测试：

const char* My_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);
	const char* s1;//遍历str1指向的字符串
	const char* s2;//遍历str2指向的字符串
	const char* cp;//记录开始匹配的位置
	if (*str2 == '\0')//如果str2是空字符串，那就没必要进去判断了
		return str1;
	cp = str1;
	while (*cp)
	{
		s1 = cp;
		s2 = str2;
		while (*s1 && *s2 && *s1 == *s2)
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')//如果*s2='\0'之后就证明找到了并且找完了
			return cp;

		cp++;
	}
	return NULL;
}
int main()
{
	char arr1[] = "abbbcdef";
	char arr2[] = "bbc";
	const char* ret = My_strstr(arr1, arr2);
	if (ret == NULL)
		printf("找不到\n");
	else
		printf("找到了：%s\n", ret);
	return 0;
}

这里有很多东西值得大家思考哦，重要的几个点我都标注了，至于大家可能会提问：为什么不直接用str1和str2直接操作呢？这里的原因是，我们在编程的过程中，不要随便去改变某个地址的指向，因为如果后面会用到的情况下，你把它改变了之后，我们再想用这个地址的内容那就找不到了。这个函数的模拟实现要比其他几个稍微困难一点，但是只要仔细想明白，我相信大家都是没问题的。

6.memcpy函数：这个函数是内存拷贝函数，与strcpy函数的区别是，这个函数可以拷贝任意类型的数据。

void* memcpy(void* destination, const void* source, size_t num);//内存拷贝函数，
//跟strcmp函数的区别是它能拷贝任何数据类型,不重叠的内存拷贝交给memcpy，//重叠的内存拷贝交给memmove
void* My_memcpy(void* dest, const void* src, size_t num)
{
	assert(dest && src);
	while (num--)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return (char*)dest;
}
int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[] = { 2,3,4,5,6 };
	char* ret = My_memcpy(arr1, arr2, 20);
	int i = 0;
	
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}

这个函数和strcpy函数基本相似，大家可以联合起来一起总结。

7.memmove函数：解释基本上都放在注释端了

//这里和memcpy函数的不同点就是memcpy函数拷贝的是不重复的数据，而拷贝重复的数据一般来说都是让
//memmove函数实现
void* My_memmove(void* dest, const void* src, size_t num)
{
	assert(dest && src);
	void* ret = dest;
	while (num)
	{
		if (dest < src)
		{
			//前往后，经过分析之后得到的结果：当目的地地址小于源头地址就从前往后
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;

		}
		else
		{
			//后往前，经过分析之后得到的结果：当目的地地址大于源头地址就从后往前
			*((char*)dest + num - 1) = *((char*)src + num - 1);
			//为什么要+(num-1)我们知道，vs2022的存储方式是小端存储，所以我们列出来所有的数据
			//01 00 00 00  02 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00
			//06 00 00 00  07 00 00 00 08 00 00 00 09 00 00 00 0a 00 00 00
			//从3-7刚好20个字节，而03+19个字节刚好是07 00 00 00-这里，刚好到达从后往前的目的地

		}
		num--;
	}
	return ret;
}
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	char* ret = My_memmove(arr1 + 2, arr1, 20);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}

ok，这里就是七个库函数的模拟实现，你面试的时候，考官可能会考哦，所以还是自己去实践一下，而且一定要多复习，人都是会健忘的，但是你只要一直复习，那么它依旧可以扎根在你脑中……加油代码工程师！！！！