8.4. Strings

A string is a continuous sequence of characters terminated by '\0', the null character. The length of a string is considered to be the number of characters excluding the terminating null character. There is no string type in C, and consequently there are no operators that accept strings as operands.

Instead, strings are stored in arrays whose elements have the type char or wchar_t. Strings of wide charactersthat is, characters of the type wchar_tare also called wide strings . The C standard library provides numerous functions to perform basic operations on strings, such as comparing, copying, and concatenating them (see the section "String Processing" in Chapter 16).

You can initialize arrays of char or wchar_t using string literals. For example, the following two array definitions are equivalent:

char str1[30] = "Let's go";       // String length: 8; array length: 30.

char str1[30] = { 'L', 'e', 't', '\'', 's',' ', 'g', 'o', '\0' };

An array holding a string must always be at least one element longer than the string length to accommodate the terminating null character. Thus the array str1 can store strings up to a maximum length of 29. It would be a mistake to define the array with length 8 rather than 30, because then it wouldn't contain the terminating null character.

If you define a character array without an explicit length and initialize it with a string literal, the array created is one element longer than the string length. An example:

char str2[ ] = " to London!";      // String length: 11 (note leading space);
                                  // array length: 12.

The following statement uses the standard function strcat( ) to append the string in str2 to the string in str1. The array str1 must be large enough to hold all the characters in the concatenated string.

#include <string.h>

char str1[30] = "Let's go";
char str2[ ] = " to London!";

/* ... */

strcat( str1, str2 );
puts( str1 );

The output printed by the puts( ) call is the new content of the array str1:

Let's go to London!

The names str1 and str2 are pointers to the first character of the string stored in each array. Such a pointer is called a pointer to a string, or a string pointer for short. String manipulation functions such as strcat( ) and puts( ) receive the beginning addresses of strings as their arguments. Such functions generally process a string character by character until they reach the terminator, '\0'. The function in Example 8-1 is one possible implementation of the standard function strcat( ). It uses pointers to step through the strings referenced by its arguments.

Example 8-1. Function strcat( )

// The function strcat( ) appends a copy of the second string
// to the end of the first string.
// Arguments:    Pointers to the two strings.
// Return value: A pointer to the first string, now concatenated with the second.

char *strcat( char * restrict s1, const char * restrict s2 )
{
  char *rtnPtr = s1;
  while ( *s1 != '\0' )                // Find the end of string s1.
    ++s1;
  while (( *s1++ = *s2++ ) != '\0' )   // The first character from s2 replaces
    ;                                  // the terminator of s1.
  return rtnPtr;
}

The char array beginning at the address s1 must be at least as long as the sum of both the two strings' lengths, plus one for the terminating null character. To test for this condition before calling strcat( ), you might use the standard function strlen( ), which returns the length of the string referenced by its argument:

if ( sizeof(str1) >= ( strlen( str1 ) + strlen( str2 ) + 1 )
  strcat( str1, str2 );

A wide string literal is identified by the prefix L (see the section "String Literals" in Chapter 3). Accordingly, the initialization of a wchar_t array looks like this:

#include <stddef.h>                // Definition of the type wchar_t.
/* ... */
wchar_t dinner[ ] = L"chop suey";   // String length: 10;
                                   // array length: 11;
                                   // array size: 11 * sizeof(wchar_t)