字符串拷贝函数

一：sprintf、snprintf

        int sprintf( char *buffer, const char *format [, argument] ... );

        int snprintf(char *restrict buf, size_t n, const char * restrict  format, ...);


        建议用法：
        1：snprintf(str, sizeof(str ) , "0123456789012345678");



二：strcpy、strncpy、strlcpy

    1：strcpy --- 自动补结束符

        strcpy是最不安全拷贝字符串函数，因为src串的长度有时会很长。随后strncpy函数为了解决这个问题出现了，但这个函数有些地方实现得也很诡异，它对于字符串末尾的’\0’处理不是很好。


    2：strncpy

        char str[11]; 
        strncpy(str, "hello world", 11);

        在例1中只会把str数组填满，但这个字符串却没有’\0’的结束符。


         char str[20]; 
         strncpy(str, "sample", 15);

        15远远大于了字符串"sample"的长度，这时strncpy要在剩下的部分补充’\0’。首先说这样会影响效率，其次对于static或者calloc这样已经初始化的数组根本不需要填写’\0’。 因此在使用strncpy拷贝字符串时，通常要这样写，

        strncpy(path, homedir, sizeof(path) – 1); 
        path[sizeof(path) – 1] = ‘\0’;



    3：strlcpy可以自动处理末尾’\0’的问题

        size_t strlcpy(char *dst, const char *src, size_t size);

        然而strlcpy不是ANSI C函数，一般在linux下使用。



三：memcpy、memmove

    1.memmove

        函数原型：void *memmove(void *dest, const void *source, size_t count)

        返回值说明：返回指向dest的void *指针

        参数说明：dest,source分别为目标串和源串的首地址。count为要移动的字符的个数

        函数说明：memmove用于从source拷贝count个字符到dest，如果目标区域和源区域有重叠的话，memmove能够保证源串在被覆盖之前将重叠区域的字节拷贝到目标区域中。



    2.memcpy

        函数原型：void *memcpy(void *dest, const void *source, size_t count);

        返回值说明：返回指向dest的void *指针

        函数说明：memcpy功能和memmove相同，但是memcpy中dest和source中的区域不能重叠，否则会出现未知结果。


 


    3.两者区别


          函数memcpy()   从source  指向的区域向dest指向的区域复制count个字符，如果两数组重叠，不定义该函数的行为。   
          而memmove(),如果两函数重叠，赋值仍正确进行。

          memcpy函数假设要复制的内存区域不存在重叠，如果你能确保你进行复制操作的的内存区域没有任何重叠，可以直接用memcpy；   
          如果你不能保证是否有重叠，为了确保复制的正确性，你必须用memmove。

         memcpy的效率会比memmove高一些，如果还不明白的话可以看一些两者的实现：


        void *memmove(void *dest, const void *source, size_t count)
        {
                 assert((NULL != dest) && (NULL != source));
                 char *tmp_source, *tmp_dest;
                 tmp_source = (char *)source;
                 tmp_dest = (char *)dest;
                 if((dest + count                        while(count--)
                      *tmp_dest++ = *tmp_source++;
                }
                else
                { //如果有重叠
                         tmp_source += count - 1;
                         tmp_dest += count - 1;
                         while(count--)
                              *--tmp_dest = *--tmp;
                }
                return dest;
        }



        void *memcpy(void *dest, const void *source, size_t count)
        {
                 assert((NULL != dest) && (NULL != source));
                 char *tmp_dest = (char *)dest;
                 char *tmp_source = (char *)source;
                 while(count --)//不对是否存在重叠区域进行判断
                       *tmp_dest ++ = *tmp_source ++;
                 return dest;
        }