库函数的模拟实现

目录

strlen函数

strcpy函数 

strcmp函数 

strcat函数 

strstr字串函数模拟 

 strncpy函数

strncmp函数 

strncat函数 

memcpy函数 

memmove函数  

qsort函数模拟实现 

---

strlen函数

size_t my_strlen1(const char* src)//count计数
{
	assert(src);
	size_t count = 0;
	while (*src++)
	{
		count++;
	}
	return count;
}

size_t my_strlen2(const char* src)//指针-指针
{
	const char* orgin = src;
	while (*src++);
	return src - orgin-1;
}

size_t my_strlen3(const char* src)//递归
{
	if (*src == '\0')
	{
		return 0;
	}
	else
	{
		return 1 + my_strlen3(++src);//abc=a+bc    bc=b+c
	}
}

strcpy函数 

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

strcmp函数 

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

strcat函数 

char* my_strcat(char* dest, const char* src)//注：不能在自己后面接自己
{
	assert(dest && src);
	char* orgin = dest;
	while (*dest)
	{
		dest++;
	}
	while (*dest++ = *src++);
	return orgin;
}

strstr字串函数模拟 

char* my_strstr(const char* s1, const char* s2)
{
	assert(s1 && s2);
	const char* cur1 = s1;//保存开始比的位置
	const char* cur2 = s2;
	while (*cur1)
	{
		s1 = cur1;
		s2 = cur2;
		while (*s1++ == *s2++)//相等开始比
		{
			if (*s2 == '\0')
			{
				return (char*)cur1;
			}
			
		}
		cur1++;//不相等cur就到下一个位置
		//s2也要回到起点
	}
	return NULL;
}

 strncpy函数

char* my_strncpy(char* dest, const char* src, size_t count)
{
	assert(dest && src);
	char* orgin = dest;
	size_t len = strlen(src);
	if (count > len)
	{
		while ( count > len)
		{
			count--;
			*((char*)dest + count) = '\0';
		}
	}
	if (dest > src)
	{
		//从后往前
		
		while (count--)
		{
			*((char*)dest + count) = *((char*)src + count);
		}

	}
	else
	{
		//<=或者不重叠统一从前往后
		while (count--)
		{
			*(char*)dest = *(char*)src;
			((char*)dest)++;
			((char*)src)++;
		}
	}
	return orgin;

}

strncmp函数 

int my_strncmp(const char* s1, const char* s2, size_t count)
{
	assert(s1 && s2);
	assert(count);
	while (count--)
	{
		if (*s1 == *s2)//相等
		{
			if (*s1 == '\0')
			{
				return 0;
			}
			s1++;
			s2++;
		}
		else//不相等
		{
			return *s1 - *s2;
		}
	}
}

strncat函数 

 

char* my_strncat(char* dest, const char* src, size_t count)//以\0为结束标志
{
	assert(dest && src);
	char* orgin = dest;
	while (*dest)//找到\0
	{
		dest++;
	}
	while (count--)//以count为结束标志
	{
		*dest++ = *src++;
		if (*src == '\0')//以\0为结束标志
		{
			break;
		}
	}
	return orgin;
}

memcpy函数 

//memcpy函数模拟实现 缺陷：内存重复时，结果不是我们想要的
void* my_memcpy(void* dest, const void* src, size_t count) 
{
	void* ret = dest;
	for (size_t i = 0; i < count; i++)
	{
		*((char*)dest + i) = *((char*)src + i);
	}
	return ret;
}

memmove函数  

//memmove 函数模拟实现 -> memcpy加强版 解决内存重复问题
void* my_memmove(void* dest, const void* src, size_t count)
{
	void* ret = dest;
	if (dest > src)
	{
		//从后往前
		while (count--)
		{
			*((char*)dest + count) = *((char*)src + count);
		}

	}
	else
	{
		//<=或者不重叠统一从前往后
		while (count--)
		{
			*(char*)dest = *(char*)src;
			((char*)dest)++;
			((char*)src)++;
		}
	}
	return ret;
}

qsort函数模拟实现 

void qsort( void *base, size_t num, size_t width, int (__cdecl *compare )(const void *elem1, const void *elem2 ) );
//compare函数由用户自己实现

 这里用冒泡排序模拟：

void swap(char* buf1, char* buf2, int width)
{
	char tmp = 0;
	for (int i = 0; i < width; i++)
	{
		tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}
void Bubblesort(void* a, size_t n, size_t width, int (*cmp)(const void*,const void*))
{
	for (int i = 0; i < n - 1; i++)
	{
		for (int j = 1; j < n - i; j++)
		{//转换成char*型，因为每次解引用1个字节，方便模拟其他类型
			if (cmp((char*)a + (j - 1) * width, (char*)a + j * width)>0)
			{
				swap((char*)a + (j - 1) * width, (char*)a + j * width,width);
	
			}
		}
	}
}