C语⾔内存函数

1.memcpy使用和模拟实现

memcpy的官方详解

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

1. 函数memcpy从source的位置开始向后复制num个字节的数据到destination指向的内存位置。
2. 这个函数在遇到’\0’的时候并不会停下来。
3. 如果source和destination有任何重叠，复制的结果都是未定义的。

#include 
#include 

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[20] = { 0 };
	memcpy(arr2, arr1, 20);//20字节 = 5 个整型

	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr2[i]);//1 2 3 4 5 0 0 0 0 0
	}

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

对于重叠的内存，交给memmove来处理。

#include 
#include 
#include 

void* my_memcpy(void* dest, const void* src, size_t num)
{
	void* ret = dest;
	assert(dest && src);

	while (num--)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return ret;
}

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[20] = { 0 };
	my_memcpy(arr2, arr1, 20);//20字节 = 5 个整型

	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr2[i]);//1 2 3 4 5 0 0 0 0 0
	}

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

2.memmove使用和模拟实现

memmove的官方详解

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

1. 与memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
2. 如果源空间和目标空间出现重叠，就得使用memmove函数处理。

#include 
#include 

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	memmove(arr1 + 2, arr1, 20);

	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

输出的结果:

1 2 1 2 3 4 5 8 9 10
1

memmove的模拟实现：

#include 
#include 
#include 

void* my_memmove(void* dest, const void* src, size_t num)
{
	void* ret = dest;
	assert(dest && src);
	if (dest <= src || (char*)dest >= (char*)src + num)
	{
		//前 -> 后
		while (num--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		//后 -> 前
		dest = (char*)dest + num - 1;
		src = (char*)src + num - 1;

		while (num--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest - 1;
			src = (char*)src - 1;
		}
	}

	return ret;
}

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memmove(arr1 + 2, arr1, 20);

	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

3.memset的使用

memset的官方详解

void* memset(void* ptr, int value, size_t num);
1

memset是用来设置内存的，将内存中的值以字节为单位设置成想要的内容。

#include 
#include 

int main()
{
	char str[] = "hello world";
	memset(str, 'x', 5);
	printf(str);

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11

输出的结果：

xxxxx world
1

4.memcmp函数的使用

memcmp的官方详解

int memcmp(const void* ptr1, const void* ptr2, size_t num);
1

• 比较从ptr1和ptr2指针指向的位置开始，向后的num个字节。
• 返回值如下：
  

#include 
#include 

int main()
{
	char str1[] = "abcdef11";
	char str2[] = "acvdef22";
	int n = memcmp(str1, str2, sizeof(str1));

	if (n > 0)
		printf("'%s' is greater than '%s'.\n", str1, str2);
	else if(n < 0)
		printf("'%s' is less than '%s'.\n", str1, str2);
	else
		printf("'%s' is the same as '%s'.\n", str1, str2);

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18