Program To Convert ASCII To Unicode In C++

Two commonly used character encoding systems in programming include ASCII and Unicode. While Unicode has the capability to represent a vast array of characters using code points from 0 to 0x10FFFF, ASCII is limited to encoding only 128 characters within 7 bits. In cases where characters beyond the ASCII range need to be processed or displayed in C++, it can be beneficial to convert ASCII character codes to their corresponding Unicode code points. This article will present a simple C++ program that converts user-inputted ASCII codes into the corresponding Unicode characters. The strategy involves directly mapping ASCII values to Unicode code points, which is effective for the standard ASCII range of 0-127. The provided code snippet demonstrates how this conversion can be achieved with concise C++ code, serving as a foundational step towards more sophisticated Unicode management in software applications.

What is the ASCCI Code?

The character encoding standard named ASCII (American Standard Code for Information Interchange) employs seven bits to represent 128 characters. Initially developed in the 1960s, ASCII was originally designed around the English alphabet.

The character set in ASCII encodes:

• ✅ Both capital and lowercase Letters in English (A-Z, a-z).
• ✅ Numbers 0 through 9.
• ✅ Symbols for punctuation.
• ✅ Control codes: line feed, carriage return, etc.
• ✅ Special Symbols such as such as !"#$%&'*+,-./:;<=>?@^_}{|}~.

The binary numbers ranging from 0000000 to 1111111 represent decimal values from 0 to 127, mapping to individual characters. For instance:

• ✅ Binary 0100001, equivalent to decimal 65, represents the character 'A',
• ✅ Whereas binary 01000010, equal to decimal 66, represents the character 'B'.

The initial 32 ASCII codes (0-31 decimal) are set aside for non-printable control characters such as null, tab, line feed, carriage return, etc. Codes 32-126 are designated for printable characters like letters, digits, and punctuation, while code 127 is specifically reserved for the deleted character.

The ASCII standard is limited to 7 bits for individual characters, whereas contemporary systems commonly employ 8 bits and designate the most significant bit as 0. This setup enables ASCII to coexist with other encodings within 8-bit environments.

What is Unicode?

In the majority of written languages, Unicode serves as a widely accepted standard within the computing field, ensuring uniform encoding, representation, manipulation, and management of text. Irrespective of the platform being used, Unicode provides a distinct numerical value to every character, regardless of its origin, purpose, or language.

Some key points about Unicode:

• ✅ Unicode enables text processing, storage, and transport independently of language and platform.
• ✅ Unicode standard can encode over 1 million characters. It includes characters of all major languages in the world.
• ✅ Unicode uses a coding space of 21 bits to define 1,112,064 code points. Each code point represents a unique character.
• ✅ The 21-bit space is divided into 17 planes, each with 65,536 (= 2^16) code points. The first plane (0000 - F) is called Basic Multilingual Plane (BMP) and contains characters for almost all modern languages.
• ✅ Unicode has bidirectional text, glyphs, collation and rendering standards to facilitate internationalization.
• ✅ The Unicode Consortium, a non-profit organization, maintains the Unicode standard. Major companies and organizations participate in developing Unicode standards.
• ✅ Unicode is device & platform-independent. The character represented by a Unicode code point will render consistently across devices.
• ✅ Unicode is backwards compatible with ASCII. The first 128 Unicode code points correspond to the ASCII characters.

What is the ASCII Table of Characters?

The ASCII chart is a character encoding standard that represents 128 characters using 7-bit binary values. ASCII is short for American Standard Code for Information Interchange.

The ASCII table includes:

• ✅ Uppercase and lowercase English letters
• ✅ Numeric digits
• ✅ Punctuation marks
• ✅ Control codes
• ✅ Special characters

Every ASCII character corresponds to a decimal value ranging from 0 to 127. This mapping enables the representation of characters through binary digits spanning from 0000000 to 1111111.

The first 32 ASCII codes (0-31) are reserved for non-printable control function characters like null, tab, line feed, carriage return, etc.

• ✅ Codes 32 to 47 represent various punctuation symbols.
• ✅ Codes 48 to 57 represent the numeric digits 0 to 9.
• ✅ Codes 65 to 90 are the uppercase letters A to Z.
• ✅ Codes 97 to 122 are the lowercase letters a to z.

The remaining codes are utilized for extra symbols and control characters. Here is the complete ASCII standard chart displaying each character linked to its decimal and hexadecimal code value:

It covers the 128-character ASCII set with control codes, printable characters, punctuation, and special symbols. The table provides the decimal and hex values representing each character in the ASCII encoding standard.

C++ Implementation

• ✅ Get the decimal value of the ASCII character that needs to be converted. For example, 'A' has a decimal value of 65.
• ✅ For ASCII values between 0 and 127, simply assign the ASCII decimal value directly to the Unicode code point. It works because Unicode is backwards compatible with ASCII and maintains the same values for the first 128 characters.
• ✅ So for 'A' with ASCII value 65, the equivalent Unicode code point value is also 65.
• ✅ To convert this to an actual Unicode character cast the code point int variable to a char or wchar_t type in C++.

For example:

int unicode = 65; 

wchar_t unicodeChar = (wchar_t)unicode; // unicodeChar contains 'A'

• ✅ It copies the ASCII value to the Unicode variable, which interprets it as a Unicode code point and converts it.
• ✅ For ASCII values above 127, lookup tables or switch statements would be required to map the ASCII value to the appropriate Unicode code point.
• ✅ Unicode library functions like mbstowcs, or MultiByteToWideChar can also convert ASCII to Unicode.

So, to recap, when dealing with the ASCII range of 0-127, you can directly map the ASCII decimal value to Unicode. For extended ASCII characters above 127, you would utilize mapping techniques to determine the corresponding Unicode code point. Then, you can convert the obtained integer code point to wchar_t or char to retrieve the Unicode character.

#include <iostream>

int main() {

 std::cout << "Enter an ASCII code (0-127): ";

 int asciiCode;

 std::cin >> asciiCode;

 // Convert ASCII to Unicode

 int unicode = asciiCode;

 

 // Print equivalent Unicode character

 std::wcout << "Unicode character: " << (wchar_t)unicode << std::endl;

 return 0;

}

Output:

Enter an ASCII code (0-127): 65

Unicode character: A