Lecture 16: Regular Expressions in C++

Objective

Equip students with an understanding of regular expressions and their practical application in C++ programming, enabling them to proficiently utilize regular expressions for pattern matching, text manipulation, and data extraction in real-world programming scenarios.

Introduction to Regular Expressions

What are regular expressions?

A regular expression (regex or regexp) is a powerful tool used for pattern matching and text manipulation.
It’s a sequence of characters that defines a search pattern.

Why are they important in text processing?

Regular expressions allow you to search for and modify text in a highly flexible and efficient way
They are widely used in programming, data validation, and data extraction tasks
Regular expressions provide a concise and expressive way to describe complex patterns in text

Real-world examples of where regular expressions are used:

Data validation: Regular expressions are used to validate user inputs such as email addresses, phone numbers, and ZIP codes.
Data extraction: They help extract specific information from text, like extracting URLs from web pages or dates from documents.
Text search and replace: Regular expressions enable you to find and replace text efficiently in large documents.
Log analysis: They are crucial for parsing and analyzing log files to extract meaningful information.
Web scraping: Regular expressions are used to scrape data from websites by matching patterns in the HTML source code.
Programming languages: Many programming languages and tools support regular expressions for string manipulation.

C++ Regular Expression Library

The <regex> header in C++:

The <regex> header is a part of the C++ Standard Library, and provides support for regular expressions
```
  // Include the <regex> header
  #include <regex> 
  using namespace std;
```
It contains classes, functions, and types that allow you to work with regular expressions in C++ programs

To declare and initialize a regex object in C++:

  regex pattern("your_regular_expression_here");

The pattern is a regex object that will hold the regular expression you want to use for matching
You can customize the regular expression based on your specific needs

Raw Strings in C++

In C++, a raw string is a literal string that is defined using the R"( ... )" syntax. This syntax allows you to create string literals without the need for escaping special characters, making it especially useful for strings that contain backslashes and multiple lines of text.

Here’s the basic syntax of a raw string in C++:

R"( your raw string here )"

Here are some key features and benefits of raw strings in C++:

No escape sequences: In a raw string, escape sequences like \", \\, and \n are treated as regular characters and not as escape sequences. This means you can include backslashes without escaping them, making it easier to represent file paths, regular expressions, and other text with backslashes.
Multi-line support: Raw strings can span multiple lines, making it convenient for defining long or multiline strings without the need for explicit line breaks or concatenation.

Here’s an example of a raw string in C++ that includes a backslash and multiple lines of text:

#include <iostream>
#include <string>
using namespace std;

int main() 
{
    string rawString = R"(This is a raw string.
It can contain backslashes \ and span multiple lines.
No need to escape special characters.)";

    cout << rawString << endl;

    return 0;
}

In this example, the R"( ... )" syntax is used to define a raw string, which can span multiple lines and includes backslashes without the need for escaping.

Raw strings can be especially handy when working with regular expressions, file paths, SQL queries, or any text that includes special characters or spans multiple lines. They improve code readability by eliminating the clutter of escape sequences and line concatenations.

Like this:

regex pattern(R"(your_regular_expression_here)");

Example: Validating an Email Address

A simple program to validate an email address from input.

validate.cpp

#include <iostream>
#include <regex>
#include <string>
using namespace std;

int main() 
{
    string email;
    cout << "Enter an email address: ";
    cin >> email;

    // Define a regular expression pattern for email validation
    regex pattern{R"([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})"};

    if (regex_match(email, pattern)) 
    {
        cout << "Valid email address!" << endl;
    } 
    else
    {
        cout << "Invalid email address." << endl;
    }

    return 0;
}

Regular Expressions Tutorial

https://regexone.com/

Complete lessons 1 through 14.

Resources

Testing your regex: regex101.com

Reference page: regular-expressions