C Standard Library wctype.h

What You’ll Learn

<ctype.h> classifies narrow char values. <wctype.h> does the same for wide characters: iswalpha asks “is this letter?”, towlower changes case. Pair it with <wchar.h> when you process international text with wchar_t strings.

Definition and Usage

Wide-character classification functions take a wint_t value and return non-zero (true) or zero (false). Conversion functions return the new wide character, or the original if no mapping exists.

Think of wctype.h as the wide mirror of ctype.h: isalpha → iswalpha, tolower → towlower. Use them when iterating over wchar_t buffers from wchar.h, not on plain char bytes.

📝 Syntax

Include the header (usually with wchar.h for wide I/O):

#include <wctype.h>
#include <wchar.h>   /* wprintf, wchar_t */

Classification functions

• iswalpha(wc) — alphabetic letter
• iswdigit(wc) — decimal digit 0–9
• iswalnum(wc) — letter or digit
• iswspace(wc) — whitespace (space, tab, newline, …)
• iswpunct(wc) — punctuation
• iswupper(wc) / iswlower(wc) — case tests
• iswprint(wc) / iswgraph(wc) — printable / visible

Conversion functions

• towlower(wc) — convert to lowercase wide character
• towupper(wc) — convert to uppercase wide character

ctype.h vs wctype.h (quick map)

isalpha(c)   →  iswalpha(wc)
isdigit(c)   →  iswdigit(wc)
isspace(c)   →  iswspace(wc)
tolower(c)   →  towlower(wc)
toupper(c)   →  towupper(wc)

Headers and linking

• #include <locale.h> and setlocale(LC_ALL, "") for locale-aware wide rules.
• Linked automatically with the C library on typical systems.
• See also ctype.h for narrow characters.

Examples Gallery

Compile with gcc file.c -std=c11 -o out. Examples use portable ASCII wide letters; extended characters need locale and Unicode terminal support.

#include <stdio.h>
#include <wctype.h>
#include <wchar.h>
#include <locale.h>

int main(void) {
    wint_t wc = L'A';
    wint_t lower;
    wint_t upper;

    setlocale(LC_ALL, "");

    if (iswalpha(wc)) {
        wprintf(L"%lc is an alphabetic character\n", (wchar_t)wc);
    } else {
        wprintf(L"%lc is not alphabetic\n", (wchar_t)wc);
    }

    lower = towlower(wc);
    upper = towupper(lower);

    wprintf(L"Lowercase of %lc is %lc\n", (wchar_t)wc, (wchar_t)lower);
    wprintf(L"Uppercase of %lc is %lc\n", (wchar_t)lower, (wchar_t)upper);

    return 0;
}

A is an alphabetic character
Lowercase of A is a
Uppercase of a is A

#include <stdio.h>
#include <wctype.h>
#include <wchar.h>

int main(void) {
    wchar_t tests[] = { L'0', L'9', L'A', L'-' };
    size_t i;

    for (i = 0; i < 4; i++) {
        wprintf(L"'%lc' -> %s\n", tests[i],
                iswdigit(tests[i]) ? L"digit" : L"not a digit");
    }

    return 0;
}

'0' -> digit
'9' -> digit
'A' -> not a digit
'-' -> not a digit

#include <stdio.h>
#include <wctype.h>
#include <wchar.h>

int main(void) {
    const wchar_t *text = L"   \t Hello";
    const wchar_t *p = text;

    while (iswspace(*p)) {
        p++;
    }

    wprintf(L"Trimmed start: \"%ls\"\n", p);

    return 0;
}

Trimmed start: "Hello"

#include <stdio.h>
#include <wctype.h>
#include <wchar.h>

int main(void) {
    const wchar_t *s = L"Hello, 42!";
    size_t alpha = 0, digit = 0, punct = 0, space = 0;
    const wchar_t *p;

    for (p = s; *p != L'\0'; p++) {
        if (iswalpha(*p)) {
            alpha++;
        } else if (iswdigit(*p)) {
            digit++;
        } else if (iswpunct(*p)) {
            punct++;
        } else if (iswspace(*p)) {
            space++;
        }
    }

    wprintf(L"String: %ls\n", s);
    wprintf(L"Letters: %zu, Digits: %zu, Punct: %zu, Space: %zu\n",
            alpha, digit, punct, space);

    return 0;
}

String: Hello, 42!
Letters: 5, Digits: 2, Punct: 2, Space: 1

#include <stdio.h>
#include <wctype.h>
#include <wchar.h>

int wide_iequal(const wchar_t *a, const wchar_t *b) {
    while (*a && *b) {
        if (towlower((wint_t)*a) != towlower((wint_t)*b)) {
            return 0;
        }
        a++;
        b++;
    }
    return *a == L'\0' && *b == L'\0';
}

int main(void) {
    const wchar_t *s1 = L"Hello";
    const wchar_t *s2 = L"hELLO";

    if (wide_iequal(s1, s2)) {
        wprintf(L"\"%ls\" equals \"%ls\" (ignore case)\n", s1, s2);
    } else {
        wprintf(L"Strings differ\n");
    }

    return 0;
}

"Hello" equals "hELLO" (ignore case)

🚀 Common Use Cases

• Input validation — reject non-digit wide characters in forms.
• Tokenizers — split wide text on iswspace boundaries.
• Password rules — require upper, lower, digit with isw* tests.
• Case-normalization — towlower before compare or hash.
• Lexers — classify wide source code characters.
• Windows UI strings — sanitize wide user input.

📝 Notes

• Do not pass char to iswalpha—cast to wchar_t only when the value is a valid wide character.
• Return value is non-zero for true; compare with if (iswalpha(wc)), not == 1.
• towlower may return unchanged character if no lowercase exists.
• Extended Unicode letters need correct locale and wide encoding support.
• For UTF-8 char text, many apps use ctype.h on bytes only for ASCII, or a Unicode library.
• Advanced: wctype, iswctype, towctrans for custom locale categories.

⚡ Optimization

Per-character isw* calls in tight loops are usually fine. For ASCII-only data, converting to narrow char and using ctype.h can be faster but only when you know the text is ASCII. Avoid calling setlocale repeatedly inside loops.

💡 Best Practices