Converting Numbers to Words in C++ with Qt: A Practical Guide

The task of converting numerical values into their word equivalents is a common challenge in software development. Whether you're working on financial applications, report generation tools, or educational software, the ability to transform numbers into readable text is invaluable. This article explores how to implement a number-to-words converter in C++ using the Qt framework.

The Challenge: Number to Word Conversion

Converting numbers to words involves several layers of complexity. Here's a breakdown of the hurdles:

• Basic Numbers: Converting single-digit and teen numbers (0-19) is straightforward.
• Tens: Handling multiples of ten (20, 30, 40, etc.) requires a separate set of rules.
• Hundreds: Incorporating "hundred" introduces another level.
• Thousands, Millions, Billions: Dealing with larger numbers requires handling different magnitude levels and their corresponding names.
• Concatenation: Correctly combining these elements to form a grammatically correct phrase is crucial.

A Qt-Based Solution

The following code snippet, adapted from a solution provided in the Qt Forum, demonstrates an elegant way to tackle this problem:

static QString numberToText(uint number)
{
    static QMap<uint, QString> numbers;
    //Only initialize once
    if (numbers.isEmpty())
    {
        numbers[0] = "zero";
        numbers[1] = "one";
        numbers[2] = "two";
        numbers[3] = "three";
        numbers[4] = "four";
        numbers[5] = "five";
        numbers[6] = "six";
        numbers[7] = "seven";
        numbers[8] = "eight";
        numbers[9] = "nine";
        numbers[10] = "ten";
        numbers[11] = "eleven";
        numbers[12] = "twelve";
        numbers[13] = "thirteen";
        numbers[14] = "fourteen";
        numbers[15] = "fifteen";
        numbers[16] = "sixteen";
        numbers[17] = "seventeen";
        numbers[18] = "eighteen";
        numbers[19] = "nineteen";
        numbers[20] = "twenty";
        numbers[30] = "thirty";
        numbers[40] = "forty";
        numbers[50] = "fifty";
        numbers[60] = "sixty";
        numbers[70] = "seventy";
        numbers[80] = "eighty";
        numbers[90] = "ninety";
    }
    static QMap<uint, QString> powers;
    //Only initialize once
    if (powers.isEmpty())
    {
        powers[2] = "hundred";
        powers[3] = "thousand";
        powers[6] = "million";
        powers[9] = "billion";
    }
    QString output;
    if (number < 21)
    {
        output = numbers[number];
    }
    else if (number < 100)
    {
        output = numbers[10 * qFloor(number / 10)];
        uint remainder = number % 10;
        if (remainder > 0)
            output += "-" + numberToText(remainder);
    }
    else
    {
        uint power = 2;
        uint place = 0;
        QString powerString;
        //QMap::keys is ordered
        foreach (uint pow, powers.keys())
        {
            uint place_value = qPow(10, pow);
            uint tmp_place = qFloor(number / place_value);
            if (tmp_place < 1)
                break;
            place = tmp_place;
            power = pow;
            powerString = powers[pow];
        }
        if (power > 0)
        {
            output = numberToText(place) + " " + powerString;
            uint remainder = number % uint(qPow(10, power));
            if (remainder > 0)
                output += " " + numberToText(remainder);
        }
    }
    return output;
}

Key Components Explained

• QMap for Storage: The code utilizes QMap to store number-word mappings. One QMap stores the basic numbers (0-90), and another stores the powers of ten (hundred, thousand, million, billion). QMap is a Qt container class that provides a dictionary-like data structure, offering efficient key-value lookups.
• Static Initialization: The QMap instances are initialized only once using the if (numbers.isEmpty()) check. This ensures efficiency by avoiding repeated initialization on subsequent function calls.
• Recursive Approach: The numberToText function is recursive. It breaks down the input number into smaller parts and calls itself to convert those parts into words. This simplifies the logic for handling larger numbers.
• Handling Different Ranges: The code uses if and else if statements to handle different number ranges:
  • Numbers less than 21 are directly looked up in the numbers map.
  • Numbers less than 100 are handled by combining the tens value with the remainder (e.g., "twenty-three").
  • Numbers greater than or equal to 100 are processed by finding the appropriate power of ten (hundred, thousand, etc.) and recursively converting the quotient and remainder.

Using the Code

To use this function, simply pass an unsigned integer as an argument:

uint number = 12345;
QString words = numberToText(number);
qDebug() << words; // Output: "twelve thousand three hundred forty-five"

Advantages of this approach

• Readability: The code is well-structured and easy to understand.
• Efficiency: The use of static QMap instances and recursion makes the code relatively efficient
• Qt Integration: The code seamlessly integrates with the Qt framework by using QString for text manipulation and QMap for data storage.

Further Improvements

• Error Handling: The code doesn't handle negative numbers or non-integer inputs. Adding error handling would make it more robust.
• Currency Support: Extending the code to handle currency (e.g., "one hundred dollars and fifty cents") would increase its versatility.
• Language Support: The current code is specific to English. Adapting it to other languages would require modifying the QMap instances with the appropriate word mappings.

Conclusion

Converting numbers to words in C++ can be achieved effectively using the Qt framework. The solution presented here provides a solid foundation for building more complex number-to-word converters. By understanding the core concepts and considering potential improvements, you can create a robust and versatile tool for your software development needs. Remember to explore additional resources and libraries to further enhance your implementation and cater to specific requirements. You can find other helpful resources on platforms like Stack Overflow.