C语言内存操作函数使用示例梳理讲解

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

void* my_memcpy(void* dest, const void* src, size_t num) {
    void *ret = dest;    //保存dest，用于最终输出
    assert(dest);
    assert(src);
	while (num--) {
		*(char*)dest = *(char*)src1;    //(char*): 取出每一个字节(8 bit)的值，以单个字节为单位进行赋值
		dest = (char*)dest + 1;    
		src = (char*)src + 1;
	}    //void * 类型是不能直接运算的，因为没有步长。(char*)将dest与src转换为以char为步长，再向后移动
	return ret;
}

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[10] = { 0 };
	memcpy(arr2, arr1, 20);    //拷贝20个字节，即5个int元素
	float arr3[] = { 1.0f,2.0f,3.0f,4.0f };
	float arr4[5] = { 0.0 };
	memcpy(arr3, arr4, 8);    //拷贝8个字节，即2个float元素
	return 0;
}

//示例来自cplusplus官网
/* memcpy example */
#include <stdio.h>
#include <string.h>
struct {
  char name[40];
  int age;
} person, person_copy;
int main ()
{
  char myname[] = "Pierre de Fermat";    //定义一个字符串
  /* 用 memcpy 拷贝字符串 */
  //每个char类型占一个字节，因此要拷贝的字节数即strlen()+1，加一是因为要把'\0'也拷贝过去。
  memcpy ( person.name, myname, strlen(myname)+1 );
  person.age = 46;
  /* 用 memcpy 拷贝结构体 */
  //sizeof操作符，可以直接得到结构体变量在内存中所占的字节数。
  memcpy ( &person_copy, &person, sizeof(person) );
  //直接完成了结构体之间的数据拷贝：从person拷贝到person_cpy，不用手动转义，非常方便
  printf ("person_copy: %s, %d \n", person_copy.name, person_copy.age );
  return 0;
}

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

#include<stdio.h>
#include<string.h>
//模拟实现memmove()
void* my_memmove(void* dest, const void* src, size_t num) 
{
	void* ret = dest;	//保存结果用于输出
	//从前向后拷贝，也可以写成if(dest <= src || (char*)dest >= (char*)src + num)
	if (dest <= src)
	{
		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;    //返回值为dest
}
//测试代码///
int main() {
	int arr1[] = { 2,3,4,5,6 };
	my_memmove(arr1+2, arr1, 8);
	//预计 2 3 2 3 6
	for (int i = 0; i < 5; i++) {
		printf("%d ", arr1[i]);
	}
	printf("\n-------------------\n");
	int arr2[] = { 2,3,4,5,6 };
	memmove(arr2 + 2, arr2, 8);
	for (int i = 0; i < 5; i++) {
		printf("%d ", arr2[i]);
	}
	return 0;
}

//错误的代码
void* my_memmove(void* dest, const void* src, size_t num)
{
    void * ret = dest;
    while (num--) {
	//从前向后拷贝
	    if (dest <= src)
	    {
		    *(char*)dest = *(char*)src;
		    dest = (char*)dest + 1;
	    	src = (char*)src + 1;
	    }
	    else
	    {
		    dest = (char*)dest + num - 1;    //错误
		    src = (char*)src + num - 1;    //错误
		    *(char*)dest = *(char*)src;
		    dest = (char*)dest - 1;
		    src = (char*)src - 1;
	    }
    return ret;
}

//示例来自cplusplus官网
/* memmove example */
#include <stdio.h>
#include <string.h>
int main ()
{
  char str[] = "memmove can be very useful......";
  memmove (str+20,str+15,11);    //表示将包括str+15向后11个字节的内容移动到str+20位置
  puts (str);
  return 0; 
}

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

//示例来自cplusplus官网
/* memset example */
#include <stdio.h>
#include <string.h>
int main ()
{
  char str[] = "almost every programmer should know memset!";
  memset (str,'-',6);    //表示将从str开始，包括str向后6个字节的内存内容置为'-'
  puts (str);
  return 0;
}

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

//示例来自cplusplus官网
/* memcmp example */
#include <stdio.h>
#include <string.h>
int main ()
{
  //创建两个要用作比较的数组
  char buffer1[] = "DWgaOtP12df0";    
  char buffer2[] = "DWGAOTP12DF0";
  //接受比较的结果
  int n;
  //要比较的字节数为buffer1的长度
  //两字符串的比较可以用strcmp(buffer1,buffer2)函数实现，原理大致相同。
  n = memcmp ( buffer1, buffer2, sizeof(buffer1) );
  if (n>0) printf ("'%s' is greater than '%s'.\n",buffer1,buffer2);
  else if (n<0) printf ("'%s' is less than '%s'.\n",buffer1,buffer2);
  else printf ("'%s' is the same as '%s'.\n",buffer1,buffer2);
  return 0;
}