std::regex_constants::error_type

#include <iomanip>
#include <iostream>
#include <regex>
#include <sstream>
#include <string>
using namespace std::string_literals;
 
void mostrar_error(const std::regex_error& e) {
    std::string mensaje_de_error = e.what();
 
#   define CASE(tipo, mensaje) \
    case std::regex_constants::tipo: mensaje_de_error += " ("s + #tipo "):\n  "s + mensaje; \
        break
    switch (e.code()) {
    CASE(error_collate, "La expresión contiene un nombre de elemento de intercalación inválido");
    CASE(error_ctype, "La expresión contiene un nombre de clase de carácteres inválido");
    CASE(error_escape, "La expresión contiene un carácter escapado o un escape al final inválidos");
    CASE(error_backref, "La expresión contiene una referencia inversa inválida");
    CASE(error_brack, "La expresión contiene corchetes que no coinciden ('[' y ']')");
    CASE(error_paren, "La expresión contiene paréntesis que no coinciden ('(' y ')')");
    CASE(error_brace, "La expresión contiene llaves que no coinciden ('{' y '}')");
    CASE(error_badbrace, "La expresión contiene un rango inválido en una expresión {}");
    CASE(error_range, "La expresión contiene un rango de caracteres inválido (p. ej., [b-a])");
    CASE(error_space, "No había suficiente memoria para convertir la expresión en una máquina de estados finitos");
    CASE(error_badrepeat, "Uno de *?+{ no fue precedido por una expresión regular válida");
    CASE(error_complexity, "La complejidad de un intento de coincidencia superó un nivel predefinido");
    CASE(error_stack, "No había suficiente memoria para realizar una coincidencia");
    }
#   undef CASE
 
    /* std::cerr */ std::cout << mensaje_de_error << ". \n\n";
}
 
void verificador(const std::string& texto,
                 const std::string& regex,
                 const std::regex::flag_type indicadores) {
    std::cout << "Texto: " << quoted(texto) << "\nExpresión regular: " << quoted(regex) << '\n';
    try {
        const std::regex re{regex, indicadores};
        const bool coincide = std::regex_match(texto, re);
 
        std::stringstream salida;
        salida << (coincide ? "COINCIDE\n" : "NO COINCIDE\n");
 
        std::smatch m;
        if (std::regex_search(texto, m, re); !m.empty()) {
            salida << "prefijo = [" << m.prefix().str().data() << "]\n";
 
            for (std::size_t i{}; i != m.size(); ++i)
                salida << "  m[" << i << "] = [" << m[i].str().data() << "]\n";
 
            salida << "sufijo = [" << m.suffix().str().data() << "]\n";
        }
        std::cout << salida.str() << '\n';
    } catch (std::regex_error& ex) {
        mostrar_error(ex);
    }
}
 
int main() {
 
    constexpr std::regex::flag_type tus_indicadores
        = std::regex::flag_type{0}
    // Elegir una de las gramáticas admitidas:
        | std::regex::ECMAScript
    //  | std::regex::basic
    //  | std::regex::extended
    //  | std::regex::awk
    //  | std::regex::grep
    //  | std::regex::egrep
    // Elegir cualquiera de las siguientes opciones:
    //  | std::regex::icase
    //  | std::regex::nosubs
    //  | std::regex::optimize
    //  | std::regex::collate
    //  | std::regex::multiline
        ;
 
    const auto tu_texto = "Hola expresiones regulares."s;
    const auto tu_regex = R"(([a-zA-Z]+) ([a-z]+) ([a-z]+)\.)"s;
    verificador(tu_texto, tu_regex, tus_indicadores);
 
    verificador("Inválido", R"(((.)(.))", tus_indicadores);
    verificador("Inválido", R"([.)", tus_indicadores);
    verificador("Inválido", R"([.]{})", tus_indicadores);
    verificador("Inválido", R"([1-0])", tus_indicadores);
}