# std::regex_constants::error_type

From cppreference.com
< cpp‎ | regex

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*/; constexpr error_type error_brace = /*unspecified*/; 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*/; |  | (since C++11) (until C++17)
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*/; 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*/; |  | (since C++17)

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 (C++11) | reports errors generated by the regular expressions library (class)

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/regex/error_type&oldid=137060"