几种常用函数的原型

最新推荐文章于 2021-08-08 11:56:09 发布

csw_100

最新推荐文章于 2021-08-08 11:56:09 发布

阅读量1.5k

点赞数

分类专栏：几种常用函数的原型文章标签： dst string null buffer returning byte

本文链接：https://blog.csdn.net/csw_100/article/details/5836079

版权

几种常用函数的原型专栏收录该内容

1 篇文章 0 订阅

订阅专栏

strcpy()、 memcpy()、memmove()、memset()的实现

memcpy, 拷贝不重叠的内存块
void *memcpy(void* pvTo, void* pvFrom, size_t size) //byte是java里的变量类型
{
assert(pvTo != NULL && pvFrom != NULL);
void* pbTo = (byte*)pvTo;
void* pbFrom = (byte*)pvFrom;
/* 内存块重叠吗？如果重叠，就使用memmove */
assert(pbTo>=pbFrom+size || pbFrom>=pbTo+size);
while(size-->0)
*pbTo++ == *pbFrom++;
return pvTo;
}

void *Memmove(void *Dst, const void*Src,size_t count)
{
assert(Dst && Src);
void* pDst = Dst;
if (Dst<Src && (char*)Dst > (char*)Src + count)
{
while(count--)
{
   *(char*)Dst = *(char*)Src;
   Dst = (char*)Dst + 1;
   Src = (char*)Src + 1;
}
}
else
{
   Dst = (char*)Dst + count - 1;
   Src = (char*)Src + count - 1;
   while(count--)
   {
      *(char*)Dst = *(char*)Src;
      Dst = (char*)Dst -1 ;
      Src = (char*)Src -1 ;
   }
}
return pDst;
}

void* memmove(void *dest, const void *src,size_t n)
{
    if (n == 0) return 0;
    if (dest == NULL) return 0;
    if (src == NULL)    return 0;
    char *psrc = (char*)src;
    char *pdest = (char*)dest;
    if((dest <= psrc) || (pdest >= psrc + n)) /*检查是否有重叠问题 */
        {
         for(int i=0; i < n; i++) /*正向拷贝*/
          {
           *pdest = *psrc;
           psrc++;
           pdest++;
          }
        }
        else /*反向拷贝*/
        {
          psrc += n;
          pdest += n;
          for(int i=0;i<n;i++)
           {
            psrc--;
            pdest--;
            *pdest = *psrc;
           }
        }
   return dest;
}

memset:把buffer所指内存区域的前count个字节设置成字符c

void * Memset(void* buffer, int c, int count)
{
char* pvTo=(char*)buffer;
assert(buffer != NULL);
while(count-->0)
*pvTo++=(char)c;
return buffer;
}

它们都是从src所指向的内存中复制count个字节到dst所指内存中，并返回dst的值。当源内存区域和目标内存区域无交叉时，两者的结果是一样的，但如果有交叉呢？先看下图：

图的上半部分为源内存区域在目标内存区域右边，下半部分为源内存区域在目标区域左边，源内存区域和目标内存区域都有交叉。

memcpy（）是从src的起始部分开始复制，所以虽然第一种情况下没有问题，但如果遇到第二种情况，则会发生错误，如图所示，后两个字节在被复制前已经被覆盖掉了。而memmove（）则由于采用了不同的复制机制，所以可以正确处理第二种情况。

void*Mymemcpy(void*dst,const void*src,size_t count)
{

ASSERT(dst!=NULL && src!=NULL);

//注意之所以转换为char*，是为了指针能够一位一位的操作，void*类型不定举个例子如果void* 为int*
    //如果不加char*转换类型，那么dst+1指针位移将是4个字节
    void *sret=dst;
    if (dst<=src||(char*)dst>=(char*)src+count)
    {
        while (count--)
        {
            *(char*)dst=*(char*)src;
            dst=(char*)dst+1;
            src=(char*)src+1;
        }
    }
    else
    {
        dst=(char*)dst+count-1;
        src=(char*)src+count-1;
        while (count--)
        {
            *(char*)dst=*(char*)src;
            dst=(char*)dst-1;
            src=(char*)src-1;
        }


    }
    return sret;
}