Understanding String Implementation

Most of the time a string is a sequence of ordinary char values. But text does not always come from one character set. A program may need to hold Japanese text, or text drawn from Unicode, and those characters do not all fit the default char element type. The source material faces this directly: it wants one string concept that can cover several character sets, rather than a separate class for each one.

Keep this goal in mind as you read. The rest of this article shows how one general template is reused to produce a string over a different character type, and how to find the exact place in a declaration where that character type is chosen.

Read this definition as a relationship between three things. basic_string is the general template, a pattern that can be filled in. char is the character type that fills it in for the ordinary case. string is the familiar name that refers to the result. So string is not a separate, independent implementation. It is one specific use of basic_string, with char plugged in.

The diagram shows the key point. A single general template can produce several distinct string types, each tied to its own character type. The string name is simply the most common of these results.

The source gives the pattern for defining a string over a custom character type. Assume a Japanese character type named Jchar already exists. The declaration that creates a Japanese string type is written as follows.

Read the line in three parts. The name being created is Jstring, which sits to the left of the equals sign. The template is basic_string, the general pattern being used. The argument is Jchar, which sits between the angle brackets and fills in the template. Read in this order, the question to ask about any such line is what goes inside the angle brackets.

Notice what changed and what did not. The only thing that differs from the ordinary string case is the character type. Everything else about the pattern is the same, which is why the same template supports both.

Once Jstring is defined, the source says you can do all the usual string operations on it, because it is a string of Japanese characters. The phrase usual string operations refers to the operations you already know from string, now applied to a string whose element type is Jchar.

The source makes the same point for Unicode: a Unicode string can be handled in the same way. The practical reading is that the character type changes what the elements are, while the set of operations the source names stays the same for the new type.

When a string result is not what you expected, the first question is where the character type was decided. For an alias like Jstring, that decision lives in the declaration that introduces the name. The source recommends checking there first, because the character type argument in that line determines the element type.