Lookahead and Lookbehind

Lookahead and lookbehind assertions in regex allow you to match a pattern only if it is followed or preceded by another pattern, without including the surrounding pattern in the match.

A lookahead assertion checks for a pattern ahead of the current position in the string.

Positive Lookahead

A positive lookahead ensures that the specified pattern exists after the current position:

1#include <iostream>
2#include <regex>
3
4int main() {
5  std::string input = "foo123";
6  std::regex pattern("foo(?=123)");
7  std::smatch match;
8
9  if (std::regex_search(input, match, pattern)) {
10    std::cout << "Match: " << match.str();
11  }
12}

1Match: foo

Here, foo(?=123) matches "foo" only if it is followed by "123".

Negative Lookahead

A negative lookahead ensures that the specified pattern does not exist after the current position:

1#include <iostream>
2#include <regex>
3
4int main() {
5  std::string input = "foo123";
6  std::regex pattern("foo(?!456)");
7  std::smatch match;
8
9  if (std::regex_search(input, match, pattern)) {
10    std::cout << "Match: " << match.str();
11  }
12}

1Match: foo

Here, foo(?!456) matches "foo" only if it is not followed by "456".

A lookbehind assertion checks for a pattern behind the current position in the string. The standard C++ regex library does not support lookbehind assertions.

To use lookbehind assertions in C++, you will need to use a different library that supports it. One such library is Boost.Regex.

Positive Lookbehind

A positive lookbehind ensures that the specified pattern exists before the current position. Here's an example using Boost.Regex:

1#include <iostream>
2#include <boost/regex.hpp>
3
4int main() {
5  std::string input = "123foo";
6  boost::regex pattern("(?<=123)foo");
7  boost::smatch match;
8
9  if (boost::regex_search(input, match, pattern)) {
10    std::cout << "Match: " << match.str();
11  } else {
12    std::cout << "No match found.";
13  }
14}

1Match: foo

Here, (?<=123)foo matches "foo" only if it is preceded by "123".

Negative Lookbehind

A negative lookbehind ensures that the specified pattern does not exist before the current position. Here's an example using Boost.Regex:

1#include <iostream>
2#include <boost/regex.hpp>
3
4int main() {
5  std::string input = "123foo";
6  boost::regex pattern("(?<!456)foo");
7  boost::smatch match;
8
9  if (boost::regex_search(input, match, pattern)) {
10    std::cout << "Match: " << match.str() << "\n";
11  } else {
12    std::cout << "No match found.\n";
13  }
14}

1Match: foo

Here, (?<!456)foo matches "foo" only if it is not preceded by "456".

Lookahead and lookbehind assertions are powerful tools in regex for conditional pattern matching. They allow you to enforce the presence or absence of surrounding patterns without including those patterns in the match.