C++11 makes the capabilities of regular expressions directly available to you, without your having to write a regular-expression engine yourself. In this chapter from C++ for the Impatient, Brian Overland explains all the basic functionality so you can learn how to do just about anything you’d want to do.

This chapter is from the book

This chapter is from the book

Applications such as Microsoft Word have long supported pattern-matching, or regular-expression, capabilities. Using C and C++, it was always possible to write your own regular-expression engines, but it required sophisticated, complex programming—and usually a degree in computer science. Now C++11 makes these capabilities directly available to you, without your having to write a regular-expression engine yourself.

Regular expressions are of practical value in many programs, as they can aid with the task of lexicalanalysis—intelligently breaking up pieces of an input string—as well as tasks such as converting from one text-file format (such as HTML) to another.

I’ve found that when the C++11 regular expression library is explained in a straightforward, simple manner, it’s easy to use. This chapter doesn’t describe all the endless variations on the regex function-call syntax, but it does explain all the basic functionality: how to do just about anything you’d want to do.

20.1. Overview of C++11 Regular Expressions

Before using any regular-expression functions, include the <regex> header.

#include <regex>

A regular expression is a string that uses special characters—in combination with ordinary characters—to create a text pattern. That pattern can then be used to match another string, search it, or identify a substring as the target of a search-and-replace function.

For example, consider a simple pattern: a string consisting only of the digits 0 through 9, and nothing else. A decimal integer, assuming it has no plus or minus sign, fulfills this pattern.

With the C++11 regular-expression syntax, this pattern can be expressed as:

[0-9]+

In this regular-expression pattern, only the “0” and “9” are intended literally. The other characters—“[”, “]”, “-”, and “+”—each have a special meaning.

The brackets specify a range of characters:

[range]

This syntax says, “Match any one character in the specified range. The following examples specify different ranges.

Notice what a difference the parentheses make. Parentheses have a special role in forming groups. As with braces and the plus sign (+), parentheses are special characters; they have to be “escaped” to be rendered literally—that is, you have to use backslashes if you want to match actual parentheses in the target string.

You should now see why “[0-9]+” matches a string that consists of one or more digits. This pattern attempts to match a single digit and then says, “Match that one or more times.” Again, the plus sign is a pattern modifier, so it matches [0-9] one or more times instead of matching it just once, not one or more times in addition to matching it once (which would’ve meant a total of two or more times overall).

The following statements attempt to match this regular-expression string against a target string. In this context, match means that the target string must match the regular-expression string completely.

The string “123000.0” does not result in a match because regex_match attempts to match the entire target string; if it cannot, it returns false. The regex_search function, in contrast, returns true if any substring matches. Therefore, the following function call returns true, because the substring consisting of the first six characters matches the pattern specified earlier for reg1.

std::regex_search("123000.0", reg1)

Generally speaking, every regular-expression operation begins by initializing a regex object with a pattern; this object can then be given as input to regex_match or regex_search. Creating a regex object builds a regular-expression engine, which is compiled at runtime (!), so for best performance, create as few new regular expression objects as you need to.

reg2 uses an asterisk (*) rather than a plus sign (+). The asterisk modifies the regular expression to mean, “Match zero or more copies of the preceding expression.” Therefore, reg2 matches an empty string as well as a digit string.

reg3 matches a digit string with an optional sign. The “or” symbol (|) means match the expression on either side of this symbol:

"a|b" // Match a or b but not both.

Putting “a|b” into a group (using parentheses) and then following it with a question mark (?), makes the entire group optional.

The following expression means, “Optionally match a plus sign or a minus sign, but not both.”

"(\\+|-)?"

Because the plus sign (+) has special meaning, it must be “escaped” by using backslashes. More about that in the next section.

NOTE

There’s a more concise way to write the expression in this case. Most symbols lose their special meaning inside brackets and do not need to be escaped. Even the minus sign (-) does not need to be escaped unless it occurs in between two other characters, indicating a run of characters (as in “[a-z]”). So the pattern just shown could be more concisely expressed as:

"[+-]?"

The limitation of a range, however, is that it is used just to match a single character, so the range syntax, [], is less general than “or” (|).