关于c++:手写strcpy和memcpy代码实现

34次阅读

共计 2624 个字符，预计需要花费 7 分钟才能阅读完成。

本篇文章聊一下 strcpy 和 memcpy 的代码实现，这两个也是 c 和 c ++ 面试中常考的问题点。

首先看一下，一份规范的 strcpy 的实现如下：

char *strcpy(char* strDest, const char* strSrc)
{assert( (strDest != NULL) && (strSrc != NULL));
    char *address = strDest;
    while((*strDest++ = *strSrc++) != '\0');
    return address;
}

这里有如下几点须要留神：

源字符串要应用 const 类型，防止在程序中被批改；
在函数入口处要加上断言，查看源字符串指针和指标字符串指针是否有为空的，否则会产生不可意料的谬误；
应用 while 循环要简略而清晰，应用尽量精简的代码；
返回值要是char*，且返回了指标字符串指针的原值，使得函数能够反对链式表达式，减少了函数的附加值。

以上这些点不只实用于 strcpy 这里，而是咱们任何时候写代码都尽量遵循这些规定，这样能力写出高可用、高健壮性的代码。

对于以上代码，咱们能够看进去，它是存在隐患的，当源字符串的长度超出指标字符串时，会导致把数据写入到咱们无法控制的地址中去，存在很大的危险，所以就有了 strncpy，上面也给一个 strncpy 的实现，如下：

char *strncpy(char* strDest, const char* strSrc, size_t n)
{assert( (strDest != NULL) && (strSrc != NULL));
    char *address = strDest;
    while (n-- && (*strDest++ = *strSrc++) != '\0');
    return address;
}

要依据输出的长度做一个管制，而往往咱们应用的时候，输出的长度都是指标字符串的长度减 1，因为要留一个地位给结束符'\0'。

memcpy 的实现其实能够参考 strncpy 的实现，比方咱们把指针类型转换成 char* 来实现拷贝，这种形式就是依照一个字节一个字节来进行拷贝了，首先还是一睹代码为快，如下：

#include <stdio.h>
#include <string.h>

struct people
{
    int iAge;
    char szName[12];
    char szSex[3];
};

// 模仿 memcpy 的实现
void * mymemcpy(void *dest, const void *src, size_t n)
{if (dest == NULL || src == NULL)
          return NULL;
    char *pDest = static_cast <char*>(dest);
    const char *pSrc  = static_cast <const char*>(src);
    if (pDest > pSrc && pDest < pSrc+n)
    {for (size_t i=n-1; i != -1; --i)
        {pDest[i] = pSrc[i];
        }
    }
    else
    {for (size_t i= 0; i < n; i++)
        {pDest[i] = pSrc[i];
        }
    }

    return dest;
}

int main()
{
    people stPeople1, stPeople2;
    memset((void*)&stPeople1, 0x00, sizeof(stPeople1));
    memset((void*)&stPeople2, 0x00, sizeof(stPeople2));
    stPeople1.iAge = 32;
    mymemcpy(stPeople1.szName, "li lei", sizeof(stPeople1.szName));
    mymemcpy(stPeople1.szSex, "man", sizeof(stPeople1.szSex));

    mymemcpy((void*)&stPeople2, (void*)&stPeople1, sizeof(stPeople2));
    
    printf("this people age is %d, name is %s, sex is %s\n", stPeople2.iAge, stPeople2.szName, stPeople2.szSex);
    
    return 0;
}

咱们看 mymemcpy 的实现，此时是一个字节的实现，但它与 strncpy 实现不能一样，看一下 memcpy 实现的留神点：

同样的，在函数入口处要查看源字符串指针和指标字符串指针是否有为空的，否则会产生不可意料的谬误；
因为是依照一个字节拷贝，那就要把形参转换成 char* 类型来操作；
要查看源内存和指标内存是否存在内存重叠，如果指标内存首地址在源内存的两头，则要从后往前拷贝，因为如果从前往后拷贝，那从指标内存首地址开始的中央就会被笼罩掉，如果没有重叠，或者源内存地址在指标内存的两头，那没有关系，能够从前往后拷贝；
不能应用 '\0' 来判断拷贝的完结，因为它是对一整块内存的拷贝，举一个通俗的例子，假如拷贝一个构造体，相似下面代码，那么它很可能拷贝到两头的某个中央就进行了，这个拷贝就相当于没有实现；
同样的，memcpy 也要返回指标字符串地址；

然而这个时候如果面试官问你，依照 4 个字节来拷贝，该怎么实现呢？

依据后面的逻辑，其实依照 4 个字节拷贝就是把指针类型转换成 int* 来拷贝，不过有一点不同的是，如果依照 4 个字节来拷贝，就没方法去判断内存重叠的状况了，因为内存的根本单位是一个字节，4 个字节是没有方法防止笼罩状况的，一个可用的 4 个字节拷贝代码如下：

void * mymemcpy(void *dest, const void *src, size_t n)
{if (dest == NULL || src == NULL)
          return NULL;
    int *pDest = (int*)dest;
    int *pSrc  = (int*)src;
    int iWordNum = n/4;
    int iSlice = n%4;
    while(iWordNum--)
    {*pDest++ = *pSrc++;}
    char* pcDest = (char*)pDest;
    char* pcSrc = (char*)pSrc;

    while(iSlice--)
    {*pcDest++ = *pcSrc++;}

    return dest;
}

依照 4 个字节判断，一个清晰的思路是满足 4 个字节的依照 int 类型去拷贝，不满足 4 个字节的就还是依照 char 类型去拷贝。

好了，对于 strcpy 和 memcpy 的实现就介绍到这里，如果我的创作对你有用的话，麻烦点个赞呗。

正文完