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

秒速五厘米 2022-06-13 13:27 201阅读 0赞

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\_t***count***);**

模拟实现：

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\_t***count***);**

模拟实现：

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\_t***count* **);**

模拟实现：

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***, int***c***);**

模拟实现：

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***, int***c***);**

模拟实现：

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\_t***count***);**

模拟实现：

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\_t***count***);**

模拟实现

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;
    }