模拟实现字符串和内存操作函数（二）：strncpy, strncat, strncmp, memcpy, memmove

模拟实现字符串和内存操作函数（二）目录：

• strncpy
• strncat
• strncmp
• strcmp
• memcpy
• memmove

---

strncpy

char* strncpy(char* dst, const char* src, size_t num)

• strncpy表示把src所指向的字符串中以src地址开始的前n个字节复制到dst所指的数组中，并返回被复制后的dst。
• strncpy与ctrcpy的区别就是可以控制拷贝的字符个数，下面的strncmp和strncat同理，我们只需要按照传进来的num执行对应次数的循环即可

char* my_strncpy(char* dst, const char* src, size_t num)
{
	size_t i;
	char* dst1 = dst;
	for (i = 0; i < num; i++)
	{
		*dst1++ = *src++;
	}
	return dst;
}

---

strncat

char* my_strncat(char* dst, const char* src, size_t num)

• strncat把src所指字符串的前n个字符添加到dst所指字符串的结尾处，并覆盖dst所指字符串结尾的’\0’，从而实现字符串的连接。

char* my_strncat(char* dst, const char* src, size_t num)
{
	char* dst1 = dst;
	size_t i;
	while (*dst1)
	{
		dst1++;
	}
	for (i = 0; i < num; i++)
	{
		if(*src)
			*dst1++ = *src++ ;
	}
	*dst1 = '\0';

	return dst;
}

---

strncmp

int my_strncmp(const char* dst, const char* src, int num)

int my_strncmp(const char* dst, const char* src, int num)
{
	assert(dst && src);
	unsigned char* dst1 = (unsigned char*)dst;
	unsigned char* src1 = (unsigned char*)src;
	while(*dst1 && *src1 && num) 
	{
		if (*dst1 < *src1)
			return -1;
		else if (*dst1 > *src1)
			return 1;
		else
		{
			dst1++;
			src1++;
			num--;
		}
	}
	if ('\0' != *dst1 && '\0' == *src1)
		return 1;
	if ('\0' == *dst1 && '\0' != *src1)
		return -1;
	else 
		return 0;
}

---

memcpy

void* my_memcpy(void* dst, const void* src, size_t num)

• 从源source所指的内存地址的起始位置开始拷贝n个字节到目标destin所指的内存地址的起始位置中。
• 这个函数在遇到’\0’的时候不会停下来
• 如果src和dst有任何的重叠，复制的结果都是未定义的
• 与strcpy的区别就是可以拷贝所有类型

void* my_memcpy(void* dst, const void* src, size_t num)
{
	assert(dst && src);
	char* dst1 = (char*)dst;
	char* src1 = (char*)src;
	//强转原因：因为需要一个字节一个字节拷贝，而只有字符型的大小为一个字节
	size_t i;
	for (i = 0; i < num; i++)
	{
		dst1[i] = src1[i];
	}
	return dst;
}

---

memmove

void* my_memmove(void* dst, const void* src, size_t num)

• 由src所指内存区域复制count个字节到dest所指内存区域。
• 和memcpy的区别就是memmove函数处理的源内存块和目标内存块是可以重叠的
• 如果源空间和目标空间出现重叠，就得使用memmove函数处理
• 为防止内存重叠，当产生前重叠时从前往后拷贝，当产生后重叠时从后往前拷贝，其他状况随意

void* my_memmove(void* dst, const void* src, size_t num)
{
	assert(dst && src);
	char* dst1 = (char*)dst;
	char* src1 = (char*)src;
	size_t i;
	int j;
	if (dst1 < src1 &&)
	{
		for (i = 0; i < num; i++)
		{
			dst1[i] = src1[i];
		}
	}
	//前重叠从前往后拷贝
	else
	{
		for (j = num - 1; j >= 0; j--)
		{
			dst1[j] = src1[j];
		}
	}
	//后重叠从后往前拷贝
	return dst;
}