C-Language-Series-#145: Counting Vowels and Consonants in C

Mastering string manipulation is crucial in C programming. One common task is analyzing the composition of text, and a great starting point is counting vowels and consonants. This exercise not only familiarizes you with character-by-character processing but also introduces you to powerful library functions that simplify such operations. In this post, we'll dive deep into developing a C program to accurately count the number of vowels and consonants within any given sentence or word.

Understanding Vowels and Consonants

Before we jump into the code, let's briefly define what we're looking for. In the context of the English alphabet:

• Vowels: These are the speech sounds produced with an open vocal tract. In English, these are typically 'a', 'e', 'i', 'o', 'u' (and their uppercase counterparts 'A', 'E', 'I', 'O', 'U').
• Consonants: These are all other letters of the alphabet that are not vowels. Examples include 'b', 'c', 'd', 'f', 'g', etc.
• Important Note: For this programming exercise, we will typically focus only on alphabetic characters and disregard numbers, spaces, punctuation, or other special symbols when counting vowels and consonants.

The Logic Behind Counting

To count vowels and consonants in a given string, our program needs to follow a systematic approach:

1. Input: First, we'll need to obtain a string (a sentence or a word) from the user.
2. Initialization: Declare two integer variables, one for vowels and one for consonants, and initialize them both to 0.
3. Iteration: Loop through each character of the input string, from the beginning until the end (marked by the null terminator '\0').
4. Character Classification: Inside the loop, for each character:
   • Is it an Alphabet? Use a function like isalpha() (from <ctype.h>) to check if the character is an alphabet (a-z or A-Z).
   • Case Conversion: If it is an alphabet, convert it to lowercase using tolower() (also from <ctype.h>). This simplifies our vowel check, as we only need to compare against 'a', 'e', 'i', 'o', 'u' once, rather than both uppercase and lowercase forms.
   • Vowel Check: Compare the lowercase character against 'a', 'e', 'i', 'o', 'u'. If it matches any of these, increment the vowels counter.
   • Consonant Check: If the character is an alphabet but is not one of the vowels, then it must be a consonant. In this case, increment the consonants counter.
5. Result: After iterating through all characters in the string, print the final counts of vowels and consonants.

C Implementation: Counting Vowels and Consonants

Let's put this logic into a complete C program. We'll utilize helper functions from the standard C library, particularly from <ctype.h>, which make character handling much cleaner.

Example Code

#include <stdio.h>  // Required for printf, fgets
#include <string.h> // Required for strlen
#include <ctype.h>  // Required for isalpha, tolower

int main() {
    char sentence[1000]; // Declare a character array (string) to store input
    int vowels = 0;      // Counter for vowels, initialized to 0
    int consonants = 0;  // Counter for consonants, initialized to 0
    int i;               // Loop counter

    // Prompt the user to enter a sentence
    printf("Enter a sentence: ");

    // Read the entire line of input, including spaces, up to 999 characters
    // (1000 - 1 for the null terminator).
    // fgets is safer than scanf("%s", ...) as it prevents buffer overflows.
    fgets(sentence, sizeof(sentence), stdin);

    // fgets includes the newline character '\n' if the user presses Enter.
    // We should remove it for accurate string processing.
    // Check if the last character before the null terminator is a newline
    if (strlen(sentence) > 0 && sentence[strlen(sentence) - 1] == '\n') {
        sentence[strlen(sentence) - 1] = '\0'; // Replace newline with null terminator
    }

    // Iterate through each character of the string until the null terminator is reached
    for (i = 0; sentence[i] != '\0'; i++) {
        char ch = sentence[i]; // Get the current character

        // First, check if the character is an alphabet
        if (isalpha(ch)) {
            // Convert the character to lowercase to simplify vowel checking.
            // This means we only need to compare against 'a', 'e', 'i', 'o', 'u'.
            ch = tolower(ch);

            // Now, check if the lowercase character is a vowel
            if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u') {
                vowels++; // Increment vowel counter
            } else {
                // If it's an alphabet and not a vowel, it must be a consonant
                consonants++; // Increment consonant counter
            }
        }
        // Non-alphabetic characters (like spaces, numbers, punctuation)
        // are ignored in this specific problem for vowel/consonant counts.
    }

    // Print the final calculated counts
    printf("Number of vowels: %d\n", vowels);
    printf("Number of consonants: %d\n", consonants);

    return 0; // Indicate successful program execution
}
    

Code Explanation

• #include <stdio.h>: This header file provides essential input/output functions, such as printf() for displaying output and fgets() for reading strings from the user.
• #include <string.h>: This header contains string manipulation functions like strlen(), which calculates the length of a string. We use it to identify and remove the newline character captured by fgets().
• #include <ctype.h>: This is a crucial header for character handling. It provides:
  • isalpha(int c): This function returns a non-zero value (true) if the character c is an alphabetic character (a-z or A-Z), and 0 (false) otherwise.
  • tolower(int c): This function converts an uppercase letter to its lowercase equivalent. If c is not an uppercase letter, it returns c unchanged. Using this simplifies our vowel check considerably.
• Character Array (String): char sentence[1000]; declares an array of 1000 characters. In C, strings are character arrays terminated by a null character ('\0').
• Input with fgets(): We use fgets(sentence, sizeof(sentence), stdin); to read the user's input. It's preferred over scanf("%s", ...) because it can read strings containing spaces and has built-in buffer overflow protection. A common side effect of fgets() is that it reads the newline character ('\n') if the input buffer has space, so we explicitly remove it.
• Looping Through the String: The for loop iterates through each character of the sentence array using the index i. The loop continues as long as the current character sentence[i] is not the null terminator '\0', which signifies the end of the string.
• Conditional Logic for Counting:
  • The outer if (isalpha(ch)) ensures that we only process letters, ignoring spaces, numbers, and symbols.
  • Inside this block, ch = tolower(ch); converts the letter to lowercase, making the subsequent vowel check case-insensitive.
  • The inner if-else block then checks if the lowercase character is one of the five vowels. If it is, vowels is incremented; otherwise, consonants is incremented.

Further Enhancements & Considerations

• Counting Other Characters: You could easily extend this program to also count digits, spaces, or special characters by adding more if-else if conditions outside the isalpha() block.
• Function Abstraction: For more complex programs, you might encapsulate the counting logic within a separate function. This function could take a string as input and return a structure containing the counts of vowels, consonants, and other character types.
• Locale Sensitivity: Be aware that for non-English alphabets (e.g., accented characters in French or German), the definition of vowels and consonants might vary, and functions like isalpha() and tolower() might behave differently based on the current locale settings.
• Performance: For very long strings, more advanced string processing algorithms might be considered, though for typical user inputs, the iterative approach demonstrated here is perfectly adequate.

Conclusion

Counting vowels and consonants in C is a fundamental string manipulation task that effectively reinforces your understanding of character processing, loops, and conditional statements. By leveraging the utility functions from <ctype.h>, we can write concise, robust, and readable code to solve this common problem efficiently. Experiment with different inputs, including those with mixed cases, numbers, and symbols, to solidify your understanding and explore potential modifications. This foundational skill will serve you well as you tackle more complex text analysis challenges in C.