库函数实现（memmove，memcpy，strstr，strcat，strcmp，strcpy，strlen）

分别实现memmove，memcpy，strstr，strcat，strcmp，strcpy，strlen函数。

#include<stdio.h>
#include<string.h>
#include<assert.h>

//memmove函数实现
void *my_memmove(void *dest, const void *src, size_t count)
{
	//判断参数合法
	assert(dest != NULL&&src != NULL);
	//定义临时变量保护数据
	char* pdest = (char*)dest;
	char* psrc = (char*)src;
	//判断是否发生内存重叠
	if (pdest <= psrc || pdest - psrc >= count)
	{
		while (count-- != 0)
		{
			*pdest = *psrc;
			pdest++;
			psrc++;
		}
	}
	else//如果内存重叠，反向拷贝
	{
		pdest += (count-1);
		psrc += (count-1);
		while (count-- != 0)
		{
			*pdest = *psrc;
			pdest--;
			psrc--;
		}
	}
	return dest;
}



//memcpy实现
void *my_memcpy(void *dest, const void *src, size_t count)
{
	//判断参数合法
	assert(dest != NULL&&src != NULL);
	//定义临时指针保护数据
	char* pdest = (char*)dest;
	char* psrc = (char*)src;
	while (count-- != 0)
	{
		*pdest = *psrc;
		pdest++;
		psrc++;
	}
	return dest;
}



//strstr
char *my_strstr(const char *string, const char *strCharSet)
{
    //判断参数合法
	assert(string != NULL && strCharSet != NULL);
	//定义临时变量保护数据
	char *s = string;
	char *t = strCharSet;
	int i = 0;
	int j = 0;
	//任一字符串结束就循环结束
	while (s[i] != '\0'&&t[j] != '\0')
	{
		if (s[i] == t[j])
		{
			i++;
			j++;
		}
		else
		{
			i = i - j + 1;
			j=0;
		}
	}
	if (t[j] == '\0')
		return s + i-j;
	return NULL;
}



//strcat
char *my_strcat(char *strDestination, const char *strSource)
{
    //判断参数合法
	assert(strDestination != NULL && strSource != NULL);
	//定义临时指针保护数据
	char *s = strDestination;
	char *t = strSource;
	//先将s的指针指向s的结束位置
	while (*s != '\0')
	{
		s++;
	}
	//将t中的内容写入s
	while (*t != '\0')
	{
		*s++ = *t++;
	}
	*(s+1)='\0';
	return strDestination;
}



//strcmp
int my_strcmp(const char *string1, const char *string2)
{
	//判断参数合法
	assert(string1 != NULL && string2 != NULL);
	//定义临时指针保护数据
	char *s = string1;
	char *t = string2;
	//任一字符串结束后，循环在执行一次
	while (*s != '\0' || *t != '\0')
	{
		if (*s - *t == 0)
		{
			*s++;
			*t++;
		}
		else
			break;
	}
	return *s - *t;
}



//strcpy
char *my_strcpy(char *strDestination, const char *strSource)
{
	//判断参数合法
	assert(strDestination != NULL && strSource != NULL);
	//定义临时指针保护数据
	char *s = strDestination;
	char *t = strSource;
	while (*t != '\0')
	{
		*s++ = *t++;
	}
	*(s + 1) = '\0';
	return strDestination;
}



//strlen
size_t my_strlen(const char *string)
{
	//判断参数合法
	assert(string != NULL);
	//定义临时指针保护数据
	char *p = string;
	size_t count = 0;
	while (*p != '\0')
	{
		p++;
		count++;
	}
	return count;
}



int main()
{
	int arr[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	int brr[10];
	int crr[10];
	char *str1 = "ababcabcdabcabc";
	char *str2 = "abcde";
	char str3[20] = "ABCDE";
	char *str4 = "abcde";

	my_memmove(brr, arr, sizeof(int)* 10);
	my_memcpy(crr, arr, sizeof(int)* 10);


	char *p=my_strstr(str1,str2);
	if (p == NULL)
		printf("不存在\n");
	else
		printf("%s\n", p);

	my_strcat(str3, str2);
	printf("%s\n", str3);


	int a = my_strcmp(str4, str2);
	int b = my_strcmp(str4, str1);
	printf("%d   %d", a, b);
	
	my_strcpy(str3, str4);
	printf("%s\n", str3); 

	size_t c = my_strlen(str1);
	printf("%d\n", c);
	return 0;
}