Home > Articles > Programming > C/C++

C++11 Regular-Expression Library

  • Print
  • + Share This
  • 💬 Discuss

This chapter is from the book

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.

Read C++ for the Impatient and more than 24,000 other books and videos on Safari Books Online. Start a free trial today.



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 lexical analysis—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.

[abc]          // Match a, b, or c.
[A-Z]          // Match any letter in range A to Z.
[a-zA-Z]       // Match any letter.

The other special character used in this example is the plus sign (+).

expr+

This syntax says, “Match the preceding expression, expr, one or more times. The plus sign is a pattern modifier, so it means that expr+, taken as a whole, matches one or more instances of expr.

Here are some examples:

a+           // Match a, aa, aaa, etc.
(ab)+        // Match ab, abab, ababab, etc.
ab+          // Match ab, abb, abbb, abbbb, etc.

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.

#include <regex>
#include <string>
#include <iostream>
. . .
std::regex  reg1("[0-9]+");
if (std::regex_match("123000", reg1)) {
     std::cout << "It's a match!" << std::endl;
}

You can test a series of strings this way:

using std::cout;
using std::endl;
using std::regex;

regex  reg1("[0-9]+");
string str1("123000");
string str2("123000.0");

bool b = regex_match(str1, reg1);
cout << str1 << (b ? " is " : " is not ");
cout << "a match." << endl;

b = regex_match(str2, reg1);
cout << str2 << (b ? " is " : " is not ");
cout << "a match." << endl;

These statements print out:

123000 is a match.
123000.0 is not a match.

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.

Here are some other useful patterns:

using std::regex;
regex reg2("[0-9]*");            // Match 0 or more digits.
regex reg3("(\\+|-)?[0-9]+");    // Match digit string with
                                 //  optional + or - sign.

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.

  • + Share This
  • 🔖 Save To Your Account
C++ for the Impatient

This chapter is from the book

C++ for the Impatient

Discussions

comments powered by Disqus