std::regex_constants::error_type
Definido en el archivo de encabezado <regex> | ||
typedef/*definido por la implementación*/ error_type; | (desde C++11) | |
constexpr error_type error_collate =/*no especificado*/; constexpr error_type error_ctype =/*no especificado*/; | (desde C++11) (hasta C++17) | |
inlineconstexpr error_type error_collate =/*no especificado*/; inlineconstexpr error_type error_ctype =/*no especificado*/; | (desde C++17) | |
error_type es un tipo que describe los errores que pueden ocurrir durante el análisis de expresiones regulares.
Contenido |
[editar]Constantes
| Constante | Explicación |
error_collate | La expresión contiene un nombre de elemento de intercalación inválido. |
error_ctype | La expresión contiene un carácter nombre de clase de caracteres inválido. |
error_escape | La expresión contiene un escape de carácter inválido o una secuencia de escape al final. |
error_backref | La expresión contiene una referencia inversa inválida. |
error_brack | La expresión contiene corchetes no coincidentes ('[' y ']'). |
error_paren | La expresión contiene paréntesis no coincidentes ('(' y ')'). |
error_brace | La expresión contiene llaves no coincidentes ('{' y '}'). |
error_badbrace | La expresión contiene un rango inválido en una expresión {}. |
error_range | La expresión contiene un rango de caracteres inválido. (p. ej., [b-a]). |
error_space | No había suficiente memoria para convertir la expresión en una máquina de estados finitos. |
error_badrepeat | Uno de *?+{ no fue precedido por una expresión regular válida. |
error_complexity | La complejidad de un intento de coincidencia excedió un nivel predefinido. |
error_stack | No había suficiente memoria para realizar una coincidencia. |
[editar]Ejemplo
Implementa un verificador de expresiones regulares. La función mostrar_error despliega un mensaje que corresponde con el tipo de error en std::regex_constants. La función verificador toma un texto de entrada y le aplica la expresión regular regex usando los indicadores dados, luego emite salida en una cadena que se envía al flujo de salida.
#include <iomanip>#include <iostream>#include <regex>#include <sstream>#include <string>usingnamespace std::string_literals; void mostrar_error(conststd::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; \ breakswitch(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(conststd::string& texto, conststd::string& regex, const std::regex::flag_type indicadores){std::cout<<"Texto: "<< quoted(texto)<<"\nExpresión regular: "<< quoted(regex)<<'\n';try{conststd::regex re{regex, indicadores};constbool 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; constauto tu_texto ="Hola expresiones regulares."s;constauto 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);}
Posible salida:
Texto: "Hola expresiones regulares." Expresión regular: "([a-zA-Z]+) ([a-z]+) ([a-z]+)\\." COINCIDE prefijo = [] m[0] = [Hola expresiones regulares.] m[1] = [Hola] m[2] = [expresiones] m[3] = [regulares] sufijo = [] Texto: "Inválido" Expresión regular: "((.)(.)" El paréntesis no está cerrado. (error_paren): La expresión contiene paréntesis que no coinciden ('(' y ')'). Texto: "Inválido" Expresión regular: "[." Carácter inesperado en expresión con corchetes. (error_brack): La expresión contiene corchetes que no coinciden ('[' y ']'). Texto: "Inválido" Expresión regular: "[.]{}" Carácter inesperado en expresión con corchetes. (error_badbrace): La expresión contiene un rango inválido en una expresión {}. Texto: "Inválido" Expresión regular: "[1-0]" Rango inválido en expresión con corchetes. (error_range): La expresión contiene un rango de caracteres inválido (p. ej., [b-a]).[editar]Notas
En C++11, estas constantes se especificaron con la palabra clave redundante static, que se eliminó en C++14 mediante el asunto LWG 2053
[editar]Véase también
(C++11) | Informa de errores generado por la biblioteca de expresiones regulares. (clase) |
