C Strings

Definition and Usage

C has no built-in string type like some languages. In a C tutorial, a string is a char array whose last meaningful character is followed by a null terminator '\0' (byte value 0). Library functions in <string.h> treat that sequence as text.

char arrays vs string literals

Writable text lives in arrays: char greeting[] = "Hello, C!";. Read-only literals use pointers: const char *label = "CodeToFun";. Mutating helpers such as strcpy() and strtok() need a writable buffer—never a literal.

What should beginners learn first?

Include <string.h>, create a char[] buffer, then practice strlen(), strcpy(), strcmp(), and strstr(). Those cover length, copy, compare, and search.

This lesson vs the Functions index

This page is the C strings lesson: null termination, char[] vs literals, buffer safety, and examples. The String Functions index is only a catalog—search and open individual guides such as strlen(). Learn here first, then browse the index.

C Syntax

Create a writable string, include the header, and call library helpers:

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

int main(void) {
    char buffer[] = "Hello, C!";
    const char *label = "CodeToFun";

    printf("buffer length: %zu\n", strlen(buffer));
    printf("label: %s\n", label);

    return 0;
}
/* gcc string_basics.c -std=c11 -o string_basics */

Core C Concepts

Ideas every C strings tutorial builds on:

Ways to create strings

When to use which function

How to Use Strings in C

A practical workflow for this tutorial track:

1. Add #include <string.h> (and <stdio.h> for printf / fgets).
2. Declare a char buffer large enough for text plus '\0'.
3. Initialize with a literal, or fill with strcpy, snprintf, or fgets.
4. Measure, compare, and search with strlen, strcmp, and strstr.
5. Only pass writable arrays to mutating functions such as strcat and strtok.
6. Open the functions index when you need a specific API guide.

Live Preview

Type text to preview strlen(s)—the same idea as calling strlen() after including <string.h>.

C Examples

Five starter patterns from a C tutorial. Compile with gcc file.c -std=c11 -o out.

#include <stdio.h>

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

    printf("Language: %s\n", language);
    printf("Site:     %s\n", site);

    return 0;
}

Language: C
Site:     CodeToFun

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

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

    editable[0] = 'h';  /* OK: array is writable */

    strcpy(combined, editable);
    strcat(combined, ", ");
    strcat(combined, readonly);

    printf("Editable: %s\n", editable);
    printf("Combined: %s\n", combined);

    return 0;
}

Editable: hello
Combined: hello, World

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

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

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

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

    return 0;
}

Length: 5
First: H
Last:  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 at: %s\n", found);
    }

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

    return 0;
}

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

Where to Go Next

This page teaches how strings work in C (char[], '\0', buffer safety, examples). The full searchable catalog of every function tutorial lives on the String Functions index—start with these six:

Need memcpy, strchr, strspn, case helpers, or the rest? Open the complete String Functions index.

Platform Support

<string.h> is part of standard C. A few helpers in this series are compiler or POSIX extensions.

Core functions such as strlen, strcpy, strcmp, strstr, and strtok are portable C89/C99/C11 APIs. When an extension appears in the index, the tutorial calls that out and shows a portable pattern.

Key Takeaways