{"id":7457,"date":"2026-05-09T00:01:51","date_gmt":"2026-05-09T07:01:51","guid":{"rendered":"https:\/\/c-for-dummies.com\/blog\/?p=7457"},"modified":"2026-05-02T13:10:24","modified_gmt":"2026-05-02T20:10:24","slug":"ctype-functions-toupper-and-tolower","status":"publish","type":"post","link":"https:\/\/c-for-dummies.com\/blog\/?p=7457","title":{"rendered":"Ctype Functions: toupper()<\/em> and tolower()<\/em>"},"content":{"rendered":"

\"\"
\nThe easiest way to mess with characters in C is to employ the ctype functions<\/a>. I name this category of library functions after the ctype.h<\/code> header file that defines them. Some are true functions, some are macros. Each function can be replicated with standard C code, though it’s quicker to use an established function than to code your own. But that’s not the point of learning to program!
\n
\nThe following code demonstrates the toupper()<\/em> and tolower()<\/em> ctype functions. As with all ctype functions, these functions work with with single characters. These two ctype functions are unique, however, in that they return values other than TRUE and FALSE: The toupper()<\/em> function returns the uppercase character of the argument passed; tolower()<\/em> returns the lowercase character. These functions have no effect on non-alphabetic characters, returning the character passed as-is.<\/p>\n

2026_05_09-Lesson-a.c<\/a><\/h3>\n
\r\n#include <stdio.h>\r\n#include <ctype.h>\r\n\r\nint main()\r\n{\r\n    char string[] = \"Nothing beats knowing the ASCII codes!\\n\";\r\n    char *s;\r\n\r\n    \/* uppercase *\/<\/span>\r\n    s = string;\r\n    while( *s != '\\0' )\r\n    {\r\n        putchar( toupper(*s) );\r\n        s++;\r\n    }\r\n\r\n    \/* lowercase *\/<\/span>\r\n    s = string;\r\n    while( *s != '\\0' )\r\n    {\r\n        putchar( tolower(*s) );\r\n        s++;\r\n    }\r\n\r\n    return 0;\r\n}<\/pre>\n
The two while<\/em> loops output the characters in array string[]<\/code>. The first loop sends the character through the toupper()<\/em> function; the second loop sends the character through the tolower()<\/em> function. Here’s the output:<\/p>\n
NOTHING BEATS KNOWING THE ASCII CODES!\r\nnothing beats knowing the ascii codes!<\/pre>\n
If you’re going to emulate these functions, it helps to know the ASCII code values for letters A through Z. The ASCII table is organized in such a fashion that uppercase and lowercase letters differ by a single bit, as shown in the following table:<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
A<\/td>\n65<\/td>\n0x41<\/td>\n0100 0001<\/td>\na<\/td>\n97<\/td>\n0x61<\/td>\n0110 0001<\/td>\n<\/tr>\n
B<\/td>\n66<\/td>\n0x42<\/td>\n0100 0010<\/td>\nb<\/td>\n98<\/td>\n0x62<\/td>\n0110 0010<\/td>\n<\/tr>\n
C<\/td>\n67<\/td>\n0x43<\/td>\n0100 0011<\/td>\nc<\/td>\n99<\/td>\n0x63<\/td>\n0110 0011<\/td>\n<\/tr>\n
D<\/td>\n68<\/td>\n0x44<\/td>\n0100 0100<\/td>\nd<\/td>\n100<\/td>\n0x64<\/td>\n0110 0100<\/td>\n<\/tr>\n
E<\/td>\n69<\/td>\n0x45<\/td>\n0100 0101<\/td>\ne<\/td>\n101<\/td>\n0x65<\/td>\n0110 0101<\/td>\n<\/tr>\n
F<\/td>\n70<\/td>\n0x46<\/td>\n0100 0110<\/td>\nf<\/td>\n102<\/td>\n0x66<\/td>\n0110 0110<\/td>\n<\/tr>\n
G<\/td>\n71<\/td>\n0x47<\/td>\n0100 0111<\/td>\ng<\/td>\n103<\/td>\n0x67<\/td>\n0110 0111<\/td>\n<\/tr>\n
H<\/td>\n72<\/td>\n0x48<\/td>\n0100 1000<\/td>\nh<\/td>\n104<\/td>\n0x68<\/td>\n0110 1000<\/td>\n<\/tr>\n
I<\/td>\n73<\/td>\n0x49<\/td>\n0100 1001<\/td>\ni<\/td>\n105<\/td>\n0x69<\/td>\n0110 1001<\/td>\n<\/tr>\n
J<\/td>\n74<\/td>\n0x4A<\/td>\n0100 1010<\/td>\nj<\/td>\n106<\/td>\n0x6A<\/td>\n0110 1010<\/td>\n<\/tr>\n
K<\/td>\n75<\/td>\n0x4B<\/td>\n0100 1011<\/td>\nk<\/td>\n107<\/td>\n0x6B<\/td>\n0110 1011<\/td>\n<\/tr>\n
L<\/td>\n76<\/td>\n0x4C<\/td>\n0100 1100<\/td>\nl<\/td>\n108<\/td>\n0x6C<\/td>\n0110 1100<\/td>\n<\/tr>\n
M<\/td>\n77<\/td>\n0x4D<\/td>\n0100 1101<\/td>\nm<\/td>\n109<\/td>\n0x6D<\/td>\n0110 1101<\/td>\n<\/tr>\n
N<\/td>\n78<\/td>\n0x4E<\/td>\n0100 1110<\/td>\nn<\/td>\n110<\/td>\n0x6E<\/td>\n0110 1110<\/td>\n<\/tr>\n
O<\/td>\n79<\/td>\n0x4F<\/td>\n0100 1111<\/td>\no<\/td>\n111<\/td>\n0x6F<\/td>\n0110 1111<\/td>\n<\/tr>\n
P<\/td>\n80<\/td>\n0x50<\/td>\n0101 0000<\/td>\np<\/td>\n112<\/td>\n0x70<\/td>\n0111 0000<\/td>\n<\/tr>\n
Q<\/td>\n81<\/td>\n0x51<\/td>\n0101 0001<\/td>\nq<\/td>\n113<\/td>\n0x71<\/td>\n0111 0001<\/td>\n<\/tr>\n
R<\/td>\n82<\/td>\n0x52<\/td>\n0101 0010<\/td>\nr<\/td>\n114<\/td>\n0x72<\/td>\n0111 0010<\/td>\n<\/tr>\n
S<\/td>\n83<\/td>\n0x53<\/td>\n0101 0011<\/td>\ns<\/td>\n115<\/td>\n0x73<\/td>\n0111 0011<\/td>\n<\/tr>\n
T<\/td>\n84<\/td>\n0x54<\/td>\n0101 0100<\/td>\nt<\/td>\n116<\/td>\n0x74<\/td>\n0111 0100<\/td>\n<\/tr>\n
U<\/td>\n85<\/td>\n0x55<\/td>\n0101 0101<\/td>\nu<\/td>\n117<\/td>\n0x75<\/td>\n0111 0101<\/td>\n<\/tr>\n
V<\/td>\n86<\/td>\n0x56<\/td>\n0101 0110<\/td>\nv<\/td>\n118<\/td>\n0x76<\/td>\n0111 0110<\/td>\n<\/tr>\n
W<\/td>\n87<\/td>\n0x57<\/td>\n0101 0111<\/td>\nw<\/td>\n119<\/td>\n0x77<\/td>\n0111 0111<\/td>\n<\/tr>\n
X<\/td>\n88<\/td>\n0x58<\/td>\n0101 1000<\/td>\nx<\/td>\n120<\/td>\n0x78<\/td>\n0111 1000<\/td>\n<\/tr>\n
Y<\/td>\n89<\/td>\n0x59<\/td>\n0101 1001<\/td>\ny<\/td>\n121<\/td>\n0x79<\/td>\n0111 1001<\/td>\n<\/tr>\n
Z<\/td>\n90<\/td>\n0x5A<\/td>\n0101 1010<\/td>\nz<\/td>\n122<\/td>\n0x7A<\/td>\n0111 1010<\/td>\n<\/tr>\n<\/table>\n
Several clever and fun approaches are available for changing uppercase to lowercase, one of which involves setting or resetting the fifth bit. But for my emulation functions, I use a comparison:<\/p>\n
2026_05_09-Lesson-b.c<\/a><\/h3>\n
\r\n#include <stdio.h>\r\n\r\n\/* convert to uppercase *\/<\/span>\r\nint toupper(int c)\r\n{\r\n    if( c>='a' && c<='z' )\r\n        c -= 32;\r\n\r\n    return(c);\r\n}\r\n\r\n\/* convert to lowercase *\/<\/span>\r\nint tolower(int c)\r\n{\r\n    if( c>='A' && c<='Z' )\r\n        c += 32;\r\n\r\n    return(c);\r\n}\r\n\r\nint main()\r\n{\r\n    char string[] = \"Nothing beats knowing the ASCII codes!\\n\";\r\n    char *s;\r\n\r\n    \/* uppercase *\/<\/span>\r\n    s = string;\r\n    while( *s != '\\0' )\r\n    {\r\n        putchar( toupper(*s) );\r\n        s++;\r\n    }\r\n\r\n    \/* lowercase *\/<\/span>\r\n    s = string;\r\n    while( *s != '\\0' )\r\n    {\r\n        putchar( tolower(*s) );\r\n        s++;\r\n    }\r\n\r\n    return 0;\r\n}<\/pre>\n
This update to the code removes including the ctype.h<\/code> header file. Instead, I wrote my own toupper()<\/em> and tolower()<\/em> functions, following the ctype format. Each of my emulations works the same: An if<\/em> test checks for a letter of the alphabet, upper- or lowercase. If true, the value 32 is subtracted from the character’s value to convert it to uppercase; the value 32 is added to the character’s value to convert it to lowercase. Otherwise, the same character is returned.<\/p>\n
The program’s output is the same:<\/p>\n
NOTHING BEATS KNOWING THE ASCII CODES!\r\nnothing beats knowing the ascii codes!<\/pre>\n
In the toupper()<\/em> function, you could replace the expression c -=  32<\/code> with c &= 0xDF<\/code> By resetting the fifth bit, you convert a lowercase letter to uppercase. Likewise, in the tolower()<\/em> function you can replace c += 32<\/code> with c |=0x20<\/code> These modifications work, relying upon bit manipulation to set or reset the bits to make the character conversion. I don’t know which approach is used internally by the C library, though either way works.<\/p>\n
Next week I explore the isupper()<\/em> and islower()<\/em> functions.<\/p>\n","protected":false},"excerpt":{"rendered":"
Character manipulation functions are handy — and easy to replicate. Continue reading →<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[2],"tags":[],"class_list":["post-7457","post","type-post","status-publish","format-standard","hentry","category-main"],"_links":{"self":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/7457","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=7457"}],"version-history":[{"count":10,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/7457\/revisions"}],"predecessor-version":[{"id":7593,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/7457\/revisions\/7593"}],"wp:attachment":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=7457"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=7457"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=7457"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}