C String strcspn() Function

What You’ll Learn

The strcspn() function measures how many leading characters in a string belong to a prefix that contains none of the characters in a reject set. It stops at the first “forbidden” character—ideal for finding tokens before delimiters.

Definition and Usage

Think of strcspn as complement span: it counts characters from the start of s until it hits any character listed in reject. The return value is that count—not including the stopping character.

If every character in s avoids the reject set, the function returns strlen(s). Pair it with pointer arithmetic to extract substrings without copying: the token is the first len bytes at s.

📝 Syntax

Standard C declaration:

size_t strcspn(const char *s, const char *reject);

Parameters

• s — null-terminated string to scan from the beginning.
• reject — C-string of characters that terminate the span (delimiter set).

Return Value

• Number of characters in the initial segment of s that contain no characters from reject.
• Range: 0 to strlen(s).

Header

• #include <string.h>

Examples Gallery

Compile with gcc strcspn.c -std=c11 -o strcspn. Return type is size_t—use %zu to print.

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

int main(void) {
    const char *text = "Hello, World!";
    const char *vowels = "aeiouAEIOU";

    size_t length = strcspn(text, vowels);

    printf("Chars before first vowel: %zu\n", length);
    printf("Prefix: %.*s\n", (int)length, text);

    return 0;
}

Chars before first vowel: 1
Prefix: H

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

int main(void) {
    const char *email = "alex@codetofun.com";
    size_t user_len = strcspn(email, "@");

    printf("Username (%zu chars): %.*s\n", user_len, (int)user_len, email);

    return 0;
}

Username (4 chars): alex

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

int main(void) {
    const char *row = "apple,banana,cherry";
    size_t field_len = strcspn(row, ",;");

    printf("First field: %.*s\n", (int)field_len, row);

    return 0;
}

First field: apple

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

int main(void) {
    const char *s = "   hello";

    size_t spaces = strspn(s, " \t");
    size_t word = strcspn(s + spaces, " \t");

    printf("Leading spaces: %zu\n", spaces);
    printf("Word length:    %zu\n", word);
    printf("Word:           %.*s\n", (int)word, s + spaces);

    return 0;
}

Leading spaces: 3
Word length:    5
Word:           hello

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

int main(void) {
    const char *cursor = "red,green,blue";
    const char *delim = ",";

    while (*cursor) {
        size_t len = strcspn(cursor, delim);
        printf("Token: %.*s\n", (int)len, cursor);
        cursor += len;
        if (*cursor) {
            cursor++;  /* skip delimiter */
        }
    }

    return 0;
}

Token: red
Token: green
Token: blue

🚀 Common Use Cases

• Delimiter parsing — measure tokens before ,, ;, or |.
• Input validation — count leading non-digit characters before a number.
• Path segments — length of name before / or \.
• Trim + extract — combine with strspn to skip padding.
• Custom lexers — scan identifiers until operator symbols.

📝 Notes

• Return type is size_t—print with %zu.
• Empty reject yields length of entire s.
• Time complexity is O(n×m) naive; libraries often optimize with lookup tables.
• Does not allocate memory or null-terminate a slice—use %.*s or copy if needed.
• For a single delimiter, strchr returns a pointer; strcspn returns a length.

⚡ Optimization

For a fixed small reject set called many times, a 256-byte bitmap of forbidden characters can beat repeated scans of reject. For occasional parsing, the standard strcspn is clear and fast enough.

💡 Best Practices