C Strings

What You’ll Learn

Strings hold almost every piece of text in C—user names, file paths, command-line arguments, and log lines. This guide teaches how C represents strings as null-terminated char arrays, how to create them safely, and how to use essential <string.h> helpers.

Definition and Usage

In C, a string is not a separate type. It is a char array whose last meaningful character is followed by a null terminator '\0' (byte value 0). The standard library treats any such sequence as text.

You declare writable strings with arrays: char greeting[] = "Hello, C!"; You read from literals with pointers: const char *label = "CodeToFun"; Functions in <string.h> measure, copy, compare, search, and tokenize these character sequences.

📝 Syntax

Common ways to create and use strings in C:

char buffer[] = "Hello, C!";     // writable array
const char *label = "CodeToFun"; // read-only literal

size_t len = strlen(buffer);     // length (exclude \0)
strcpy(dest, src);               // copy (dest must be big enough)
int cmp = strcmp(a, b);          // compare bytes

Creating Strings

• Array initializer (char s[] = "...";) — creates a modifiable null-terminated array.
• Explicit size (char s[32];) — allocate space, then fill with strcpy or fgets.
• Pointer to literal (const char *p = "...";) — read-only; do not pass to mutating functions.
• Character constant ('A') — single character, not a string (strings need '\0').

Common string.h Helpers

C string functions are global functions—the buffer or pointer is passed as an argument:

strlen(s)
strcpy(dest, src)
strcmp(s1, s2)
strcat(dest, src)
strchr(s, 'c')
strstr(haystack, needle)

Examples Gallery

Work through these five examples from basic string creation to comparison, concatenation, and tokenization patterns used in real C programs.

#include <stdio.h>

int main(void) {
    char language[] = "C";
    const char *site = "CodeToFun";

    printf("Language: %s\n", language);
    printf("Site:     %s\n", site);
    printf("Ready to learn C strings!\n");

    return 0;
}

Language: C
Site:     CodeToFun
Ready to learn C strings!

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

int main(void) {
    char editable[] = "Hello";
    const char *readonly = "World";

    editable[0] = 'h';  /* OK: array is writable */
    printf("Editable: %s\n", editable);

    /* readonly[0] = 'w';  ERROR: literal is read-only */

    char combined[32];
    strcpy(combined, editable);
    strcat(combined, ", ");
    strcat(combined, readonly);
    printf("Combined: %s\n", combined);

    return 0;
}

Editable: hello
Combined: hello, World

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

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

    printf("Length: %zu\n", strlen(word));
    printf("First char: %c\n", word[0]);
    printf("Last char:  %c\n", word[strlen(word) - 1]);

    for (size_t i = 0; i < strlen(word); i++) {
        printf("word[%zu] = %c\n", i, word[i]);
    }

    return 0;
}

Length: 5
First char: H
Last char:  o
word[0] = H
word[1] = e
word[2] = l
word[3] = l
word[4] = o

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

int main(void) {
    const char *input = "yes";
    char buffer[16];

    strcpy(buffer, input);

    if (strcmp(buffer, "yes") == 0) {
        printf("Command accepted.\n");
    } else {
        printf("Unknown command: %s\n", buffer);
    }

    printf("Compare to \"no\": %d\n", strcmp(buffer, "no"));

    return 0;
}

Command accepted.
Compare to "no": 1

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

int main(void) {
    char line[] = "apple,banana,cherry";
    char *found = strstr(line, "banana");

    if (found != NULL) {
        printf("Found substring at: %s\n", found);
    }

    char *token = strtok(line, ",");
    while (token != NULL) {
        printf("Token: %s\n", token);
        token = strtok(NULL, ",");
    }

    return 0;
}

Found substring at: banana,cherry
Token: apple
Token: banana
Token: cherry

🚀 Common Use Cases

• User input — read names and commands with fgets into char buffers.
• File paths — build and compare directory strings with strcat and strcmp.
• Validation — check prefixes and suffixes with strstr and manual indexing.
• CSV and config — split lines with strtok or span functions strspn/strcspn.
• Sorting names — order text with strcmp or locale-aware strcoll.
• Error messages — map errno codes to text with strerror.

📝 Notes

• C strings are null-terminated byte sequences, not abstract string objects.
• Never use == to compare string content—use strcmp.
• Do not pass string literals to strcpy, strcat, or strtok as the destination.
• strcpy and strcat do not check destination size—prefer strncpy/strncat or snprintf when bounded.
• strlen is O(n); cache the result if you need it repeatedly in a loop.
• C string functions are global functions, not methods—unlike C# text.Length or PHP strlen($text) with different syntax rules.

💡 Best Practices