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)