C语言 string及memcpy,memmove函数的模拟实现

1.strlen（字符串长度），其函数原型为：size_t strlen( const char *string);

此函数模拟实现有三种方法：

int my_strlen(const char *str)//第一种：用count计数
{
	int count = 0;
	while (*str++ != '\0')
		count++;
	return count;
}

int my_strlen(const char *str)//第二种：递归，不创建临时变量
{
	if (*str != '\0')
		return 1 + my_strlen(str + 1);
	else
		return 0;
}

int my_strlen(const char *str)//第三种：用指针相减
{
	const char*end = str;
	while (*end++)
		;
	return end - str - 1;
}

2.strcpy（长度不受限的字符串拷贝），其函数原型为：

char *strcpy( char *strDestination, const char *strSource );

模拟实现：

char *my_strcpy(char *dst, const char *src)
{
	char *ret = dst;
	while (*dst++ = *src++)
		;
	return ret;
}

3.strncpy（长度受限的字符串拷贝），其函数原型为：

char *strncpy( char *strDest, const char *strSource, size_tcount);

模拟实现：

char *my_strncpy(char *dst, const char*src, int n)
{
	char *tmp = dst;
	while (n&&(*dst++ = *src++))
		n--;
	if (n)
	{
		while (--n)
			*dst = '\0';
	}
	return tmp;
}

4.strcat（长度不受限的字符串连接），其函数原型为：

char *strcat( char *strDestination, const char *strSource);

模拟实现：

char *my_strcat(char *dst, const char *src)
{
	char *ret = dst;
	while (*dst != '\0')
		dst++;
	while (*dst++ = *src++)
		;
	return ret;
}

5.strncat（长度受限的字符串连接），其函数原型：

char *strncat( char *strDest, const char *strSource, size_tcount);

模拟实现：

char *my_strncat(char *dst, const char *src, int n)
{
	char *tmp = dst;
	while (*dst != '\0')
		dst++;
	while (n&&(*dst++ = *src++))
		n--;
	*dst = '\0';
	return tmp;
}

6.strcmp（长度不受限的字符串比较），其函数原型：

int strcmp( const char *string1, const char *string2);

模拟实现：

int my_strcmp(const char*s1, const char*s2)
{
	while (*s1 == *s2)
	{
		if (*s1 == '\0')
			return 0;
		s1++;
		s2++;
	}
	return *s1 - *s2;
}

7.strncmp(长度受限的字符串比较），其函数原型：

int strncmp( const char *string1, const char *string2, size_tcount );

模拟实现：

int my_strncmp(const char *str1, const char *str2, int n)
{
	assert(str1);
	assert(str2);
	while (n && (*str1 == *str2))
	{
		if (*str1 == '\0')
			return 0;
		str1++;
		str2++;
		n--;
	}
	if (!n)
		return 0;
	else
		return *str1 - *str2;
}

8.strchr（字符串中从前向后查找字符），其函数原型：

char *strchr( const char *string, intc);

模拟实现：

char *my_strchr(const char *str, int ch)
{
	while (*str && *str != (char)ch)
		str++;
	if (*str == (char)ch)
		return str;
	return NULL;
}

9.strrchr（字符串中从后向前查找字符），其函数原型为：

char *strrchr( const char *string, intc);

模拟实现：

char *my_strrchr(const char *str, int ch)
{
	char *start = str;
	while (*str++)
		;
	while ((--str != start)&&(*str != (char)ch))
		;
	if (*str == (char)ch)
		return str;
	return NULL;
}

10.strstr（字符串中查找子串），其函数原型：

char *strstr( const char *string, const char *strCharSet);

模拟实现：

char *my_strstr(const char*str, const char*substr)
{
	const char *s1 = str;
	const char *s2 = substr;
	const char *cur = str;
	if (*substr == '\0')
		return (char*)str;
	while (*cur)
	{
		s1 = cur;
		s2 = substr;
		while (*s1 && *s2 && (*s1 ==*s2))
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
			return (char*)cur;
		cur++;
	}
	return NULL;
}

关于strstr函数还有另一种实现，采用for循环，原理与上一种基本相同，代码如下：

char *my_strstr(const char *str1, const char *str2)
{
	int i = 0;
	int j = 0;
	for (i = 0; str1[i] != '\0'; i++)
	{
		for (j = 0; str2[j] != '\0'; j++)
		{
			if(str1[j+i] != str2[j])
				break;
		}
		if (str2[j] == '\0')
			return str1+i;
	}
	return NULL;
}
int main()
{
	char *p1 = "abbbcdef";
	char *p2 = "bbc";
	char *ret = my_strstr(p1, p2);
	if (ret != NULL)
		printf("%s\n", ret);
}

11.memcpy（内存拷贝），其函数原型为：

void *memcpy( void *dest, const void *src, size_tcount);

模拟实现：

void *my_memcpy(void* dst, const void* src, size_t count)
{
	void *ret = dst;
	while(count--)
	{
		*(char*)dst = *(char*)src;
		dst = (char*)dst + 1;
		src = (char*)src + 1;
	}
	return ret;
}

12.memmove（允许重叠的拷贝），其函数原型：

void *memmove( void *dest, const void *src, size_tcount);

模拟实现

void *my_memmove(void* dst, const void* src, size_t count)
{
	void *ret = dst;
	if (dst < src)
	{//前--后拷贝
		while (count--)
		{
			*(char*)dst = *(char*)src;
			dst = (char*)dst + 1;
			src = (char*)src + 1;
		}
	}
	else
	{//后--前
		while (count--)
		{
			*((char*)dst + count) = *((char*)src + count);
		}
	}
	return ret;
}