Regular expressions (regex) are a powerful tool for pattern-based string extraction and splitting. In C++, the <regex> library provides a robust, Perl-like syntax that works across Linux, Windows, and embedded environments. This guide focuses on practical extraction and splitting tasks—extracting phone numbers from text, splitting CSV lines, parsing key-value pairs—using std::regex, std::regex_search, std::sregex_token_iterator, and std::regex_replace. We'll cover common pitfalls, performance considerations, and a full worked example.
Why Use Regex for Extraction and Splitting?
Manual string parsing with loops and conditionals is error-prone and hard to maintain. Regex offers:
- Declarative patterns: Describe what to match, not how.
- Portability: Same regex works across C++, Python, Java, etc.
- Flexibility: Handle optional parts, varying whitespace, and nested structures.
Common use cases:
- Extract all email addresses from a document.
- Split a log line into timestamp, level, and message.
- Validate and parse user input (phone numbers, IDs).
Core C++ Regex Classes for Extraction
C++ regex is in <regex> and centers on three classes:
| Class | Purpose |
|---|---|
std::regex |
Compiled regex object (like Pattern in Java) |
std::smatch |
Match results for std::string (submatches) |
std::sregex_token_iterator |
Iterate over all matches or split on non-matches |
Using std::regex_search for Extraction
regex_search finds the first match and populates a std::smatch object. Use capturing groups () to extract sub-parts.
#include <iostream>
#include <regex>
#include <string>
int main() {
std::string text = "Contact: (123) 456-7890 or 987-654-3210";
std::regex phone_regex(R"(\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4})");
std::smatch match;
if (std::regex_search(text, match, phone_regex)) {
std::cout << "Found: " << match.str() << std::endl; // (123) 456-7890
}
return 0;
}
Note: The raw string literal R"(...)" avoids escaping backslashes. In C++11 and later, prefer raw strings for regex.
Extracting All Matches with sregex_token_iterator
To extract all occurrences, use std::sregex_token_iterator with index 0 (the whole match) or a positive index for a specific capturing group.
std::string text = "Emails: alice@example.com, bob@test.org, charlie@domain.co.uk";
std::regex email_regex(R"([\w.-]+@[\w.-]+\.\w+)");
std::sregex_token_iterator it(text.begin(), text.end(), email_regex, 0);
std::sregex_token_iterator end;
while (it != end) {
std::cout << *it++ << std::endl;
}
// Output:
// alice@example.com
// bob@test.org
// charlie@domain.co.uk
Splitting Strings with sregex_token_iterator (Negative Index)
Pass -1 as the fourth argument to split on the regex (like Python's re.split).
std::string csv = "apple, banana; cherry | date";
std::regex delimiter(R"([,;|]\s*)");
std::sregex_token_iterator it(csv.begin(), csv.end(), delimiter, -1);
std::sregex_token_iterator end;
while (it != end) {
std::cout << "[" << *it++ << "]" << std::endl;
}
// Output:
// [apple]
// [banana]
// [cherry]
// [date]
Full Worked Example: Parsing a Phonebook Entry
Suppose we have a phonebook line:
John Doe: (555) 123-4567, jdoe@example.com; Jane Smith: 555-987-6543, jane@work.net
Goal: Extract each person's name, phone, and email.
Step 1: Define the Pattern
We'll use named-like capturing groups (C++ doesn't support named groups, but we can use numbered groups):
(\w+\s+\w+):\s+(\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}),\s+([\w.-]+@[\w.-]+\.\w+)
- Group 1: Name (two words)
- Group 2: Phone
- Group 3: Email
Step 2: Iterate Over All Matches
#include <iostream>
#include <regex>
#include <string>
int main() {
std::string text = "John Doe: (555) 123-4567, jdoe@example.com; Jane Smith: 555-987-6543, jane@work.net";
std::regex entry_regex(R"((\w+\s+\w+):\s+(\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}),\s+([\w.-]+@[\w.-]+\.\w+))");
std::sregex_iterator it(text.begin(), text.end(), entry_regex);
std::sregex_iterator end;
for (; it != end; ++it) {
std::smatch match = *it;
std::cout << "Name: " << match[1] << std::endl;
std::cout << "Phone: " << match[2] << std::endl;
std::cout << "Email: " << match[3] << std::endl;
std::cout << "---" << std::endl;
}
return 0;
}
Output: ``` Name: John Doe Phone: (555) 123-4567 Email: jdoe@example.com
Name: Jane Smith Phone: 555-987-6543 Email: jane@work.net
## Common Pitfalls
- **Greedy vs. lazy quantifiers**: `.*` matches as much as possible; use `.*?` for minimal match.
- **Escaping in regular strings**: Always use raw string literals `R"(...)"` to avoid double backslashes.
- **Overlapping matches**: `regex_search` and `sregex_token_iterator` do **not** find overlapping matches by default. For overlapping, use a lookahead or manual positioning.
- **Performance**: Compile regex once (static or reused object). Avoid recompiling in loops.
- **Unicode**: C++ `std::regex` with `std::string` works on UTF-8 bytes, not code points. For proper Unicode matching, use `std::wregex` with `std::wstring` or a library like ICU.
## Performance Considerations
- **Precompile regex**: Store `std::regex` as a static or global variable when used repeatedly.
- **Use `std::regex::optimize` flag**: `std::regex(pattern, std::regex::optimize)` may speed up matching at the cost of slower compilation.
- **Avoid `std::regex` in hot loops**: If you must, extract once outside the loop.
- **Prefer `std::string_view` (C++17)**: Use `std::regex_iterator` with `std::string_view` to avoid copies.
## FAQ
### How do I extract only the first match?
Use `std::regex_search` (as shown above). It returns `bool` and fills one `std::smatch`.
### Can I split a string using a regex and keep the delimiters?
Yes. Use `sregex_token_iterator` with index `-1` for the parts *between* delimiters. To include delimiters, iterate with index `0` and combine with the split parts manually, or use a capturing group and index `-1` with an alternation trick.
### Why does my regex match nothing?
Check for:
- Incorrect escaping (use raw string literals).
- Missing anchors (`^`, `
Regex for String Extraction and Splitting: A Practical C++ Guide | MyUtl
MyUtl
正在加载，请稍候…
) if you want full-string match.
- Greedy quantifiers consuming too much.
- Use a regex tester like our [regex tester](/regex-tester) to debug.
### Is `std::regex` thread-safe?
Yes, `std::regex` objects are thread-safe after construction. But `std::smatch` and iterators are not—each thread needs its own match object.
### How do I handle Unicode in C++ regex?
`std::regex` with `std::string` treats UTF-8 as bytes. For character class `\w` may not match Unicode letters. Use `std::wregex` with `std::wstring` and `\w` with `std::regex::ECMAScript` flag, or consider Boost.Regex or ICU for full Unicode support.
## Try It Yourself
Experiment with these patterns in our [regex tester](/regex-tester). Paste your text and pattern, see matches highlighted in real time. It supports the same ECMAScript syntax as C++.
