关于string.h库函数的一些函数功能，和代码模拟实现

关于string.h库函数里面的一个比较字符串大小的函数，

库函数的格式是：int strcmp ( const char * str1, const char * str2 );

我们在使用的时候，需要给他传两个需要比较大小的字符串地址，如果第一个字符串的ASCII码大于第二个字符串ASCII码的话，就会返回一个大于0的整数，如果他们相等就会返回一个整数0，如果小于的话，就会返回 一个整数-1，下面是模拟库函数的实现代码

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <assert.h>
int My_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);
	while (*str1++ == *str2++&&*str1!='')
	{
		//if (*str1 == '')
		//{
		//	return 0;
		//}
		//str1++;
		//str2++;
	}
	return (*str1 - *str2);
}

int main()
{
	char arr1[] = "abcd";
	char arr2[] = "abc";
	int ret= My_strcmp(arr1, arr2);
	if (ret > 0)
	{
		printf(">
");
	}
	else if (ret < 0)
	{
		printf("<
");
	}
	else
	{
		printf("==
");
	}
	return 0;
}

关于string.h库函数里的一个查找字符串是否存在的函数，strstr，

库函数的格式是：const char * strstr ( const char * str1, const char * str2 );

需要使用的时候 ，需要传入两个字符串的地址，如果在str1里面，找到了str2是存在的，就会返回在str1里面，str2存在的字符串第一个地址，如果没有找到就会返回 一个Null。

下面是模拟strstr功能实现的代码

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <assert.h>
const char* My_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);
	const char* s1 = str1;//创建一个指针，保留最开始的地址
	const char* s2 = str2;//创建一个指针，保留最开始的地址
	const char* p = str1;
	while (*p)
	{
		s1 = p;
		s2 = str2;
		while (*s1 == *s2 && *s1!=''&& *s2!='')
        //这里循环的判断条件是两个字符串都不为''
		{
			s1++;
			s2++;
		}
		if (*s2 == '')
		{
			return p;
		}
		p++;
	}
	return NULL;
}

int main()
{
	char arr1[] = "abbck";
	char arr2[] = "bbc";
	const char* ret= My_strstr(arr1, arr2);
	if (ret!=NULL)
	{
		printf("%s
", ret);
	}
	else
	{
		printf("子串不存在");
	}
	return 0;
}

关于string.h库函数里的一个按字节复制的函数memcpy，

他的格式是

void * memcpy ( void * destination, const void * source, size_t num );

使用的时候 ，需要给他传递两个地址，和要拷贝的字节个数，第一个地址是要粘贴的地址，第二个地址是要复制的地址，这个函数复制的前提是要两个独立的空间，自己复制自己是不行的，下面是代码的模拟实现

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <assert.h>
void* My_memcpy(void* dest, const void* src, size_t num)
{
	assert(dest && src);
	void* ret = dest;//保留刚开始的地址，复制完成后，返回原先的地址
	while (num--)
	{
		*(char*)dest = *(char*)src;//转换成char*类型，一个字节一个字节复制
		dest=(char*)dest+1;
		src = (char*)src + 1;
	}
	return ret;//返回复制好的起始地址
}
int main()
{
	char arr1[] = "asdfsdagkj";
	char arr2[20]={0};
	char* ret = (char*)My_memcpy(arr2, arr1, sizeof(arr1));
	printf("%s
",ret );
	return 0;
}

关于string.h库函数里的memmove函数，他的格式是

void * memmove ( void * destination, const void * source, size_t num );

这个函数跟前面的memcpy很像，不过他是可以实现自己拷贝自己的，在使用的时候 ，需要给他传递两个地址 ，一个是粘贴的地址，和一个复制的地址，和要拷贝多少个字节，代码模拟实现的难点就是，在于自己复制自己的时候 ，是要先从前面拷贝，还是先后面拷贝的判断，下面是代码的模拟实现

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <assert.h>
void* My_memmove(void* dest, const void* src, size_t num)
{
	assert(dest && src);
	void* ret = dest;
	if (dest < src)//判断一下如果粘贴的地址，小于复制的地址，直接从前往后拷贝
	{
		while (num--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else//如果是粘贴的地址大于复制的地址，就需要从后往前拷贝了
	{
		dest = (char*)dest + num-1;
		src = (char*)src + num-1;
		for (int i = 0; i < num; i++)
		{
			*((char*)dest - i) = *((char*)src - i);
		}
	}
	return ret;
}

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