Cómo utilizar expresiones regulares en lenguaje C
Te vi discutiendo este aspecto, haz alguna contribución para mostrar tu dedicación desinteresada a esta versión: Ups:
Si el usuario Si eres Si están familiarizados con sed, awk, grep o vi en Linux, entonces el concepto de expresiones regulares definitivamente les resultará familiar. Debido a que puede simplificar enormemente la complejidad del procesamiento de cadenas, ahora se usa en muchas utilidades de Linux. No crea que las expresiones regulares son solo una patente para lenguajes de secuencias de comandos como Perl, Python y Bash. , como un programa en lenguaje C.
Los miembros y usuarios también pueden utilizar expresiones regulares en sus propios programas.
Los estándares C y C++ no admiten expresiones regulares, pero existen algunas bibliotecas de funciones que pueden ayudar a los programadores de C/C++ a completar esta función. La más conocida es la biblioteca de expresiones regulares compatible con Perl de Philip Hazel, que se incluye en muchas distribuciones de Linux.
Compilar expresiones regulares
Para mejorar la eficiencia, antes de usar expresiones regulares para comparar una cadena, primero debes compilarla con la función regcomp() y convertirla en una estructura regex_t. :
int regcomp(regex_t *preg, const char *regex, int cflags);
El parámetro regex es una cadena que representa la expresión regular a la que apunta el parámetro preg; una estructura de datos regex_t declarada utilizada para guardar los resultados de la compilación; el parámetro cflags determina los detalles de cómo se deben procesar las expresiones regulares.
Si la función regcomp() se ejecuta exitosamente y los resultados de la compilación se completan correctamente en preg, la función devolverá 0, cualquier otro resultado devuelto representa algún tipo de error.
Coincidencia de expresiones regulares
Una vez que la función regcomp() compila correctamente la expresión regular, se puede llamar a la función regexec() para completar la coincidencia de patrones:
int regexec(const regex_t *preg, const char *string, size_t nmatch, regmatch_t pmatch[], int e flags);
estructura typedef {
regoff _ t rm _ so
p>regoff _ t rm _ eo
} regmatch _ t;
El parámetro preg apunta a la expresión regular compilada y la cadena del parámetro es la cadena a coincidir. nmatch y pmatch se utilizan para devolver resultados coincidentes al programa que llama, y el último parámetro eflags determina los detalles coincidentes.
En el proceso de coincidencia de patrones llamando a la función regexec(), la expresión regular dada en la cadena puede coincidir varias veces y el parámetro pmatch se utiliza para garantizar esto.
Al almacenar estas posiciones coincidentes, el parámetro nmatch le dice a la función regexec() cuántos resultados coincidentes se pueden completar en la matriz pmatch como máximo. Cuando la función regexec() regresa exitosamente
Atrás, desde string+pmatch[0]. rm_so a cadena+pmatch[0]. rm_eo es la primera cadena coincidente, de
String+pmatch[1]. rm_so a cadena+pmatch[1]. rm_eo es la segunda cadena coincidente, y así sucesivamente.
Liberar la expresión regular
Siempre que la expresión regular compilada ya no sea necesaria, se debe llamar a la función regfree() para liberarla y evitar pérdidas de memoria.
void regfree(regex _ t * preg);
La función regfree() no devolverá ningún resultado. Solo recibe un puntero al tipo de datos regex_t, que es el resultado de la compilación obtenido al llamar antes a la función regcomp().
Si la función regcomp() se llama varias veces en la misma estructura regex_t en el programa, el estándar POSIX no estipula si la función regfree() debe llamarse cada vez.
Sin embargo, se recomienda llamar a la función regfree() cada vez que llame a la función regcomp() para compilar una expresión regular para liberar el espacio de almacenamiento ocupado lo antes posible.
Informar un mensaje de error
Si llama a la función regcomp() o regexec() y obtiene un valor de retorno distinto de cero, significa que ocurrió algún tipo de error durante el procesamiento de la expresión regular. Se puede obtener información detallada sobre el error llamando a la función regerror().
size_t regerror(int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size);
El parámetro errcode es de la función regcomp() o regexec() Código de error, El parámetro preg es el resultado de la compilación de la función regcomp().
El propósito es proporcionar a la función regerror() el contexto necesario para formatear el mensaje. Cuando se ejecuta la función regerror() se seguirá el número máximo de caracteres indicado por el parámetro errbuf_size.
Número de segmento, complete la información de error formateada en el búfer errbuf y devuelva la longitud de la información de error.
Aplicación de expresiones regulares
Finalmente, se utilizará un ejemplo específico para presentar cómo procesar expresiones regulares en programas en lenguaje C.
# incluir & ltstdio.h & gt;
# incluir & ltsys/types .h & gt
# incluir & ltregex.h & gt ;
/*Función que acepta subcadenas*/
Static char* substr(const char*str, unsigned start, unsigned end)
{
Sin firmar n = fin-inicio;
carácter estático ST buf[256];
strncpy(stbuf, str + inicio, n
); p>
ST buf[n]= 0;
Devolver stbuf
}
/*Programa principal*/
int main(int argc, char** argv)
{
char *modo;
int x, z, lno = 0, cflags = 0;
char ebuf[128], lbuf[256];
regex _ t reg
reg match _ t pm[10];
const size _ t n match = 10;
/*Compilar expresión regular*/
patrón = argv[1];
z = regcomp( & reg, patrón, cflags);
if (z!= 0){
regerror(z & reg, ebuf, sizeof(ebuf));
p>
fprintf(stderr, " %s: patrón '%s' \n ", ebuf, patrón
Retorno 1; p>/*Procesar datos de entrada línea por línea*/
while(fgets(lbuf, sizeof(lbuf), stdin)) {
++ lno;
if((z = strlen(lbuf))& gt; 0 & amp& amplbuf[z-1] == '\n ' '
lbuf[z-1]= 0;
/*Aplicar expresión regular a cada línea para que coincida*/
z = regexec(& reg, lbuf, nmatch, pm, 0); == REG_NOMATCH) continuar;
si no (z! = 0) {
regerror(z & reg, ebuf, sizeof(ebuf));
fprintf(stderr, " %s: regcom('%s')\ n " , ebuf, lbuf);
return 2;
}
/*Resultados del procesamiento de salida*/
for(x = 0 ; x & lt no coincide. rm_so! = -1;++ x) {
if (! lno, lbuf);
printf(" $%d='% s'\n ", x, substr(lbuf, pm[x]). rm_so, pm[x].
RM_EO));
}
}
/*Liberar expresión regular*/
regfree(& reg );
devuelve 0;
}
El programa anterior es responsable de obtener expresiones regulares de la línea de comando y luego aplicarlas a cada línea de datos e imprimir las coincidencias. resultados. Ejecute el siguiente comando para compilar y ejecutar el programa:
# gcc expresión regular. c -o expresión regular
# ./regexp ' regex[a-z]* ' & lt; expresión Expresión c
0003:# include & lt;regex.h & gt;
$0='regex '
0027:regex _ t reg;
$0='regex '
0054:z = regexec(& reg, lbuf, nmatch, pm, 0);
$0='regexec '
Resumen
Para aquellos programas que requieren un procesamiento de datos complejo, las expresiones regulares son sin duda una herramienta muy útil. Este artículo se centra en cómo utilizar expresiones regulares en lenguaje C para simplificar el procesamiento de cadenas, obteniendo así una flexibilidad similar a la de Perl en el procesamiento de datos.