C++ String strspn() Function

What You’ll Learn

The strspn() function measures how many characters at the start of a C-string belong to an accept set. The name means span of characters that are in the set. It stops at the first character not listed in the set—the opposite rule from strcspn().

Definition and Usage

In C++, strspn() is declared in <cstring>. It walks str from left to right while each character is found in acceptSet. The return value is how many characters passed that test before the scan stopped.

If the first character of str is not in the set, the result is 0. If the entire string uses only allowed characters, the result equals strlen(str). The accept set is a collection of individual characters, not a substring to match as a block.

📝 Syntax

Function signature and a typical call:

#include <cstring>

size_t strspn(const char* str, const char* acceptSet);

// Example:
size_t n = strspn("   trim me", " \t");
// n == 3  (three leading spaces)

Parameters

• str — null-terminated C-string to scan.
• acceptSet — set of characters that may appear in the initial segment.

Return Value

Returns the number of leading characters in str that are all members of acceptSet.

Examples Gallery

Compile with g++ strspn.cpp -std=c++17 -o strspn. Each example shows how the accept set controls where counting stops.

#include <iostream>
#include <cstring>

int main() {
    const char* line = "   \t  Hello";

    std::size_t pad = std::strspn(line, " \t");

    std::cout << "Leading whitespace: " << pad << " chars\n";
    std::cout << "Text starts at:     \"" << (line + pad) << "\"\n";

    return 0;
}

Leading whitespace: 6 chars
Text starts at:     "Hello"

#include <iostream>
#include <cstring>

int main() {
    const char* text = "C++ is awesome!";
    const char* lettersAndSpace =
        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ";

    std::size_t span = std::strspn(text, lettersAndSpace);

    std::cout << "Accepted prefix length: " << span << "\n";
    std::cout << "Prefix:                 ";
    for (std::size_t i = 0; i < span; ++i) {
        std::cout << text[i];
    }
    std::cout << "\n";
    std::cout << "Stopped at:             '" << text[span] << "'\n";

    return 0;
}

Accepted prefix length: 1
Prefix:                 C
Stopped at:             '+'

#include <iostream>
#include <cstring>

int main() {
    const char* data = "12345abc";

    std::size_t digitsOnly = std::strspn(data, "0123456789");
    std::size_t notDigits = std::strcspn(data, "0123456789");

    std::cout << "strspn (digits):  " << digitsOnly << "\n";
    std::cout << "strcspn (digits): " << notDigits << "\n";
    std::cout << "Same?             "
              << std::boolalpha << (digitsOnly == notDigits) << "\n";

    return 0;
}

strspn (digits):  5
strcspn (digits): 5
Same?             true

#include <iostream>
#include <cstring>

int main() {
    const char* line = "    trim me   ";

    std::size_t skip = std::strspn(line, " \t");
    const char* start = line + skip;

    std::size_t wordLen = std::strcspn(start, " \t");

    std::cout << "Token: ";
    for (std::size_t i = 0; i < wordLen; ++i) {
        std::cout << start[i];
    }
    std::cout << "\n";

    return 0;
}

Token: trim

#include <iostream>
#include <cstring>

int main() {
    const char* values[] = { "42px", "100", "9 Lives" };

    for (const char* v : values) {
        std::size_t n = std::strspn(v, "0123456789");
        std::cout << "\"" << v << "\" -> " << n << " leading digit(s)\n";
    }

    return 0;
}

"42px" -> 2 leading digit(s)
"100" -> 3 leading digit(s)
"9 Lives" -> 1 leading digit(s)

🚀 Common Use Cases

• Skipping whitespace — measure leading spaces and tabs before parsing.
• Input validation — verify a prefix contains only digits or hex digits.
• Lexer-style scanning — accept runs of letters, then switch rules.
• Pairing with strcspn() — trim padding, then read until delimiter.
• Teaching span functions — complement to strcspn and strpbrk.

📝 Notes

• Returns 0 when the first character of str is not in the accept set.
• acceptSet is a character set, not a substring pattern.
• Both arguments must be valid null-terminated C-strings.
• Not part of the C++ STL—it lives in <cstring>.
• For complex parsing, prefer std::string utilities or regular expressions.

⚡ Optimization

Library implementations often use lookup tables for ASCII accept sets. For repeated scans on long buffers, cache results or use dedicated lexers. In typical beginner programs, a single strspn call per line is more than fast enough.

💡 Best Practices