String Functions in C: strlen, strcpy, strcat, strcmp, and More

Every function in <string.h> is a small loop over a char array that stops at the null terminator. Once that is clear, the library stops looking like a list of cryptic names and starts looking like the handful of loops you would have written yourself. This page covers the ones that carry almost all real work - and the sizing rules that keep them from writing past the end of your buffers.

Everything here needs one include:

#include <string.h>

strlen: How Many Characters

strlen counts bytes up to but not including the terminator. It returns size_t, so print it with %zu.

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

int main(void) {
    char word[32] = "banana";

    printf("strlen = %zu\n", strlen(word));
    printf("sizeof = %zu\n", sizeof word);
    return 0;
}

strlen is 6; sizeof is 32. The first is the text, the second is the storage - see strings for why that distinction matters so much.

strlen walks the whole string each call, so do not put it in a loop condition over the same unchanging string:

/* re-counts the whole string on every iteration */
for (size_t i = 0; i < strlen(s); i++) { ... }

/* count once */
size_t n = strlen(s);
for (size_t i = 0; i < n; i++) { ... }

strcpy and strncpy: Copying

strcpy(dst, src) copies the characters plus the terminator. It has no idea how large dst is, so the caller must guarantee dst holds at least strlen(src) + 1 bytes.

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

int main(void) {
    char src[] = "portable";
    char dst[16];

    strcpy(dst, src);
    printf("%s\n", dst);

    /* the sizing rule, checked explicitly */
    if (strlen(src) + 1 <= sizeof dst) {
        printf("fits with %zu bytes to spare\n", sizeof dst - strlen(src) - 1);
    }
    return 0;
}

strncpy takes a maximum count, but it has a famous trap: when the source is at least n bytes long it copies exactly n characters and no terminator. Always terminate yourself:

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

int main(void) {
    char src[] = "a very long project name";
    char dst[10];

    strncpy(dst, src, sizeof dst - 1);
    dst[sizeof dst - 1] = '\0';        /* required, not optional */

    printf("[%s]\n", dst);
    return 0;
}

The sizeof dst - 1 plus explicit terminator is the pattern to memorize. (strncpy also pads short sources with zeros out to n bytes, which is wasted work for large buffers - it was designed for fixed-width records, not for safety.)

strcat and strncat: Joining

strcat(dst, src) appends src to the end of whatever is already in dst. The destination must hold both strings plus one terminator, and it must already contain a valid string - appending to uninitialized memory is undefined behavior.

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

int main(void) {
    char path[64] = "/home/ada";

    strcat(path, "/");
    strcat(path, "notes.txt");

    printf("%s\n", path);
    printf("used %zu of %zu bytes\n", strlen(path) + 1, sizeof path);
    return 0;
}

Note char path[64] = "/home/ada"; rather than char path[64]; - the initializer is what makes it a valid string for the first strcat.

strncat(dst, src, n) appends at most n characters and always adds a terminator, so n is the space remaining, not the total buffer size:

strncat(dst, src, sizeof dst - strlen(dst) - 1);

Repeated strcat calls re-scan the destination to find its end every time. Building a long string in a loop that way is quadratic; for anything sizeable, track your own write position or use snprintf, covered in string conversion.

strcmp: Comparing

== compares addresses, so it is false for two distinct arrays holding the same text. strcmp compares the characters and returns the sign of the difference.

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

int main(void) {
    char a[] = "apple";
    char b[] = "apple";
    char c[] = "banana";

    const char *pa = a;
    const char *pb = b;
    printf("pa == pb (addresses)? %s\n", pa == pb ? "yes" : "no");
    printf("strcmp(a, b) == 0?  %s\n", strcmp(a, b) == 0 ? "yes" : "no");

    printf("strcmp(a, c) sign: %s\n", strcmp(a, c) < 0 ? "a before c" : "a after c");
    return 0;
}

Three rules:

• Test strcmp(a, b) == 0 for equality. Writing if (strcmp(a, b)) means "if they differ", which reads backwards to almost everyone.
• Only the sign is defined. Do not compare the result against 1 or -1.
• The ordering is by byte value, so "Zebra" sorts before "apple" in ASCII. For case-insensitive comparison, lowercase both copies first - the widely seen strcasecmp is a POSIX extension, not standard C.

strncmp(a, b, n) compares only the first n characters, which is the clean way to test a prefix:

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

int main(void) {
    const char *url = "https://coddy.tech";

    if (strncmp(url, "https://", 8) == 0) {
        printf("secure URL\n");
    }
    return 0;
}

strchr and strstr: Searching

strchr(s, ch) finds the first occurrence of a character; strrchr finds the last. strstr(haystack, needle) finds a substring. All three return a pointer into the original string, or NULL when there is no match.

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

int main(void) {
    char email[] = "ada@coddy.tech";

    char *at = strchr(email, '@');
    if (at != NULL) {
        printf("'@' at index %td\n", at - email);
        printf("domain: %s\n", at + 1);
    }

    char *dot = strrchr(email, '.');
    printf("extension: %s\n", dot != NULL ? dot + 1 : "(none)");

    if (strstr(email, "coddy") != NULL) {
        printf("contains \"coddy\"\n");
    }
    return 0;
}

Subtracting the returned pointer from the start gives the index; its type is ptrdiff_t, printed with %td. Because the result points inside the original array, at + 1 is the rest of the string with no copying at all - a very common C idiom.

Always check for NULL before dereferencing. strchr(email, '@') + 1 on a string with no @ computes an address from NULL and the program is no longer defined.

Splitting a String

There is no split function, but strchr plus a terminator does the job in place. This example cuts an email into user and domain:

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

int main(void) {
    char input[] = "ada@coddy.tech";
    char user[32];
    char domain[64];

    char *at = strchr(input, '@');
    if (at == NULL) {
        printf("not an email address\n");
        return 1;
    }

    size_t user_len = (size_t)(at - input);
    if (user_len >= sizeof user) {
        printf("user part too long\n");
        return 1;
    }

    memcpy(user, input, user_len);
    user[user_len] = '\0';

    strncpy(domain, at + 1, sizeof domain - 1);
    domain[sizeof domain - 1] = '\0';

    printf("user:   %s\n", user);
    printf("domain: %s\n", domain);
    return 0;
}

memcpy copies an exact byte count without caring about terminators, which is what you want when you already know the length. The terminator is then written by hand.

A Worked Example: Normalizing a Name

Putting the tour together - trim, compare, copy, and join:

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

int main(void) {
    char first[32] = "  ada  ";
    char last[32]  = "lovelace";
    char full[80];

    /* skip leading spaces */
    char *start = first;
    while (*start == ' ') {
        start++;
    }

    /* cut trailing spaces */
    size_t len = strlen(start);
    while (len > 0 && start[len - 1] == ' ') {
        start[--len] = '\0';
    }

    /* capitalize the first letter of each part */
    start[0] = (char)toupper((unsigned char)start[0]);
    last[0]  = (char)toupper((unsigned char)last[0]);

    /* join with a bounded copy */
    strncpy(full, start, sizeof full - 1);
    full[sizeof full - 1] = '\0';
    strncat(full, " ", sizeof full - strlen(full) - 1);
    strncat(full, last, sizeof full - strlen(full) - 1);

    printf("[%s]\n", full);
    printf("is it Ada Lovelace? %s\n",
           strcmp(full, "Ada Lovelace") == 0 ? "yes" : "no");
    return 0;
}

Every write is bounded by the destination's own sizeof, and every strncpy is followed by an explicit terminator. That discipline, applied consistently, is what makes C string code safe.

Sizing Rules to Keep

• strcpy needs strlen(src) + 1 bytes free in the destination.
• strcat needs strlen(dst) + strlen(src) + 1.
• After strncpy, write dst[n - 1] = '\0' yourself.
• For strncat, the count is the space left over: sizeof dst - strlen(dst) - 1.
• Check strchr and strstr for NULL before using the result.
• Use sizeof dst only when dst is a real array. Inside a function taking char *dst, sizeof gives the pointer's size - pass the buffer length as a separate parameter.