hello~~,我是~小鹿,这是我的第二篇博客,算是接着上一篇的字符串函数写的吧,这一篇讲的是内存函数,能够直接操作内存,内存函数不需要知道被操作的内容类型,只需要告知内存即可。
有什么不对的地方希望指正,有什么不好地方可以给我些意见呀~
这篇文章讲解了以下四种内存函数以及它们的模拟函数(自定义函数)
[C语言]一组内存函数—memory
1.memcpy()-内存拷贝(不可重叠)
函数的声明方式:
void* memcpy(void* destination, const void* source, size_t num);
· 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置;
· 这个函数在遇到 ‘\0’ 的时候并不会停下来;
· 参数的类型是无类型指针(void*),可以拷贝任意类型数据;
· 如果source和destination有任何重叠,复制的类型都是未定义的;
· 返回值:返回目标空间的起始地址;
· memcpy()函数的头文件是#include <string.h> 。
memcpy()函数代码示例:
将arr1中的前五个数据复制到arr2中
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>//memcpy函数的头文件
int main()
{
int i = 0;
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[10] = { 0 };
memcpy(arr2, arr1, 20);//从arr1中复制20个字节的数据到arr2中(int类型一个数据占四个字节,20个字节相当于五个int类型的数据)
for (i = 0; i < 10; i++)
{
printf("%d ", arr2[i]);
}
return 0;
}
运行结果:1 2 3 4 5 0 0 0 0 0
memcpy()函数的模拟实现,代码示例:
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <assert.h>//assert函数的头文件
void* my_memcpy(void* dest, const void* src, size_t num)
{
assert(dest && src);//断言,确保dest与src不是空指针
void* ret = dest;
while (num--)
{
*(char*)dest = *(char*)src;//void类型解引用时不知访问几个字节,需强制转换,char*类型最为合适
dest = (char*)dest + 1;
src = (char*)src + 1;
}
return ret;//需要返回dest的起始位置
}
int main()
{
int i = 0;
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[10] = { 0 };
int* ret = my_memcpy(arr2, arr1, 20);
for (i = 0; i < 10; i++)
{
printf("%d ", *(ret+i));
}
return 0;
}
如果source和destination有任何重叠,复制的类型都是未定义的:
例如:
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
memcpy(arr1 + 2, arr1, 20);
//此时目标数据与源头数据内存重叠,会发生数据拷贝内容被覆盖
arr[0]的值赋给arr[2],此时arr[2]=1;同理arr[3]=2;然后将arr[2]的值赋给arr[4],因为此时的arr[2]=1,所以赋给arr[4]后,arr[4]为1;以此类推,给arr[5],arr[6]赋值。
所以此时memcpy函数后的arr1为1 2 1 2 1 2 1 8 9 10
2.memmove()-内存拷贝(可重叠)
函数声明:
void* memmove(void* destination, void* source, size_t num);
memmove函数与memcpy函数用法相同
区别:memmove 函数可以处理内存重叠的情况
· · · · · memcpy 函数可以拷贝内存不重叠的情况
memmove()函数代码示例:
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>//memmove函数的头文件
#include <assert.h>//assert函数的头文件
int main()
{
int i = 0;
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
memmove(arr1+2, arr1, 20);
for (i = 0; i < 10; i++)
{
printf("%d ", arr1[i]);
}
return 0;
}
运行结果:1 2 1 2 3 4 5 8 9 10
memmove()函数的模拟实现
原理:
1.若目标空间(dest)的地址在源头数据(src)的地址前方: 将源头数据(就是图中黑色框中的内容)依次从前往后拷贝(即从4开始拷贝,依次是5,6,7)将目标空间中的数据(橙色框中的内容)依次覆盖,此时就不会造成内存重叠。
2.当目标空间(dest)的地址在源头数据(src)的地址后方: 将源头数据从后向前一次拷贝(即从7开始,然后依次是6,5,4)将目标空间中的数据依次覆盖,此时就不会造成内存重叠。
memmove()函数的模拟实现,代码示例:
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <assert.h>//assert函数的头文件
void* my_memmove(void* dest, void* src, size_t num)
{
assert(dest && src);//断言,确保不是空指针
void* ret = dest;
if (dest < src)//从前往后拷贝
{
while (num -- )
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
}
else//从后往前拷贝
{
while (num--)
{
*((char*)dest + num) = *((char*)src + num);
}
}
}
int main()
{
int i = 0;
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
my_memmove(arr+2, arr, 20);
for (i = 0; i < 10; i++)
{
printf("%d ",arr[i]);
}
return 0;
}
运行结果:1 2 1 2 3 4 5 8 9 10
总结:
memcpy只需要实现不重叠的拷贝就可以了
memmove是需要实现重叠内存的拷贝的
可以说memmove包含memcpy,但不可以反
3.memcmp()-内存比较
函数声明:int memcmp(const void* ptr1,const void* ptr2,size_t num);
· 比较从ptr1和ptr2指针开始的num个字节;
· 参数的类型是无类型指针(void*),可以比较任意类型数据;
· 这个函数在遇到 ‘\0’ 的时候并不会停下来;
· 返回值:ptr1 > ptr2 时返回 > 0 的值;
· ptr1 < ptr2 时返回 < 0 的值;
· ptr1 = ptr2 时返回 = 0 的值;
· memcmp()函数的头文件是#include <string.h> 。
memcmp()函数代码示例:
比较数组arr1与arr2中前13个字节的大小
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>//memcmp函数的头文件
int main()
{
int arr1[] = { 1,2,3,4,5 };//内存中: 01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00
int arr2[] = { 1,2,3,0,0 };//内存中: 01 00 00 00 02 00 00 00 03 00 00 00 00 00 00 00 00 00 00 00
int ret = memcmp(arr1, arr2, 13);//比较前13个字节的大小,一个一个字节比较,前12个字节的内容相同,比较到第13个字节时,arr1中存的04>arr2中存的00,说明在前13个字节中,arr1>arr2
printf("%d\n", ret);
return 0;
}
运行结果:1
memcmp()的模拟实现,代码示例:
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <assert.h>//assert函数的头文件
int my_memcmp(const void* ptr1, const void* ptr2, size_t num)
{
assert(ptr1 && ptr2);//断言,确保不是空指针
while ((--num) && (*(char*)ptr1 == *(char*)ptr2))
{
ptr1 = (char*)ptr1 + 1;
ptr2 = (char*)ptr2 + 1;
}
if (*(char*)ptr1 > *(char*)ptr2)
return 1;
else if (*(char*)ptr1 == *(char*)ptr2)
return 0;
else
return -1;
}
int main()
{
int arr1[] = { 1,2,3,4,5 };//内存中: 01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00
int arr2[] = { 1,2,3,0,0 };//内存中: 01 00 00 00 02 00 00 00 03 00 00 00 00 00 00 00 00 00 00 00
int ret = my_memcmp(arr1, arr2, 13); //比较前13个字节的大小,一个一个字节比较
printf("%d\n", ret);
return 0;
}
运行结果:1
4.memset()–内存设置
函数声明:void* memset(void* ptr, int value,size_t num);
· 将指针变量ptr所指向的前num字节的内存单元用value替换;
· 可以内存设置为字符型,整型与字符型是互通的(ASCII码);
· 参数的类型是无类型指针(void*),可以设置任意类型数据;
· 这个函数在遇到 ‘\0’ 的时候并不会停下来;
· 返回值:返回ptr的起始地址;
· memset()函数的头文件是#include <string.h>。
memset()函数代码示例:
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>//memset函数的头文件
int main()
{
int arr[] = { 1,2,3,4,5 };//内存中: 01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00
memset(arr, 0, 9);//arr中前九个字节变为0:00 00 00 00 00 00 00 00 00 00 00 00 04 00 00 00 05 00 00 00
int i = 0;
for (i = 0; i < 5; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
运行结果:0 0 0 4 5
memset()的模拟实现,代码示例:
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <assert.h>//assert函数的头文件
int my_memset(void* ptr, int val, size_t num)
{
assert(ptr);//断言,确保不是空指针
void* ret = ptr;
while (num--)
{
*(char*)ptr = val;
ptr = (char*)ptr + 1;
}
return ret;
}
int main()
{
int arr[] = { 1,2,3,4,5 };//内存中: 01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00
int* ret=my_memset(arr, 0, 9);//arr中前九个字节变为0:00 00 00 00 00 00 00 00 00 00 00 00 04 00 00 00 05 00 00 00
int i = 0;
for (i = 0; i < 5; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
好啦,文章到这里就结束了,求求求求求求求求求求三连呀(*≧▽≦)~,文章对你有所帮助的话可以给我点个赞嘛(。’▽’。)♡欸嘿 ~