内存函数+数据在内存中的存储

1.内存函数

1.memcpy函数的模拟和使用

memcpy也是拷贝函数，但是相对于strcpy和strncpy的区别是，memcpy指针任何类型的数据，而strcpy和strncpy只针对字符串。

void* memcpy(void* dest, const void* s, size_t num);

1.memcpy从s的未知向后复制num个字符的数据到dest指向的内容 。

2.这个函数在遇到'\0'时不会停下来。

3.如果dest和s有任何的重叠，复制的结果都是未定义的。

下面模拟函数memcpy

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<assert.h>
void* my_memcpy(void* dest, const void* s, size_t num)
{
	assert(dest&& s);
	void* ret = dest;
	while (num--)
	{
		*(char*)dest = *(char*)s;
		((char*)dest)++;
		((char*)s)++;
	}
	return ret;
}
int main()
{
	int a[10] = {1,2,3,4,5};
	int a1[] = { 6,7,8,9,10 };
	void* ret=my_memcpy(a+5, a1, 5 * sizeof(a1[0]));
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", a[i]);
	}
	return 0;
}

 当函数dest和s有重叠时，以下举个例子：

1.用模拟的memcpy函数输出：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<assert.h>
void* my_memcpy(void* dest, const void* s, size_t num)
{
	assert(dest && s);
	void* ret = dest;
	while (num--)
	{
		*(char*)dest = *(char*)s;
		((char*)dest)++;
		((char*)s)++;
	}
	return ret;
}
int main()
{
	int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
	void* ret = my_memcpy(arr + 2, arr, 20);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

结果如下： 

 

得到结果0 1 0 1 0 1 0 7 8 9的原因： 

上面的是用我们自己编写的模拟函数，如果用内存函数memcpy，结果为0 1 0 1 2 3 4 7 8 9

但是，我们在处理有重叠函数的拷贝时，有个专门的函数memmove来处理。 

2.memmove函数的模拟和使用

void* memmove(void* dest, const void* s, size_t num);

1.和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。

 第一种情况：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<assert.h>
void* my_memmove(void* dest, const void* s, size_t num)
{
	assert(dest && s);
	void* ret = dest;
	if (dest > s)
	{
		while (num--)
		{
			*((char*)dest + num) = *((char*)s + num);
		}
	}
	else
	{
		while (num--)
		{
			*(char*)dest = *(char*)s;
			((char*)dest)++;
			((char*)s)++;
		}
	}
	return ret;
}
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	void* ret = my_memmove(arr + 2, arr, 20);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

 输出结果：

第二种情况：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<assert.h>
void* my_memmove(void* dest, const void* s, size_t num)
{
	assert(dest && s);
	void* ret = dest;
	if (dest > s)
	{
		while (num--)
		{
			*((char*)dest + num) = *((char*)s + num);
		}
	}
	else
	{
		while (num--)
		{
			*(char*)dest = *(char*)s;
			((char*)dest)++;
			((char*)s)++;
		}
	}
	return ret;
}
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	void* ret = my_memmove(arr , arr+2, 20);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

输出结果： 

 

 因此运用函数memmove可以很好的解决函数重叠时的拷贝。

3.memset函数的使用

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

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

这里的意思是将ptr指向的数组中元素设置成value,设置num个！

例子1：

int main()
{
	char arr[] = { "helloworld!" };
	memset(arr + 2, 'r', 8);
	printf("%s", arr);
	return 0;
}

结果为： 

例子2：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	/*char arr[] = { "helloworld!" };
	memset(arr + 2, 'r', 8);
	printf("%s", arr);
	return 0;*/
	int arr[5] = { 0 };
	memset(arr, 1, 20);
	for (int i = 0; i < 5; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

 

解释如下图：

 但将其他数字设置为0就相对容易实现。

4.memcmp函数的使用

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

 1.比较从ptr1和ptr2指针指向的位置开始，向后的num个字节。

num：最多比较的字节数，如果在num之前可以判断出大小，则无需进行后面的比较。

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 1,2,3,3,3 };
	int ret=memcmp(arr1, arr2 , 15);
	printf("%d", ret);
	return 0;
}

结果为1，大于0，说明arr1数组在第15个字节之前比arr2数组的大。 

 

 2.数据在内存中的存储

两种存储方式，大端字节序存储和小端字节序存储。

1.大端字节序存储

把一个数据的低位字节的内容存储到高地址处，把高位字节的内容存储到低地址。

 2.小端字节序存储

把一个数据的高位字节的内容存储到高地址处，把低位字节的内容存储到低地址处。

3. 小端和大端字节序是取决于编译器的，我们可以通过下面的代码判断编译器中数据的存储方式

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int judge(int n)
{
	return *(char*)&n;
}
int main()
{
	int n = 1;
	int ret=judge(n);
	if (ret = 1)
	{
		printf("小端");
	}
	else
		printf("大端");
	return 0;
}

在vs上是小端字节序存储，所以ret=1.