C语言 库函数的模拟实现

一、字符串函数

1. strlen（3种方法）

int my_strlen(const char* str)
{
	int count = 0;
	assert(str);
	while (*str)
	{
		count++;
		str++;
	}
	return count;
}
//2.递归
int my_strlen(const char* str)
{
	assert(str);
	if (*str == '\0')
		return 0;
	else
		return 1 + my_strlen(str + 1);
}
//3.指针-指针
int my_strlen(const char* str)
{
	assert(str);
	char* p = str;
	while (p != '\0')
		p++;
	return p - str;
}

2. strcpy 、strncpy

char* my_strcpy(char* dest, const char* src)
{
	char* ret = dest;//为了实现链式访问
	assert(dest && src);
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}

char* my_strncpy(char* dest, const char* src, size_t count)
{
	char* ret = dest;//为了实现链式访问
	assert(dest && src);
	while (count-- && (*dest++ = *src++))
	{
		;
	}
	if (count)//当count大于src的长度时，将补充空字符
	{
		while (--count)
		{
			*dest++ = '\0';
		}
	}
	return ret;
}

3. strcat 、strncat

char* my_strcat(char* dest, const char* src)
{
	char* ret = dest;
	assert(dest && src);
	while (*dest)//找到目标空间中的\0
	{
		dest++;
	}
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}

char* my_strncat(char* dest, const char* src, size_t count)
{
	char* ret = dest;
	assert(dest && src);
	while (*dest++)//找到目标空间中的\0
	{
		;
	}
	while (count-- && (*dest++ = *src++))
	{
		;
	}
	return ret;
}

4. strcmp

int my_strcmp(const char* str1, const char* str2)
{
	int ret = 0;
	assert(str1 && str2);
	while (*str1 == *str2)
	{
		if (*str1 == '\0')
			return 0;
		str1++;
		str2++;
	}
	return *str1 - *str2;
}

5. strstr

char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);
	char* cur = (char*)str1;
	char* s1, * s2;
	
	if (!*str2)
		return ((char*)str1);

	while(*cur)
	{
		s1 = cur;
		s2 = (char*)str2;
		while (*s1 && *s2 && *s1 == *s2)
		{
			s1++;
			s2++;
		}

		if (!*s2)
			return cur;

		cur++;
	}
	return(NULL);
}

二、内存函数

1. memcpy

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

2. memmove

void* memmove(void* dst, const void* src, size_t count)
{
	void* ret = dst;
	assert(dst && src);
	if ((dst <= src) || (char*)dst >= ((char*)src + count))
	{
		while (count--)
		{
			*(char*)dst = *(char*)src;
			dst = (char*)dst + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		dst = (char*)dst + count - 1;
		src = (char*)src + count - 1;
		while (count--)
		{
			*(char*)dst = *(char*)src;
			dst = (char*)dst - 1;
			src = (char*)src - 1;
		}
	}
	return ret;
}