Strings in C

C has no dedicated built-in string data type. Instead, a 'string' in C is simply a sequence of characters stored in a char array, terminated by a special sentinel character called the null character, '\0' (numeric value 0). This null terminator marks the end of the string's content and tells string-handling functions where to stop reading, since the array itself may be larger than the text it holds.

Because strings are just char arrays under the hood, they inherit all the rules of arrays covered previously — contiguous memory, zero-based indexing, and (crucially) no automatic bounds checking. Almost all standard string manipulation in C is done through functions declared in the <string.h> header, such as strlen, strcpy, strcat, and strcmp.

A C string's length as reported by strlen() counts only the visible characters, not the null terminator itself. However, the storage allocated for the string must always be at least strlen(s) + 1 bytes to make room for that terminating '\0'. Forgetting to account for this extra byte is one of the most frequent sources of bugs in C string handling.

There is an important distinction between char str[] = "Hello"; and const char *ptr = "Hello";. In the first form, "Hello" is used to initialize a mutable array; the characters are copied into str's own stack (or static) storage, and individual characters can be modified afterward (str[0] = 'J'; is legal). In the second form, ptr points directly at a string literal, which the compiler typically places in read-only memory; attempting to modify *ptr (e.g. ptr[0] = 'J';) is undefined behavior and often crashes with a segmentation fault on common platforms. As a best practice, string literals accessed through a pointer should always be declared const char * to make this immutability explicit and let the compiler catch accidental writes.

The <string.h> header provides the core toolkit for C string manipulation. strlen(const char *s) scans forward from s until it finds '\0' and returns the count of characters before it (an unsigned size_t, not including the terminator). strcpy(char *dest, const char *src) copies characters from src into dest, including the terminating null byte, and assumes dest has enough space — it performs no bounds checking whatsoever. strcat(char *dest, const char *src) appends src onto the end of dest (locating the end of dest via its existing null terminator) and again assumes sufficient space in dest. strcmp(const char *s1, const char *s2) performs a lexicographic (dictionary-order) comparison and returns 0 if the strings are equal, a negative value if s1 sorts before s2, and a positive value if s1 sorts after s2.

strcpy and strcat are notoriously unsafe because they copy or append data with no awareness of the destination buffer's actual capacity. If src is longer than the space available in dest, these functions will happily write past the end of the destination array — a classic buffer overflow. This is undefined behavior that can corrupt adjacent stack variables, overwrite a function's saved return address, and has historically been one of the most exploited categories of security vulnerabilities in C programs (e.g., stack-smashing attacks).

A safer alternative is strncpy(char *dest, const char *src, size_t n), which copies at most n characters from src into dest, preventing the function itself from writing past n bytes. However, strncpy has its own gotcha: if src is longer than or equal to n characters, strncpy does NOT null-terminate dest — you must manually ensure termination, typically by setting dest[n-1] = '\0' after the call. Similarly, strncat(dest, src, n) limits how many characters are appended from src (though the total dest buffer must still be large enough, since strncat does properly null-terminate the result). Modern code should always know the destination buffer size and pass it explicitly to these bounded variants.