• Functions whose names begin with mem manipulate sequences of arbitrary characters. One argument (s) points to the start of the string — the lowest subscripted element. Another (n) counts the number of elements.
• Functions whose names begin with strn manipulate sequences of non-null characters. The arguments s and n are the same as above. The string ends just before the element s[n] or with the lowest value of i for which s[i] is zero ('\0'), whichever defines a shorter sequence.
• All other functions whose names begin with str manipulate null-terminated sequences of characters. These functions use only the argument s to determine the start of the string. Each group has its distinct uses, as you might expect.

• Many of the functions that search, return a null pointer when the search fails. You have to capture the return value and test it before you can safely use it further. A pointer to the end of the string is just as good a failure code and much more usable in expressions.
• The functions that copy, return a pointer to the start of the destination area. That is sometimes useful in a larger expression, but the address of the end of the copy is more informative. You can perform multiple copies more effectively with the latter return value than with the former.
• The names of some functions are mysterious. strcspn and strpbrk, for example, do not loudly proclaim what they do.
• The set of functions is incomplete and inconsistent. strnlen and memrchr are two sensible additions, for example, whereas strncat is surprising.

The header <string.h> contains quite a few functions. I will be describing them in several installments. The first group consists mostly of the simple functions that copy and concatenate strings, plus a few miscellaneous additions.

   #include <string.h>
   void *memcpy(void *s1, const void *s2, size_t n);

   #include <string.h>
   void *memmove(void *s1, const void *s2, size_t n);

   #include <string.h>
   char *strcpy(char *s1, const char *s2);

   #include <string.h>
   char *strncpy(char *s1, const char *s2, size_t n);

If the array pointed to by s2 is a string that is shorter than n characters, null characters are appended to the copy in the array pointed to by s1, until n characters in all have been written.

   #include <string.h>
   char *strcat(char *s1, const char *s2);

   #include <string.h>
   char *strncat(char *s1, const char *s2, size_t n);

Forward references: the strlen function (7.11.6.3).

Footnotes

133. See "future library directions" (7.13.8).

134. Thus, if there is no null character in the first n characters of the array pointed to by s2, the result will not be

null-terminated.

135. Thus, the maximum number of characters that can end up in the array pointed to by s1 is strlen.(s1)+n+1.

Here is the second quote from the C Standard:

   #include <string.h>
   void *memset(void *s, int c, size_t n);

   #include <string.h>
   char *strerror(int errnum);

The implementation shall behave as if no library function calls the strerror function.

   #include <string.h>
   size_t strlen(const char *s);

• If a string can contain null characters, you must also specify its length (call it n) as an additional argument. n can be zero. Use the functions whose names begin with mem.
• If a string may or may not have a terminating null character, you must similarly specify its maximum length n, which can be zero. Use the functions whose names begin with strn.
• If a string assuredly has a terminating null character, you specify only s. Use the remaining functions whose names begin with str.

memcpy — If you can be certain that the destination s1 and source s2 do not overlap, memcpy(s1, s2, n) will perform the copy safely and rapidly. If the two might overlap, use mem-move(s1, s2, n) instead. Do not assume that either function accesses storage in any particular order. In particular, if you want to store the same value throughout a contiguous sequence of elements in a character array, use memset.

memmove — See memcpy above.

strcat — If you have only two strings s1 and s2 to concatenate, or just a few short strings, use strcat(s1, s2). Otherwise, favor a form such as strcpy(s1 += strlen(s1), s2). That saves repeated, and ever-lengthening, rescans of the initial part of the string. Be sure that the destination array is large enough to hold the concatenated string. Note that strcat returns s1, not a pointer to the new end of the string.

memset — This is the safe way to store the same value throughout a contiguous sequence of elements in a character array.

strcpy — If you can be certain that the destination s1 and source s2 do not overlap, strcpy(s1, s2) will perform the copy safely and rapidly. If the two might overlap, use memmove(s1, s2, strlen(s2) + 1) instead. Do not assume that either function accesses storage in any particular order.

strerror — Use strerror(errcode) to determine the null-terminated message string that corresponds to the error code errcode. errcode should be errno or one of the macros defined in <errno.h> whose name begins with E. Be sure to copy or write out the message before you call strerror again. A later call can alter the message. If you simply want to write to the standard error stream a message containing strerror(errno), see perror, declared in <stdio.h>.

strlen — Use this function wherever possible to determine the length of a null-terminated string. It may well be implemented with inline code.

strncat — The strn in strncat(s1, s2, n2) refers to the string s2 the the function concatenates onto the end of the null-terminated string s1. The function copies at most n2 characters plus a terminating null if it doesn't copy a terminating null. Thus, strlen(s1) increases by at most n2 as a result of the call to strncat. That makes strncat a safer function than strcat, at the risk of truncating s2 to length n2.

strncpy — If you can be certain that the destination s1 and source s2 do not overlap, strncpy(s1, s2, n2) will perform the copy safely. Note, however, that the function stores exactly n2 characters starting at s1. It may drop trailing characters, including the terminating null. It stores additional null characters as needed to make up a short count. If the two areas might overlap, use memmove(s1, s2, n2) instead. (You must then store the appropriate number of null characters at the end, if that is important to you.) Do not assume that either function accesses storage in any particular order.