Using Locales

When using I/O streams, data is formatted according to a particular locale. Locales are objects that can be attached to a stream, and they are defined in the <locale> header file. Locale names are implementation specific. The POSIX standard is to separate a language and an area into two-letter sections with an optional encoding. For example, the locale for the English language as spoken in the U.S. is en_US, while the locale for the English language as spoken in Great Britain is en_GB. The locale for Japanese spoken in Japan with Japanese Industrial Standard encoding is ja_JP.jis.

Locale names on Windows can have two formats. The preferred format is very similar to the POSIX format, but uses a dash instead of an underscore. The second, old format, looks like this:

lang[_country_region[.code_page]]

Everything between the square brackets is optional. The following table lists some examples.

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 std::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. The following code demonstrates how to use the user’s locale for a stream by calling the imbue() method on the stream. The result is that everything that is sent to wcout is formatted according to the formatting rules for your environment:

wcout.imbue(locale(""));
wcout << 32767 << endl;

This means that if your system locale is English United States and you output the number 32767, the number is displayed as 32,767; however, if your system locale is Dutch Belgium, the same number is displayed as 32.767.

The default locale is the classic/neutral locale, and not the user’s locale. The classic locale uses ANSI C conventions, and has the name C. The classic C locale is similar to U.S. English, but there are slight differences. For example, numbers are handled without any punctuation:

wcout.imbue(locale("C"));
wcout << 32767 << endl;

The output of this code is as follows:

32767

The following code manually sets the U.S. English locale, so the number 32767 is formatted with U.S. English punctuation, independent of your system locale:

wcout.imbue(locale("en-US")); // "en_US" for POSIX
wcout << 32767 << endl;

The output of this code is as follows:

32,767

A locale object allows you to query information about the locale. For example, the following program creates a locale matching the user’s environment. The name() method is used to get a C++ string that describes the locale. Then, the find() method is used on the string object to find a given substring, which returns string::npos when the given substring is not found. The code checks for the Windows name and the POSIX name. One of two messages is output, depending on whether or not the locale appears to be U.S. English:

locale loc("");
if (loc.name().find("en_US") == string::npos &&
    loc.name().find("en-US") == string::npos) {
    wcout << L"Welcome non-U.S. English speaker!" << endl;
} else {
    wcout << L"Welcome U.S. English speaker!" << endl;
}

Character Classification

The <locale> header contains the following character classification functions: std::isspace(), isblank(), iscntrl(), isupper(), islower(), isalpha(), isdigit(), ispunct(), isxdigit(), isalnum(), isprint(), isgraph(). They all accept two parameters: the character to classify, and the locale to use for the classification. Here is an example of isupper() using the user’s environment locale:

bool result = isupper('A', locale(""));

Character Conversion

The <locale> header also defines two character conversion functions: std::toupper() and tolower(). They accept two parameters: the character to convert, and the locale to use for the conversion.

Using Facets

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

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 is defined in the <locale> header and its associated files. The following table lists the facet categories defined by the standard. Consult a Standard Library reference for details about the individual facets.

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. If your environment is set up to handle it, you may actually get the British pound symbol:

locale locUSEng("en-US");       // For Windows
//locale locUSEng("en_US");     // For Linux
locale locBritEng("en-GB");     // For Windows
//locale locBritEng("en_GB");   // For Linux

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

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

Anchors

The special characters ^ and $ are called anchors. The ^ character matches the position immediately following a line termination character, and $ matches the position of a line termination character. By default, ^ and $ also match the beginning and ending of a string, respectively, but this behavior can be disabled.

For example, ^test$ matches only the string test, and not strings that contain test somewhere in the line, such as 1test, test2, test abc, and so on.

Wildcards

The wildcard character . can be used to match any character except a newline character. For example, the regular expression a.c will match abc, and a5c, but will not match ab5c, ac, and so on.

Alternation

The | character can be used to specify the “or” relationship. For example, a|b matches a or b.

Grouping

Parentheses () are used to mark subexpressions, also called capture groups. Capture groups can be used for several purposes:

• Capture groups can be used to identify individual subsequences of the original string; each marked subexpression (capture group) is returned in the result. For example, take the following regular expression: (.)(ab|cd)(.). It has three marked subexpressions. Running a regex_search() with this regular expression on 1cd4 results in a match with four entries. The first entry is the entire match, 1cd4, followed by three entries for the three marked subexpressions. These three entries are 1, cd, and 4. The details on how to use the regex_search() algorithm are shown in a later section.
• Capture groups can be used during matching for a purpose called back references (explained later).
• Capture groups can be used to identify components during replace operations (explained later).

Repetition

Parts of a regular expression can be repeated by using one of four repeats:

• * matches the preceding part zero or more times. For example, a*b matches b, ab, aab, aaaab, and so on.
• + matches the preceding part one or more times. For example, a+b matches ab, aab, aaaab, and so on, but not b.
• ? matches the preceding part zero or one time. For example, a?b matches b and ab, but nothing else.
• {…} represents a bounded repeat. a{n} matches a repeated exactly n times; a{n,} matches a repeated n times or more; and a{n,m} matches a repeated between n and m times inclusive. For example, a{3,4} matches aaa and aaaa but not a, aa, aaaaa, and so on.

The repeats described in the previous list are called greedy because they find the longest match while still matching the remainder of the regular expression. To make them non-greedy, a ? can be added behind the repeat, as in *?, +?, ??, and {…}?. A non-greedy repetition repeats its pattern as few times as possible while still matching the remainder of the regular expression.

For example, the following table shows a greedy and a non-greedy regular expression, and the resulting submatches when running them on the input sequence aaabbb.

Precedence

Just as with mathematical formulas, it’s important to know the precedence of regular expression elements. Precedence is as follows:

• Elements like a are the basic building blocks of a regular expression.
• Quantifiers like +, *, ?, and {…} bind tightly to the element on the left; for example, b+.
• Concatenation like ab+c binds after quantifiers.
• Alternation like | binds last.

For example, take the regular expression ab+c|d. This matches abc, abbc, abbbc, and so on, and also d. Parentheses can be used to change these precedence rules. For example, ab+(c|d) matches abc, abbc, abbbc, …, abd, abbd, abbbd, and so on. However, by using parentheses you also mark it as a subexpression or capture group. It is possible to change the precedence rules without creating new capture groups by using (?:…). For example, ab+(?:c|d) matches the same as the preceding ab+(c|d) but does not create an additional capture group.

Character Set Matches

Instead of having to write (a|b|c|…|z), which is clumsy and introduces a capture group, a special syntax for specifying sets of characters or ranges of characters is available. In addition, a “not” form of the match is also available. A character set is specified between square brackets, and allows you to write [c₁c₂…c_n], which matches any of the characters c₁, c₂ , …, or c_n. For example, [abc] matches any character a, b, or c. If the first character is ^, it means “any but”:

• ab[cde] matches abc, abd, and abe.
• ab[^cde] matches abf, abp, and so on but not abc, abd, and abe.

If you need to match the ^, [, or ] characters themselves, you need to escape them; for example, [[^]] matches the characters [, ^, or ].

If you want to specify all letters, you could use a character set like [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ]; however, this is clumsy and doing this several times is awkward, especially if you make a typo and omit one of the letters accidentally. There are two solutions to this.

One solution is to use the range specification in square brackets; this allows you to write [a-zA-Z], which recognizes all the letters in the range a to z and A to Z. If you need to match a hyphen, you need to escape it; for example, [a-zA-Z-]+ matches any word including a hyphenated word.

Another solution is to use one of the character classes. These are used to denote specific types of characters and are represented as [:name:]. Which character classes are available depends on the locale, but the names listed in the following table are always recognized. The exact meaning of these character classes is also dependent on the locale. This table assumes the standard C locale.

Character classes are used within character sets; for example, [[:alpha:]]* in English means the same as [a-zA-Z]*.

Because certain concepts like matching digits are so common, there are shorthand patterns for them. For example, [:digit:] and [:d:] mean the same thing as [0-9]. Some classes have an even shorter pattern using the escape notation . For example, d means [:digit:]. Therefore, to recognize a sequence of one or more numbers, you can write any of the following patterns:

• [0-9]+
• [[:digit:]]+
• [[:d:]]+
• d+

The following table lists the available escape notations for character classes.

Here are some examples:

• Test[5-8] matches Test5, Test6, Test7, and Test8.
• [[:lower:]] matches a, b, and so on, but not A, B, and so on.
• [^[:lower:]] matches any character except lowercase letters like a, b, and so on.
• [[:lower:]5-7] matches any lowercase letter like a, b, and so on, and the numbers 5, 6, and 7.

Word Boundaries

A word boundary can mean the following:

• The beginning of the source string if the first character of the source string is one of the word characters, that is, a letter, digit, or an underscore. For the standard C locale this is equal to [A-Za-z0-9_]. Matching the beginning of the source string is enabled by default, but you can disable it (regex_constants::match_not_bow).
• The end of the source string if the last character of the source string is one of the word characters. Matching the end of the source string is enabled by default, but you can disable it (regex_constants::match_not_eow).
• The first character of a word, which is one of the word characters, while the preceding character is not a word character.
• The end of a word, which is a non-word character, while the preceding character is a word character.

You can use  to match a word boundary, and B to match anything except a word boundary.

Back References

Back references allow you to reference a captured group inside the regular expression itself: refers to the n-th captured group, with n > 0. For example, the regular expression (d+)-.*-1 matches a string that has the following format:

• one or more digits captured in a capture group (d+)
• followed by a dash -
• followed by zero or more characters .*
• followed by another dash -
• followed by exactly the same digits captured by the first capture group 1

This regular expression matches 123-abc-123, 1234-a-1234, and so on but does not match 123-abc-1234, 123-abc-321, and so on.

Lookahead

Regular expressions support positive lookahead (which uses ?=pattern) and negative lookahead (which uses ?!pattern). The characters following the lookahead must match (positive), or not match (negative) the lookahead pattern, but those characters are not yet consumed.

For example: the pattern a(?!b) contains a negative lookahead to match a letter a not followed by a b. The pattern a(?=b) contains a positive lookahead to match a letter a followed by a b, but b is not consumed so it does not become part of the match.

The following is a more complicated example. The regular expression matches an input sequence that consists of at least one lowercase letter, at least one uppercase letter, at least one punctuation character, and is at least eight characters long. Such a regular expression can, for example, be used to enforce that passwords satisfy certain criteria.

 (?=.*[[:lower:]])(?=.*[[:upper:]])(?=.*[[:punct:]]).{8,}

Regular Expressions and Raw String Literals

As you saw in the preceding sections, regular expressions often use special characters that should be escaped in normal C++ string literals. For example, if you write d in a regular expression, it matches any digit. However, because is a special character in C++, you need to escape it in your regular expression string literal as \d; otherwise, your C++ compiler tries to interpret the d. It can get more complicated if you want your regular expression to match a single back-slash character . Because is a special character in the regular expression syntax itself, you need to escape it as \. The character is also a special character in C++ string literals, so you need to escape it in your C++ string literal, resulting in \\.

You can use raw string literals to make a complicated regular expression easier to read in your C++ source code. (Raw string literals are discussed in Chapter 2.) For example, take the following regular expression:

"( |\n|\r|\\)"

This regular expression matches spaces, newlines, carriage returns, and back slashes. As you can see, you need a lot of escape characters. Using raw string literals, this can be replaced with the following more readable regular expression:

R"(( |
|
|\))"

The raw string literal starts with R"( and ends with )". Everything in between is the regular expression. Of course, you still need a double back slash at the end because the back slash needs to be escaped in the regular expression itself.

This concludes a brief description of the ECMAScript grammar. The following sections explain how to actually use regular expressions in your C++ code.

regex_match() Example

Suppose you want to write a program that asks the user to enter a date in the format year/month/day, where year is four digits, month is a number between 1 and 12, and day is a number between 1 and 31. You can use a regular expression together with the regex_match() algorithm to validate the user input as follows. The details of the regular expression are explained after the code.

regex r("\d{4}/(?:0?[1-9]|1[0-2])/(?:0?[1-9]|[1-2][0-9]|3[0-1])");
while (true) {
    cout << "Enter a date (year/month/day) (q=quit): ";
    string str;
    if (!getline(cin, str) || str == "q")
        break;

    if (regex_match(str, r))
        cout << "  Valid date." << endl;
    else
        cout << "  Invalid date!" << endl;
}

The first line creates the regular expression. The expression consists of three parts separated by a forward slash (/) character: one part for year, one for month, and one for day. The following list explains these parts.

• d{4}: This matches any combination of four digits; for example, 1234, 2010, and so on.
• (?:0?[1-9]|1[0-2]): This subpart of the regular expression is wrapped inside parentheses to make sure the precedence is correct. You don’t need a capture group, so (?:…) is used. The inner expression consists of an alternation of two parts separated by the | character.
• 0?[1-9]: This matches any number from 1 to 9 with an optional 0 in front of it. For example, it matches 1, 2, 9, 03, 04, and so on. It does not match 0, 10, 11, and so on.
• 1[0-2]: This matches 10, 11, or 12, and nothing else.
• (?:0?[1-9]|[1-2][0-9]|3[0-1]): This subpart is also wrapped inside a non-capture group and consists of an alternation of three parts.
• 0?[1-9]: This matches any number from 1 to 9 with an optional 0 in front of it. For example, it matches 1, 2, 9, 03, 04, and so on. It does not match 0, 10, 11, and so on.
• [1-2][0-9]: This matches any number between 10 and 29 inclusive and nothing else.
• 3[0-1]: This matches 30 or 31 and nothing else.

The example then enters an infinite loop to ask the user to enter a date. Each date entered is given to the regex_match() algorithm. When regex_match() returns true, the user has entered a date that matches the date regular expression pattern.

This example can be extended a bit by asking the regex_match() algorithm to return captured subexpressions in a results object. You first have to understand what a capture group does. By specifying a match_results object like smatch in a call to regex_match(), the elements of the match_results object are filled in when the regular expression matches the input string. To be able to extract these substrings, you must create capture groups using parentheses.

The first element, [0], in a match_results object contains the string that matched the entire pattern. When using regex_match() and a match is found, this is the entire source sequence. When using regex_search(), discussed in the next section, this is a substring in the source sequence that matches the regular expression. Element [1] is the substring matched by the first capture group, [2] by the second capture group, and so on. To get a string representation of a capture group, you can write m[i] as in the following code, or write m[i].str(), where i is the index of the capture group and m is a match_results object.

The following code extracts the year, month, and day digits into three separate integer variables. The regular expression in the revised example has a few small changes. The first part matching the year is wrapped in a capture group, while the month and day parts are now also capture groups instead of non-capture groups. The call to regex_match() includes a smatch parameter, which receives the matched capture groups. Here is the adapted example:

regex r("(\d{4})/(0?[1-9]|1[0-2])/(0?[1-9]|[1-2][0-9]|3[0-1])");
while (true) {
    cout << "Enter a date (year/month/day) (q=quit): ";
    string str;
    if (!getline(cin, str) || str == "q")
        break;

    smatch m;
    if (regex_match(str, m, r)) {
        int year = stoi(m[1]);
        int month = stoi(m[2]);
        int day = stoi(m[3]);
        cout << "  Valid date: Year=" << year
             << ", month=" << month
             << ", day=" << day << endl;
    } else {
        cout << "  Invalid date!" << endl;
    }
}

In this example, there are four elements in the smatch results objects:

• [0]: the string matching the full regular expression, which is the full date in this example
• [1]: the year
• [2]: the month
• [3]: the day

When you execute this example, you can get the following output:

Enter a date (year/month/day) (q=quit): 2011/12/01
  Valid date: Year=2011, month=12, day=1
Enter a date (year/month/day) (q=quit): 11/12/01
  Invalid date!

regex_search() Example

The regex_search() algorithm can be used to extract matching substrings from an input sequence. The following example extracts code comments from input lines. The regular expression searches for a substring that starts with // followed by some optional whitespace s* followed by one or more characters captured in a capture group (.+). This capture group captures only the comment substring. The smatch object m receives the search results. If successful, m[1] contains the comment that was found. You can check the m[1].first and m[1].second iterators to see where exactly the comment was found in the source string.

regex r("//\s*(.+)$");
while (true) {
    cout << "Enter a string with optional code comments (q=quit): ";
    string str;
    if (!getline(cin, str) || str == "q")
        break;

    smatch m;
    if (regex_search(str, m, r))
        cout << "  Found comment '" << m[1] << "'" << endl;
    else
        cout << "  No comment found!" << endl;
}

The output of this program can look as follows:

Enter a string (q=quit): std::string str;   // Our source string
  Found comment 'Our source string'
Enter a string (q=quit): int a; // A comment with // in the middle
  Found comment 'A comment with // in the middle'
Enter a string (q=quit): float f; // A comment with a       (tab) character
  Found comment 'A comment with a       (tab) character'

The match_results object also has a prefix() and suffix() method, which return the string preceding or following the match, respectively.

regex_iterator Example

The following example asks the user to enter a source string, extracts every word from the string, and prints all words between quotes. The regular expression in this case is [w]+, which searches for one or more word-letters. This example uses std::string as source, so it uses sregex_iterator for the iterators. A standard iterator loop is used, but in this case, the end iterator is done slightly differently from the end iterators of ordinary Standard Library containers. Normally, you specify an end iterator for a particular container, but for regex_iterator, there is only one “end” iterator. You can get this end iterator by declaring a regex_iterator type using the default constructor.

The for loop creates a start iterator called iter, which accepts a begin and end iterator into the source string together with the regular expression. The loop body is called for every match found, which is every word in this example. The sregex_iterator iterates over all the matches. By dereferencing an sregex_iterator, you get a smatch object. Accessing the first element of this smatch object, [0], gives you the matched substring:

regex reg("[\w]+");
while (true) {
    cout << "Enter a string to split (q=quit): ";
    string str;
    if (!getline(cin, str) || str == "q")
        break;

    const sregex_iterator end;
    for (sregex_iterator iter(cbegin(str), cend(str), reg);
        iter != end; ++iter) {
        cout << """ << (*iter)[0] << """ << endl;
    }
}

The output of this program can look as follows:

Enter a string to split (q=quit): This, is    a test.
"This"
"is"
"a"
"test"

As this example demonstrates, even simple regular expressions can do some powerful string manipulation!

Note that both a regex_iterator and a regex_token_iterator internally contain a pointer to the given regular expression. They both explicitly delete constructors accepting an rvalue regular expression, so you cannot construct them with a temporary regex object. For example, the following does not compile:

for (sregex_iterator iter(cbegin(str), cend(str), regex("[\w]+"));
    iter != end; ++iter) { … }

regex_token_iterator Examples

The previous regex_iterator example can be rewritten using a regex_token_iterator as follows. Note that *iter is used in the loop body instead of (*iter)[0] as in the regex_iterator example, because the token iterator with 0 as the default submatch index automatically iterates over all capture groups with index 0. The output of this code is exactly the same as the output generated by the regex_iterator example:

regex reg("[\w]+");
while (true) {
    cout << "Enter a string to split (q=quit): ";
    string str;
    if (!getline(cin, str) || str == "q")
        break;

    const sregex_token_iterator end;
    for (sregex_token_iterator iter(cbegin(str), cend(str), reg);
        iter != end; ++iter) {
        cout << """ << *iter << """ << endl;
    }
}

The following example asks the user to enter a date and then uses a regex_token_iterator to iterate over the second and third capture groups (month and day), which are specified as a vector of integers. The regular expression used for dates is explained earlier in this chapter. The only difference is that ^ and $ anchors are added since we want to match the entire source sequence. Earlier, that was not necessary, because regex_match() automatically matches the entire input string.

regex reg("^(\d{4})/(0?[1-9]|1[0-2])/(0?[1-9]|[1-2][0-9]|3[0-1])$");
while (true) {
    cout << "Enter a date (year/month/day) (q=quit): ";
    string str;
    if (!getline(cin, str) || str == "q")
        break;

    vector<int> indices{ 2, 3 };
    const sregex_token_iterator end;
    for (sregex_token_iterator iter(cbegin(str), cend(str), reg, indices);
        iter != end; ++iter) {
        cout << """ << *iter << """ << endl;
    }
}

This code prints only the month and day of valid dates. Output generated by this example can look like this:

Enter a date (year/month/day) (q=quit): 2011/1/13
"1"
"13"
Enter a date (year/month/day) (q=quit): 2011/1/32
Enter a date (year/month/day) (q=quit): 2011/12/5
"12"
"5"

The regex_token_iterator can also be used to perform a so-called field splitting or tokenization. It is a much safer and more flexible alternative to using the old strtok() function from C. Tokenization is triggered in the regex_token_iterator constructor by specifying -1 as the capture group index to iterate over. When in tokenization mode, the iterator iterates over all substrings of the input sequence that do not match the regular expression. The following code demonstrates this by tokenizing a string on the delimiters , and ; with zero or more whitespace characters before or after the delimiters:

regex reg(R"(s*[,;]s*)");
while (true) {
    cout << "Enter a string to split on ',' and ';' (q=quit): ";
    string str;
    if (!getline(cin, str) || str == "q")
        break;

    const sregex_token_iterator end;
    for (sregex_token_iterator iter(cbegin(str), cend(str), reg, -1);
        iter != end; ++iter) {
        cout << """ << *iter << """ << endl;
    }
}

The regular expression in this example is specified as a raw string literal and searches for patterns that match the following:

• zero or more whitespace characters
• followed by a , or ; character
• followed by zero or more whitespace characters

The output can be as follows:

Enter a string to split on ',' and ';' (q=quit): This is,   a; test string.
"This is"
"a"
"test string."

As you can see from this output, the string is split on , and ;. All whitespace characters around the , and ; are removed, because the tokenization iterator iterates over all substrings that do not match the regular expression, and because the regular expression matches , and ; with whitespace around them.

regex_replace() Examples

As a first example, take the following HTML source string,

<body><h1>Header</h1><p>Some text</p></body>

and the regular expression,

<h1>(.*)</h1><p>(.*)</p>

The following table shows the different escape sequences and what they will be replaced with.

The following code demonstrates the use of regex_replace():

const string str("<body><h1>Header</h1><p>Some text</p></body>");
regex r("<h1>(.*)</h1><p>(.*)</p>");

const string format("H1=$1 and P=$2");  // See above table
string result = regex_replace(str, r, format);

cout << "Original string: '" << str << "'" << endl;
cout << "New string     : '" << result << "'" << endl;

The output of this program is as follows:

Original string: '<body><h1>Header</h1><p>Some text</p></body>'
New string     : '<body>H1=Header and P=Some text</body>'

The regex_replace() algorithm accepts a number of flags that can be used to manipulate how it is working. The most important flags are given in the following table.

The following example modifies the previous code to use the format_no_copy flag:

const string str("<body><h1>Header</h1><p>Some text</p></body>");
regex r("<h1>(.*)</h1><p>(.*)</p>");

const string format("H1=$1 and P=$2");
string result = regex_replace(str, r, format,
    regex_constants::format_no_copy);

cout << "Original string: '" << str << "'" << endl;
cout << "New string     : '" << result << "'" << endl;

The output is as follows. Compare this with the output of the previous version.

Original string: '<body><h1>Header</h1><p>Some text</p></body>'
New string     : 'H1=Header and P=Some text'

Another example is to get an input string and replace each word boundary with a newline so that the output contains only one word per line. The following example demonstrates this without using any loops to process a given input string. The code first creates a regular expression that matches individual words. When a match is found, it is replaced with $1 where $1 is replaced with the matched word. Note also the use of the format_no_copy flag to prevent copying whitespace and other non-word characters from the source string to the output.

regex reg("([\w]+)");
const string format("$1
");
while (true) {
    cout << "Enter a string to split over multiple lines (q=quit): ";
    string str;
    if (!getline(cin, str) || str == "q")
        break;

    cout << regex_replace(str, reg, format,
        regex_constants::format_no_copy) << endl;
}

The output of this program can be as follows:

Enter a string to split over multiple lines (q=quit):   This is   a test.
This
is
a
test