5.4 複製和串接

— 函式： void * memcpy (void *restrict to, const void *restrict from, size_t size)

memcpy 函式複製 from 物件最前面的 size 位元組到 to 物件的最前面，如果 to 和 from 陣列重疊的話，這個函式會變成未定義的；假如有可能重疊可以改用 memmove 。

memcpy 的傳回值是 to的值。

這裡有一個如何使用memcpy 來複製陣列內容的例子：

          struct foo *oldarray, *newarray;
          int arraysize;
          ...
          memcpy (new, old, arraysize * sizeof (struct foo));

— 函式： wchar_t * wmemcpy (wchar_t *restrict wto, const wchar_t *restrict wfrom, size_t size)

wmemcpy 函式複製 wfrom 物件最前面的 size 寬字元到 wto物件的最前面，如果wto 和 wfrom  陣列重疊的話，這個函式會變成未定義的；假如有可能重疊可以改用 wmemmove 。

下面是 wmemcpy 可能實作的方式但還有最佳化的可能。

          wchar_t *
          wmemcpy (wchar_t *restrict wto, const wchar_t *restrict wfrom,
                   size_t size)
          {
            return (wchar_t *) memcpy (wto, wfrom, size * sizeof (wchar_t));
          }

wmemcpy 的傳回值是 wto的值。

此函式在ISO C90 修訂1時被提出。

— 函式： void * mempcpy (void *restrict to, const void *restrict from, size_t size)

mempcpy 函式跟 memcpy 函式幾乎相同，它複製 from 物件最前面的 size 位元組到 to，它不是傳回 to 的值而是傳回一個指向 to 物件最前面後的 size 位址的指標，例如，值是((void *) ((char *) to + size))。

這在連續不斷的記憶體位置做一些物件的複製是有用的。

          void *
          combine (void *o1, size_t s1, void *o2, size_t s2)
          {
            void *result = malloc (s1 + s2);
            if (result != NULL)
              mempcpy (mempcpy (result, o1, s1), o2, s2);
            return result;
          }

這個函式是GNU擴充的。

— 函式： wchar_t * wmempcpy (wchar_t *restrict wto, const wchar_t *restrict wfrom, size_t size)

wmempcpy 函式跟 wmemcpy 函式幾乎相同，它複製 wfrom 物件最前面的 size 寬字元到 wto 物件，它不是傳回 wto 的值而是傳回一個指向 wto 物件最前面後的size 位址的指標，例如值是 wto + size。

這在連續不斷的記憶體位置做一些物件的複製是有用的。

下面是 wmemcpy 可能實作的方式但還有最佳化的可能。

          wchar_t *
          wmempcpy (wchar_t *restrict wto, const wchar_t *restrict wfrom,
                    size_t size)
          {
            return (wchar_t *) mempcpy (wto, wfrom, size * sizeof (wchar_t));
          }

這個函式是GNU擴充的。

— 函式： void * memmove (void *to, const void *from, size_t size)

memmove 從 from 複製 size 位元組到 to 的 size 位元組即使這兩個空間的區塊有重疊，假如碰上重疊的情形，memmove 會小心地複製 from 區塊原始值，包括那些也屬於 to 區塊的重疊位元組。

memmove 的傳回值是 to的值。

— 函式： wchar_t * wmemmove (wchar_t *wto, const wchar_t *wfrom, size_t size)

wmemmove 從 wfrom 複製 size 寬字元到 wto 的 size 寬字元即使這兩個空間的區塊有重疊，假如碰上重疊的情形，memmove 會小心地複製 wfrom 區塊的原始值，包括那些也屬於 wto區塊的重疊位元組。

下面是 wmemcpy 可能實作的方式但還有最佳化的可能。

          wchar_t *
          wmempcpy (wchar_t *restrict wto, const wchar_t *restrict wfrom,
                    size_t size)
          {
            return (wchar_t *) mempcpy (wto, wfrom, size * sizeof (wchar_t));
          }

wmemmove 的傳回值是 wto 的值。

這個函式是GNU擴充的。

— 函式： void * memccpy (void *restrict to, const void *restrict from, int c, size_t size)

這個函式會從 from 複製不超過 size 位元組到 to，假如發現一個位元跟 c 匹配的話，傳回值是一個到 c 的指標被複製，或是假如在 from 最前面的 size 位元組沒有出現 c 的匹配位元組時則傳回一個空指標。

範例：

#include<string.h>
main()
{
char a[]=”string[a]”;
char b[]=”string(b)”;
memccpy(a,b,’b’,sizeof(b));
printf(“memccpy():%sn”,a);
}

執行：memccpy():string(b]

— 函式： void * memset (void *block, int c, size_t size)

這個函式會把記憶體空間 block 前面的 size 位元組的範圍，用字元 c 把它填滿（轉換成非負整數），它傳回 block 指標。

— 函式： wchar_t * wmemset (wchar_t *block, wchar_t wc, size_t size)

這個函式會把 block 前面的 size 寬字元的範圍，用寬字元 wc 把它填滿，它傳回 block 指標。

— 函式： char * strcpy (char *restrict to, const char *restrict from)

這會從字串 from（包括結束的空字元）複製字元到字串 to，像 memcpy一樣，假如字串有重疊函式會變成未定義，傳回值是 to的值。

— 函式： wchar_t * wcscpy (wchar_t *restrict wto, const wchar_t *restrict wfrom)

這會從字串 wfrom （包括結束的空寬字元）複製寬字元到字串 wto，像 wmemcpy一樣，假如字串有重疊函式會變成未定義，傳回值是 to的值。

— 函式： char * strncpy (char *restrict to, const char *restrict from, size_t size)

這個函式跟 strcpy 類似但是只會複製 size 個字元到 to。

假如 from 的長度大於 size，那麼 strncpy 只會複製前面的 size 個字元，注意這裡不會有空值終止符寫到 to裡。

假如 from 長度小於 size，那麼 strncpy 會複製所有的 from， 後面會會填滿空字元到 size 個字元，這很少用，但是由 ISO C 標準指定。

假如字串有重疊 strncpy 會變成未定義。

使用 strncpy 而不使用 strcpy 是避免關於寫超過 to配置空間的結束錯誤，然而它也會使你的程式比一般的使用還慢：複製一個可能很小的字串到一個相當大的緩衝區裡，在這種情況下， size 可能很大，而這時候 strncpy 會浪費很可觀的時間在複製空字元。

— 函式： wchar_t * wcsncpy (wchar_t *restrict wto, const wchar_t *restrict wfrom, size_t size)

這個函式跟 wcscpy 類似但是只會複製 size 個寬字元到 wto。

假如 wfrom 的長度大於 size，那麼 wcsncpy 只會複製前面的 size 個寬字元，注意這裡不會有空值終止符寫到 wto裡。

假如 wfrom 的長度小於 size，那麼 wcsncpy 會附製所有的 wfrom，後面會填滿空的寬字元到 size 個寬字元，這很少用，但是 ISO C 標準指定。

假如字串有重疊 wcsncpy 會變成未定義。

使用 wcsncpy 而不使用 wcscpy 是避免關於寫超過 wto 配置空間的結束錯誤，然而它也會使你的程式比一般的使用還慢：複製一個可能很小的字串到一個相當大的緩衝區裡，在這種情況下， size 可能很大，而這時候 wcsncpy 會浪費很可觀的時間再複製空的寬字元。

— 函式： char * strdup (const char *s)

這函式複製具空字元結束的字串 s 到新配置的字串，這個字串是使用 malloc配置的；見 Unconstrained Allocation，假如　malloc 不能配置新字串的空間， strdup 傳回一個空指標，否則它會傳回新字串的指標。

— 函式： wchar_t * wcsdup (const wchar_t *ws)

這函式複製具空字元結束的寬字元字串 ws 到新配置的字串，這個字串是使用 malloc配置的；見 Unconstrained Allocation，假如 malloc 不能配置新字串的空間， wcsdup 傳回一個空指標，否則它會傳回新的寬字元字串的指標。

這個函式是GNU擴充的。

— 函式： char * strndup (const char *s, size_t size)

這函式類似 strdup 但最多只能複製 size 個字元到新配置的字串。

假如 s 的長度大於 size，那麼 strndup 只會複製前面 size 個字元並新增一個結束的空值終止符，否則所有的字元會被覆製，字串會有終止符。

這函式不同於 strncpy 差別在於目的字串會有終止符。

strndup 是GNU擴充的。

— 函式： char * stpcpy (char *restrict to, const char *restrict from)

這函式像 strcpy，除了它是傳回字串 to 結尾的指標（也就是，to + strlen (from)及結束字元的位址）而不是最前面的位址。

例如，這個程式使用 stpcpy 來串接 ‘foo’ 跟 ‘bar’ 來產生‘foobar’，然後印出。

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

          int
          main (void)
          {
            char buffer[10];
            char *to = buffer;
            to = stpcpy (to, "foo");
            to = stpcpy (to, "bar");
            puts (buffer);
            return 0;
          }

這函式不是 ISO 或 POSIX 標準，而且在Unix系統上也不常用，但我們也沒有創造這個函式，或許它是來自 MS-DOG。

假如字串有重疊的話函式會變成未定義的，這個函式宣告在 string.h。

— 函式： wchar_t * wcpcpy (wchar_t *restrict wto, const wchar_t *restrict wfrom)

這函式像 wcscpy，除了它傳回字串 wto 結尾的指標（也就是， wto + strlen (wfrom)及結束自元的地址）而不是最前面的位址。

這函式不是 ISO 或 POSIX 標準，但在開發自己的GNU C 函式庫時候很有用。

假如字串有重疊的話 wcpcpy 會變成未定義的。

wcpcpy 是 GNU 擴充而且宣告在 wchar.h。

— 函式： char * stpncpy (char *restrict to, const char *restrict from, size_t size)

這函式跟 stpcpy 類似但是會複製 size 個字元到 to。

假如 from 長度大於 size，那麼 stpncpy 只會複製前面 size 個字元並傳回最後面複製的字元指標，注意在這種情況下不會有空值終止符寫入 to。

假如 from 長度小於 size，那麼 stpncpy 複製所有的 from，之後會填滿空字元直到 size 個字元，這很少用到，但是在使用 strncpy 的實作下是有用的， stpncpy 傳回第一個寫入的空字元指標。

這函式不是 ISO 或 POSIX 標準，但在開發自己的GNU C 函式庫時候很有用。

假如字串有重疊的話，這函式會變成未定義的，這函式宣告在 string.h。

— 函式： wchar_t * wcpncpy (wchar_t *restrict wto, const wchar_t *restrict wfrom, size_t size)

這函式類似 wcpcpy 但是只複製 wsize 個字元到 wto。

假如 wfrom 長度大於 size，那麼 wcpncpy 只會複製前面 size 個寬字元並傳回最後面複製的非空寬字元的指標，注意再這種情況下不會有空值終止符寫入 wto。

假如 wfrom 長度小於 size，那麼 wcpncpy 複製所有的 wfrom，之後會填滿空字元直到 size 個字元，這很少用到，但是在使用 wcsncpy 的實作下是有用的， wcpncpy 傳回第一個寫入的空字元指標。

這函式不是 ISO 或 POSIX 標準，但在開發自己的GNU C 函式庫時候很有用。

假如字串有重疊的話，這函式會變成未定義的。

wcpncpy 是 GNU 擴充且宣告在 wchar.h。

— 巨集： char * strdupa (const char *s)

這個巨集類似 strdup 但是會使用 alloca 而不是使用 malloc 來配置新字串（見 Variable Size Automatic）， 當然這意味著傳回的字串有跟使用 alloca配置記憶體區塊一樣的限制。

出於顯而易見的原因，strdupa 只是一個巨集的實作；你不能從這個函式取得位址，除了這個限制外，它是有用的函式，下面的程式碼顯示了使用 malloc 會是浪費的狀況。

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

          const char path[] = _PATH_STDPATH;

          int
          main (void)
          {
            char *wr_path = strdupa (path);
            char *cp = strtok (wr_path, ":");

            while (cp != NULL)
              {
                puts (cp);
                cp = strtok (NULL, ":");
              }
            return 0;
          }

請注意呼叫直接使用 path 來呼叫 strtok 是不正確的，它也不允許在 strtok 的引數列表中呼叫 strdupa ，因為 strdupa 使用alloca （見 Variable Size Automatic）會影響傳遞的參數。

這函式只在GNU CC使用時才能用。

— 巨集： char * strndupa (const char *s, size_t size)

這函式類似 strndup 但是像 strdupa 一樣，它使用 alloca 配置新的字串見 Variable Size Automatic，  strndupa 跟 strdupa 一樣有相同的好處跟限制。

這函式以巨集的方式實作，就像 strdupa 一樣， 就像 strdupa 一樣這個巨集也必須不能在函式呼叫中做為參數列表來使用。

strndupa 只在GNU CC使用時才能用。

— 函式： char * strcat (char *restrict to, const char *restrict from)

strcat 函式類似 strcpy，但是 from 的字元會加到 to的後面，而不會覆寫它，那就是， from 的第一個字元會覆寫 to 結尾的空字元。

跟 strcat 一樣的定義是：

          char *
          strcat (char *restrict to, const char *restrict from)
          {
            strcpy (to + strlen (to), from);
            return to;
          }

假如字串有重疊這函式會變成未定義的。

— 函式： wchar_t * wcscat (wchar_t *restrict wto, const wchar_t *restrict wfrom)

wcscat 函式類似 wcscpy，但是 wfrom 的字元會加到 wto的後面，而不會覆寫它，那就是， wfrom 的第一個字元會覆寫 wto結尾的空字元。

跟 wcscat 一樣的定義是：

          wchar_t *
          wcscat (wchar_t *wto, const wchar_t *wfrom)
          {
            wcscpy (wto + wcslen (wto), wfrom);
            return wto;
          }

假如字串有重疊這函式會變成未定義的。

— 函式： char * strncat (char *restrict to, const char *restrict from, size_t size)

這函式像 strcat 除了 from 不能超過 size 個字元附加到 to 的結尾，字串的空字元也會附加到 to，所以 to 全部配置的大小至少是 size + 1 位元組的長度會比原來的長度長。

strncat 函式會像這樣實作：

          char *
          strncat (char *to, const char *from, size_t size)
          {
            to[strlen (to) + size] = '0';
            strncpy (to + strlen (to), from, size);
            return to;
          }

假如字串有重疊 strncat 會變成未定義的。

— 函式： wchar_t * wcsncat (wchar_t *restrict wto, const wchar_t *restrict wfrom, size_t size)

這函式像 wcscat 除了 wfrom 不能超過 size 個字元附加到 wto 的結尾，字串的空字元也會附加到 wto，所以 wto 全部配置的大小至少是 size + 1 位元組的長度會比原來的長度長。

The wcsncat function could be implemented like this:

          wchar_t *
          wcsncat (wchar_t *restrict wto, const wchar_t *restrict wfrom,
                   size_t size)
          {
            wto[wcslen (to) + size] = L'0';
            wcsncpy (wto + wcslen (wto), wfrom, size);
            return wto;
          }

假如字串有重疊 wcsncat 會變成未定義的。

— 函式： void bcopy (const void *from, void *to, size_t size)

這是 memmove 的替代函式已經有些廢棄，源自 BSD，注意它不完全跟 memmove一樣，因為引數的順序不同，而且沒有傳回值。

— 函式： void bzero (void *block, size_t size)

這是 memset 的替代函式已經有些廢棄，源自 BSD，注意它也不跟 memset 一樣，因為它只能儲存的值是0。