Greedy vs Lazy Quantifiers

Greedy and lazy quantifiers control how much of the input string is matched by the quantifiers in a regex pattern.

Greedy Quantifiers

Greedy quantifiers match as much of the input string as possible. By default, the quantifiers *, +, and {n,m} are greedy. This means they try to match the longest possible substring that fits the pattern.

For example:

1#include <iostream>
2#include <regex>
3
4int main() {
5  std::string input = "abc123def456";
6  std::regex pattern(".*\\d");
7  std::smatch match;
8  std::regex_search(input, match, pattern);
9  std::cout << match.str();
10}

1abc123def456

In this example, .*\d matches the entire string because .* is greedy and matches as many characters as possible before the final digit.

Lazy Quantifiers

Lazy quantifiers match as little of the input string as possible. To make a quantifier lazy, you append a ? to it. The lazy versions are *?, +?, and {n,m}?.

For example:

1#include <iostream>
2#include <regex>
3
4int main() {
5  std::string input = "abc123def456";
6  std::regex pattern(".*?\\d");
7  std::smatch match;
8  std::regex_search(input, match, pattern);
9  std::cout << match.str();
10}

1abc1

Here, .*?\d matches only abc1 because .*? is lazy and stops matching as soon as it finds a digit.

When to Use Each

Use greedy quantifiers when you want to match the longest possible substring and lazy quantifiers when you want the shortest match.

Understanding the difference helps in fine-tuning regex patterns for specific use cases, such as extracting or replacing substrings within larger text.