常见内存函数

目录

前言

一、strncpy的模拟实现

1、函数的声明

2、注意事项

3、模拟实现

二、strncat的模拟实现

1、函数的声明

2、函数的使用

3、模拟实现

三、memcpy的模拟实现 

1、函数的声明

2、函数的使用

 3、模拟实现

四、memmove的模拟实现

1、函数的声明

2、函数分析

3、模拟实现

总结

---

一、strncpy的模拟实现

1、函数的声明

char * strncpy ( char * destination, const char * source, size_t num )

2、注意事项

当被铐的函数的长度小于我们要铐的长度时要在被铐函数完结时跳出循环并且添加一个\0，从而防止数组越界访问

3、模拟实现

char* my_strncpy(char* arr1, const char* arr2, int n)
{
	int i = 0;
	for (i = 0; arr1[i] != '\n' && i < n; i++)
	{
		*(arr1 + i) = *(arr2 + i);
	}
	if (i < n)//当arr2的长度小于n时为了防止越界访问添加一个\0
	{
		*(arr1 + i) = '\0';
	}
	return arr1;
}
int main()
{
	char arr1[] = "afjksdfj";
	char arr2[] = "s";
	int n = 2;
	my_strncpy(arr1, arr2, n);
	printf("%s", arr1);
	return 0;
}

这种是按照标准库中的用法写的，如果我们向拷贝过去后，删去后面的内容我们可以怎么写

char* my_strncpy(char* arr1, const char* arr2, int n)
{
	int i = 0;
	for (i = 0; arr[i] != '\n' && i < n; i++)
	{
		*(arr1 + i) = *(arr2 + i);
	}
	*(arr1 + i) = '\0';
	return arr1;
}
int main()
{
	char arr1[] = "afjksdfj";
	char arr2[] = "s";
	int n = 2;
	my_strncpy(arr1, arr2, n);
	printf("%s", arr1);
	return 0;
}

二、strncat的模拟实现

1、函数的声明

 char * strncat ( char * destination, const char * source, size_t num );

2、函数的使用

将source指向字符串的前num个字符追加到destination指向的字符串末尾，再追加⼀个 \0 字

符。 如果source 指向的字符串的长度小于num的时候，只会将字符串中到 \0 的内容追加destination指向的字符串末尾。

3、模拟实现

char* my_strncat(char* arr1, const char* arr2, int n)
{
	char* dest = arr1;
	while (*arr1)//找到\0的位置
	{
		arr1++;
	}
	int i = 0;
	for (i = 0; arr2[i] && i < n; i++)
	{
		arr1[i] = arr2[i];
	}
	arr1[i] = '\0';//循环结束后添加一个\0
	return dest;
}
int main()
{
	char arr1[50] = { "kfakdsaf" };
	char arr2[] = { "daks" };
	int n = 2;
	my_strncat(arr1, arr2, n);
	printf("%s", arr1);
	return 0;
}

三、memcpy的模拟实现 

1、函数的声明

void * memcpy ( void * destination, const void * source, size_t num );

2、函数的使用

1、函数memcpy从source的位置开始向后复制num个字节的数据到destination指向的内存位置。

2、这个函数在遇到 '\0' 的时候并不会停下来。

3、如果source和destination有任何的重叠，复制的结果都是未定义的。也就是说两个所指向的空间不能有重叠。如果有用memmove解决。

 3、模拟实现

void* my_memcpy(void* arr1, const void* arr2, int n)
{
	char* dest = (char*)arr1;
	for (int i = 0; i < n; i++)//每一个字节都交换
	{
		*(char*)arr1 = *(char*)arr2;
		arr1 = (char*)arr1 + 1;//强制转换后才能加减运算
		arr2 = (char*)arr2 + 1;
	}
	return dest;
}
int main()
{
	int arr1[10] = { 0 };
	int arr2[] = { 1,2,3,4 };
	int n = 4;
	my_memcpy(arr1, arr2, n);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}

四、memmove的模拟实现

1、函数的声明

void * memmove ( void * destination, const void * source, size_t num );

2、函数分析

 在拷贝之前我们先考虑这么一个问题，那就是该按什么顺序拷贝呢？我们先假设按从前向后的顺序，arr1向后20个字节的内容拷贝到arr1+2的后面：

可以发现这样会导致数据的丢失那么我们换一种方法呢？

可以发现数据并没有丢失。那么我们就可以做出以下的总结：

destination指针在source指针的左侧的时候，从后向前拷贝。当destination在source右侧的时候，我们采取从前向后拷贝。

有了以上的分析我们就可以很容易的写出代码。

3、模拟实现

void* my_memmove(void* dst, const void* src, size_t count)
{
	void* ret = dst;
	if (dst > src )//只有大于的情况是从后向前
	{
		dst = (char*)dst + count - 1;//找到后面的地址从前向后拷贝
		src = (char*)src + count - 1;
		while (count--) 
		{
			*(char*)dst = *(char*)src;
			dst = (char*)dst - 1;
			src = (char*)src - 1;
		}
	}
	else 
	{
		while (count--) 
		{
			*(char*)dst = *(char*)src;
			dst = (char*)dst + 1;
			src = (char*)src + 1;
		}
	}
	return(ret);
}
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7 };
	int n = 8;
	my_memmove(arr1+2, arr1, 8);
	for (int i = 0; i < 7; i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}