前言；上期我们给大家介绍了C语言中字符函数与字符串函数，这一期我们给大家介绍C语言中的一些内存函数。
上一篇：字符函数与字符串函数
文章目录
一，memcpy函数使用和模拟实现
1,memcpy的使用
memcpy作为我们今天要介绍的第一个函数，它能实现将源头的数据复制到目的地。要学习一个函数我们首先来看看它的函数原型：
void * memcpy ( void * destination, const void * source, size_t num );
- 首先第一个参数为
void*的destnation即目的地，指我们最终想要复制到的那个地方，使用void*类型是为了接收任意类型的数据。 - 第二个参数为
void*的source即源头，指我们需要复制数据的初始位置，加上const修饰是为了不改变源头(起始位置)的数据。 - 第三个参数是
size_t的num即所需要复制的数据的大小(单位是字节)。 - 最后返回值是
void*类型，返回的是任意类型的数据。
要注意：
• 这个函数在遇到 ‘\0’ 的时候并不会停下来。
• 如果source和destination有任何的重叠，复制的结果都是未定义的。
了解完以上的知识我们就来使用一下这个函数：
//memcpy的使用
//打印数组的函数
void print_arr(int arr2[], int sz)
{
int i = 0;
for (i = 0;i < sz;i++)
{
printf("%d ", arr2[i]);
}
printf("\n");
}
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[10] = { 0 };
int sz = sizeof(arr2) / sizeof(arr2[0]);
memcpy(arr2, arr1, 40);//拷贝数据
print_arr(arr2,sz);//实行打印数组的功能
}
我们使用memcpy将arr1中的数据复制拷贝到arr2中，从运行结果来看是成功了。那就会有人问了，memcpy内部执行的逻辑是什么？他是怎么样去执行的呢？不要着急，接下来我们就来分析一下他是如何来实现的。
2,memcpy的模拟实现
分析完紧接着我们就来模拟实现：
void* my_memcpy(void* dest,const void* src,size_t num)
{
assert(dest && src);//防止传入的是空指针
void* ret = dest;//存储dest的首地址方便返回
while(num--)
{
*(char*)dest=*(char*)src;//将源头的数据赋给目的地
dest=(char*)dest+1;//由于dest与src是void*的指针在偏移的时候采用这种方式
src=(char*)src+1;
}
return ret;//返回原dest的地址
}
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[10] = { 0 };
int sz = sizeof(arr2) / sizeof(arr2[0]);
my_memcpy(arr2, arr1, 40);
print_arr(arr2,sz);
}
以上代码就是模拟memcpy的代码。但有一点要注意的是：有些读者可能不理解为什么转换成char*类型的指针，和循环为什么是num - -？
其实无论任何类型，我们想要将值自己的值拷贝给对方言外之意就是让对方每一个字节的值都与我相同其值自然就和我是一样的了！另外使用num–自然就是为了控制num个字节与我相同这样才能达到我们想要的目的。
上面的复制是分成两块不同的空间来进行的，那如果我们在一块空间上进行呢？假如我们像让arr1中的12345拷贝复制到34567的位置变成12123458910，如何呢？
void print_arr(int arr2[], int sz)
{
int i = 0;
for (i = 0;i < sz;i++)
{
printf("%d ", arr2[i]);
}
printf("\n");
}
void* my_memcpy(void* dest,const void* src,size_t num)
{
assert(dest && src);//防止传入的是空指针
void* ret = dest;//存储dest的首地址方便返回
while(num--)
{
*(char*)dest=*(char*)src;//将源头的数据赋给目的地
dest=(char*)dest+1;//由于dest与src是void*的指针在偏移的时候采用这种方式
src=(char*)src+1;
}
return ret;//返回原dest的地址
}
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int sz = sizeof(arr1) / sizeof(arr1[0]);
my_memcpy(arr1+2, arr1, 20);//从arr1+3的位置处开始拷贝数据
print_arr(arr1,sz);//实行打印数组的功能
return 0;
}
我们发现结果不符合我们的要求，为什么呢？
那有没有解决在同一块内存里拷贝数据的函数呢？有的，那就是memmove函数，接下来我们介绍memmove函数。
二，memmove函数使用和模拟实现
1,memmove的使用
我们先来看看它的函数原型：
void * memmove ( void * destination, const void * source, size_t num );
memmove函数的参数返回值均与memcpy一样，返回值也一样在这就不再过多赘述。
要注意：
• 和memcpy的差别就是memmove函数处理的源内存块和⽬标内存块是可以重叠的。蓝色字体
• 如果源空间和目标空间出现重叠，就得使用memmove函数处理。
我们直接来使用memmove解决我们上面提出的问题：
//void* memmove
// (void* destination, //void*接受任意类型的数据 复制目标
// const void* source, //复制的源头 接受的是地址
// size_t num); //需要复制的字节数 注意是字节数而不是元素个数 接受的是地址
//int main()
//{
// int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
// int sz = sizeof(arr) / sizeof(arr[0]);
// memmove(arr + 2, arr, 8);//从第3个元素开始往后复制连个元素 复制的这两个元素是从首元素开始的 因为传的是首元素的地址
// print_arr(arr, sz);
//}
void print_arr(int arr1[], int sz)
{
int i = 0;
for (i = 0;i < sz;i++)
{
printf("%d ", arr1[i]);
}
printf("\n");
}
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int sz = sizeof(arr1) / sizeof(arr1[0]);
memmove(arr1+2, arr1, 20);//拷贝数据
print_arr(arr2,sz);//实行打印数组的功能
}
从运行结果来看一定满足了我们想要的结果，那这时就会有人好奇说，既然memove能处理内存重叠的数据拷贝，那它是怎么实现的呢？我们紧接着就来分析memove的模拟实现。
2,memove的模拟实现
由于memove需要考虑的情况比较多，我们画图来给大家分析：
所以我们目前要解决的就是，是什么时候往前拷贝，什么时候往后拷贝的问题，仔细观察会发现，如果我们要将前面的数据拷贝到后面就是往前拷贝(倒着拷贝)；如果要将后面的数据拷贝到前面采用的是顺着拷贝。我们画图让大家更加直观的看到：
注意：当dest与src指向的两块内存分离的时候两种方法都适用！
下面我们给出模拟实现的代码：
//memmove的模拟实现
my_memmove(void* dest, const void* src, size_t num)
{
assert(dest && src);
void* ret = dest;
//从前往后
if (dest < src)
{
while (num--)
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
}
//从后往前
else
{
while (num--)
{
*((char*)dest + num) = *((char*)src + num);
//
}
}
return ret;
}
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
int sz = sizeof(arr) / sizeof(arr[0]);
my_memmove(arr + 2, arr, 8);
print_arr(arr, sz);
}
注意*((char*)dest + num) = *((char*)src + num);这段代码很巧妙的运用num–偏移来实现倒着拷贝每一个字节的数据。
有了内存拷贝函数，我们再介绍两个函数分别时内存设置函数，和比较函数。
三，memset函数使用和模拟实现
1,memset的使用
先来看看它的函数原型：
void * memset ( void * ptr, int value, size_t num );
- 第一个参数时
void*类型的ptr用于接收任意类型的地址。 - 第二个参数是
int类型的value 即想要设置的整型值。 - 第三个参数是
size_t类型的num即想要设置的大小(单位是字节)。 - 返回值是
void*返回任意类型数据的地址。
有了以上的了解，下面我们来使用一下：
//memset内存设置函数的使用
int main()
{
char arr1[] = "hello word";
memset(arr1 + 2, 'x', 7);
printf("%s\n", arr1);
int arr2[10] = { 1,2,3,4,5,6,7,8,9,10 };
//memset(arr, 1, 40);//注意memset是不能给数组设置为1的 因为memset是以一个字节为单位的设置
memset(arr2, 0, 40);//注意设置成0就可以
for (int i = 0;i < 10;i++)
{
printf("%d ", arr2[i]);
}
return 0;
}
在使用memset时要注意一个点，就是假设要是有memset去给数组全部设置成1，这一点是做不到了，我们调试一下让大家看看就知道了：
接着我们就来模拟实现，由于memset模拟的底层逻辑与我们上memcoy模拟的逻辑比一样，所以就不再分析直接给出代码：
2,memset的模拟实现
/************ memset的模拟实现 ***********/
void* my_memset(void* ptr, int value, size_t num)
{
assert(ptr);
void* ret = ptr;
while (num--)
{
//ptr是void*的指针要先强制类型转换后才能解引用
*((char*)ptr+num) = value;//先转换为char*类型的指针，加num偏移量，再将需要设置的值value赋给ptr
}
return ret;
}
int main()
{
char arr1[] = "hello word";
//my_memset(arr + 2, 'x', 7);
int arr2[10] = { 1,2,3,4,5,6,7,8,9,10 };
my_memset(arr2, 0, 40);
//printf("%s", arr);
for (int i = 0;i<10;i++)
{
printf("%d ", arr2[i]);
}
//printf("%d", arr);
return 0;
}
最后再来介绍memcmp函数。
四，memcmp函数使用和模拟实现
1,memcmp的使用
memcmp是C语言的比较函数，先来看看它的函数原型：
int memcmp ( const void * ptr1, const void * ptr2, size_t num );
- 第一个参数是
const void*类型的ptr1接收任意类型地址，比较的地址1。 - 第二个参数是
const void*类型的ptr2，比较的地址2。 - 第三个参数是
size_t类型的num，即需要比较的字节数。 - 注意，这里的返回类型是
int类型 如果ptr1>ptr2返回大于0的数 等于返回0 小于返回小于0的数。
有了以上的了解我们就来尝试使用它：
/********* memcmp的使用 **********/
int main()
{
int arr1[] = { 1,2,3,4,5 };
int arr2[] = { 1,2,3,4,0x12233301 };
int ret = memcmp(arr1, arr2, 17);
printf("%d\n", ret);
return 0;
}
上面的代码比较的结果ret的值是大于0的数还是等于0的数还是小于0的数呢？
运行结果为1，说明ptr1大于ptr2即arr1大于arr2，为什么呢？我们调试让大家看看，5与0x12233301在内存中是怎么存储的大家就知道了。
紧接着我们来模拟实现memcmp函数，我们给出代码，由于模拟逻辑跟上一篇字符函数与字符串函数中的strcmp是一样的在这就不再赘述。
字符函数与字符串函数
2,memcmp的模拟实现
/*********** memcmp的模拟实现 ***********/
int my_memcmp(const void* ptr1, const void* ptr2, size_t num)
{
assert(ptr1 && ptr2);
while (*(char*)ptr1 == *(char*)ptr2)
{
ptr1 = (char*)ptr1 + 1;
ptr2 = (char*)ptr2 + 1;
}
const unsigned char* p1 = ptr1;//比较数据的时候转换为无符号char类型比较保险
//因为char类型范围是-128~127，当字节值为0xFF时会被当作-1
//正确做法应使用unsigned char比较，确保按二进制值比较
const unsigned char* p2 = ptr2;
if (*p1>*p2)
{
return 1;
}
else
{
return -1;
}
return 0;
}
int main()
{
int arr1[] = { 1,2,3,4,5 };
int arr2[] = { 1,2,3,4,0x12233301 };
int r = my_memcmp(arr1, arr2, 17);
printf("%d", r);
return 0;
}
以上就是本章的全部内容啦！
最后感谢能够看到这里的读者，如果我的文章能够帮到你那我甚是荣幸，文章有任何问题都欢迎指出！制作不易还望给一个免费的三连，你们的支持就是我最大的动力！
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
