一起talk C栗子吧（第六十四回：C语言实例--DIY字符串复制函数）
各位看官们，大家好，上一回中咱们说的是字符串查找的例子，这一回咱们说的例子是：DIY字符串复制函数。闲话休提，言归正转。让我们一起talk C栗子吧！
我们在前面的章回中介绍过字符串复制函数，时间不长，但是有些看官已经忘记了，为了加深看官们对字符串复制函数的印象，我们准备DIY字符串复制函数。just do it by yourself!
我们在前面的章回中一共介绍了四个字符串复制函数:strcpy,strncpy,memcpy,memmove。接下来我们分别介绍如何DIY它们。
DIY strcpy函数：
char *diy_strcpy(char *s1,const char *s2)
- 1.在s2所指的字符串中，从第一个字符开始，把s2中的字符，赋值给s1指向的字符；
- 2.判断是不是s2的小尾巴，如果是小尾巴，那么停止复制操作；如果不是，进入下一步；
- 3.重复步骤1和2，直到从步骤2中停止为止。
下面是我写的代码，其实核心代码只有一行：
char *diy_strcpy(char *s1,const char *s2)
{
char *pStr = NULL;
if(NULL == s1 || NULL == s2)
return NULL;
pStr = s1;
while((*pStr++ = *s2++) != '\0') // 核心代码
;
return s1;
}其实，在Linux系统中也提供了标准C库，文件路径/lib/string.c。下面我们看看该文件中是如何实现字符串复制函数：strcpy的。
/** * strcpy - Copy a %NUL terminated string * @dest: Where to copy the string to * @src: Where to copy the string from */
char *strcpy(char *dest, const char *src)
{
char *tmp = dest;
while ((*dest++ = *src++) != '\0')
/* nothing */;
return tmp;
}对比一下，我们DIY的strcpy函数，两者在核心代码上是一致的。
DIY strncpy函数：
char *diy_strncpy(char *s1,const char *s2,int n)
- 1.在s2所指的字符串中，从第一个字符开始，把s2中的字符，赋值给s1指向的字符；
- 2.判断下面两个条件，只有满足了其中的任何一个条件 ，那么停止复制操作；如果两个条件都不满足，那么进入第三步：
- 条件一：赋值的字符是不是s2的小尾巴；
- 条件二：赋值的次数是不是超过了n次；
- 3.重复步骤1和2，直到从步骤2中停止为止；
- 4.判断步骤2中复制字符的数量，如果数量小于n,那么把空字符赋值给s1,赋值的次数为剩下的数量。
下面是我写的代码，大家可以参考：
char *diy_strncpy(char *s1,const char *s2,int n)
{
char *pStr = NULL;
if(NULL == s1 || NULL == s2)
return NULL;
pStr = s1;
while(*s2!='\0' && n-->0) // \0 is not copyed to s1
*pStr++ = *s2++;
while(n-- > 0) // if the size of s2 is less then n, copy \0 to s1.
*pStr++ = '\0';
return s1;
}大家想想 ，我们在给字符赋值过程中，能不能使用像strcpy中的语句进行赋值操作：
while ((*dest++ = *src++) != '\0')
；其实是不行的，这样会把小尾巴也复制到s1中，下面是标准库中strncpy的实现，请大家和咱们DIY的strncpy进行对比：
/**
* strncpy - Copy a length-limited, C-string
* @dest: Where to copy the string to
* @src: Where to copy the string from
* @count: The maximum number of bytes to copy
*
* The result is not %NUL-terminated if the source exceeds
* @count bytes.
*
* In the case where the length of @src is less than that of
* count, the remainder of @dest will be padded with %NUL.
*
*/
char *strncpy(char *dest, const char *src, size_t count)
{
char *tmp = dest;
while (count) {
if ((*tmp = *src) != 0) src++; tmp++; count--; } return dest; }大家对比一下就会发现，我们DIY的strncpy函数和标准库中的strncpy函数不一样，但是功能是相同的。最大
的区别在于标准库在不足n个字符的时候使用空字符进行补充。标准库使用：
if ((*tmp = *src) != 0)
src++;这个判断巧妙地进行补充空字符的操作，而我们DIY的时候，是专门进行补充操作。
DIY memcpy函数:
void *diy_memcpy(void *s1,const void *s2,int n)
- 1.在s2所指的字符串中，从第一个字符开始，把s2中的字符，赋值给s1指向的字符；
- 2.判断赋值的次数是不是超过了n次。如果是，那么停止复制操作；否则进入第三步：
- 3.重复步骤1和2，直到从步骤2中停止为止；
与strncpy相比，memcpy完全按照n进行复制操作，它不管s2中字符数量与n的关系，既不会像strncpy那样补充小尾巴，也不会像strcpy那样复制字符串的小尾巴。通过源代码，可以体现出memcpy和strcpy以及strncpy函数的区别，下面是我写的代码，大家可以参考：
void *diy_memcpy(void *s1,const void *s2,int n)
{
char *pStr = NULL;
const char *pCStr = NULL;
if(NULL == s1 || NULL == s2)
return NULL;
pStr = (char*)s1; // change the void * to char *
pCStr = (char*)s2;
while(n-- > 0) // \0 is not copyed to s1
*pStr++ = *pCStr++;
return s1;
}下面是标准库中memcpy的实现，请大家和咱们DIY的memcpy函数进行对比：
/** * memcpy - Copy one area of memory to another * @dest: Where to copy to * @src: Where to copy from * @count: The size of the area. * * You should not use this function to access IO space, use memcpy_toio() * or memcpy_fromio() instead. */
void *memcpy(void *dest, const void *src, size_t count)
{
char *tmp = dest;
const char *s = src;
while (count--)
*tmp++ = *s++;
return dest;
}大家可以发现，我们DIY的函数和标准库的memcpy函数是一样的。
DIY memmove函数：
void *diy_memmove(void *s1,const void *s2,int n)
- 1.在s2所指的字符串中，从第一个字符开始，把s2中的字符，赋值给s1指向的字符；
- 2.判断s1和s2的在内存空间中的位置，如果s1在s2后面或者说s1的内存地址比s2的大，并且s1和s2指 向的内存空间有重叠，那么从s1和s2指向的字符串n个字符后面开始复制操作，复制时从后向前进行复制操作；否则从前向后进行复制操作；当然了，这里的复制操作和memcpy的复制操作完全一致。
与memcpy相比，memmove增加了对内存空间重叠的判断，这点我们在介绍memmove函数时强调过。其它的操作，它就和memcpy完全相同。memmove和memcpy函数一样，完全按照n进行复制操作，它不管s2中字符数量与n的关系，既不会像strncpy那样补充小尾巴，也不会你strcpy那样复制字符串的小尾巴。通过源代码，可以体现出memmove和strcpy以及strncpy函数的区别，下面是我写的代码，大家可以参考：
void *diy_memmove(void *s1,const void *s2,int n)
{
char *pStr = NULL;
const char *pCStr = NULL;
if(NULL == s1 || NULL == s2)
return NULL;
pStr = (char*)s1; // change the void * to char *
pCStr = (char*)s2;
if((pStr > pCStr) && (pStr < pCStr+n)) // if s1 and s2 have some same memory
{
pStr += n;
pCStr +=n;
while(n-->0)
*--pStr = *--pCStr;// \0 is not copyed to s1
}
else
{
while(n-->0) // \0 is not copyed to s1
*pStr++ = *pCStr++;
}
return s1;
}下面是标准库中memmove的实现，请大家和咱们DIY的memmove函数进行对比：
/** * memmove - Copy one area of memory to another * @dest: Where to copy to * @src: Where to copy from * @count: The size of the area. * * Unlike memcpy(), memmove() copes with overlapping areas. */
void *memmove(void *dest, const void *src, size_t count)
{
char *tmp;
const char *s;
if (dest <= src) {
tmp = dest;
s = src;
while (count--)
*tmp++ = *s++;
} else {
tmp = dest;
tmp += count;
s = src;
s += count;
while (count--)
*--tmp = *--s;
}
return dest;
}通过对比，我们可以发现标准库中的函数在判断内存空间重叠时比我们DIY的函数要简洁一些。除此之外， 它和我们DIY的函数是相同的。
看官们，我把这四个DIY函数整理成了一个文件，并且添加了详细的注释，除此之外，我还使用了前面章回中的测试case进行测试。正文中就不写代码了，详细的代码放到了我的资源中，大家可以点击这里下载使用。前面章回中的程序可以点击这里下载。
下面是程序运行的结果，大家可以和前面章回中的程序结果进行对比：
-----------------------------------
addr: 0xbf980b79 | s0 : string
addr: 0xbf980b81 | s1 : str-1
addr: 0xbf980b91 | s2 : str-2and123
addr: 0xbf980b89 | s3 : AB
addr: 0xbf980b77 | s4 : ABstring
----- after running strcpy(s1,s3) -----
addr: 0xbf980b79 | s0 : string
addr: 0xbf980b81 | s1 : AB
addr: 0xbf980b91 | s2 : str-2and123
addr: 0xbf980b89 | s3 : AB
addr: 0xbf980b77 | s4 : ABstring
----- after running strcpy(s1,s2) -----
addr: 0xbf980b79 | s0 : string
addr: 0xbf980b81 | s1 : str-2and123
addr: 0xbf980b91 | s2 : str-2and123
addr: 0xbf980b89 | s3 : 123
addr: 0xbf980b77 | s4 : ABstring
-----------------------------------
addr: 0xbf980b79 | s0 : string
addr: 0xbf980b81 | s1 : str-1
addr: 0xbf980b91 | s2 : str-2and123
addr: 0xbf980b89 | s3 : AB
addr: 0xbf980b77 | s4 : ABstring
----- after running strncpy(s1,s3,SIZE) -----
addr: 0xbf980b79 | s0 : string
addr: 0xbf980b81 | s1 : AB
addr: 0xbf980b91 | s2 : str-2and123
addr: 0xbf980b89 | s3 : AB
addr: 0xbf980b77 | s4 : ABstring
----- after running strncpy(s1,s2,SIZE) -----
addr: 0xbf980b79 | s0 : string
addr: 0xbf980b81 | s1 : str-2andAB
addr: 0xbf980b91 | s2 : str-2and123
addr: 0xbf980b89 | s3 : AB
addr: 0xbf980b77 | s4 : ABstring
----- after running strncpy(s1,s2,SIZE-1) -----
addr: 0xbf980b79 | s0 : string
addr: 0xbf980b81 | s1 : str-2an
addr: 0xbf980b91 | s2 : str-2and123
addr: 0xbf980b89 | s3 : AB
addr: 0xbf980b77 | s4 : ABstring
----- after running strncpy(s1,s2,SIZE+3) -----
addr: 0xbf980b79 | s0 : string
addr: 0xbf980b81 | s1 : str-2and123
addr: 0xbf980b91 | s2 : str-2and123
addr: 0xbf980b89 | s3 : 123
addr: 0xbf980b77 | s4 : ABstring
-----------------------------------
addr: 0xbf980b79 | s0 : string
addr: 0xbf980b81 | s1 : str-1
addr: 0xbf980b91 | s2 : str-2and123
addr: 0xbf980b89 | s3 : AB
addr: 0xbf980b77 | s4 : ABstring
----- after running memcpy(s1,s3,SIZE) -----
addr: 0xbf980b79 | s0 : string
addr: 0xbf980b81 | s1 : AB
addr: 0xbf980b91 | s2 : str-2and123
addr: 0xbf980b89 | s3 : AB
addr: 0xbf980b77 | s4 : ABstring
----- after running memcpy(s1,s2,SIZE) -----
addr: 0xbf980b79 | s0 : string
addr: 0xbf980b81 | s1 : str-2andAB
addr: 0xbf980b91 | s2 : str-2and123
addr: 0xbf980b89 | s3 : AB
addr: 0xbf980b77 | s4 : ABstring
----- after running memcpy(s1,s2,SIZE-1) -----
addr: 0xbf980b79 | s0 : string
addr: 0xbf980b81 | s1 : str-2an
addr: 0xbf980b91 | s2 : str-2and123
addr: 0xbf980b89 | s3 : AB
addr: 0xbf980b77 | s4 : ABstring
----- after running memcpy(s1,s2,SIZE+3) -----
addr: 0xbf980b79 | s0 : string
addr: 0xbf980b81 | s1 : str-2and123
addr: 0xbf980b91 | s2 : str-2and123
addr: 0xbf980b89 | s3 : 123
addr: 0xbf980b77 | s4 : ABstring
-----------------------------------
addr: 0xbf980b79 | s0 : string
addr: 0xbf980b81 | s1 : str-1
addr: 0xbf980b91 | s2 : str-2and123
addr: 0xbf980b89 | s3 : AB
addr: 0xbf980b77 | s4 : ABstring
----- after running memmove(s1,s3,SIZE) -----
addr: 0xbf980b79 | s0 : string
addr: 0xbf980b81 | s1 : AB
addr: 0xbf980b91 | s2 : str-2and123
addr: 0xbf980b89 | s3 : AB
addr: 0xbf980b77 | s4 : ABstring
----- after running strcpy(s2,s2+1) -----
addr: 0xbf980b91 | s2 : tr-2and123
----- after running strncpy(s2,s2+1,SIZE) -----
addr: 0xbf980b91 | s2 : tr-2and1123
----- after running memcpy(s2,s2+1,SIZE) -----
addr: 0xbf980b91 | s2 : tr-2and1123
----- after running memmove(s2,s2+1,SIZE) -----
addr: 0xbf980b91 | s2 : tr-2and1123 各位看官，关于DIY字符串复制函数的例子咱们就说到这里。欲知后面还有什么例子，且听下回分解。