Strings

• We have discussed arrays previously, but we have not discussed them in depth in the context of character arrays. These character arrays are referred to as strings. Again, strings are not directly supported in C. Let's try that again, there is no direct string support in C.
• So how do we emulate strings in C? By correctly creating string constants or properly allocating space for a character array we can get some string action in C.

Strings :: Declaration and Syntax

• Let's see some examples of string declarations:

    char str[5] = {'l', 'i', 'n', 'u', 'x'};
    char str[6] = {'l', 'i', 'n', 'u', 'x', '\0'};
    char str[3];
    char str[ ] = "linux";
    char str[5] = "linux";
    char str[9] = "linux";
  

  All of the above declarations are legal. But which ones don't work? The first one is a valid declaration, but will cause major problems because it is not null-terminated. The second example shows a correct null-terminated string. The special escape character \0 denotes string termination. The fifth example also suffers the same problem. The fourth example, however does not. This is because the compiler will determine the length of the string and automatically initialize the last character to a null-terminator.

Strings :: Dynamic Memory Allocation

• This stuff is much the same as the previous section. You must be careful to allocate one additonal space to contain the null-terminator.
• For example:

    char *s;
  
    if ((s = malloc(sizeof(char) * 5)) == NULL) {
      /* ERROR Handling code */
    }
    strcpy(s, "linux");
    printf("%s\n", s);
  

  This would result in a bunch of junk being printed to the screen. printf will try to print the string, but will continue to print past the allocated memory for s, because there is no null-terminator. The simple solution would be to add 1 to the malloc call.
• You must be particularly careful when using malloc or realloc in combination with strlen. strlen returns the size of a string minus the null-terminator. More on strlen on the next sub-section.
• A final note: What's wrong with the following code:

    char s1[ ] = "linux";
    char *s2;
  
    strcpy(s2, s1);
  

  Remember that simply declaring a pointer does not create any space for the pointer to point to (remember that?).

Strings :: string.h Library

• You can add support for string operations via the string.h library. (Note: If you understand everything that has gone on by now, you should be able to code most of the functions in string.h!)
• Below is a listing of prototypes for commonly used functions in string.h:

    size_t strlen(const char *s);
    char *strdup(const char *s);
    char *strcpy(char *dest, const char *src);
    char *strncpy(char *dest, const char *src, size_t n);
    char *strcat(char *dest, const char *src);
    char *strncat(char *dest, const char *src, size_t n);
    int strcmp(const char *s1, const char *s2);
    int strncmp(const char *s1, const char *s2, size_t n);
    int atoi(const char *nptr);
    double atof(const char *nptr);
  

  See Weiss pg. 486 (Appendix D.14) for a full string.h listing. Weiss Appendix D is your friend. Use it!

Strings Review

• Strings are just character arrays. Nothing more, nothing less.
• Strings must be null-terminated if you want to properly use them.
• Remember to take into account null-terminators when using dynamic memory allocation.
• The string.h library has many useful functions.
• Most of the I/O involved with strings was covered in the Input/Output and File I/O section. If you still don't grasp strings, read Weiss Chapter 8.

© 1999-2008 Alfred Park (fred AT randu.org)