Conceptos básicos de expresiones regulares en C ++

Regular Expression Basics C



Considere la siguiente oración entre comillas:

Aquí está mi hombre.

Esta cadena puede estar dentro de la computadora y el usuario puede querer saber si tiene la palabra man. Si tiene la palabra hombre, es posible que desee cambiar la palabra hombre por mujer; de modo que la cadena debería leer:







Aquí está mi mujer.

Hay muchos otros deseos como estos del usuario de la computadora; algunos son complejos. La expresión regular, abreviada, regex, es el tema del manejo de estos problemas por parte de la computadora. C ++ viene con una biblioteca llamada regex. Entonces, un programa en C ++ para manejar expresiones regulares debería comenzar con:



#incluir

#incluir

usando el espacio de nombres std;

Este artículo explica los conceptos básicos de las expresiones regulares en C ++.



Contenido del artículo

Fundamentos de expresiones regulares

Regex

Una cuerda como Aquí está mi hombre. arriba está la secuencia objetivo o cadena objetivo o simplemente, objetivo. man, que se buscó, es la expresión regular, o simplemente, regex.





Pareo

Se dice que la coincidencia ocurre cuando se localiza la palabra o frase que se busca. Después de la coincidencia, se puede realizar un reemplazo. Por ejemplo, después de que el hombre se encuentra arriba, puede ser reemplazado por una mujer.

Coincidencia simple

El siguiente programa muestra cómo se empareja la palabra hombre.



#incluir

#incluir

usando el espacio de nombres std;

En tprincipal()
{

regex reg('hombre');
si (regex_search(Aquí está mi hombre.,reg))
costo<< 'emparejado' <<endl;
demás
costo<< 'no coinciden' <<endl;

regreso 0;
}

La función regex_search () devuelve verdadero si hay una coincidencia y devuelve falso si no ocurre ninguna coincidencia. Aquí, la función toma dos argumentos: el primero es la cadena de destino y el segundo es el objeto regex. La expresión regular en sí es 'man', entre comillas dobles. La primera declaración en la función main () forma el objeto regex. Regex es un tipo y reg es el objeto regex. La salida del programa anterior es 'coincidente', ya que 'man' se ve en la cadena de destino. Si no se hubiera visto 'man' en el objetivo, regex_search () habría devuelto falso y la salida habría sido 'no coincidente'.

La salida del siguiente código no coincide:

regex reg('hombre');
si (regex_search('Aquí está mi creación'.,reg))
costo<< 'emparejado' <<endl;
demás
costo<< 'no coinciden' <<endl;

No coincide porque la expresión regular 'man' no se pudo encontrar en toda la cadena de destino, 'Aquí está mi creación'.

Patrón

La expresión regular, man above, es muy simple. Las expresiones regulares no suelen ser tan simples. Las expresiones regulares tienen metacaracteres. Los metacaracteres son personajes con significados especiales. Un metacarácter es un personaje sobre personajes. Los metacaracteres de expresiones regulares de C ++ son:

^$ .* + ? ( ) [ ] { } |

Una expresión regular, con o sin metacaracteres, es un patrón.

Clases de personajes

Corchetes

Un patrón puede tener caracteres entre corchetes. Con esto, una posición particular en la cadena de destino coincidiría con cualquiera de los caracteres de los corchetes. Considere los siguientes objetivos:

El gato está en la habitación.

El murciélago está en la habitación.

La rata está en la habitación.

La expresión regular, [cbr] en coincidiría con gato en el primer objetivo. Coincidiría con el murciélago en el segundo objetivo. Coincidiría con la rata en el tercer objetivo. Esto se debe a que gato, murciélago o rata comienzan con 'c', 'b' o 'r'. El siguiente segmento de código ilustra esto:

regex reg('[cbr] en');
si (regex_search(El gato está en la habitación.,reg))
costo<< 'emparejado' <<endl;
si (regex_search(El murciélago está en la habitación.,reg))
costo<< 'emparejado' <<endl;
si (regex_search(La rata está en la habitación.,reg))
costo<< 'emparejado' <<endl;

La salida es:

emparejado

emparejado

emparejado

Rango de caracteres

La clase, [cbr] en el patrón [cbr], coincidiría con varios caracteres posibles en el objetivo. Coincidiría con 'c', 'b' o 'r' en el objetivo. Si el objetivo no tiene 'c', 'b' o 'r', seguido de una en, no habría ninguna coincidencia.

Algunas posibilidades como 'c' o 'b' o 'r' existen en un rango. El rango de dígitos, 0 a 9 tiene 10 posibilidades, y el patrón para eso es [0-9]. El rango de alfabetos en minúsculas, de la a a la z, tiene 26 posibilidades, y el patrón para eso es [a-z]. El rango de alfabetos en mayúsculas, de la A a la Z, tiene 26 posibilidades, y el patrón para eso es [A-Z]. - no es oficialmente un metacarácter, pero entre corchetes, indicaría un rango. Entonces, lo siguiente produce una coincidencia:

si (regex_search('ID6id',regex('[0-9]')))

costo<< 'emparejado' <<endl;

Observe cómo se ha construido la expresión regular como segundo argumento. La coincidencia se produce entre el dígito, 6 en el rango, 0 a 9, y el 6 en el objetivo, ID6id. El código anterior es equivalente a:

si (regex_search('ID6id',regex('[0123456789]')))

costo<< 'emparejado' <<endl;

El siguiente código produce una coincidencia:

carbonizarsepag[] = 'ID6iE';

si (regex_search(pag,regex('[Arizona]')))

costo<< 'emparejado' <<endl;

Tenga en cuenta que el primer argumento aquí es una variable de cadena y no el literal de cadena. La coincidencia es entre 'i' en [a-z] e 'i' en ID6iE.

No olvide que un rango es una clase. Puede haber texto a la derecha del rango o a la izquierda del rango en el patrón. El siguiente código produce una coincidencia:

si (regex_search('ID2id es una identificación ',regex('ID [0-9] id')))

costo<< 'emparejado' <<endl;

La coincidencia es entre ID [0-9] id e ID2id. El resto de la cadena de destino, es un ID, no coincide en esta situación.

Como se usa en el sujeto de expresión regular (regexes), la palabra clase en realidad significa un conjunto. Es decir, uno de los personajes del set va a coincidir.

Nota: El guión - es un metacarácter solo entre corchetes, lo que indica un rango. No es un metacarácter en la expresión regular, fuera de los corchetes.

Negación

Se puede negar una clase que incluya un rango. Es decir, ninguno de los personajes del conjunto (clase) debe coincidir. Esto se indica con el metacarácter ^ al principio del patrón de clase, justo después del corchete de apertura. Entonces, [^ 0-9] significa hacer coincidir el carácter en la posición apropiada en el destino, que no es ningún carácter en el rango, 0 a 9 inclusive. Entonces, el siguiente código no producirá una coincidencia:

si (regex_search('0123456789101112',regex('[^0-9]')))

costo<< 'emparejado' <<endl;

demás

costo<< 'no coinciden' <<endl;

Se puede encontrar un dígito dentro del rango de 0 a 9 en cualquiera de las posiciones de la cadena de destino, 0123456789101112; entonces no hay coincidencia - negación.

El siguiente código produce una coincidencia:

si (regex_search('ABCDEFGHIJ',regex('[^0-9]')))

costo<< 'emparejado' <<endl;

No se pudo encontrar ningún dígito en el destino, ABCDEFGHIJ; entonces hay un partido.

[a-z] es un rango fuera de [^ a-z]. Y entonces [^ a-z] es la negación de [a-z].

[A-Z] es un rango fuera de [^ A-Z]. Y entonces [^ A-Z] es la negación de [A-Z].

Existen otras negaciones.

Coincidencia de espacios en blanco

'' O t o r o n o f es un carácter de espacio en blanco. En el siguiente código, la expresión regular n coincide con ' n' en el destino:

si (regex_search(De la línea uno. r orteDe la línea dos.,regex(' orte')))

costo<< 'emparejado' <<endl;

Coincidencia de cualquier carácter de espacio en blanco

El patrón o la clase que coincide con cualquier carácter de espacio en blanco es [ t r n f]. En el siguiente código, '' coincide:

si (regex_search('uno dos',regex('[ t r orteF]')))

costo<< 'emparejado' <<endl;

Coincidir con cualquier carácter que no sea un espacio en blanco

El patrón o clase para coincidir con cualquier carácter de espacio en blanco es [^ t r n f]. El siguiente código produce una coincidencia porque no hay espacios en blanco en el destino:

si (regex_search('1234abcd',regex('[^ t r orteF]')))

costo<< 'emparejado' <<endl;

El punto (.) En el patrón

El punto (.) En el patrón coincide con cualquier carácter, incluido él mismo, excepto n, en el destino. Se produce una coincidencia en el siguiente código:

si (regex_search('1234abcd',regex('.')))

costo<< 'emparejado' <<endl;

No hay resultados coincidentes en el siguiente código porque el destino es n.

si (regex_search(' orte',regex('.')))

costo<< 'emparejado' <<endl;

demás

costo<< 'no coinciden' <<endl;

Nota: Dentro de una clase de caracteres con corchetes, el punto no tiene un significado especial.

Repeticiones coincidentes

Un carácter o un grupo de caracteres puede aparecer más de una vez dentro de la cadena de destino. Un patrón puede coincidir con esta repetición. Los metacaracteres,?, *, + Y {} se utilizan para hacer coincidir la repetición en el objetivo. Si x es un carácter de interés en la cadena de destino, los metacaracteres tienen los siguientes significados:

x*:significa partido'x' 0o mas veces,I.Y.,cualquier cantidad de veces

x+:significa partido'x' 1o mas veces,I.Y.,al menos una vez

x? :significa partido'x' 0o1 tiempo

x{norte,}:significa partido'x'al menos no más veces.Notala coma.

x{norte} :fósforo'x'exactamente n veces

x{norte,metro}:fósforo'x'al menos n veces,pero no más de m veces.

Estos metacaracteres se llaman cuantificadores.

Ilustraciones

*

El * coincide con el carácter o grupo anterior, cero o más veces. o * coincide con 'o' en el perro de la cadena de destino. También coincide con oo en libro y mirando. La expresión regular, o * coincide con boooo en The animal booooed .. Nota: o * coincide con dig, donde 'o' ocurre cero (o más) tiempo.

+

El + coincide con el carácter o grupo anterior, 1 o más veces. Compárelo con cero o más veces para *. Entonces, la expresión regular, e + coincide con 'e' en comer, donde 'e' aparece una vez. e + también coincide con ee en ovejas, donde 'e' aparece más de una vez. Nota: e + no coincidirá con dig porque en dig, 'e' no aparece al menos una vez.

?

Los ? coincide con el carácter o grupo anterior, 0 o 1 vez (y no más). Entonces, ¿e? coincide con excavar porque 'e' aparece en excavación, tiempo cero. ¿mi? coincidencias establecidas porque 'e' aparece en el conjunto, una vez. Nota: e? todavía coincide con las ovejas; aunque hay dos 'e' en ovejas. Aquí hay un matiz, ver más adelante.

{norte,}

Esto coincide con al menos n repeticiones consecutivas de un carácter o grupo anterior. Entonces, la expresión regular, e {2,} coincide con las dos 'e' en la oveja objetivo, y las tres 'e' en la oveja objetivo. e {2,} no coincide con el conjunto, porque el conjunto solo tiene una 'e'.

{norte}

Esto coincide exactamente con n repeticiones consecutivas de un carácter o grupo anterior. Entonces, la expresión regular, e {2} coincide con las dos 'e' en el objetivo, oveja. e {2} no coincide con el conjunto porque el conjunto tiene solo una 'e'. Bueno, e {2} coincide con dos 'e' en el objetivo, carnero. Aquí hay un matiz, ver más adelante.

{Nuevo Méjico}

Esto coincide con varias repeticiones consecutivas de un carácter o grupo anterior, desde n hasta m, inclusive. Entonces, e {1,3} no coincide con nada en dig, que no tiene 'e'. Coincide con la 'e' del conjunto, las dos 'e' en oveja, las tres 'e' en oveja y las tres 'e' en oveja. Hay un matiz en el último partido, ver más adelante.

Alternancia coincidente

Considere la siguiente cadena de destino en la computadora.

La granja tiene cerdos de diferentes tamaños.

El programador puede querer saber si este objetivo tiene una cabra, un conejo o un cerdo. El código sería el siguiente:

carbonizarsepag[] = 'La granja tiene cerdos de diferentes tamaños'.;

si (regex_search(pag,regex('cabra | conejo | cerdo')))

costo<< 'emparejado' <<endl;

demás

costo<< 'no coinciden' <<endl;

El código produce una coincidencia. Tenga en cuenta el uso del carácter de alternancia, |. Puede haber dos, tres, cuatro y más opciones. C ++ primero intentará hacer coincidir la primera alternativa, cabra, en cada posición de carácter en la cadena de destino. Si no tiene éxito con cabra, prueba la siguiente alternativa, conejo. Si no tiene éxito con conejo, prueba la siguiente alternativa, cerdo. Si el cerdo falla, entonces C ++ pasa a la siguiente posición en el objetivo y comienza de nuevo con la primera alternativa.

En el código anterior, el cerdo coincide.

Coincidencia de principio o final

Comienzo


Si ^ está al principio de la expresión regular, entonces el texto inicial de la cadena de destino puede coincidir con la expresión regular. En el siguiente código, el inicio del objetivo es abc, que coincide:

si (regex_search('abc y def',regex('^abc')))

costo<< 'emparejado' <<endl;

No se produce ninguna coincidencia en el siguiente código:

si (regex_search('Sí, abc y def',regex('^abc')))

costo<< 'emparejado' <<endl;

demás

costo<< 'no coinciden' <<endl;

Aquí, abc no está al principio del objetivo.

Nota: El carácter circunflejo, '^', es un metacarácter al comienzo de la expresión regular, que coincide con el comienzo de la cadena de destino. Sigue siendo un metacarácter al comienzo de la clase de personaje, donde niega la clase.

Fin

Si $ está al final de la expresión regular, entonces el texto final de la cadena de destino puede coincidir con la expresión regular. En el siguiente código, el final del destino es xyz, que coincide:

si (regex_search('uvw y xyz',regex('xyz $')))

costo<< 'emparejado' <<endl;

No se produce ninguna coincidencia en el siguiente código:

si (regex_search('uvw y xyz final',regex('xyz $')))

costo<< 'emparejado' <<endl;

demás

costo<< 'no coinciden' <<endl;

Aquí, xyz no está al final del objetivo.

Agrupamiento

Los paréntesis se pueden utilizar para agrupar caracteres en un patrón. Considere la siguiente expresión regular:

'un concierto (pianista)'

El grupo aquí es pianista rodeado por los metacaracteres (y). En realidad, es un subgrupo, mientras que un concierto (pianista) es todo el grupo. Considera lo siguiente:

'El (pianista es bueno)'

Aquí, el subgrupo o subcadena es, pianist is good.

Subcadenas con piezas comunes

Un contable es una persona que se ocupa de los libros. Imagínese una biblioteca con un contador y una estantería. Suponga que una de las siguientes cadenas de destino está en la computadora:

'La biblioteca tiene una estantería que se admira.';

'Aquí está el contable.';

'El contable trabaja con la estantería.';

Suponga que el interés del programador no es saber cuál de estas oraciones está en la computadora. Aún así, su interés es saber si la estantería o el tenedor de libros está presente en cualquier cadena de destino que haya en la computadora. En este caso, su expresión regular puede ser:

'librería | contable'.

Usando alternancia.

Observe que el libro, que es común a ambas palabras, se ha escrito dos veces, en las dos palabras del patrón. Para evitar escribir el libro dos veces, la expresión regular estaría mejor escrita como:

'libro (estante | guardián)'

Aquí, el grupo, estante | guardián El metacarácter de alternancia todavía se ha utilizado, pero no por dos palabras largas. Se ha utilizado para las dos partes finales de las dos palabras largas. C ++ trata a un grupo como una entidad. Entonces, C ++ buscará el estante o el guardián que viene inmediatamente después del libro. La salida del siguiente código coincide:

carbonizarsepag[] = 'La biblioteca tiene una estantería que es admirada'.;

si (regex_search(pag,regex('libro (estante | guardián)')))

costo<< 'emparejado' <<endl;

estantería y no contable se han emparejado.

Las constantes regex_constants de icase y multiline

icase

La coincidencia distingue entre mayúsculas y minúsculas de forma predeterminada. Sin embargo, se puede hacer que no distinga entre mayúsculas y minúsculas. Para lograr esto, use la constante regex :: icase, como en el siguiente código:

si (regex_search('Realimentación',regex('alimentación',regex::icase)))

costo<< 'emparejado' <<endl;

La salida coincide. Por lo tanto, los comentarios con 'F' en mayúscula se han emparejado con el feed con 'f' en minúscula. regex :: icase se ha convertido en el segundo argumento del constructor regex (). Sin eso, la declaración no produciría una coincidencia.

Multilínea

Considere el siguiente código:

carbonizarsepag[] = 'línea 1 ortelínea 2 ortelínea 3';

si (regex_search(pag,regex('^.*$')))

costo<< 'emparejado' <<endl;

demás

costo<< 'no coinciden' <<endl;

La salida no coincide. La expresión regular, ^. * $, Coincide con la cadena de destino desde el principio hasta el final. . * significa cualquier carácter excepto n, cero o más veces. Entonces, debido a los caracteres de nueva línea ( n) en el destino, no hubo coincidencia.

El objetivo es una cadena de varias líneas. Para que '.' Coincida con el carácter de nueva línea, se debe realizar la constante regex :: multiline, el segundo argumento de la construcción regex (). El siguiente código ilustra esto:

carbonizarsepag[] = 'línea 1 ortelínea 2 ortelínea 3';

si (regex_search(pag,regex('^.*$',regex::multilínea)))

costo<< 'emparejado' <<endl;

demás

costo<< 'no coinciden' <<endl;

Coincidencia de toda la cadena de destino

Para hacer coincidir toda la cadena de destino, que no tiene el carácter de nueva línea ( n), se puede utilizar la función regex_match (). Esta función es diferente de regex_search (). El siguiente código ilustra esto:

carbonizarsepag[] = 'primera segunda tercera';

si (regex_match(pag,regex('.*segundo.*')))

costo<< 'emparejado' <<endl;

Aquí hay un partido. Sin embargo, tenga en cuenta que la expresión regular coincide con toda la cadena de destino y que la cadena de destino no tiene ningún ' n'.

El objeto match_results

La función regex_search () puede tomar un argumento entre el objetivo y el objeto regex. Este argumento es el objeto match_results. La cadena completa (parte) coincidente y las subcadenas coincidentes se pueden conocer con él. Este objeto es una matriz especial con métodos. El tipo de objeto match_results es cmatch (para cadenas literales).

Obtención de partidos

Considere el siguiente código:

carbonizarsepag[] = ¡La mujer que buscabas!;

cmatch m;

si (regex_search(pag,metro,regex('w.m.n')))

costo<<metro[0] <<endl;

La cadena de destino tiene la palabra mujer. La salida es woman ’, que corresponde a la expresión regular, w.m.n. En el índice cero, la matriz especial contiene la única coincidencia, que es mujer.

Con las opciones de clase, solo la primera subcadena que se encuentra en el destino se envía a la matriz especial. El siguiente código ilustra esto:

cmatch m;

si (regex_search(¡La rata, el gato, el murciélago!,metro,regex('[bcr] en')))

costo<<metro[0] <<endl;

costo<<metro[1] <<endl;

costo<<metro[2] <<endl;

La salida es rata desde el índice cero. m [1] y m [2] están vacíos.

Con las alternativas, solo la primera subcadena que se encuentra en el destino se envía a la matriz especial. El siguiente código ilustra esto:

si (regex_search(¡El conejo, la cabra, el cerdo!,metro,regex('cabra | conejo | cerdo')))

costo<<metro[0] <<endl;

costo<<metro[1] <<endl;

costo<<metro[2] <<endl;

La salida es conejo desde el índice cero. m [1] y m [2] están vacíos.

Agrupaciones

Cuando hay grupos involucrados, el patrón completo coincide, entra en la celda cero de la matriz especial. La siguiente subcadena encontrada va a la celda 1; la subcadena que sigue, entra en la celda 2; etcétera. El siguiente código ilustra esto:

si (regex_search('¡El mejor librero de hoy!',metro,regex('libro ((sel) (ler))')))

costo<<metro[0] <<endl;

costo<<metro[1] <<endl;

costo<<metro[2] <<endl;

costo<<metro[3] <<endl;

La salida es:

librero

vendedor

celda

leer

Tenga en cuenta que el grupo (vendedor) viene antes que el grupo (sel).

Posición del partido

Se puede conocer la posición de coincidencia para cada subcadena en la matriz cmatch. El conteo comienza desde el primer carácter de la cadena de destino, en la posición cero. El siguiente código ilustra esto:

cmatch m;

si (regex_search('¡El mejor librero de hoy!',metro,regex('libro ((sel) (ler))')))

costo<<metro[0] << '->' <<metro.posición(0) <<endl;

costo<<metro[1] << '->' <<metro.posición(1) <<endl;

costo<<metro[2] << '->' <<metro.posición(2) <<endl;

costo<<metro[3] << '->' <<metro.posición(3) <<endl;

Tenga en cuenta el uso de la propiedad de posición, con el índice de celda, como argumento. La salida es:

librero->5

vendedor->9

celda->9

leer->12

Buscar y reemplazar

Una nueva palabra o frase puede reemplazar la coincidencia. La función regex_replace () se usa para esto. Sin embargo, esta vez, la cadena donde se produce el reemplazo es el objeto de cadena, no el literal de cadena. Por lo tanto, la biblioteca de cadenas debe incluirse en el programa. Ilustración:

#incluir

#incluir

#incluir

usando el espacio de nombres std;

En tprincipal()
{
cadena str= 'Aquí viene mi hombre. Ahí va tu hombre.;
cadena newStr=regex_replace(pag,regex('hombre'), 'mujer');
costo<<newStr<<endl;

regreso 0;
}

La función regex_replace (), como se codifica aquí, reemplaza todas las coincidencias. El primer argumento de la función es el objetivo, el segundo es el objeto regex y el tercero es la cadena de reemplazo. La función devuelve una nueva cadena, que es el objetivo pero que tiene el reemplazo. La salida es:

Aquí viene mi mujer. Ahí va tu mujer.

Conclusión

La expresión regular usa patrones para hacer coincidir subcadenas en la cadena de secuencia de destino. Los patrones tienen metacaracteres. Las funciones más utilizadas para las expresiones regulares de C ++ son: regex_search (), regex_match () y regex_replace (). Una expresión regular es un patrón entre comillas dobles. Sin embargo, estas funciones toman el objeto regex como argumento y no solo la expresión regular. La expresión regular debe convertirse en un objeto de expresión regular antes de que estas funciones puedan usarlo.