内存的操作

我们对于内存的操作借助于 string.h 这个库提供的内存操作函数。
内存填充
头文件： #include <string.h>
函数原型： void *memset(void *s,int c,size_t n);
函数功能：填充s开始的堆内存空间前n个字节，使得每个字节值为c。
函数参数：
void *s：待操作内存首地址。
int c：填充的字节数据。
size_t n：填充的字节数。
返回值：返回s
注意：c常常设置为0，用于动态内存初始化
案例：

/**
* 内存操作函数-memset
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void test1()
{
// 在堆内存申请了一块存储空间
int *p = (int*)malloc(4 * sizeof(int));
if(!p)
{
puts("内存分配失败！");
return;// 后续代码不需要执行
}
// 给这块内存进行初始化操作（填充）
memset(p,0, 4 * sizeof(int));
printf("%d\n",*(p+1));
// 内存使用完毕，进行回收
free(p);
p = NULL;
}
int main()
{
test1();
return 0;
}

内存拷贝
头文件： #include <string.h>
函数原型： void *memcpy(void *dest,const void *src,size_t n); 适合目标地址与源地址内存无
重叠的情况。
void *memmove(void *dest,const void *src,size_t n);
函数功能：拷贝src开始的堆内存空间前n个字节，到dest对应的内存中。
函数参数：
void *dest：目标内存首地址。
void *src：源内存首地址。

size_t n：拷贝的字节数。
返回值：返回dest
注意：内存申请了几个内存空间，就访问几个内存空间，否则数据不安全
注意：memcpy与memmove一般情况下是一样的，更建议使用memmove进行内存拷贝；
因为memmove函数是从自适应（从后往前或者从前往后）拷贝，当被拷贝的内存和目的地的内存
有重叠时，数据不会出现拷贝错误。而memcpy函数是从前往后拷贝，当被拷贝的内存和目的地内
存有重叠时，数据会出现拷贝错误。
案例：

内存比较
头文件： #include <string.h>
函数原型： int memcmp(void *dest,const void *src,size_t n)
函数功能：比较src和dest所代表的内存前n个字节的数据；
函数参数：
void *dest：目标内存首地址
const void* src：源内存首地址
size_t n：比较的字节数
返回值：

0 ：数据相同
>0 ：dest中的数据大于src
<0 ：dest中的数据小于src
注意：n一般和src，dest的总容量一样；如果不一样，内促比较的结果就不确定了。
案例：

/**
* 内存操作-memcmp
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void test1()
{
// 申请内存
int *p1 = (int*)malloc(3*sizeof(int));
int *p2 = (int*)malloc(4*sizeof(int));
// int p1[4] = {1,0,3,6};
// int p2[4] = {1,2,3,4};
// int result = memcmp(p1,p2,4*sizeof(int));
*p1 = 65;
*p2 = 70;
char *a = (char*)p1;// 类型转换
char *b = (char*)p2;
printf("%c,%c\n",*a,*b);
int result = memcmp(a+1,b+1,1*sizeof(char));
printf("%d\n",result);
}
int main()
{
test1();
}

内存查找
头文件： #include <string.h>
函数原型： int *memchr|*memrchr(const void *s,int c,size_t n)
函数功能：在s开始的堆内存空间前n个字节中查找字节数据c
函数参数：
const void *s：待操作内存首地址；
int c：待查找的字节数据
size_t n：查找的字节数
返回值：返回查找到的字节数据地址
注意：如果内存中没有重复数据，memchr和memrchr结果是一样的；如果内存中有重复数据，
memchr和memrchr结果就不一样；
举例：

            void *memrchr(..);// 在使用时编译会报错，需要使用外部声明
        // 外部申请
        extern void *memrchr(..);

案例：

/**
* 内存操作-memchr | memrchr
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 声明外部函数
extern void *memrchr(const void *s,int c,size_t n);
void test1()
{
// 申请内存
int *p = (int*)malloc(4*sizeof(int));
if(!p)
{
puts("内存分配失败！");
return;
}
// 给变量赋值
for(int i = 0; i < 4; i++)
{
p[i] = i * 2;
}
p[3] = 4;
// 输出
for(int i = 0; i < 4; i++)
{
printf("%d,",p[i]);
}
printf("\n");
// 内存查找 memchr
int *x = (int*)memchr(p,4,4*sizeof(int));
printf("%p--%p--%d\n",x,p,*x);
// 内存查找 memrchr
int *y = (int*)memrchr(p,4,4*sizeof(int));
printf("%p--%p--%d\n",y,p,*y);
// 回收内存
free(p);
p = NULL;
}
int main()
{
test1();
}