Strings and Character Handling

1The convention

A C string is a sequence of characters followed by '\0', the character with value zero. Nothing records the length; every function that needs it scans forward until it finds the terminator.

char greeting[6] = { 'h', 'e', 'l', 'l', 'o', '\0' };
char greeting[]  = "hello";     /* identical — the compiler adds '\0' */

Two consequences follow immediately, and both cost real money every year.

Length is O(n), not O(1). strlen walks the whole string. Calling it in a loop condition — for (i = 0; i < strlen(s); i++) — makes an O(n) loop into an O(n²) one. Compute it once.

Every buffer needs one extra byte. A buffer for ten characters must be char buf[11]. Off-by-one here is not a wrong answer; it is memory corruption.

2Literals are read-only

char  array[]  = "hello";    /* a modifiable copy in the array   */
char *pointer  = "hello";    /* a pointer to read-only storage   */

array[0]   = 'H';            /* fine                              */
pointer[0] = 'H';            /* undefined behavior — usually crash */

The distinction is not stylistic. The first line creates a six-byte array on the stack and copies the literal into it. The second stores the address of the literal, which lives in a read-only section of the executable — the .rodata section that week 52 inspects directly. Writing there fails at the hardware level.

Always declare a pointer to a literal as const, so the compiler catches the mistake rather than the operating system:

const char *pointer = "hello";
pointer[0] = 'H';            /* now a compile error */

C23 finally made string literals const-qualified by default. Until a codebase is on C23, writing it yourself is the only protection.

3The <string.h> functions

strcmp returns 0 for equal

if (strcmp(a, b) == 0) { /* the strings are equal */ }
if (strcmp(a, b))       { /* the strings DIFFER   */ }

The second reads like "if a equals b" and means the opposite. Always compare explicitly against 0.

strncpy is not the safe strcpy

It looks like a bounded copy and is widely used as one. It is not. If the source is at least n bytes, no terminator is written, and you are left with an unterminated character array that the next strlen will run off the end of.

char dst[5];
strncpy(dst, "hello world", 5);   /* dst = "hello" with NO terminator */
printf("%s\n", dst);              /* reads past the end */

It also pads with zeros to the full length when the source is shorter, which is wasted work on a large buffer. It was designed in the 1970s for fixed-width database fields, not for safety. Use snprintf instead:

snprintf(dst, sizeof dst, "%s", source);   /* always terminates */

strtok modifies its input

char text[] = "a,b,c";            /* must be modifiable — not a literal */
char *token = strtok(text, ",");
while (token != NULL) {
    puts(token);
    token = strtok(NULL, ",");    /* NULL means "continue the same string" */
}
/* text is now "a\0b\0c" */

It writes terminators into your buffer and remembers its position in a hidden static variable, which makes it unusable from two places at once and unsafe with threads. Week 41 returns to this under reentrancy; the thread-safe variant is strtok_r.

4Block memory operations

These work on raw bytes and know nothing about terminators, so they need an explicit length. They are also the right tool for any array, not just characters.

memcpy(dst, src, n);    /* copy n bytes; regions must not overlap */
memmove(dst, src, n);   /* copy n bytes; overlap is handled        */
memset(buf, 0, n);      /* fill n bytes with a value               */
memcmp(a, b, n);        /* compare n bytes; 0 means equal          */

Why both memcpy and memmove

memcpy promises the regions do not overlap, which lets it copy in whatever order is fastest — several bytes at a time, possibly backwards. Give it overlapping regions and the result is undefined: it may copy a byte it has already overwritten.

char buf[] = "abcdef";
memcpy(buf + 1, buf, 5);    /* UNDEFINED: regions overlap  */
memmove(buf + 1, buf, 5);   /* correct: "aabcde"           */

memmove checks the direction and copies accordingly. It is marginally slower and always correct. When in doubt, use it.

memset sets bytes, which is why it is only useful for 0 and for single-byte values. memset(arr, 1, sizeof arr) on an int array does not fill it with ones; it fills every byte with 1, giving elements of 0x01010101.

5<ctype.h> and safe construction

#include <ctype.h>

isalpha(c)  isdigit(c)  isalnum(c)  isspace(c)
isupper(c)  islower(c)  ispunct(c)
toupper(c)  tolower(c)

One subtlety with a real consequence: these take an int whose value must be representable as unsigned char, or be EOF. Passing a plain char that is negative — which happens with byte values above 127 where char is signed, as week 4 noted — is undefined behavior. Cast:

if (isalpha((unsigned char)s[i])) { … }

Building strings safely

snprintf is the workhorse. It writes at most size bytes including the terminator, always terminates, and returns the length it would have written — which is how you detect truncation.

char line[32];
int needed = snprintf(line, sizeof line, "%s: %d", name, score);

if (needed < 0) {
    /* encoding error */
} else if ((size_t)needed >= sizeof line) {
    /* truncated: needed bytes were required */
}

That return value is the part people miss. A program that ignores it silently produces truncated output, which in a filename or a command is a security problem rather than a cosmetic one.

6Worked example: a string toolkit, by hand and by library

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

/* --- written by hand, to show what the library does --- */

static size_t my_strlen(const char *s)
{
    const char *start = s;
    while (*s != '\0') {
        s++;
    }
    return (size_t)(s - start);      /* pointer subtraction: week 15 */
}

static void my_strcpy(char *dst, const char *src)
{
    while ((*dst++ = *src++) != '\0') {
        /* copies, including the terminator, then stops */
    }
}

static int my_strcmp(const char *a, const char *b)
{
    while (*a != '\0' && *a == *b) {
        a++;
        b++;
    }
    return (unsigned char)*a - (unsigned char)*b;
}

/* --- a safe copy, which the library does not provide --- */

static bool copy_into(char *dst, size_t dst_size, const char *src)
{
    int needed = snprintf(dst, dst_size, "%s", src);
    return needed >= 0 && (size_t)needed < dst_size;
}

static void to_upper_in_place(char *s)
{
    for (; *s != '\0'; s++) {
        *s = (char)toupper((unsigned char)*s);
    }
}

static size_t count_words(const char *s)
{
    size_t words = 0;
    bool in_word = false;
    for (; *s != '\0'; s++) {
        if (isspace((unsigned char)*s)) {
            in_word = false;
        } else if (!in_word) {
            in_word = true;
            words++;
        }
    }
    return words;
}

int main(void)
{
    const char *sample = "the quick brown fox";

    puts("== hand-written versus library ==");
    printf("  my_strlen  = %zu   strlen  = %zu\n",
           my_strlen(sample), strlen(sample));

    char a[32], b[32];
    my_strcpy(a, sample);
    strcpy(b, sample);
    printf("  my_strcpy  = \"%s\"\n", a);
    printf("  strcpy     = \"%s\"\n", b);

    printf("  my_strcmp(\"abc\",\"abd\") = %d   strcmp = %d\n",
           my_strcmp("abc", "abd"), strcmp("abc", "abd"));
    printf("  equal strings give 0: %d\n", strcmp("same", "same"));

    puts("\n== strlen versus sizeof ==");
    char buffer[32] = "hello";
    printf("  strlen(buffer) = %zu   sizeof buffer = %zu\n",
           strlen(buffer), sizeof buffer);
    puts("  the difference is room for growth plus the terminator");

    puts("\n== truncation, detected ==");
    char small[8];
    if (copy_into(small, sizeof small, "short")) {
        printf("  \"short\" fitted: \"%s\"\n", small);
    }
    if (!copy_into(small, sizeof small, "a much longer string")) {
        printf("  long string truncated to \"%s\" — and we know it\n", small);
    }

    puts("\n== strncpy does not always terminate ==");
    char danger[6];
    memset(danger, 'X', sizeof danger);      /* poison, to make it visible */
    strncpy(danger, "hello world", 5);
    printf("  first five bytes: %.5s\n", danger);
    printf("  byte 5 is '%c' (%d) — not a terminator\n",
           danger[5], danger[5]);
    puts("  printing this with %s would read past the end");

    puts("\n== memmove versus memcpy ==");
    char overlap[] = "abcdef";
    memmove(overlap + 1, overlap, 5);
    printf("  memmove overlapping: %s\n", overlap);
    puts("  memcpy on the same input is undefined behavior");

    puts("\n== tokenizing modifies the buffer ==");
    char csv[] = "red,green,blue";
    printf("  before: %s\n", csv);
    for (char *tok = strtok(csv, ","); tok != NULL; tok = strtok(NULL, ",")) {
        printf("    token: %s\n", tok);
    }
    printf("  after:  %s   <-- only the first token; commas became '\\0'\n", csv);

    puts("\n== character classification ==");
    char text[32];
    strcpy(text, sample);
    printf("  words in \"%s\" = %zu\n", text, count_words(text));
    to_upper_in_place(text);
    printf("  upper-cased: %s\n", text);

    return EXIT_SUCCESS;
}

gcc -std=c17 -Wall -Wextra -g -fsanitize=address -o strings strings.c
./strings

The crash worth causing

Add these two lines and run it:

char *literal = "hello";      /* no const — the compiler allows it */
literal[0] = 'H';             /* undefined behavior */

Segmentation fault (core dumped)

Now add const and rebuild:

const char *literal = "hello";
literal[0] = 'H';

error: assignment of read-only location '*literal'

The same defect, moved from a run-time crash to a compile-time error by one keyword. That is the entire argument for const correctness, which week 16 develops into a discipline.

The overflow worth causing

char tiny[4];
strcpy(tiny, "far too long");   /* no bound checking anywhere */

Without the sanitizer this may appear to work, corrupting a neighbouring variable exactly as week 12's array overflow did. With -fsanitize=address:

==12345==ERROR: AddressSanitizer: stack-buffer-overflow
WRITE of size 13 at 0x7ffd... thread T0
    #0 0x... in main strings.c:118

This is the defect class that produced the Morris worm in 1988 and has not stopped since. Week 36 examines why it is so exploitable.

7Common mistakes

9Where this leads

That is the Basic level complete. You can build, format, version, and reason about a C program; you know how values are represented, how types convert, how control flows, and how pointers and strings work. Week 15 opens the Intermediate level by developing pointer arithmetic properly — the s - start in my_strlen above was a preview — and weeks 19 and 20 then apply it to memory you allocate yourself.