Several functions are provided to test whether characters belong to certain sets or classifications, such as upper-case, letter, digit, etc.… These classifications depend on the LC_CTYPE locale category.

#include <ctype.h>
int isalpha(int c);
int islower(int c);
int isupper(int c);
int isdigit(int c);
int isxdigit(int c);
int isalnum(int c);
int isblank(int c);
int isspace(int c);
int iscntrl(int c);
int isgraph(int c);
int isprint(int c);
int ispunct(int c);

#include <wctype.h>
int iswalpha(wint_t c);
int iswlower(wint_t c);
int iswupper(wint_t c);
int iswdigit(wint_t c);
int iswxdigit(wint_t c);
int iswalnum(wint_t c);
int iswblank(wint_t c);
int iswspace(wint_t c);
int iswcntrl(wint_t c);
int iswgraph(wint_t c);
int iswprint(wint_t c);
int iswpunct(wint_t c);

Single-byte characters supplied as char should be converted to unsigned char before passing to the is… functions, e.g., isalnum((unsigned char) c). Functions like getchar return a character already in this form. The wide-character functions need no such conversion.

Each function returns non-zero if the supplied character c belongs to the set implied by the function's name:

For wide characters, it is possible to represent these categories textually:

#include <wctype.h>
wctype_t wctype(const char *prop);
int iswctype(wint_t c, wctype_t prop);

For example, iswctype(c, wctype("xdigit")) has the same behaviour as iswxdigit(c). If the string prop is not recognized, wctype returns zero, identifying a class that no character belongs to.

Depending on the LC_CTYPE category of the current locale, additional classifications may be recognized. Also, the locale is recorded in the wctype_t value, so even if LC_CTYPE is changed between the calls to wctype and iswctype, the second call works as if the old setting applies.

[: Looks like wctype(NULL) also returns zero.]

Six functions allow letters to be converted to upper- or lower-case according to the current LC_CTYPE locale category. They return the converted character if the original can be converted, or the original character if not:

#include <ctype.h>
int tolower(int c);
int toupper(int c);

#include <wctype.h>
wint_t towlower(wint_t c);
wint_t towupper(wint_t c);

Single-byte characters supplied as char should first be converted to unsigned char before passing to the to… functions, e.g., tolower((unsigned char) c). Functions like getchar return a character already in this form. The wide-character functions need no such conversion.

For wide characters, it is possible to represent these tranformations textually:

#include <wctype.h>
wctrans_t wctrans(const char *prop);
int towctrans(wint_t c, wctrans_t prop);

For example, towctrans(c, wctrans("toupper")) has the same behaviour as towupper(c). If the string prop is not recognized, wctrans returns zero, identifying an identity transformation.

Depending on the LC_CTYPE category of the current locale, additional transformations may be recognized. Also, the locale is recorded in the wctrans_t value, so even if LC_CTYPE is changed between the calls to wctrans and towctrans, the second call works as if the old setting applies.

[: Looks like wctrans(NULL) also returns zero.]