std::regex_constants::error_type(3) | C++ Standard Libary | std::regex_constants::error_type(3) |
NAME¶
std::regex_constants::error_type - std::regex_constants::error_type
Synopsis¶
Defined in header <regex>
typedef /*implementation defined*/ error_type; (since C++11)
constexpr error_type error_collate = /*unspecified*/;
constexpr error_type error_ctype = /*unspecified*/;
constexpr error_type error_escape = /*unspecified*/;
constexpr error_type error_backref = /*unspecified*/;
constexpr error_type error_brack = /*unspecified*/;
constexpr error_type error_paren = /*unspecified*/; (since C++11)
constexpr error_type error_brace = /*unspecified*/; (until C++17)
constexpr error_type error_badbrace = /*unspecified*/;
constexpr error_type error_range = /*unspecified*/;
constexpr error_type error_space = /*unspecified*/;
constexpr error_type error_badrepeat = /*unspecified*/;
constexpr error_type error_complexity = /*unspecified*/;
constexpr error_type error_stack = /*unspecified*/;
inline constexpr error_type error_collate = /*unspecified*/;
inline constexpr error_type error_ctype = /*unspecified*/;
inline constexpr error_type error_escape = /*unspecified*/;
inline constexpr error_type error_backref = /*unspecified*/;
inline constexpr error_type error_brack = /*unspecified*/;
inline constexpr error_type error_paren = /*unspecified*/;
inline constexpr error_type error_brace = /*unspecified*/; (since
C++17)
inline constexpr error_type error_badbrace = /*unspecified*/;
inline constexpr error_type error_range = /*unspecified*/;
inline constexpr error_type error_space = /*unspecified*/;
inline constexpr error_type error_badrepeat = /*unspecified*/;
inline constexpr error_type error_complexity = /*unspecified*/;
inline constexpr error_type error_stack = /*unspecified*/;
The error_type is a type that describes errors that may occur during regular
expression parsing.
Constants¶
Constant Explanation
error_collate the expression contains an invalid collating element name
error_ctype the expression contains an invalid character class name
error_escape the expression contains an invalid escaped character or a
trailing
escape
error_backref the expression contains an invalid back reference
error_brack the expression contains mismatched square brackets ('[' and ']')
error_paren the expression contains mismatched parentheses ('(' and ')')
error_brace the expression contains mismatched curly braces ('{' and '}')
error_badbrace the expression contains an invalid range in a {} expression
error_range the expression contains an invalid character range (e.g. [b-a])
error_space there was not enough memory to convert the expression into a
finite
state machine
error_badrepeat one of *?+{ was not preceded by a valid regular expression
error_complexity the complexity of an attempted match exceeded a predefined
level
error_stack there was not enough memory to perform a match
Notes¶
In C++11, these constants were specified with redundant keyword
static, which was
removed by C++14 via LWG issue 2053
Example¶
Implements regular expressions checker.
// Run this code
#include <iomanip>
#include <iostream>
#include <regex>
#include <sstream>
#include <string>
using namespace std::string_literals;
void show_regex_error(const std::regex_error& e) {
std::string err_message = e.what();
# define CASE(type, msg) \
case std::regex_constants::type: err_message += " ("s + #type
"):\n "s + msg; \
break
switch (e.code()) {
CASE(error_collate, "The expression contains an invalid collating
element name");
CASE(error_ctype, "The expression contains an invalid character class
name");
CASE(error_escape, "The expression contains an invalid escaped character
or a trailing escape");
CASE(error_backref, "The expression contains an invalid back
reference");
CASE(error_brack, "The expression contains mismatched square brackets
('[' and ']')");
CASE(error_paren, "The expression contains mismatched parentheses ('('
and ')')");
CASE(error_brace, "The expression contains mismatched curly braces ('{'
and '}')");
CASE(error_badbrace, "The expression contains an invalid range in a {}
expression");
CASE(error_range, "The expression contains an invalid character range
(e.g. [b-a])");
CASE(error_space, "There was not enough memory to convert the expression
into a finite state machine");
CASE(error_badrepeat, "one of *?+{ was not preceded by a valid regular
expression");
CASE(error_complexity, "The complexity of an attempted match exceeded a
predefined level");
CASE(error_stack, "There was not enough memory to perform a
match");
}
# undef CASE
/* std::cerr */ std::cout << err_message << ". \n\n";
}
void regular_expression_checker(const std::string& text,
const std::string& regex,
const std::regex::flag_type flags) {
std::cout << "Text: " << quoted(text) <<
"\nRegex: " << quoted(regex) << '\n';
try {
const std::regex re{regex, flags};
const bool matched = std::regex_match(text, re);
std::stringstream out;
out << (matched ? "MATCH!\n" : "DOES NOT
MATCH!\n");
std::smatch m;
if (std::regex_search(text, m, re); !m.empty()) {
out << "prefix = [" << m.prefix().str().data() <<
"]\n";
for (std::size_t i{}; i != m.size(); ++i)
out << " m[" << i << "] = [" <<
m[i].str().data() << "]\n";
out << "suffix = [" << m.suffix().str().data() <<
"]\n";
}
std::cout << out.str() << '\n';
} catch (std::regex_error& ex) {
show_regex_error(ex);
}
}
int main() {
constexpr std::regex::flag_type your_flags
= std::regex::flag_type{0}
// Choose one of the supported grammars:
| std::regex::ECMAScript
// | std::regex::basic
// | std::regex::extended
// | std::regex::awk
// | std::regex::grep
// | std::regex::egrep
// Choose any of the next options:
// | std::regex::icase
// | std::regex::nosubs
// | std::regex::optimize
// | std::regex::collate
// | std::regex::multiline
;
const auto your_text = "Hello regular expressions."s;
const auto your_regex = R"(([a-zA-Z]+) ([a-z]+) ([a-z]+)\.)"s;
regular_expression_checker(your_text, your_regex, your_flags);
regular_expression_checker("Invalid!", R"(((.)(.))",
your_flags);
regular_expression_checker("Invalid!", R"([.)",
your_flags);
regular_expression_checker("Invalid!", R"([.]{})",
your_flags);
regular_expression_checker("Invalid!", R"([1-0])",
your_flags);
}
Possible output:¶
Text: "Hello regular expressions."
Regex: "([a-zA-Z]+) ([a-z]+) ([a-z]+)\\."
MATCH!
prefix = []
m[0] = [Hello regular expressions.]
m[1] = [Hello]
m[2] = [regular]
m[3] = [expressions]
suffix = []
Text: "Invalid!"
Regex: "((.)(.)"
Parenthesis is not closed. (error_paren):
The expression contains mismatched parentheses ('(' and ')').
Text: "Invalid!"
Regex: "[."
Unexpected character in bracket expression. (error_brack):
The expression contains mismatched square brackets ('[' and ']').
Text: "Invalid!"
Regex: "[.]{}"
Unexpected token in brace expression. (error_badbrace):
The expression contains an invalid range in a {} expression.
Text: "Invalid!"
Regex: "[1-0]"
Invalid range in bracket expression. (error_range):
The expression contains an invalid character range (e.g. [b-a]).
See also¶
regex_error reports errors generated by the regular expressions
library
(C++11) (class)
2022.07.31 | http://cppreference.com |