内存操作函数memmove,memcpy,memset

通过字符串的学习,我们知道字符串操作函数的操作对象是字符串,并且它的结束标志是结束符\0,当然这个说的是不

受限制的字符串函数。然而当我们想要将一段内存的数据复制到另一块内存时,我们不能使用字符串操作函数,当然也

不能一个一个复制,所以就引入了内存操作函数。

memcpy函数原型:

void *memcpy(void *dst, const void *src, size_t size);将一块内存的数据复制到另一块内存。当两块内存重叠              的时候,memcpy就不能保证拷贝正确。

memmove函数原型:

void *memmove(void *dst, const void *src, size_t size); 可以拷贝内存重叠的,也可以拷贝不重叠的。

下面模拟实现memcpy函数:

[objc] view plain copy

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include<stdio.h>
  3. #include<assert.h>
  4. voidvoid *my_memcpy(voidvoid *dest, const voidvoid *src, size_t size)
  5. {
  6. assert(dest);
  7. assert(src);
  8. charchar *str1 = (charchar *)dest;
  9. const charchar *str2 = (const charchar *)src;
  10. while (size)
  11. {
  12. *str1 = *str2;
  13. str1++;
  14. str2++;
  15. size--;
  16. }
  17. return dest;
  18. }
  19. int main()
  20. {
  21. char arr[] = "hel love you";
  22. voidvoid *ret = my_memcpy(arr,"ylrr",3);
  23. charchar *p = (charchar *)ret;
  24. printf("%s",p);
  25. system("pause");
  26. return 0;
  27. }

代码分析:函数的参数有三个,两个为void型指针,最后一个是整形变量,表示拷贝内存的字节数。

为什么要写成void型指针呢?主要是为了可以接收各种类型的指针,因为我们有时想拷贝的区域是存放整           形数的,有时想拷贝的区域是存放字符串的,我们总不能根据内存区域数据的类型经常改函数参数吧,这           样得有多麻烦呀~~所以用void*就比较好~~

函数的返回值是void*类型,这一点类似上边的参数。

另外需要注意的是,void型的指针不能进行自加操作,也不能进行解引用,所以函数中都进行了强制类型           转化。因为操作过程中是一个字节一个字节进行,所以强制转化成char *。比如:

void *p;

p++;//错误

*p = 1;//错误

下边我们来模拟实现memmove函数:

首先来分析memmove实现拷贝的几种情况:如下图

从图中我们可以看出,当dest>src  &&   dest < src+size,我们需要从后向前拷贝,其他情况从前向后拷贝。

代码如下:

[objc] view plain copy

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include<stdio.h>
  3. #include<assert.h>
  4. <pre name="code" class="objc">void* my_memmove(voidvoid *dest, const voidvoid *src, size_t size)
  5. {
  6. assert(dest);
  7. assert(src);
  8. charchar *str1 = (charchar *)dest;
  9. const charchar *str2 = (const charchar *)src;
  10. if ((str2 > str1) && (str2< str1 + size))
  11. {
  12. while (size)
  13. {
  14. *str1 = *str2;
  15. str1++;
  16. str2++;
  17. size--;
  18. }
  19. }
  20. else
  21. {
  22. while (size--)
  23. {
  24. *(str1 + size) = *(str2 + size);
  25. }
  26. }
  27. return dest;
  28. }
  29. int main()
  30. {
  31. char arr[] = "abcdef";
  32. voidvoid *ret = my_memmove(arr+2,arr,4);
  33. printf("%s",arr);
  34. system("pause");
  35. return 0;
  36. }

代码分析:代码中所给出的测试案例是从后向前拷贝,程序运行结果是ababcd,在程序输出时,不能输出返回的值,           因为一般情况那都是不对的,具体原因其实很简单。

从前向后拷贝比较简单,直接赋值,然后自加;从后向前拷贝时,第一次复制时,目标串和原串均向后偏移size-1,在程序代码中,当进行while循环条件判断时,       size自减,所以到循环体内,size已经减了1.所以,你看到的是偏移size。

memset函数:

函数原型:void* memset(void *dest,int c,size_t size);给出内存的起始地址,将从起始地址开始的size个字节

赋值为字符c。这个函数实现起来比较简单。

[objc] view plain copy

  1. voidvoid * my_memset(voidvoid *dest, int c, size_t size)
  2. {
  3. assert(dest);
  4. charchar *pdest = (charchar *)dest;
  5. while (size--)
  6. {
  7. *pdest++ = c;
  8. }
  9. return dest;
  10. }
  11. int main()
  12. {
  13. char arr[] = "abcdef";
  14. my_memset(arr,‘0‘,3);
  15. printf("%s",arr);
  16. system("pause");
  17. return 0;
  18. }

注:函数中给出的字符是整形,这个赋值的时候不用强制类型转换,因为字符变量在内存中就是以其ascii形式存储~~

时间: 2024-10-13 23:03:41

内存操作函数memmove,memcpy,memset的相关文章

内存操作函数

为什么引入内存操作函数:在定义中字符串以NUL(空字节)结尾,所以字符串操作函数遇见'\0'停止.因此我们引入内存操作函数,来解决"非字符串类型"中遇到NUL(数字0)的情况. 内存操作函数:内存操作函数与字符串操作函数非常类似,只不过内存操作函数能够处理任何类型的字节序列.在内存操作函数的参数中,有一个显示的参数说明了要处理的字节数,所以他遇见NUL不会停下来. 下面介绍两种常用的内存操作函数原型: void *memcpy(void *dst,void const *src,siz

Delphi中复制带有String的记录结构时不能使用Move之类的内存操作函数

请看下面的代码: program TestRecord; {$APPTYPE CONSOLE} uses  SysUtils,  Math; type  TRecordA = record    Name: string;  end; procedure RunTestRecord;var  R1, R2: TRecordA;begin  R1.Name := StringOfChar('A', RandomRange(64, 256) * 1024);  Move(R1, R2, SizeOf

PCI设备内存操作函数总结

1.  ExAllocatePool() 函数说明: ExAllocatePool allocates pool memory of the specified type and returns a pointer to the allocated block. 函数定义: PVOID ExAllocatePool( __in  POOL_TYPE PoolType, __in  SIZE_T NumberOfBytes ); 代码中用来分配设备描述DMA adepter设备的特性(DEVICE

c++中内存拷贝函数(C++ memcpy)详解

原型:void*memcpy(void*dest, const void*src,unsigned int count); 功能:由src所指内存区域复制count个字节到dest所指内存区域. 说明:src和dest所指内存区域不能重叠,函数返回指向dest的指针. 举例: // memcpy.c #include <stdlib.h> #include <string.h> main() { char *s= "Golden Global View "; c

c语言中的内存操作函数

int arr[20] =   {0};//再定义并初始化的时候可以这样操作: arr[20] = {0};//不能这样修改数组的值.语法错误. int str[20] = {0}; //将一块内存初始化一个值 memset(arr ,0 ,sizeof(arr))//第一个参数表示初始化地址,第二个参数表示初始化值,第三个参数表示初始化内存大小. memcpy(arr ,str ,sizeof(str))//将str内存空间的内容拷贝到arr指向的内存空间,拷贝的大小为sizeof(str)

Delphi 的内存操作函数(1): 给字符指针分配内存

马上能想到的函数有: GetMem AllocMem ReallocMem FreeMem GetMemory ReallocMemory FreeMemory New Dispose NewStr DisposeStr StrNew StrAlloc StrDispose GlobalAllocPtr GlobalFreePtr WideStrAlloc AnsiStrAlloc StrDispose Move MoveMemory CopyMemory ZeroMemory FillMemo

c语言学习之基础知识点介绍(十九):内存操作函数

一.malloc函数 /* 首先需要导入头文件 #include <stdlib.h> malloc void* malloc(n); n是字节大小 开辟堆空间,开辟的字节数以n为准 返回的是开辟空间的首地址 void*是万能指针,也就是说你可以用任意类型的指针去指向 */ //malloc用法 int *p = malloc(sizeof(int)); *p = 30; printf("%p %d\n",p,*p);//0x100105490 char *pc = mal

Delphi 的内存操作函数(1): 给字符指针分配内存( 给字符指针(PChar、PWideChar、PAnsiChar)分配内存最佳的选择是StrAlloc。分配内存的时候会对字符串进行初始化)

马上能想到的函数有: GetMem AllocMem ReallocMem FreeMem GetMemory ReallocMemory FreeMemory New Dispose NewStr DisposeStr StrNew StrAlloc StrDispose GlobalAllocPtr GlobalFreePtr WideStrAlloc AnsiStrAlloc StrDispose Move MoveMemory CopyMemory ZeroMemory FillMemo

Delphi 的内存操作函数(2): 给数组指针分配内存

静态数组, 在声明时就分配好内存了, 譬如: var   arr1: array[0..255] of Char;   arr2: array[0..255] of Integer; begin   ShowMessageFmt('数组大小分别是: %d.%d', [SizeOf(arr1), SizeOf(arr2)]);   {数组大小分别是: 512.1024} end; 对静态数组指针, 虽然在声明之处并没有分配内存, 但这个指针应该分配多少内存是有定数的. 这种情况, 我们应该用 Ne