Demystifying C++ I/O

// Read the current number to advance the stream. ioData >> number;

}

}

Of course, an approach like this will only work properly if the data is of a fixed size. When the preceding program switched from reading to writing, the output data overwrote other data in the file. To preserve the format of the file, and to avoid writing over the next record, the data had to be the same size.

String streams can also be accessed in a bidirectional manner through the stringstream class.

Bidirectional streams have separate pointers for the read position and the write position. When switching between reading and writing, you will need to seek to the appropriate position.

Internationalization

When you’re learning how to program in C or C++, it’s useful to think of a character as equivalent to a byte and to treat all characters as members of the ASCII (U.S.) character set. In reality, Professional C++ programmers recognize that successful software programs are used throughout the world. Even if you don’t initially write your program with international audiences in mind, you shouldn’t prevent yourself from localizing, or making the software internationally aware, at a later date.

Wide Characters

The problem with viewing a character as a byte is that not all languages, or character sets, can be fully represented in 8 bits, or 1 byte. Luckily, C++ has a built-in type called wchar_t that holds a wide character. Languages with non-ASCII (U.S.) characters such as Japanese and Arabic can be represented in C++ with wchar_t.

If there is any chance that your program will be used in a non-Western character set context (hint: there is!), you should use wide characters from the beginning. Using wchar_t is simple because it works just like a char. The only difference is that string and character literals are prefixed with the letter L to indicate that a wide-character encoding should be used. For example, to initialize a wchar_t character to be the letter m, you would write it like this:

wchar_t myWideCharacter = L’m’;

There are wide-character versions of all your favorite types and classes. The wide string class is wstring. The “prefix the letter w” pattern applies to streams as well. Wide-character file output streams are handled with the wofstream, and input is handled with the wifstream. The joy of pronouncing these class names (woof-stream? whiff-stream?) is reason enough to make your programs internationally aware!

In addition to cout, cin, and cerr, there are wide versions of the built-in console and error streams called wcout, wcin, and wcerr. As with the other wide-stream classes and types, using them is no different from using the nonwide versions, as shown by the following simple program:

397

Chapter 14

#include <iostream>

using namespace std;

int main(int argc, char** argv)

{

wcout << L”I am internationally aware.” << endl;

}

Non-Western Character Sets

Wide characters are a great step forward because they increase the amount of space available to define a single character. The next step is to figure out how that space is used. In traditional (i.e., obsolete) ASCII characters, each letter corresponded to a particular number. Each number could fit in a single byte, so a letter was the same as a number, which was the same as a byte.

Modern character representation isn’t very different. The map of characters to numbers (now called code points) is quite a bit larger because it handles many different character sets in addition to the characters that English-speaking programmers are familiar with. The map of characters to code points in all the known character sets is defined by the Unicode standard. For example, the Hebrew character (pronounced aleph) maps to the Unicode code point 05D0. No other character in any other character set maps to that code point.

To work properly with Unicode text, you also need to know its encoding. Different applications can store Unicode characters in different ways. In C++, the standard encoding of wide characters is known as UTF-16 because each character is held in 16 bits.

Locales and Facets

Character sets are only one of the differences in data representation between countries. Even countries that use similar character sets, such as Great Britain and the United States, still differ in how they represent data such as dates and money.

The standard C++ library contains a built-in mechanism that groups specific data about a particular place together into a locale. A locale is a collection of settings about a particular location. An individual setting is called a facet. An example of a locale is U.S. English. An example of a facet is the format used to display a date. There are several built-in facets that are common to all locales. The language also provides a way to customize or add facets.

Using Locales

From a programmer’s perspective, locales are an automatic feature of the language. When using I/O streams, data is formatted according to a particular locale. Locales are simply objects that can be attached to a stream. For example, the following line uses the output stream’s imbue() method to attach the U.S. English locale (usually named “en_U”) to the wide-character console output stream:

U.S. English is usually not the default locale. The default locale is generally the classic locale, which uses ANSI C conventions. The classic C locale is similar to U.S. English settings, but there are slight differences.

398

Demystifying C++ I/O

For example, if you do not set a locale at all, or set the default locale, and you output a number, it will be presented without any punctuation:

wcout.imbue(locale(“C”))

wcout << 32767 << endl;

The output of this code will be:

32767

If you set the U.S. English locale, however, the number will be formatted with U.S. English punctuation. The following code to set the locale to U.S. English before outputting the number:

wcout.imbue(locale(“en_US”));

wcout << 32767 << endl;

The output of this code will be:

32,767

As you may be aware, different regions have different approaches to formatting numerical data, including the punctuation used to separate thousands and denote a decimal place.

The names of locales can be implementation-specific, although most implementations have standardized on the practice of separating the language and the area in two-letter sections with an optional encoding. For example, the locale for the French language, as spoken in France is fr_FR. The locale for Japanese spoken in Japan with Japanese Industrial Standard encoding is ja_JP.jis.

Most operating systems have a mechanism to determine the locale as defined by the user. In C++, you can pass an empty string to the locale object constructor to create a locale from the user’s environment. Once this object is created, you can use it to query the locale, possibly making programmatic decisions based on it.

For example, the following program creates a default locale. The name() method is used to get a C++ string that describes the locale. One of two messages is output, depending on whether the locale appears to be U.S. English or not.

#include <iostream> #include <string>

using namespace std;

int main(int argc, char** argv)

{

locale loc(“”);

if (loc.name().find(“en_US”) == string::npos && loc.name().find(“United States”) == string::npos) { wcout << L”Welcome non-U.S. user!” << endl;

} else {

wcout << L”Welcome U.S. user!” << endl;

}

}

399

Chapter 14

Determining a location based on the name of the locale is not necessarily an accurate way to decide where the user is physically located, but it can provide a clue.

Using Facets

You can use the std::use_facet() function to obtain a particular facet in a particular locale. For example, the following expression retrieves the standard monetary punctuation facet of the British English facet.

use_facet<moneypunct<wchar_t> >(locale(“en_GB”));

Note that the innermost template type determines the character type to use. This is usually wchar_t or char. The use of nested template classes is unfortunate, but once you get past the syntax, the result is an object that contains all the information you want to know about British money punctuation. The data available in the standard facets are defined in the <locale> header and its associated files.

The following program brings together locales and facets by printing out the currency symbol in both U.S. English and British English. Note that, depending on your environment, the British currency symbol may appear as a question mark, a box, or not at all. Also note that locale names can vary by platform. If your environment is equipped to handle it, you may actually get the British pound symbol.

#include <iostream> #include <locale>

using namespace std;

int main(int argc, char** argv)

{

locale locUSEng (“en_US”);

locale locBritishEng (“en_GB”);

wstring dollars = use_facet<moneypunct<wchar_t> >(locUSEng).curr_symbol(); wstring pounds = use_facet<moneypunct<wchar_t> >(locBritishEng).curr_symbol();

wcout << L”In the US, the currency symbol is “ << dollars << endl; wcout << L”In Great Britain, the current symbol is “ << pounds << endl;

}

Summar y

As we hope you have discovered, streams provide a flexible and object-oriented way to perform input and output. The most important message in this chapter, even more important that the use of streams, is the concept of a stream. Some operating systems may have their own file access and I/O facilities, but knowledge of how streams and streamlike libraries work is essential to working with any type of modern I/O system.

We also hope you have gained an appreciation for coding with internationalization in mind. As anyone who has been through a localization effort will tell you, adding support for a new language or locale is infinitely easier if you have planned ahead by using Unicode characters and being mindful of locales.

400