C-Style Strings: A Refresher

In CS 70 (and perhaps CS 105), you learned about C-style strings, but it's always good to have a refresher. In this guide, we'll revisit the basics of C-style strings, their memory representation, common operations, and best practices. Understanding C-style strings is essential for systems programming, including OS development.

How Does C Handle Strings?

In C, a string is just an area of memory that holds a sequence of characters. Here are two declarations of C strings:

char greeting[] = "Hello, world!";
const char* magic_word = "Xyzzy";

Whether we use the array syntax or declare a pointer to a string literal, the result is the same: a sequence of characters in memory.

To know where the string ends, we use a special character called the NUL terminator (written as '\0', and just a zero byte in memory). So in memory, our greeting string looks like

Although there are some downsides to C's choice, it's arguably simpler to just have an array of characters rather than an array of characters and a length field. And this approach does allow some tricks. For example, we can turn greeting into two separate strings:

greeting[5] = '\0';         // Overwrite the comma with a NUL terminator
char* hello = greeting;     // Points to "Hello"
char* world = greeting + 7; // Points to "world!"

In a memory-constrained environment, this trick can be useful for saving space by not copying the string, but instead just transforming it in place.

Common Operations and string.h

The string.h header provides essential functions for C-style string manipulation:

Example usage:

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

#define LITTLE_BUFFER_SIZE 50

int
main() {
        char str1[LITTLE_BUFFER_SIZE] = "Operating";    // Writeable buffer
        const char *str2 = "Super Systems";             // Fixed literal
        char str3[LITTLE_BUFFER_SIZE];
        char *str4;
        const char *cp;

        printf("Length of str1: %zu\n", strlen(str1));
        cp = strstr(str2, " S");                        // Find some substring

        strcat(str1, cp);
        printf("Concatenated string: %s\n", str1);

        strcpy(str3, str1);
        str3[5] = '\0';  // Shorten the string
        printf("First 5 characters: %s\n", str3);

        str4 = strdup(str3);    // Make a duplicate of str3 on the heap
        printf("Duplicated string: %s\n", str4);
        free(str4);             // Free the heap memory

        return 0;
}

• Try in OnlineGDB

Here's a safer version of strcpy where we specify the end of the buffer:

/* safer_strcpy(dest, dest_end, src): copy a string into a buffer
 *   dest: destination buffer
 *   dest_end: past-the-end (should be dest + buffer size)
 *   src: source string
 *
 * - returns the address of the null terminator on success (supports chaining)
 * - returns NULL if the buffer is too small
 *
 * Note: In safe code, you need to *check* the return value!
 */
char *
safer_strcpy(char *dest, char *dest_end, const char *src)
{
        char c;

        do {
                if (dest >= dest_end) {     // Out of space? Bail out
                        return NULL;
                }
                c = *src++;                 // Copy a character
                *dest++ = c;
        } while (c != '\0');                // Done when we copied NUL
        return --dest;                      // Back up to be on the NUL
}

• Try in OnlineGDB
  • Try changing LITTLE_BUFFER_SIZE to 10 to see what happens when the buffer is too small.

As we can see here, one nice thing about the simplicity of C strings is that if the C library doesn't provide the helper function you need, you can write it yourself pretty easily.

Comparison with C++ std::string

While std::string offers convenience and safety, C-style strings are still crucial in systems programming. Here's a quick comparison:

Best Practices and Pitfalls

1. Always ensure strings are NUL-terminated.
2. Avoid code that could cause a buffer overflow (either avoid fixed-size buffers or be sure to check buffer sizes somehow).
3. Check return values of string functions for error handling.
4. Be cautious with user input to avoid buffer overflow vulnerabilities.
5. Remember that string literals are immutable.

(When logged in, completion status appears here.)