Write A Program To Toggle All Characters In A String In C Program

Toggling the case of characters in a string involves converting all uppercase letters to lowercase and all lowercase letters to uppercase, while leaving other characters unchanged. This common string manipulation task is useful in various programming scenarios.

In this article, you will learn how to implement a C program to toggle the case of all alphabetic characters within a given string using different approaches.

Problem Statement

The challenge is to modify a string in-place or create a new string where every uppercase letter becomes its lowercase equivalent, and every lowercase letter becomes its uppercase equivalent. Characters that are not alphabetic (e.g., numbers, symbols, spaces) should remain untouched. This is crucial for tasks like standardizing text, generating unique identifiers, or simple text obfuscation.

Example

Consider the following input string and its desired toggled output:

• Input: "HeLlO wOrLd! 123"
• Output: "hElLo WoRlD! 123"

Background & Knowledge Prerequisites

To understand the solutions presented, familiarity with the following C concepts is beneficial:

• C Strings: Represented as arrays of characters terminated by a null character (\0).
• ASCII Values: Understanding that characters have numerical ASCII values and how uppercase and lowercase letters are arranged (e.g., 'A' is 65, 'a' is 97; the difference is 32).
• Loops: for or while loops for iterating through string characters.
• Conditional Statements: if-else structures for checking character properties.
• Standard Library Functions: Basic knowledge of functions from for input/output and potentially for character manipulation.

Use Cases or Case Studies

Toggling character cases finds application in several areas:

• Text Processing: Normalizing user input that might have inconsistent casing (e.g., converting "USA" to "usa" for easier comparison, or "apple" to "Apple" for titles).
• Password/Identifier Generation: Creating mixed-case strings for stronger passwords or unique IDs, then toggling for display purposes.
• Data Masking/Obfuscation: Simple scrambling of text for non-security-critical applications, making it slightly harder to read at a glance.
• User Interface Formatting: Presenting text in specific styles, such as alternating case for visual emphasis (though often done with CSS in web contexts).
• Lexical Analysis: In compilers or interpreters, toggling case might be part of an initial pass to standardize keywords or identifiers before further processing.

Solution Approaches

Here are two effective methods to toggle character cases in a C string.

Approach 1: Using ASCII Values and if-else

This approach directly manipulates characters based on their ASCII values. We check if a character falls within the ASCII range of uppercase or lowercase letters and then add or subtract 32 accordingly to toggle its case.

• Summary: Iterate through the string, identify alphabetic characters using their ASCII ranges, and adjust their ASCII value by 32 to switch case.

// Toggle Characters using ASCII Values
#include <stdio.h> // For printf, gets
#include <string.h> // For strlen (optional, can use null terminator directly)

#define MAX_LENGTH 100

int main() {
    char str[MAX_LENGTH];

    // Step 1: Prompt user for input string
    printf("Enter a string: ");
    fgets(str, MAX_LENGTH, stdin); // Read string including spaces

    // Remove trailing newline character if present
    str[strcspn(str, "\\n")] = 0;

    // Step 2: Iterate through the string to toggle characters
    int i = 0;
    while (str[i] != '\\0') {
        // Check if the character is an uppercase letter
        if (str[i] >= 'A' && str[i] <= 'Z') {
            str[i] = str[i] + 32; // Convert to lowercase
        }
        // Check if the character is a lowercase letter
        else if (str[i] >= 'a' && str[i] <= 'z') {
            str[i] = str[i] - 32; // Convert to uppercase
        }
        // If not an alphabet, leave it unchanged
        i++;
    }

    // Step 3: Print the modified string
    printf("Toggled string: %s\\n", str);

    return 0;
}

Run

• Sample Output:

Enter a string: C prOgraMming Is Fun!
    Toggled string: c PRogRAmMING iS fUN!

• Stepwise Explanation:

1. Input: The program prompts the user to enter a string, which is stored in a character array str. fgets is used for safer input. A trailing newline character is removed if fgets captures one.
2. Iteration: A while loop iterates through each character of the string until the null terminator (\0) is encountered.
3. Case Check:
   • Inside the loop, if (str[i] >= 'A' && str[i] <= 'Z') checks if the current character is an uppercase letter. If true, str[i] = str[i] + 32; converts it to its lowercase equivalent (e.g., 'A' (65) + 32 = 'a' (97)).

1. Output: After the loop completes, the modified string with toggled cases is printed.

Approach 2: Using ctype.h Functions (isupper, islower, tolower, toupper)

The C standard library provides functions in that simplify character classification and conversion. This approach is generally more robust and readable as it abstracts away the direct ASCII value manipulation.

• Summary: Utilize isupper(), islower(), tolower(), and toupper() functions to safely determine character case and perform conversions.

// Toggle Characters using ctype.h Functions
#include <stdio.h>  // For printf, gets
#include <string.h> // For strcspn
#include <ctype.h>  // For isupper, islower, tolower, toupper

#define MAX_LENGTH 100

int main() {
    char str[MAX_LENGTH];

    // Step 1: Prompt user for input string
    printf("Enter a string: ");
    fgets(str, MAX_LENGTH, stdin);

    // Remove trailing newline character if present
    str[strcspn(str, "\\n")] = 0;

    // Step 2: Iterate through the string to toggle characters
    int i = 0;
    while (str[i] != '\\0') {
        // Check if the character is an uppercase letter
        if (isupper(str[i])) {
            str[i] = tolower(str[i]); // Convert to lowercase
        }
        // Check if the character is a lowercase letter
        else if (islower(str[i])) {
            str[i] = toupper(str[i]); // Convert to uppercase
        }
        // If not an alphabet, leave it unchanged
        i++;
    }

    // Step 3: Print the modified string
    printf("Toggled string: %s\\n", str);

    return 0;
}

Run

• Sample Output:

Enter a string: hELLo wORLd!
    Toggled string: HellO WorlD!

• Stepwise Explanation:

1. Input: Similar to the first approach, the program takes string input from the user.
2. Iteration: A while loop processes each character of the string.
3. Case Check and Conversion (using ctype.h):
   • isupper(str[i]) checks if the character is an uppercase letter. If true, tolower(str[i]) converts it to its lowercase equivalent.

1. Output: The modified string is printed.

Conclusion

Toggling character cases in a C string is a fundamental string manipulation task. Both direct ASCII manipulation and using ctype.h functions are effective ways to achieve this. While direct ASCII manipulation offers a clear understanding of character encoding, the ctype.h approach provides a more robust, readable, and portable solution by abstracting character set details.

Summary

• Problem: Convert uppercase letters to lowercase and lowercase to uppercase in a string, leaving other characters unchanged.
• Approach 1 (ASCII): Directly add or subtract 32 from a character's ASCII value after checking if it falls within 'A'-'Z' or 'a'-'z' ranges.
• Approach 2 (ctype.h): Use standard library functions isupper(), islower(), tolower(), and toupper() for safer and more portable case toggling.
• Benefits: ctype.h functions are generally preferred for their readability and robustness across different character encodings and locales.