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 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 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.

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.