内存操作函数(memcpy,memmove,memset,memcmp)

1.11 memcpy

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

• 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
• 例如memcpy(arr2,arr1,40):就是将arr1的前40个字节的地址拷贝到arr2中
• 这个函数在遇到 '\0' 的时候并不会停下来。
• 如果source和destination有任何的重叠，复制的结果都是未定义的。（memcpy函数是用来处理不重叠函数的功能）

/* memcpy example */
#include <stdio.h>
#include <string.h>
struct {
  char name[40];
  int age;
} person, person_copy;
int main ()
{
  char myname[] = "Pierre de Fermat";
  /* using memcpy to copy string: */
  memcpy ( person.name, myname, strlen(myname)+1 );
  person.age = 46;
  /* using memcpy to copy structure: */
  memcpy ( &person_copy, &person, sizeof(person) );
  printf ("person_copy: %s, %d \n", person_copy.name, person_copy.age );
  return 0;
}

自己写出一个函数实现

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <assert.h>

void my_memcpy(void* dest,const void* ret, int num)
{
	void* src = dest;
	assert(dest && ret);  //不为空值
	while (num--)
	{
		*(char*)dest = *(char*)ret;
		ret=(char*)ret+1;
		dest=(char*)dest + 1;
	}
	return dest;
}

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[20] = { 0 };
	my_memcpy(arr2, arr1, 20);
	
	for (int i = 0; i < 20; i++)
	{
		printf("%d", arr2[i]);
	}

	return 0;
}

1.12 memmove

---

void * memmove ( void  * destination, const void * source, size_t num ) //和memcpy函数一模一样

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

#include <stdio.h>
#include <string.h>
int main()
{
	int str[20] = {1,2,3,4,5,6,7,8,9,10};
	memmove(str + 2, str, 8);
		for (int i = 0; i < 20; i++)
		{
			printf("%d", str[i]);
		}
	return 0;
}

函数实现

void my_memove(void* dest, const void* srt, int num)
{
	void* ret = dest;
	assert(dest && srt);
	if (dest < srt)
	{
		//前-->后
		while (num--)
		{
			*((char*)dest) = *((char*)srt);
			srt = (char*)srt + 1;
			dest = (char*)dest + 1;
		}
	}
	else
	{
		//后-->前
		while (num--)
		{
			*((char*)dest + num) = *((char*)srt + num);
		}
	}
	return ret;
}

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

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

当两块空间会重叠，我们在进行拷贝的时候会把原来需要拷贝的source地址进行覆盖；

（例如我们源头地址在目的地地址之前）

如图红色为源头（srt）地址，蓝色(dest)为目的地地址；

当我们将4 拷贝到 5，再将源头地址第二位拷贝到6的地址时，会发现原来的5已经被4覆盖，不能正确的做到拷贝。

 

 

我们就要通过不同位置的覆盖来达到正确完成拷贝的功能；

我们可以分三种情况来进行分析

• 当dest在srt之前时是可以从前往后拷贝
• 当dest在srt数组之中是可以从后往前拷贝
• 当dest在srt之后可以从前往后也可以从后往前拷贝

所以我们在进行拷贝之前就可以进行一次判断分为两种情况来拷贝

 

1.13 memcmp

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

• 比较从ptr1和ptr2指针开始的num个字节
• 返回值如下：

/* memcmp example */
#include <stdio.h>
#include <string.h>
int main ()
{
  char buffer1[] = "DWgaOtP12df0";
  char buffer2[] = "DWGAOTP12DF0";
  int n;
  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;
}