C语言之内存函数篇（3）

今天我们继续介绍几个重要的内存操作函数。🙂🙂🙂

在前面一章我们学过strcpy,strcmp等字符串函数，那这里我们来学习与它们功能类似的内存函数。

还是从参数，返回值，头文件，模拟实现等方面来讲解

注意是void* ,什么类型都🆗

模拟实现必须要会

size_t num代表的是字节

memcpy

memcpy - C++ Reference memcpy与strcpy是类似的，但是strcpy仅仅用在字符串拷贝上，内存中的数据，不仅仅是字   符，还有整型，浮点型等等，这里就要用到我们的memcpy

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

• memcpy是库函数，从source的位置开始向后拷贝num个字节的数据到desitination的内存位置
• C语言标准值规定，memcpy来实现不重叠的内存的拷贝。memcpy达到60分可以实现功能
• 在我们VS2022这个环境中，memcpy也可以实现重叠内存的拷贝。此时memcpy达到100分
• 头文件#include
• 参数size_t num是拷贝的字节个数
• 参数const void * source 是拷贝的字节的起始位置（const防止source修改,void*类型）
• 参数void * destination 是拷贝到的空间的起始位置（void*类型）
• 返回类型void *
• void*类型表示可以接收任何类型的数据，但是不能 解引用 哦
• 这个函数在遇到 '\0' 的时候并不会停下来。
• 如果source和destination有任何的重叠，复制的结果都是未定义的
• memcpy的模拟实现

memcpy的使用

#include<stdio.h>
int main()
{
  int a[] = { 0 };
  int b[] = { 6,7,8,9,10 };//5✖4
  void* p = memcpy(a, b, 20);
  int i = 0;
  for (i = 0; i < 5 ;i++)
  {
    printf("%d ", a[i]);
  }
  return 0;
}

• 这下无论是什么类型的数据都可以从一个空间拷贝到另外一个空间里去。

memcpy的模拟实现

#include<stdio.h>
#include<assert.h>
void* my_memcpy(void* destination, const void* source, size_t num)//记住num是字节的个数
{
    assert(dest && src);
  void* ret = destination;
  while (num--)
  {
    *((char*)destination) = *((char*)source);
    (char*)destination = (char*)destination + 1;
    (char*)source = (char*)source + 1;
  }
  return ret;
}
int main()
{
  int a[20] = { 0 };
  int b[] = { 1,2,3,4,5 };//5✖4
  void* p = my_memcpy(a, b, 20);
  int i = 0;
  for (i = 0; i < 5 ;i++)
  {
    printf("%d ", a[i]);
  }
  return 0;
}

NO1.

有同学说可以直接一个整型一个整型的拷贝过去，但是问题在于编写库函数的程序员并不会知道我们需要拷贝怎样的类型数据，所以这里我们又可以用到回调函数当时使用的一个方法

回调函数------->

C语言之指针进阶篇（3）_唐棣棣的博客-CSDN博客

NO2.

*((char*)destination) = *((char*)source);
(char*)destination++;
(char*)source++;

那有同学这样写可以吗？

答：当然是不可以的啦。其实关于前置和后置++我们都尽量少去使用。  因为副作用很多。我们也不清楚它的能使用的情况是怎样一回事，所以尽量少用。这里不能使用的原因是：destination和source强制转化后，再去++，强制转化已经失效了，++时destination和source已经变成void*类型的啦

++(char*)destination;
++(char*)source;

虽然以上写法可能可以，但是会存在无法编译的问题。

还有同学问就不能直接++？

答：当然不行。回调函数我们那篇博文我们已经讲解过 void*类型的指针变量不能解引用和            计算++ --等等。

memcpy可否实现重叠空间的拷贝

当我们学习了上面memcpy的知识了，有人就动了动自己的小脑袋。🙂🙂

memcpy真的不能实现重叠内存的拷贝吗？

my_memcpy

#include<stdio.h>
void* my_memcpy(void* destination, const void* source, size_t num)//记住num是字节的个数
{
  void* ret = destination;
  while (num--)
  {
    *((char*)destination) = *((char*)source);
    destination = (char*)destination + 1;
    source = (char*)source + 1;
  }
  return ret;
}
int main()
{
  int b[] = { 1,2,3,4,5 };
  //把1 2 3拷贝到3 4 5
  void* p = my_memcpy(b+2, b, 12);
  int i = 0;
  for (i = 0; i < 5 ;i++)
  {
    printf("%d ", b[i]);
  }
  return 0;
}

那问题到底出现在那里呢？

memcpy

int main()
{
  int b[] = { 1,2,3,4,5 };
  //把1 2 3拷贝到3 4 5
  void* p = memcpy(b+2, b, 12);
  int i = 0;
  for (i = 0; i < 5 ;i++)
  {
    printf("%d ", b[i]);
  }
  return 0;
}

综上所述：事实证明只是我们my_memcpy不可以。

C语言标准值规定，memcpy来实现不重叠的内存的拷贝。memcpy达到60分可以实现功能

在我们VS2022这个环境中，memcpy也可以实现重叠内存的拷贝。此时memcpy达到100分

C语言标准值规定，memmove来实现重叠的内存拷贝。  

memmove

使用memmove是否可以实现？

//当然可以
int main()
{
  int b[] = { 1,2,3,4,5 };
  //把1 2 3拷贝到3 4 5
  void* p = memmove(b+2, b, 12);
  int i = 0;
  for (i = 0; i < 5 ;i++)
  {
    printf("%d ", b[i]);
  }
  return 0;
}

memmove

memmove - C++ Reference (cplusplus.com)

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

• C语言标准值规定，memcpy来实现不重叠的内存的拷贝。memcpy达到60分可以实现功能
• 在我们VS2022这个环境中，memcpy也可以实现重叠内存的拷贝。此时memcpy达到100分
• C语言标准值规定，memmove来实现重叠的内存拷贝。
• memmove也是是库函数，类似memcpy，基本一致所不在详细介绍。
• 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
• 如果源空间和目标空间出现重叠，就得使用memmove函数处理。
• memmove的模拟实现

memmove模拟实现

分析

代码

#include<stdio.h>
#include<strng.h>
#include<assert.h>
void* my_memmove(void* p1, void* p2，size_t num)
{
  assert(p1 && p2);
  void* ret = p1;
  //p1在p2的前面从后往前拷贝
  if (p1 < p2)
  {
    while (num--)
    {
      *(char*)p1 = *(char*)p2;
      p2 = (char*)p2 + 1;
      p1 = (char*)p1 + 1;
    }
  }
  //p1在p2的后面从后往前拷贝
  else
  {
    while (num--)
    {
      *((char*)p1 + num) = *9(char*)p2 + num);
    }
  }
  return ret;
}
int main()
{
  char arr1[30] = "abcdef";
  void* ret = my_memmove(arr1, arr1+2,4);
  //4个字节
  printf("%s\n", ret);
}

memset

memset - C++ Reference (cplusplus.com)

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

• memset是库函数，是设置内存的，是以字节为单位设置内存的
• 头文件#include
• 参数size_t num是设置的字节个数
• 参数int value 是设置的字节
• 参数void * ptr是设置的空间的起始位置（void*类型）
• 返回类型void *
• void*类型表示可以接收任何类型的数据，但是不能 解引用 哦和计算++，--等
• 准确来说memset更加适合char类型的变量，但是可以把整型设置全设为1
• 注意char可以放到int里，int不能放到char里

memset的使用

#include<stdio.h>
#include<string.h>
int main()
{
  char arr[] = "tsqxgd.haha";
  memset(arr+6, 'x', 3);//再次强调是3个字节
  printf("%s\n", arr);
}

memcmp

memcmp - C++ Reference (cplusplus.com)

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

• memcmp是库函数，是比较内存的，是以字节为单位比较内存的
• 比较从ptr1和ptr2指针开始的num个字节
• 头文件#include
• 参数size_t num是设置的字节个数
• 参数const void * ptr1 是比较的字节的起始位置（const防止source修改,void*类型）
• 参数const void * ptr2 是比较的空间的起始位置（void*类型）
• void*类型表示可以接收任何类型的数据，但是不能 解引用 哦和计算++，--等
• 返回类型int
• 返回值如下图：

memcmp的使用

<0

#include<stdio.h>
#include<string.h>
int main()
{
  int arr1[] = { 1,2,3,4,5 };
  int arr2[] = { 1,2,3,4,6 };
  int ret = memcmp(arr1, arr2, 20);
  printf("%d\n", ret);
}

=0

#include<stdio.h>
#include<string.h>
int main()
{
  int arr1[] = { 1,2,3,4,5 };
  int arr2[] = { 1,2,3,4,6 };
  int ret = memcmp(arr1, arr2, 16);
  printf("%s\n", ret);
}

>0

#include<stdio.h>
#include<string.h>
int main()
{
  int arr1[] = { 1,2,3,4,7 };
  int arr2[] = { 1,2,3,4,6 };
  int ret = memcmp(arr1, arr2,20 );
  printf("%d\n", ret);
}

特别提醒：

只是在vs2022编译器下，才是0，1，-1这样的数值，

在其他编译器下可能就不是但是肯定是<0 >0 =0这样的范围的。

✔✔✔✔✔最后，感谢大家的阅读，若有错误和不足，欢迎指正！

我知青山不复在，也知绿水难长流。

下篇博文我们总结各种函数的模拟实现。🆗🆗🆗🆗走的每一步都是算数的。

代码------→【gitee:唐棣棣 (TSQXG) - Gitee.com】

联系------→【邮箱：2784139418@qq.com】