The easiest way to mess with characters in C is to employ the ctype functions. I name this category of library functions after the ctype.h 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!

The following code demonstrates the toupper() and tolower() 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() function returns the uppercase character of the argument passed; tolower() returns the lowercase character. These functions have no effect on non-alphabetic characters, returning the character passed as-is.

2026_05_09-Lesson-a.c

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

int main()
{
    char string[] = "Nothing beats knowing the ASCII codes!\n";
    char *s;

    /* uppercase */
    s = string;
    while( *s != '\0' )
    {
        putchar( toupper(*s) );
        s++;
    }

    /* lowercase */
    s = string;
    while( *s != '\0' )
    {
        putchar( tolower(*s) );
        s++;
    }

    return 0;
}

The two while loops output the characters in array string[]. The first loop sends the character through the toupper() function; the second loop sends the character through the tolower() function. Here’s the output:

NOTHING BEATS KNOWING THE ASCII CODES!
nothing beats knowing the ascii codes!

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:

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:

2026_05_09-Lesson-b.c

#include <stdio.h>

/* convert to uppercase */
int toupper(int c)
{
    if( c>='a' && c<='z' )
        c -= 32;

    return(c);
}

/* convert to lowercase */
int tolower(int c)
{
    if( c>='A' && c<='Z' )
        c += 32;

    return(c);
}

int main()
{
    char string[] = "Nothing beats knowing the ASCII codes!\n";
    char *s;

    /* uppercase */
    s = string;
    while( *s != '\0' )
    {
        putchar( toupper(*s) );
        s++;
    }

    /* lowercase */
    s = string;
    while( *s != '\0' )
    {
        putchar( tolower(*s) );
        s++;
    }

    return 0;
}

This update to the code removes including the ctype.h header file. Instead, I wrote my own toupper() and tolower() functions, following the ctype format. Each of my emulations works the same: An if 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.

The program’s output is the same:

NOTHING BEATS KNOWING THE ASCII CODES!
nothing beats knowing the ascii codes!

In the toupper() function, you could replace the expression c -= 32 with c &= 0xDF By resetting the fifth bit, you convert a lowercase letter to uppercase. Likewise, in the tolower() function you can replace c += 32 with c |=0x20 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.

Next week I explore the isupper() and islower() functions.