C Standard Library string.h

What You’ll Learn

C has no built-in string type—text is a char array ending with '\0'. <string.h> supplies the standard toolkit: copy (strcpy), join (strcat), measure (strlen), compare (strcmp), and search (strstr). Master these and you can parse input, build messages, and work with files alongside <stdio.h>.

Definition and Usage

A C string is a sequence of characters stored in consecutive memory, terminated by a null character '\0' (byte value 0). Functions in string.h assume this layout—they read until they see '\0' unless a length limit applies (strncpy, strncat, strncmp).

The header also defines memory helpers—memcpy, memmove, memset, memcmp—that work on raw bytes, not necessarily null-terminated strings.

📝 Syntax

Include the header:

#include <string.h>

Common string functions

• strlen(s) — length of string (excludes '\0')
• strcpy(dest, src) — copy src into dest
• strncpy(dest, src, n) — copy at most n characters
• strcat(dest, src) — append src to end of dest
• strncat(dest, src, n) — append at most n characters
• strcmp(a, b) — lexicographic compare; 0 if equal
• strncmp(a, b, n) — compare at most n characters
• strchr(s, c) — find first occurrence of character c
• strstr(haystack, needle) — find first substring

Memory functions (also in string.h)

• memcpy(dest, src, n) — copy n bytes (non-overlapping)
• memmove(dest, src, n) — copy n bytes (overlapping OK)
• memset(dest, value, n) — fill n bytes with value
• memcmp(a, b, n) — compare n bytes

Typical patterns

size_t len = strlen(msg);

strncpy(dest, src, sizeof(dest) - 1);
dest[sizeof(dest) - 1] = '\0';

if (strcmp(a, b) == 0) { /* equal */ }

char *p = strstr(text, "error");
if (p != NULL) { /* found */ }

Headers and linking

• #include <string.h> — uses size_t from <stddef.h>.
• Linked automatically; no extra flags.
• See also C string function tutorials for per-function deep dives.

Examples Gallery

Compile with gcc file.c -std=c11 -o out. Buffers are sized generously so strcpy/strcat are safe in these demos.

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

int main(void) {
    char str1[32] = "Hello, ";
    char str2[] = "World!";
    char str3[32];

    strcpy(str3, str2);
    printf("str3: %s\n", str3);

    strcat(str1, str2);
    printf("str1: %s\n", str1);
    printf("Length of str1: %zu\n", strlen(str1));

    printf("strcmp(str2, str3): %d\n", strcmp(str2, str3));

    return 0;
}

str3: World!
str1: Hello, World!
Length of str1: 13
strcmp(str2, str3): 0

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

int main(void) {
    char dest[20];
    char source[] = "Hello, World!";

    strncpy(dest, source, 5);
    dest[5] = '\0';

    printf("First 5 chars: \"%s\"\n", dest);
    printf("Full source length: %zu\n", strlen(source));

    return 0;
}

First 5 chars: "Hello"
Full source length: 13

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

int main(void) {
    char a[] = "Hello";
    char b[] = "World";
    char c[] = "Help";

    printf("strcmp(\"Hello\", \"World\"): %d\n", strcmp(a, b));
    printf("strncmp(\"Hello\", \"Help\", 3): %d\n", strncmp(a, c, 3));

    if (strcmp(a, b) < 0) {
        printf("\"Hello\" comes before \"World\"\n");
    }

    return 0;
}

strcmp("Hello", "World"): -15
strncmp("Hello", "Help", 3): 0
"Hello" comes before "World"

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

int main(void) {
    char line[] = "Hello, World!";
    char *ch = strchr(line, 'W');
    char *sub = strstr(line, "World");

    if (ch != NULL) {
        printf("First 'W' at index %td: \"%s\"\n",
               ch - line, ch);
    }

    if (sub != NULL) {
        printf("Found \"World\" at index %td\n", sub - line);
    } else {
        printf("Substring not found\n");
    }

    return 0;
}

First 'W' at index 7: "World!"
Found "World" at index 7

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

int main(void) {
    char buf[16];

    memset(buf, 0, sizeof(buf));
    strcpy(buf, "Ada");

    printf("buf = \"%s\" (len %zu)\n", buf, strlen(buf));

    memset(buf, '-', 5);
    buf[5] = '\0';
    printf("buf = \"%s\"\n", buf);

    return 0;
}

buf = "Ada" (len 3)
buf = "-----"

🚀 Common Use Cases

• User input — trim, compare commands with strcmp.
• Building paths — strcat directory + filename (with size checks).
• Parsing logs — strstr to find keywords like "ERROR".
• Sorting names — pass strcmp to qsort from <stdlib.h>.
• Tokenizing — combine strchr with loops (or strtok carefully).
• Binary data — memcpy/memcmp for structs and buffers.

📝 Notes

• String literals are read-only—do not strcpy into them.
• strncpy may pad with zeros if source is shorter than n—surprising but standard.
• strtok modifies the string and is not re-entrant—avoid in threaded code.
• Do not pass overlapping buffers to strcpy/strcat—use memmove.
• strlen is O(n)—cache length if you need it repeatedly in a loop.
• Comparing with == checks pointer equality, not string content.

⚡ Optimization

Standard library string functions are highly tuned. Avoid hand-rolled loops unless profiling proves a bottleneck. Reduce repeated strlen calls, prefer single-pass parsing, and use memcmp for fixed-length binary keys. For many small strings, consider storing length alongside data (common in custom string types).

💡 Best Practices