C Standard Library ctype.h

What You’ll Learn

The <ctype.h> header provides functions to classify characters (letter, digit, space, etc.) and map case (upper/lower). They make text parsing readable and portable compared to manual range checks like c >= 'a' && c <= 'z'.

Definition and Usage

Character-handling functions in <ctype.h> fall into two groups: classification (isalpha, isdigit, isspace, …) return non-zero if the character matches a category, and mapping (toupper, tolower) return a converted character or the original if no conversion applies.

All of these functions take an int argument. The value must be representable as unsigned char or be EOF. On platforms where char is signed, cast before calling: isalpha((unsigned char)c).

📝 Syntax

Include the header:

#include <ctype.h>

Character testing functions

• isalnum(c) — letter or digit.
• isalpha(c) — letter (A–Z, a–z in C locale).
• isdigit(c) — decimal digit 0–9.
• islower(c) / isupper(c) — lowercase / uppercase letter.
• isspace(c) — whitespace (space, tab, newline, etc.).
• isprint(c) — printable character including space.
• ispunct(c) — punctuation (neither alphanumeric nor space).
• isxdigit(c) — hexadecimal digit (0–9, a–f, A–F).

Character mapping functions

• toupper(c) — lowercase letter to uppercase; else returns c.
• tolower(c) — uppercase letter to lowercase; else returns c.

Common declarations

int isalpha(int c);
int isdigit(int c);
int isspace(int c);
int toupper(int c);
int tolower(int c);

Headers and linking

• #include <ctype.h>
• No special link flag required.
• Compile: gcc program.c -std=c11 -o program

Examples Gallery

Compile every example with gcc file.c -std=c11 -o out. Cast char values to unsigned char before passing to is* functions when char may be signed.

#include <ctype.h>
#include <stdio.h>

void analyze_character(char ch) {
    unsigned char c = (unsigned char)ch;

    if (isalpha(c)) {
        printf("'%c' is alphabetic.\n", ch);
        if (islower(c)) {
            printf("  lowercase; uppercase form is '%c'\n", (char)toupper(c));
        } else {
            printf("  uppercase; lowercase form is '%c'\n", (char)tolower(c));
        }
    } else if (isdigit(c)) {
        printf("'%c' is a digit.\n", ch);
    } else if (isspace(c)) {
        printf("'%c' is whitespace.\n", ch == ' ' ? ' ' : ch);
    } else {
        printf("'%c' is a special character.\n", ch);
    }
}

int main(void) {
    char chars[] = { 'a', 'Z', '5', ' ', '@' };
    size_t i;

    for (i = 0; i < sizeof(chars); i++) {
        analyze_character(chars[i]);
    }

    return 0;
}

'a' is alphabetic.
  lowercase; uppercase form is 'A'
'Z' is alphabetic.
  uppercase; lowercase form is 'z'
'5' is a digit.
' ' is whitespace.
'@' is a special character.

#include <ctype.h>
#include <stdio.h>

int all_digits(const char *s) {
    if (s == NULL || *s == '\0') {
        return 0;
    }
    while (*s) {
        if (!isdigit((unsigned char)*s)) {
            return 0;
        }
        s++;
    }
    return 1;
}

int main(void) {
    printf("12345: %s\n", all_digits("12345") ? "all digits" : "not all digits");
    printf("12a45: %s\n", all_digits("12a45") ? "all digits" : "not all digits");

    return 0;
}

12345: all digits
12a45: not all digits

#include <ctype.h>
#include <stdio.h>

void str_to_lower(char *s) {
    while (*s) {
        *s = (char)tolower((unsigned char)*s);
        s++;
    }
}

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

    printf("Before: %s\n", word);
    str_to_lower(word);
    printf("After:  %s\n", word);

    return 0;
}

Before: Hello, C!
After:  hello, c!

#include <ctype.h>
#include <stdio.h>

const char *skip_space(const char *s) {
    while (*s && isspace((unsigned char)*s)) {
        s++;
    }
    return s;
}

int main(void) {
    const char *line = "   \t  hello world";
    const char *start = skip_space(line);

    printf("Original: \"%s\"\n", line);
    printf("Trimmed:  \"%s\"\n", start);

    return 0;
}

Original: "   	  hello world"
Trimmed:  "hello world"

#include <ctype.h>
#include <stdio.h>

size_t count_alnum(const char *s) {
    size_t n = 0;

    while (*s) {
        if (isalnum((unsigned char)*s)) {
            n++;
        }
        s++;
    }
    return n;
}

int main(void) {
    const char *pwd = "P@ssw0rd!";

    printf("String: %s\n", pwd);
    printf("Alphanumeric count: %zu\n", count_alnum(pwd));

    return 0;
}

String: P@ssw0rd!
Alphanumeric count: 7

🚀 Common Use Cases

• Input validation — check usernames, numeric fields, hex strings.
• Parsing — skip whitespace, read tokens, validate characters in a lexer.
• Case normalization — lowercase emails or commands before compare.
• Password rules — count letters, digits, or punctuation with is* functions.
• CSV / text filters — keep only printable or alphanumeric characters.
• Command-line tools — classify options and arguments character by character.

📝 Notes

• Argument must be unsigned char value or EOF—cast signed char to avoid undefined behavior.
• is* returns non-zero for true; do not compare to exactly 1.
• toupper/tolower do not modify in place—assign the return value.
• Behavior depends on the current locale (default is often C locale).
• Not suitable for UTF-8 multibyte characters—one byte at a time only.
• isupper(toupper(c)) is true when c is a lowercase letter.

⚡ Optimization

ctype functions are typically implemented as small table lookups and are very fast. For extremely hot inner loops processing ASCII-only data, hand-tuned range checks can sometimes win—but ctype is clear, portable, and plenty fast for almost all application code.

💡 Best Practices