std::regex_constants::error_type
De cppreference.com
<tbody>
</tbody>
<tbody class="t-dcl-rev ">
</tbody><tbody>
</tbody>
| 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*/; constexpr error_type error_escape = /*no especificado*/; constexpr error_type error_backref = /*no especificado*/; constexpr error_type error_brack = /*no especificado*/; constexpr error_type error_paren = /*no especificado*/; constexpr error_type error_brace = /*no especificado*/; constexpr error_type error_badbrace = /*no especificado*/; constexpr error_type error_range = /*no especificado*/; constexpr error_type error_space = /*no especificado*/; constexpr error_type error_badrepeat = /*no especificado*/; constexpr error_type error_complexity = /*no especificado*/; constexpr error_type error_stack = /*no especificado*/; |
(desde C++11) (hasta C++17) |
|
inline constexpr error_type error_collate = /*no especificado*/; inline constexpr error_type error_ctype = /*no especificado*/; inline constexpr error_type error_escape = /*no especificado*/; inline constexpr error_type error_backref = /*no especificado*/; inline constexpr error_type error_brack = /*no especificado*/; inline constexpr error_type error_paren = /*no especificado*/; inline constexpr error_type error_brace = /*no especificado*/; inline constexpr error_type error_badbrace = /*no especificado*/; inline constexpr error_type error_range = /*no especificado*/; inline constexpr error_type error_space = /*no especificado*/; inline constexpr error_type error_badrepeat = /*no especificado*/; inline constexpr error_type error_complexity = /*no especificado*/; inline constexpr error_type error_stack = /*no especificado*/; |
(desde C++17) | |
error_type es un tipo que describe los errores que pueden ocurrir durante el análisis de expresiones regulares.
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. |
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.
Ejecuta este código
#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);
}
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]).
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
Véase también
(C++11) |
Informa de errores generado por la biblioteca de expresiones regulares. (clase) |