c语言——内存函数

1.memcpy函数使用和模拟

2.memmove函数使用和模拟

3.memset函数使用

4.memcmp函数使用

上一篇博客我给大家一 一介绍了字符串相关的函数，那么这一篇我想给大家介绍关于内存方面的函数，内存函数，他是不考虑类型的，他只考虑从内存进行处理的一系列函数

1.memcpy函数

memcpy是用来拷贝内存信息的内存函数，它可以拷贝我们想要的信息，但是要注意，他是通过字节的大小进行拷贝的，而不是元素个数

memcpy函数是用来拷贝不相关的内存数据，可以是任意类型的数据

但是如果是同一个内存同一个空间拷贝，那么拷贝就会出错

而strcpy只能拷贝字符串

#include<stdio.h>
#include<string.h>
int main()
{
  int arr1[10]={1,2,3,4,5,6,7,8,9,10};
  int arr2[10]={0};
  memcpy(arr2,arr1,5*sizeof(int));
//arr2是destination，arr1是source，将源头拷贝到目标地址
//并且只拷贝5*sizeof（int）个字节，即20个字节，即5个元素
  int i = 0;
  for(i=0;i<10;i++)
   {
      printf("%d ",arr2[i]);
   }
  return 0;
}

当我们会使用memcpy这个函数时，那让我们来模拟实现一下吧！！！

#include<stdio.h>
#include<string.h>
#include<assert.h>
void* my_memcpy(void* dest,void* src,size_t num)
{
   char* r = dest;//接收dest的起始地址，为了方便我们最后return dest的起始地址
   assert(dest && src!=NULL);
   while(num--)
   {
      *(char*)dest = *(char*)src;//因为memcpy是void*，他并不知道我们要传递多少个字节
     //如果以后我们要传递7个字节的char类型，但是我们强制类型转换为int，那么int一次会跳过4个字 
     //节，所以我们使用char*，一次访问一个字节，就可以避免以后跳过字节不匹配
     
     dest = (char*)dest + 1;//所以这里我们也把dest和src每次前进一个char*字节
     src = (char*)src + 1;   //每次一个字节一个字节交换
   }

    return r;
}


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

  return 0;
}

2.memmove函数

他的使用方法和memcpy相同

不同的是memmove可以拷贝重叠的内容，即同一个地址的内容

#include<stdio.h>
#include<string.h>
int main()
{
  int arr[10]={1,2,3,4,5,6,7,8,9,10};
  memmove(arr+5,arr+3,5*sizeof(int));
//将arr+3后面的5*sizeof（int）个字节的元素，拷贝到第arr+5后面的元素中
//这就是memmove特别的地方
  int i = 0;
  for(i=0;i<10;i++)
   {
      printf("%d ",arr[i]);
   }


  return 0;
}

当我们知道如何使用memmove时，让我们来尝试模拟实现一下吧！！

#include<stdio.h>
#include<string.h>
#include<assert.h>
void* my_memmove(void* dest,void* src,size_t num)
{
   void* r = dest;//记住dest起始地址，方便return dest的起始地址打印
   assert(dest && src !=NULL);
   //这里拷贝重叠内容会有俩种情况
   //第一种：dest的起始地址大小于src的起始地址，说明dest再src前面
   //所以要从前-->往后拷贝
     if(dest < src)
     {
        while(num--)
        {
            *(char*)dest = *(char*)src;
             dest = (char*)dest + 1;
             src = (char*)src + 1;
         }
     }
      //第二种情况：当dest的起始地址大于src
      //说明dest再src后面，所以要从后-->往前拷贝
     else
     { 
        while(num--)
         {
             //num进来时候，num=19，就可以让dets和src跑到最后一个字节，从后向前一个字节一个 
              //字节拷贝
           *((char*)dest + num) = *((char*)src + num);
         }
     }
       return r;
}


int main()
{
   int arr[10]={1,2,3,4,5,6,7,8,9,10};
   my_memmove(arr+5,arr+3,5*sizeof(int));
   int i = 0;
   for(i=0 ; i<10 ; i++)
    {
       printf("%d ",arr[i]);
    }

   return 0;
}

再模拟实现memmove时候，我们要多考虑一步，dest是再src的前面呢？还是在src后面呢？

如果再src前面，那么从前-->向后拷贝

如果再src后面，那么从后-->向前拷贝

多考虑这一步是为了避免我们拷贝的内容拷贝重复

3.memset的使用

memset可以设置我们想要更换元素的多少字节

注意：这里更换的是字节！！！不是元素个数！！

#include<stdio.h>
#include<string.h>
int main()
{
   char arr[10]={0};
   memset(arr,'k',6*sizeof(char));
//在arr数组中，我要更换6*sizeof（char）个字节的字符k
//这里要通过调试观察

   return 0;
}

#include<stdio.h>
#include<string.h>
int main()
{
   int arr[10]={0};
   memset(arr,1,5*sizeof(int));
//在arr数组中，将5*sizeof（int）个字节设置为1
//在调试中观察
   return 0;
}

4.memcmp的使用

memcmp是用来比较我们给定字节的大小

注意：是我们给定的字节的大小！！！

#include<stdio.h>
#include<string.h>
int main()
{
   int arr1[10]={1,2,3,4,5,6,7,8,9,10};
   int arr2[10]={1,2,3,9};
   int r1 = memcmp(arr1,arr2,3*sizeof(int));
//第一个memcmp比较的是arr1和arr2中前3*sizeof（int）个字节的大小，即前3个元素的大小
//如果arr1大于arr2，那么返回>0,如果相等，则返回0，小于，则返回<0
   printf("%d\n",r1);

   int r2 = memcmp(arr1,arr2,4*sizeof(int));
//这里是比较arr1和arr2中前4*sizeof（int）个字节的大小，即前4个元素的大小
/如果arr1大于arr2，则返回>0,相等则返回0，小于则返回<0
   printf("%d\n",r2);

   return 0;
}