Regular Expressions in C++

Regular expressions, often referred to as "regex" or "regexp", are powerful tools that allow for the search and manipulation of text. They are used to detect if a string meets specific requirements, to extract information from text, or to change text in specific ways.

Some examples where they’re useful include:

• Validating user input - for example, ensuring a string looks like an email address, phone number, or another type of data we were expecting
• Syntax highlighting - your code editor, or the code snippets displayed in our lessons, use regular expressions to change the color and formatting of characters to make our code more readable
• Data extraction - for example, if we want to create a system that reads through text and extracts anything that looks like a date
• Redaction - for example, automatically removing contents from a document that could be sensitive

In this lesson, we’ll introduce the syntax for creating a regular expression, and show how to use it to determine if our C++ string matches the given pattern. In the next lesson, we’ll expand this to cover how we can use a regex pattern to extract and replace parts of our content in a targeted way.

Regular expressions can be quite challenging to understand at first. Using them to look for complex patterns or solve larger tasks can be tough. However, working with text is ubiquitous in programming, and regular expressions are the tool we reach for when our task gets a little more complex.

Additionally, regular expression syntax adheres to broadly similar standards across all programming - not just C++. As such, once we’re familiar with them, we can use them regardless of what programming language we’re working in.

Using Regular Expressions in C++

Regular expression functionality in the C++ library is available by including the <regex> header:

1#include <regex>
2

Regular expressions, sometimes called patterns, are themselves strings. The standard way to create a regex pattern in C++ is through the std::basic_regex type, which is aliased to std::regex:

1std::regex Pattern{"hello world"};
2

The two most common functions we have for running regular expressions are std::regex_match and std::regex_search.

In their most basic usage, they accept two arguments - the string we want to test, and the regex we want to use:

1std::string Input{"hello world"};
2std::regex Pattern{"hello"};
3
4bool MatchResult{
5    std::regex_match(Input, Pattern)};
6
7bool SearchResult{
8    std::regex_search(Input, Pattern)};
9

• std::regex_match returns true if the entire input string matches the pattern
• std::regex_search returns true if at least one substring in the input matches the pattern

Below, we run the regex pattern hello on the string hello world. The regex_match call will return false because the string doesn’t match the entire pattern. The regex_search call will return true because a substring within the input that did match the pattern was found:

1#include <iostream>
2#include <regex>
3
4int main() {
5  std::string Input{"hello world"};
6  std::regex Pattern{"hello"};
7
8  bool MatchResult{
9      std::regex_match(Input, Pattern)};
10
11  bool SearchResult{
12      std::regex_search(Input, Pattern)};
13
14  std::cout << "The regex_match pattern "
15            << (MatchResult ? "did" : "did NOT")
16            << " match";
17
18  std::cout << "\nThe regex_search pattern "
19            << (SearchResult ? "did"
20                             : "did NOT")
21            << " match";
22}
23

1The regex_match pattern did NOT match
2The regex_search pattern did match
3

Case-Insensitive Regex Patterns

When creating our pattern using the std::regex constructor accepts a second argument. This is where we can pass flags that modify the behavior of our expression. Most of these flags are for advanced use cases that we won’t cover here.

However, there is one exception: std::regex::icase flags our expression as being case insensitive:

1std::regex Pattern{"hello", std::regex::icase};
2

Below, we do a search for hello. Our string doesn’t contain hello, but it does have Hello:

1#include <iostream>
2#include <regex>
3
4int main() {
5  std::string Input{"Hello world"};
6  std::regex SensitivePattern{"hello"};
7  std::regex InsensitivePattern{
8      "hello", std::regex::icase};
9
10  bool SensitiveResult{std::regex_search(
11      Input, SensitivePattern)};
12
13  bool InsensitiveResult{std::regex_search(
14      Input, InsensitivePattern)};
15
16  std::cout << "The sensitive pattern "
17            << (SensitiveResult ? "did"
18                                : "did NOT")
19            << " match";
20
21  std::cout << "\nThe insensitive pattern "
22            << (InsensitiveResult ? "did"
23                                  : "did NOT")
24            << " match";
25}
26

1The sensitive pattern did NOT match
2The insensitive pattern did match
3

Raw String Literals

In the next section, we’ll begin to see more complicated regular expressions, that include a lot of special characters. This particularly includes the backslash character, \, which needs to be escaped in standard C++ string literals.

These additional escape characters can make regular expressions even more difficult to follow. So, for more complex expressions, it is recommended to construct our patterns from raw string literals.

Whilst string literals begin and end with ", raw string literals begin with R"( and end with )":

1// String Literal
2std::regex PatternA{"hello"};
3
4// Raw String Literal
5std::regex PatternB{R"(hello)"};
6

Special Characters

With regular expressions, we’re not just restricted to simple character matching. We have the option to add more complex syntax into our pattern, to create more elaborate behavior.

Below, we cover the most common special characters:

Wildcard: .

The period character . acts as a wildcard, matching any symbol:

1✔️ c.t -> cat
2✔️ c.t -> cut
3❌ c.t -> colt
4
5✔️ c..t -> colt
6

Alternation: |

The vertical bar character, | allows the input to match either the left or the right pattern:

1✔️ cat|hat -> cat
2✔️ cat|hat -> hat
3❌ cat|hat -> tat
4
5✔️ cat|h.t -> hit
6

Optional: ?

The question mark character, ? flags the previous symbol as being optional:

1✔️ can?t -> cant
2✔️ can?t -> cat
3
4✔️ ca.?t -> cart
5✔️ ca.?t -> cat
6

Start of input: ^

The caret symbol ^ denotes the start of the input, allowing is to match patterns that only at the beginning of our string:

1✔️ ^cat -> cat
2❌ ^cat -> the cat
3
4✔️ ^cat|the -> the
5
6✔️ ^.at -> mat
7❌ ^.at -> the mat
8

End of input: $

Conversely, the dollar symbol $ denotes the end of the input, which allows us to restrict our search just to the end of the string:

1✔️ cat$ -> cat
2❌ cat$ -> the cat sat
3
4✔️ cat|mat$ -> the cat
5✔️ cat|mat$ -> sat on the mat
6
7✔️ ca.$ -> the can
8

Earlier, we noted the C++ standard library has the regex_match function, which matches the entire input, whilst regex_search looks for substrings. Many programming languages don’t draw a distinction here - they just offer the equivalent of regex_search.

However, using the ^ and $ symbols allow us to create a pattern that restricts our pattern to matching against the entire input anyway:

1✔️ ^cat$ -> cat
2❌ ^cat$ -> cats
3❌ ^cat$ -> the cat
4
5✔️ ^.at$ -> cat
6✔️ ^.at$ -> mat
7❌ ^.at$ -> mate
8

Escaping Special Characters

Often, we want to use one of the special characters as their literal meaning within our patterns. For example, we want to check for a literal period within our input, but . denotes a wild card, so adding it to our regex will match any character.

We can escape characters using the backslash symbol: \

1// Unescaped . is a wild card
2✔️ sat on the mat. -> sat on the mat.
3✔️ sat on the mat. -> sat on the mat and
4✔️ sat on the mat. -> sat on the mate
5
6// Escape a special character using \
7✔️ sat on the mat\. -> sat on the mat.
8❌ sat on the mat\. -> sat on the mate
9❌ sat on the mat\. -> sat on the mat
10
11// Unescaped ? is the optional symbol
12✔️ hello? -> hello
13✔️ hello? -> hell
14
15// Escape it using \
16❌ hello\? -> hello
17❌ hello\? -> hell
18✔️ hello\? -> hello?
19
20// Unescaped $ denotes end of input
21❌ $3.50 -> $3.50
22
23// Unescaped . is a wild card
24✔️ \$3.50 -> $3.50
25✔️ \$3.50 -> $3 50
26
27// Escaping both special characters
28❌ \$3\.50 -> $3 50
29✔️ \$3\.50 -> $3.50
30

When we want to search for a literal \ in our input, the escape character itself can be escaped with an additional \:

1❌ yes\no -> yes\no
2✔️ yes\\no -> yes\no
3
4// To search for literal \\ we escape both
5❌ \\user\files -> \\user\files
6✔️ \\\\user\\files -> \\user\files
7

Character Sets / Character Classes

When we want to search for one of a rang of possible characters, we can introduce a character set, sometimes also called character class. We do this by wrapping our characters in [ and ]:. The following searches for bat, cat, mat or rat:

1std::regex Pattern{R"([bcmr]at)"};
2

The order of characters within the set doesn’t matter.

Character sets interact with surrounding special characters as expected. For example, we can check if our input starts with something in a character set using the start-of-input symbol ^, or make the entire set optional using the optional symbol ?:

1✔️ ^[Tt]he -> the cat
2✔️ ^[Tt]he -> The cat
3❌ ^[Tt]he -> Not the cat
4
5✔️ [cbm]?at -> at
6✔️ [cbm]?at -> cat
7✔️ [cbm]?at -> bat
8✔️ [cbm]?at -> mat
9

Within the [ and ] boundary of a character set, the special characters ., ?, ^, $ and | revert back to their literal values. For example, the period symbol . matches only a literal . in the input:

1✔️ cat[.] -> cat.
2❌ cat[.] -> cats
3

Character Set Ranges

We can specify numeric or alphabetic ranges within our character sets using -. For example, [a-e] will match any of a, b, c, d, or e:

1✔️ [a-h]am -> cam
2✔️ [a-h]am -> ham
3❌ [a-h]am -> ram
4
5✔️ [a-z]am -> ram
6❌ [a-z]am -> 9am
7
8❌ [0-9]am -> ram
9✔️ [0-9]am -> 9am
10
11✔️ [0-9a-z]am -> 9am
12✔️ [0-9a-z]am -> ram
13
14// Hexadecimal value
15✔️ [A-F0-9][A-F0-9] -> FF
16✔️ [A-F0-9][A-F0-9] -> E4
17❌ [A-F0-9][A-F0-9] -> G4
18

Some character sets have shortcut symbols we can use instead:

• \d for any numeric digit, equivalent to [0-9]
• \w for any alphabetic character, digit or underscore, equivalent to [a-zA-Z0-9_]
• \s for any white space (can be a space character, a line break character, a tab character, and so on)

1// \d can be any digit
2✔️ \d -> 9
3❌ \d -> m
4✔️ \dam -> 9am
5❌ \dam -> dam
6❌ \dam -> ram
7
8// Any two digits
9✔️ \d\d -> 10
10❌ \d\d -> 1
11
12// Making the second digit optional
13✔️ \d\d? -> 10
14✔️ \d\d? -> 1
15
16// \w can be any letter, digit or underscore
17✔️ \w -> m
18✔️ \w -> 9
19✔️ \wam -> ram
20✔️ \w\wam -> roam
21✔️ help\w -> helps
22❌ help\w -> help!
23
24// \s can be any whitespace
25✔️ the\sfox -> the fox
26
27// The \n here is a line break
28✔️ the\sfox -> the\nfox
29
30// Any whitespace followed by any letter
31✔️ the\s\wat -> the cat
32✔️ the\s\wat -> the mat
33❌ the\s\wat -> themat
34
35// Making whitespace optional
36✔️ the\s?\wat -> themat
37
38// Combining \d \s and \w
39❌ \d\d\s\wats -> 1 cat
40❌ \d\d\s\wats -> 5 cats
41✔️ \d\d\s\wats -> 05 cats
42✔️ \d\d\s\wats -> 24 rats
43✔️ \d\d\s\wats -> 24\nrats
44❌ \d\d\s\wats -> 100 cats
45❌ \d\d\s\wats -> four cats
46
47// The second \d and final s are optional
48✔️ \d\d?\s\wats? -> 1 cat
49✔️ \d\d?\s\wats? -> 5 cats
50✔️ \d\d?\s\wats? -> 05 cats
51✔️ \d\d?\s\wats? -> 24 rats
52✔️ \d\d?\s\wats? -> 24\nrats
53❌ \d\d?\s\wats? -> 100 cats
54❌ \d\d?\s\wats? -> four cats
55

Escaping Character Sets

Character sets, and their shortcuts, can be escaped in the usual way, with \:

1❌ \[hello\] -> h
2✔️ \[hello\] -> [hello]
3
4❌ \\w -> a
5✔️ \\w -> \w
6
7❌ \\d -> 5
8✔️ \\d -> \d
9
10❌ \\s -> the cat
11✔️ \\s -> \s
12

Negating Character Sets

By including the caret symbol, ^ at the beginning of our character set, we can negate it. This allows us to ensure a set of characters is not included in our input at that position.

1✔️ [^cbm]at -> at
2❌ [^cbm]at -> cat
3❌ [^cbm]at -> bat
4❌ [^cbm]at -> mat
5✔️ [^cbm]at -> rat
6
7✔️ [^c-m]at -> rat
8
9✔️ [^\d]at -> cat
10❌ [^\d]at -> 5at
11✔️ [^\d]at -> 5 at
12
13✔️ cat[^\w] -> cat
14✔️ cat[^\w] -> the cat sat
15❌ cat[^\w] -> caterpillar
16❌ cat[^\w] -> vacate
17✔️ cat[^\w] -> copycat
18
19❌ [^\w]cat[^\w] -> copycat
20

Repetition

We can look for repeating patterns within our input. We do that by adding syntax directly after the symbol or character set we want to look for repetitions of. We have 3 options:

Zero or More: *

The * character states there can be any number of the proceeding symbol or character set. That can include zero:

1✔️ ab*c -> ac
2✔️ ab*c -> abc
3✔️ ab*c -> abbc
4✔️ ab*c -> abbbbbc
5
6✔️ a.*c -> ac
7✔️ a.*c -> abc
8✔️ a.*c -> a123c
9✔️ a.*c -> a123 abc
10
11✔️ a[bcd]*e -> ae
12✔️ a[bcd]*e -> abe
13✔️ a[bcd]*e -> ace
14✔️ a[bcd]*e -> abcde
15✔️ a[bcd]*e -> abcdcdbe
16❌ a[bcd]*e -> a1e
17

One or More: +

The + character specifies we want at least one of the proceeding symbol or character set, but there can be more:

1❌ ab+c -> ac
2✔️ ab+c -> abc
3✔️ ab+c -> abbc
4✔️ ab+c -> abbbbbc
5
6❌ a.+c -> ac
7✔️ a.+c -> abc
8✔️ a.+c -> a123c
9✔️ a.+c -> a123 abc
10
11❌ a[bcd]+e -> ae
12✔️ a[bcd]+e -> abe
13✔️ a[bcd]+e -> ace
14✔️ a[bcd]+e -> abcde
15✔️ a[bcd]+e -> abcdcdbe
16❌ a[bcd]+e -> ale
17

Exactly x repetitions: {x}

The brace syntax allows us to be more specific with how many repetitions we want. We can pass a single number between the braces, to specify we want a specific number of repetitions.

Note, a common mistake here comes when using this syntax alongside a substring search, like std::regex_search. In that context, a pattern like [0-9]{2} which searches for exactly 2 digits will return true on an input like 123. Whilst the entire string of 123 has 3 digits, it has two substrings of 2 digits - 12 and 23.

If we wanted this input to not match, we’d need to be more specific. For example, if we wanted our entire string to be exactly 2 digits, we could use std::regex_match, instead of std::regex_search, or add the start and end of input symbols ^ and $ to our regex.

In the following example, we look for exactly two repetitions:

1❌ ab{2}c -> ac
2❌ ab{2}c -> abc
3✔️ ab{2}c -> abbc
4❌ ab{2}c -> abbbc
5
6❌ a.{2}c -> ac
7❌ a.{2}c -> abc
8✔️ a.{2}c -> a12c
9❌ a.{2}c -> a123c
10
11❌ a[bcd]{2}e -> ae
12❌ a[bcd]{2}e -> abe
13❌ a[bcd]{2}e -> ace
14✔️ a[bcd]{2}e -> abce
15✔️ a[bcd]{2}e -> acde
16❌ a[bcd]{2}e -> abcde
17
18// 256 bit hexadecimal
19✔️ [A-F0-9]{2} -> 6F
20
21// hexadecimal color
22✔️ [A-F0-9]{6} -> 6F4AFF
23

At least x repetitions: {x,}

By adding a trailing comma within our braces, we specify that we want at least x repetitions, without an upper limit. Below, we search for at least two repetitions:

1❌ ab{2,}c -> ac
2❌ ab{2,}c -> abc
3✔️ ab{2,}c -> abbc
4✔️ ab{2,}c -> abbbc
5
6❌ a.{2,}c -> ac
7❌ a.{2,}c -> abc
8✔️ a.{2,}c -> a12c
9✔️ a.{2,}c -> a123c
10
11❌ a[bcd]{2,}e -> ae
12❌ a[bcd]{2,}e -> abe
13❌ a[bcd]{2,}e -> ace
14✔️ a[bcd]{2,}e -> abce
15✔️ a[bcd]{2,}e -> acde
16✔️ a[bcd]{2,}e -> abcde
17

From x to y repetitions: {x, y}:

By adding a second number to our braces, we can specify both a lower and upper range for the number of repetitions we are looking for. Below, we search for at least one, but not more than three repetitions of our previous symbol or character set:

1// Looking for 1 to 3 repetitions
2❌ ab{1,3}c -> ac
3✔️ ab{1,3}c -> abc
4✔️ ab{1,3}c -> abbc
5✔️ ab{1,3}c -> abbbc
6❌ ab{1,3}c -> abbbbc
7
8❌ a.{1,3}c -> ac
9✔️ a.{1,3}c -> abc
10✔️ a.{1,3}c -> a12c
11✔️ a.{1,3}c -> a123c
12❌ a.{1,3}c -> a1234c
13
14❌ a[bcd]{1,3}e -> ae
15✔️ a[bcd]{1,3}e -> abe
16✔️ a[bcd]{1,3}e -> ace
17✔️ a[bcd]{1,3}e -> abce
18✔️ a[bcd]{1,3}e -> acde
19✔️ a[bcd]{1,3}e -> abcde
20❌ a[bcd]{1,3}e -> abbcde
21

Repetition with Character Set Shortcuts

The repetition specifiers also work with the character set shortcuts \s, \w, and \d:

1❌ the\s+cat -> thecat
2✔️ the\s+cat -> the cat
3✔️ the\s+cat -> the    cat
4
5✔️ c\w*t -> ct
6✔️ c\w*t -> cat
7✔️ c\w*t -> coat
8❌ c\w*t -> c5t
9
10❌ \d{2} -> 1
11✔️ \d{2} -> 10
12
13// Substring match
14✔️ \d{2} -> 100
15
16// Full string match
17❌ ^\d{2}$ -> 100
18
19❌ \d{2,} -> 1
20✔️ \d{2,} -> 10
21✔️ \d{2,} -> 100
22
23✔️ \d{1.3} -> 1
24✔️ \d{1.3} -> 10
25✔️ \d{1.3} -> 100
26
27// Substring match
28✔️ \d{1.3} -> 1000
29
30// Full string match
31❌ ^\d{1.3}$ -> 1000
32

In the next lesson, we’ll cover regular expression capture groups. These build on the regex syntax we learned but will allow us to go beyond just checking whether or not the text matches the regular expression pattern we created.

With capture groups, we will learn how to use regex to filter through and extract parts of our text, or to replace segments of it in a targeted way.