# wctype

***

**1. Character Classification:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'a';
  if (iswalpha(c)) {
    // c is an alphabetic character
  }
  return 0;
}
```

**2. Case Conversion:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'A';
  wctype_t type = wctype("alpha");
  wint_t lower = towlower(c, type);
  // lower now contains 'a'
  return 0;
}
```

**3. Check for Whitespace:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L' ';
  if (iswspace(c)) {
    // c is a whitespace character
  }
  return 0;
}
```

**4. Check for Punctuation:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'.';
  if (iswpunct(c)) {
    // c is a punctuation character
  }
  return 0;
}
```

**5. Get Character Width:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'ア';
  int width = wcswidth(&c, 1);
  // width now contains the width of the character 'ア'
  return 0;
}
```

**6. Check for Control Character:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'\n';
  if (iswcntrl(c)) {
    // c is a control character
  }
  return 0;
}
```

**7. Check for Decimal Digit:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'5';
  if (iswdigit(c)) {
    // c is a decimal digit
  }
  return 0;
}
```

**8. Check for Hexadecimal Digit:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'F';
  if (iswxdigit(c)) {
    // c is a hexadecimal digit
  }
  return 0;
}
```

**9. Check for Letter:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'z';
  if (iswalpha(c) || iswupper(c) || iswlower(c)) {
    // c is a letter
  }
  return 0;
}
```

**10. Check for Number:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'9';
  if (iswdigit(c)) {
    // c is a number
  }
  return 0;
}
```

**11. Check for Uppercase Letter:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'A';
  if (iswupper(c)) {
    // c is an uppercase letter
  }
  return 0;
}
```

**12. Check for Lowercase Letter:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'a';
  if (iswlower(c)) {
    // c is a lowercase letter
  }
  return 0;
}
```

**13. Check for Alphabetic Character:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'Z';
  if (iswalnum(c) && iswalpha(c)) {
    // c is an alphabetic character
  }
  return 0;
}
```

**14. Check for Alphanumeric Character:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'3';
  if (iswalnum(c)) {
    // c is an alphanumeric character
  }
  return 0;
}
```

**15. Check for Blank Character:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L' ';
  if (iswblank(c)) {
    // c is a blank character
  }
  return 0;
}
```

**16. Check for Control Character:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'\n';
  if (iswcntrl(c)) {
    // c is a control character
  }
  return 0;
}
```

**17. Check for Decimal Digit:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'5';
  if (iswdigit(c)) {
    // c is a decimal digit
  }
  return 0;
}
```

**18. Check for Hexadecimal Digit:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'E';
  if (iswxdigit(c)) {
    // c is a hexadecimal digit
  }
  return 0;
}
```

**19. Check for Lowercase Letter:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'r';
  if (iswlower(c)) {
    // c is a lowercase letter
  }
  return 0;
}
```

**20. Check for Punctuation:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L',';
  if (iswpunct(c)) {
    // c is a punctuation character
  }
  return 0;
}
```

**21. Check for Whitespace Character:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L' ';
  if (iswspace(c)) {
    // c is a whitespace character
  }
  return 0;
}
```

**22. Check for Uppercase Letter:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'J';
  if (iswupper(c)) {
    // c is an uppercase letter
  }
  return 0;
}
```

**23. Check for Unicode Code Point:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'\u0644';
  if (c) {
    // c is a valid Unicode code point
  }
  return 0;
}
```

**24. Convert to Lowercase Letter:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'Q';
  wint_t lower = towlower(c);
  // lower now contains 'q'
  return 0;
}
```

**25. Convert to Uppercase Letter:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'q';
  wint_t upper = towupper(c);
  // upper now contains 'Q'
  return 0;
}
```

**26. Convert Character to String:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'a';
  wchar_t str[] = {c, L'\0'};
  // str now contains "a"
  return 0;
}
```

**27. Convert String to Character:**

```cpp
#include <wctype.h>

int main() {
  wchar_t str[] = L"b";
  wint_t c = *str;
  // c now contains 'b'
  return 0;
}
```

**28. Check for Letter or Digit:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'0';
  if (iswalpha(c) || iswdigit(c)) {
    // c is a letter or digit
  }
  return 0;
}
```

**29. Check for Printable Character:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'!';
  if (iswprint(c)) {
    // c is a printable character
  }
  return 0;
}
```

**30. Check for Graphic Character:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'?';
  if (iswgraph(c)) {
    // c is a graphic character
  }
  return 0;
}
```

**31. Check for Letter:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'J';
  if (iswalpha(c)) {
    // c is a letter
  }
  return 0;
}
```

**32. Check for Digit:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'9';
  if (iswdigit(c)) {
    // c is a digit
  }
  return 0;
}
```

**33. Check for Uppercase Letter:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'C';
  if (iswupper(c)) {
    // c is an uppercase letter
  }
  return 0;
}
```

**34. Check for Lowercase Letter:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'm';
  if (iswlower(c)) {
    // c is a lowercase letter
  }
  return 0;
}
```

**35. Check for Alphabetic Character:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'T';
  if (iswalpha(c)) {
    // c is an alphabetic character
  }
  return 0;
}
```

**36. Check for Alphanumeric Character:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'7';
  if (iswalnum(c)) {
    // c is an alphanumeric character
  }
  return 0;
}
```

**37. Check for Space Character:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L' ';
  if (iswspace(c)) {
    // c is a space character
  }
  return 0;
}
```

**38. Check for Tab Character:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'\t';
  if (iswcntrl(c) && c == L'\t') {
    // c is a tab character
  }
  return 0;
}
```

**39. Check for Newline Character:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'\n';
  if (iswcntrl(c) && c == L'\n') {
    // c is a newline character
  }
  return 0;
}
```

**40. Check for Carriage Return Character:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'\r';
  if (iswcntrl(c) && c == L'\r') {
    // c is a carriage return character
  }
  return 0;
}
```

**41. Check for Vertical Tab Character:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'\v';
  if (iswcntrl(c) && c == L'\v') {
    // c is a vertical tab character
  }
  return 0;
}
```

**42. Check for Form Feed Character:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'\f';
  if (iswcntrl(c) && c == L'\f') {
    // c is a form feed character
  }
  return 0;
}
```

**43. Check for Printable Character:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'!';
  if (iswprint(c)) {
    // c is a printable character
  }
  return 0;
}
```

**44. Check for Graphic Character:**

```cpp
#include <wctype.h>

int main() {
  wint_t c = L'$';
  if (iswgraph(c)) {
    // c is a graphic character
  }
  return 0;
}

```