c/c++内存函数（memcpy，memmove，memset，memcmp）的详解和自已实现

1.mempy指的是C和C++使用的内存拷贝函数，
函数原型为void* memcpy(void* destin, void* source, unsigned n)；
函数的功能是从源内存地址的起始位置开始拷贝若干个字节到目标内存地址中，
即从源source中拷贝n个字节到目标destin中。函数原型
void *memcpy(void *destin, void *source, unsigned n);
参数
destin-- 指向用于存储复制内容的目标数组，类型强制转换为 void* 指针。
source-- 指向要复制的数据源，类型强制转换为 void* 指针。
n-- 要被复制的字节数。
返回值:该函数返回一个指向目标存储区destin的指针。
所需头文件
C语言：#include<string.h>
C++：#include<cstring>
下面通过自己编辑实现memcpy来介绍相关使用

#include<iostream>
using namespace std;
void* my_memcpy(void* destin, void* source, unsigned n);
struct student
{
    int num;
    char name[20];
};
int main()
{
    struct student t1;
    struct student t2 = { 0 };
    t1 = { 2142415,"wu" };
    my_memcpy(&t2, &t1, sizeof(struct student));
    cout << t1.name << t1.num;
}
void* my_memcpy(void* destin, void* source, unsigned n)
{
    void* ret = destin;
    while (n--)
    {
        *(char*)destin = *(char*)source;
        destin = ((char*)destin)+1;
         source = ((char*)source)+1;
    }
    return ret;
}

!!！该内存函数原内存（void*source)和目标内存（void*destin)不可重复
! （有些编译器不通过，VS可以）
! 尽量不要使用
2.下面介绍memmove函数可以用来处理重叠区域。
! memmove用于拷贝字节，如果目标区域和源区域有重叠的话，
! memmove能够保证源串在被覆盖之前将重叠区域的字节拷贝到目标区域中，
! 但复制后源内容会被更改。但是当目标区域与源区域没有重叠则和memcpy函数功能相同
void* memmove(void* dest, const void* src, size_t count);
头文件：<string.h>
 

#include<iostream>
using namespace std;
#include<string>
void*my_memmove(void* dest, const void* src, unsigned int count);
int main()
{//一整形数组为例
    int a[10] = { 1,2,3,4,5,6,7,8,9,10 };
    //将1，2，3复制到3，4，5的位置
    //memcpy(a + 3, a, 3 * sizeof(int));
    //那么a[10]={1,2,1,2,1,6,7,8,9,10}即开始第三个元素被第一元素覆盖（vs不会发生该情况）
    memmove(a + 3, a, 3 * sizeof(int));
    //那么a[10]={1,2,1,2,3,6,7,8,9,10}
    for (int i = 0; i < 10; i++)
        cout << a[i];
}

下面来讲解memmove（）是怎么实现的；

1  2  3  4  5   6  7  8  9  10

它是先将3复制到5； 即1 2 3 4 3 6 7 8 9 10

2复制到4；               即1 2 3 2 3 6 7 8 9 10

1复制到3；               即1 2 1 2 3 6 7 8 9 10

总结：它是从后向前复制的；

后面分析讲述（什么情况从前往后，什么情况从后往前）

1）将1 2 3复制到 3 4 5；从后往前。

该情况即source小于destin。

2）将3 4 5复制到 1 2 3；从前往后。

该情况source大于destin

3）将1 2 3复制到 4 5 6；二者都可。

4）将4 5 6复制到 1 2 3；二者都可。

总结：分为两种情况：

1.内存重叠的话对应上述1） 2）

2.内存不从叠的话对应上述3） 4）

下面我们来自己编辑实现这种功能：

#include<iostream>
using namespace std;
void* my_memmove(void*, void*, unsigned int);
int main()
{
	int a[6] = { 1,2,3,4,5,6 };
	//将 1 2 3复制到 3 4 5位置
	my_memmove(a, a+2, 3*sizeof(int));
	for (int i = 0; i < 6; i++)
	{
		cout << a[i]<<endl;
	}
}
void* my_memmove(void* destin, void* source, unsigned int n)
{
	void* ret = destin;
	if (destin > source)//从后往前
	{
		source = (char*)source + n - 1;
		destin = (char*)destin + n - 1;
		for(int i=0;i<n;i++)
		{
			*(char*)destin = *(char*)source;
			destin = (char* )destin -1;
			source = (char*)source - 1;
		}
	}
	if (destin <= source)//从前往后
	{
		for (int i = 0; i < n; i++)
		{
			*(char*)destin = *(char*)source;
			destin = (char*)destin + 1;
			source = (char*)source + 1;
		}

	}
	return ret;
}

3.介绍memset函数

memset是计算机中C/C++语言初始化函数。作用是将某一块内存中的内容全部设置为指定的值， 这个函数通常为新申请的内存做初始化工作。

void *memset(void *s, int ch,unsigned int n）

memset：作用是在一段内存块中填充某个给定的值，它是对较大的结构体或数组进行清零操作的一种最快方法 

memset()函数原型是extern void *memset(void *buffer, int c, int count)

buffer：为指针或是数组,

c：是赋给buffer的值,

count：是buffer的长度.

注意：不能用它将int数组初始化为0和-1之外的其他值

下面使用该函数初始化。

#include<iostream>
using namespace std;
#include<string>
int main()
{
	int a[6] = { 1,2,3,4,5,6 };
	memset(a, 0, 6 * sizeof(int));
	//a数组清零了
	return 0;
}

4.memcmp函数

memcmp函数的原型为 int memcmp(const void *str1, const void *str2, size_t n));

其功能是把存储区 str1 和存储区 str2 的前 n 个字节进行比较。该函数是按字节比较的。 

• 如果返回值 < 0，则表示 str1 小于 str2。

• 如果返回值 > 0，则表示 str2 小于 str1。

• 如果返回值 = 0，则表示 str1 等于 str2。