Mga Karaniwang Pangunahing Kaalaman sa Pagpapahayag sa C ++

Ang string na ito ay maaaring nasa loob ng computer, at maaaring gusto ng gumagamit na malaman kung mayroon itong salitang lalaki. Kung mayroon itong salitang lalaki, maaaring gusto niyang baguhin ang salitang lalaki sa babae; upang ang string ay dapat basahin:

Maraming iba pang mga kagustuhan na tulad nito mula sa gumagamit ng computer; ang ilan ay kumplikado. Ang regular na Expression, dinaglat, regex, ay ang paksa ng paghawak ng mga isyung ito ng computer. Ang C ++ ay may kasamang library na tinatawag na regex. Kaya, ang isang C ++ na programa upang hawakan ang regex ay dapat magsimula sa:

Ipinapaliwanag ng artikulong ito ang Mga Pangunahing Kaalaman sa Pagpapahayag sa C ++.

Nilalaman ng Artikulo

• Mga Batayan ng Regular na Pagpapahayag
• Pattern
• Mga Klase ng Character
• Pagtutugma ng Mga Puti
• Ang Panahon (.) Sa Huwaran
• Pagtutugma ng Mga Pag-uulit
• Pagtutugma ng Kahalili
• Pagtutugma sa Simula o Pagtatapos
• Pagpapangkat
• Ang icase at multiline regex_constants
• Pagtutugma sa Buong Target
• Ang tumutugma sa Object_results
• Posisyon ng Pagtutugma
• Maghanap at Palitan
• Konklusyon

Mga Batayan ng Regular na Pagpapahayag

Regex

Isang string tulad ng Narito ang aking tao. sa itaas ay ang target na pagkakasunud-sunod o target na string o simpleng, target. ang tao, na hinanap, ay ang regular na expression, o simpleng, regex.

Pagtutugma

Sinasabing nagaganap ang pagtutugma kapag ang salita o parirala na hinahanap ay matatagpuan. Pagkatapos ng pagtutugma, maaaring maganap ang isang kapalit. Halimbawa, matapos ang lalaki ay matatagpuan sa itaas, maaari itong mapalitan ng babae.

Simpleng Pagtutugma

Ipinapakita ng sumusunod na programa kung paano tumugma ang salitang lalaki.

Ang function na regex_search () ay nagbabalik totoo kung mayroong isang tugma at nagbabalik ng hindi totoo kung walang nangyayari na tugma. Dito, tumatagal ang pagpapaandar ng dalawang mga argumento: ang una ay ang target na string, at ang pangalawa ay ang regex object. Ang regex mismo ay 'man', sa mga dobleng quote. Ang unang pahayag sa pangunahing () pagpapaandar ay bumubuo ng regex object. Ang Regex ay isang uri, at ang reg ay ang regex object. Ang output ng program sa itaas ay 'naitugma', tulad ng 'man' ay nakikita sa target na string. Kung ang 'tao' ay hindi nakita sa target, ang regex_search () ay bumalik na hindi totoo, at ang output ay 'hindi maitugma'.

Ang output ng sumusunod na code ay hindi tugma:

Hindi naitugma sapagkat ang regex 'man' ay hindi matagpuan sa buong target na string, 'Narito ang aking paggawa.'

Pattern

Ang regular na expression, ang tao sa itaas, ay napaka-simple. Ang mga regex ay karaniwang hindi ganoon kadali. Ang mga regular na expression ay may mga metacharacter. Ang mga metacharacter ay mga character na may mga espesyal na kahulugan. Ang metacharacter ay isang character tungkol sa mga character. Ang C ++ regex metachar character ay:

Ang isang regex, mayroon o walang mga metacharacter, ay isang pattern.

Mga Klase ng Character

Mga Square Bracket

Ang isang pattern ay maaaring magkaroon ng mga character sa loob ng mga square bracket. Sa pamamagitan nito, ang isang partikular na posisyon sa target na string ay tutugma sa anumang mga character ng square bracket. Isaalang-alang ang mga sumusunod na target:

Ang regex, [cbr] ay tumutugma sa pusa sa unang target. Tutugma ito sa bat sa pangalawang target. Tutugma ito sa daga sa pangatlong target. Ito ay sapagkat, pusa o bat o daga ay nagsisimula sa 'c' o 'b' o 'r'. Ang sumusunod na segment ng code ay naglalarawan nito:

Ang output ay:

Saklaw ng Mga Character

Ang klase, [cbr] sa pattern na [cbr], ay tumutugma sa maraming mga posibleng character sa target. Itutugma ito sa 'c' o 'b' o 'r' sa target. Kung ang target ay walang anumang 'c' o 'b' o 'r', na sinusundan ng at, walang tugma.

Ang ilang mga posibilidad tulad ng 'c' o 'b' o 'r' ay umiiral sa isang saklaw. Ang saklaw ng mga digit, 0 hanggang 9 ay may 10 posibilidad, at ang pattern para doon ay [0-9]. Ang saklaw ng mga maliliit na alpabeto, a hanggang z, ay may 26 mga posibilidad, at ang pattern para doon ay [a-z]. Ang saklaw ng mga malalaking alpabeto, A hanggang Z, ay may 26 posibilidad, at ang pattern para doon ay [A-Z]. - ay hindi opisyal na isang metacharacter, ngunit sa loob ng mga square bracket, ipahiwatig nito ang isang saklaw. Kaya, ang sumusunod ay gumagawa ng isang tugma:

Tandaan kung paano itinayo ang regex bilang pangalawang argument. Ang tugma ay nangyayari sa pagitan ng digit, 6 sa saklaw, 0 hanggang 9, at ang 6 sa target, ID6id. Ang code sa itaas ay katumbas ng:

Ang sumusunod na code ay gumagawa ng isang tugma:

Tandaan na ang unang argumento dito ay isang variable ng string at hindi literal na string. Ang laban ay nasa pagitan ng ‘i’ sa [a-z] at ‘i’ sa ID6iE.

Huwag kalimutan na ang isang saklaw ay isang klase. Maaaring may teksto sa kanan ng saklaw o sa kaliwa ng saklaw sa pattern. Ang sumusunod na code ay gumagawa ng isang tugma:

Ang laban ay sa pagitan ng ID [0-9] id at ID2id. Ang natitirang string ng target, ay isang ID, ay hindi tugma sa sitwasyong ito.

Tulad ng ginamit sa regular na paksa ng pagpapahayag (regexes), ang salitang klase ay talagang nangangahulugang isang hanay. Iyon ay, ang isa sa mga character sa set ay upang tumugma.

Tandaan: Ang gitling - ay isang metacharacter lamang sa loob ng mga square bracket, na nagpapahiwatig ng isang saklaw. Hindi ito isang metacharacter sa regex, sa labas ng mga square bracket.

Negasyon

Ang isang klase na may kasamang isang saklaw ay maaaring tanggihan. Iyon ay, hindi ng mga character sa hanay (klase) ay dapat na tumugma. Ito ay ipinahiwatig ng ^ metacharacter sa simula ng pattern ng klase, pagkatapos lamang ng pagbubukas ng square bracket. Kaya, ang ibig sabihin ng [^ 0-9] ay tumutugma sa character sa naaangkop na posisyon sa target, na hindi anumang character sa saklaw, 0 hanggang 9 kasama. Kaya't ang sumusunod na code ay hindi makakagawa ng isang tugma:

Ang isang digit sa loob ng saklaw na 0 hanggang 9 ay maaaring matagpuan sa alinman sa mga posisyon ng target na string, 0123456789101112 ,; kaya't walang tugma - pagwawalang-bahala.

Ang sumusunod na code ay gumagawa ng isang tugma:

Walang digit na matagpuan sa target, ABCDEFGHIJ,; kaya may laban.

Ang [a-z] ay isang saklaw sa labas [^ a-z]. At sa gayon [^ a-z] ang pagwawaksi ng [a-z].

Ang [A-Z] ay isang saklaw sa labas [^ A-Z]. At sa gayon [^ A-Z] ang pagwawaksi ng [A-Z].

Ang iba pang mga negasyon ay mayroon.

Pagtutugma ng Mga Puti

Ang ‘’ o t o r o n o f ay isang whitespace character. Sa sumusunod na code, ang regex, n tumutugma sa ' n' sa target:

Pagtutugma sa anumang Whitespace Character

Ang pattern o klase upang tumugma sa anumang puting space character ay, [ t r n f]. Sa sumusunod na code, ang ‘’ ay naitugma:

Pagtutugma sa anumang Non-whitespace Character

Ang pattern o klase upang tumugma sa anumang di-puting space character ay, [^ t r n f]. Ang sumusunod na code ay gumagawa ng isang tugma dahil walang whitespace sa target:

Ang panahon (.) Sa pattern

Ang panahon (.) Sa pattern ay tumutugma sa anumang character kasama ang sarili nito, maliban sa n, sa target. Ang isang tugma ay ginawa sa sumusunod na code:

Walang mga tumutugmang resulta sa sumusunod na code dahil ang target ay n.

Tandaan: Sa loob ng klase ng character na may mga square bracket, ang panahon ay walang espesyal na kahulugan.

Pagtutugma ng Mga Pag-uulit

Ang isang character o isang pangkat ng mga character ay maaaring mangyari nang higit sa isang beses sa loob ng target na string. Maaaring tumugma ang isang pattern sa pag-uulit na ito. Ang mga metacharacter,?, *, +, At {} ay ginagamit upang tumugma sa pag-uulit sa target. Kung ang x ay isang character ng interes sa target na string, kung gayon ang mga metacharacter ay may mga sumusunod na kahulugan:

Ang mga metachar character na ito ay tinawag mga dami.

Mga guhit

*

Ang * ay tumutugma sa naunang karakter o naunang pangkat, zero o higit pang beses. o * tumutugma sa 'o' sa aso ng target na string. Tumutugma din ito oo sa libro at pagtingin. Ang regex, o * ay tumutugma sa boooo sa Ang hayop na booooed .. Tandaan: o * tumutugma sa paghukay, kung saan ang ‘o’ ay nangyayari zero (o higit pa) na oras.

+

Ang + ay tumutugma sa naunang character o naunang pangkat, 1 o higit pang mga beses. Ikumpara ito sa zero o higit pang beses para sa *. Kaya't ang regex, e + ay tumutugma sa 'e' sa eat, kung saan ang 'e' ay nangyayari isang beses. Ang e + ay tumutugma din sa mga tupa, kung saan ang ‘e’ ay nangyayari nang higit sa isang beses. Tandaan: ang e + ay hindi tutugma sa paghukay sapagkat sa paghukay, ang ‘e’ ay hindi nagaganap kahit isang beses.

?

Ang? tumutugma sa naunang karakter o naunang pangkat, 0 o 1 beses (at hindi higit pa). Kaya, e? tumutugma sa paghukay sapagkat ang ‘e’ ay nangyayari sa dig, zero time. e? itinakda ang mga tugma dahil ang ‘e’ ay nangyayari sa hanay, isang beses. Tandaan: e? tumutugma pa rin sa tupa; bagaman mayroong dalawang ‘e sa tupa. Mayroong isang pananarinari dito - tingnan sa paglaon.

{n,}

Tumutugma ito sa hindi bababa sa magkakasunod na pag-uulit ng isang naunang karakter o naunang pangkat. Kaya't ang regex, e {2,} ay tumutugma sa dalawang ‘e sa target, tupa, at ang tatlong‘ e sa target na sheeep. e {2,} ay hindi tumutugma sa itinakdang set, dahil ang set ay may isang ‘e’ lamang.

{n}

Tugma ito nang eksakto at magkakasunod na pag-uulit ng isang naunang karakter o naunang pangkat. Kaya't ang regex, e {2} ay tumutugma sa dalawang ‘e sa target, tupa. e {2} ay hindi tumutugma sa itinakda dahil ang set ay may isang ‘e’ lamang. Kaya, tumutugma ang {2} sa dalawang ‘e sa target, sheeep. Mayroong isang pananarinari dito - tingnan sa paglaon.

{n, m}

Tumutugma ito sa maraming magkakasunod na pag-uulit ng isang naunang karakter o naunang pangkat, saanman mula n hanggang m, kasama. Kaya, ang e {1,3} ay tumutugma sa wala sa paghukay, na walang ‘e’. Ito ay tumutugma sa isang 'e' sa hanay, ang dalawang 'e sa tupa, ang tatlong' e sa sheeep, at tatlong 'e sa sheeeep. Mayroong isang pananarinari sa huling laban - tingnan sa paglaon.

Pagtutugma ng Kahalili

Isaalang-alang ang sumusunod na target string sa computer.

Ang bukirin ay may mga baboy na magkakaiba ang laki.

Maaaring nais malaman ng programmer kung ang target na ito ay mayroong kambing o kuneho o baboy. Ang code ay ang mga sumusunod:

Gumagawa ang code ng isang tugma. Tandaan ang paggamit ng character na paghahalili, |. Maaaring may dalawa, tatlo, apat, at maraming mga pagpipilian. Susubukan muna ng C ++ na itugma ang unang kahalili, kambing, sa bawat posisyon ng character sa target na string. Kung hindi ito magtagumpay sa kambing, susubukan nito ang susunod na kahalili, kuneho. Kung hindi ito magtagumpay sa kuneho, susubukan nito ang susunod na kahalili, baboy. Kung nabigo ang baboy, pagkatapos ang C ++ ay lumilipat sa susunod na posisyon sa target at nagsisimula muli sa unang kahalili.

Sa code sa itaas, ang baboy ay naitugma.

Pagtutugma sa Simula o Pagtatapos

Simula

Kung ang ^ ay nasa simula ng regex, kung gayon ang panimulang teksto ng target na string ay maaaring maitugma ng regex. Sa sumusunod na code, ang simula ng target ay abc, na naitugma:

Walang pagtutugma na magaganap sa sumusunod na code:

Dito, ang abc ay wala sa simula ng target.

Tandaan: Ang karakter na circumflex, '^', ay isang metacharacter sa simula ng regex, na tumutugma sa simula ng target na string. Ito ay isang metacharacter pa rin sa simula ng klase ng character, kung saan tinanggihan nito ang klase.

Tapusin

Kung ang $ ay nasa dulo ng regex, kung gayon ang nagtatapos na teksto ng target na string ay maaaring maitugma ng regex. Sa sumusunod na code, ang dulo ng target ay xyz, na naitugma:

Walang pagtutugma na magaganap sa sumusunod na code:

Dito, wala si xyz sa dulo ng target.

Pagpapangkat

Maaaring gamitin ang mga magulang upang mapangkat ang mga character sa isang pattern. Isaalang-alang ang sumusunod na regex:

Ang pangkat dito ay piyanista na napapalibutan ng mga metacharacter (at). Ito ay talagang isang sub-grupo, habang ang isang konsyerto (pianista) ay ang buong pangkat. Isaalang-alang ang mga sumusunod:

Dito, ang sub-group o sub-string ay, mahusay ang pianist.

Mga sub-string na may Mga Karaniwang Bahagi

Ang isang bookkeeper ay isang taong nag-aalaga ng mga libro. Pag-isipan ang isang silid-aklatan na may isang bookkeeper at bookhelf. Ipagpalagay na ang isa sa mga sumusunod na target na string ay nasa computer:

Ipagpalagay na ang interes ng programmer ay hindi malaman kung alin sa mga pangungusap na ito ang nasa computer. Gayunpaman, ang kanyang interes ay malaman kung ang bookhelf o bookkeeper ay naroroon sa anumang target string na nasa computer. Sa kasong ito, ang kanyang regex ay maaaring:

Gumagamit ng paghahalili.

Pansinin ang librong iyon, na karaniwan sa parehong mga salita, na-type nang dalawang beses, sa dalawang salita sa pattern. Upang maiwasan ang pag-type ng libro nang dalawang beses, ang regex ay mas mahusay na isusulat bilang:

Dito, ang pangkat, istante | tagapag-alaga Ang alternatibong metacharacter ay ginamit pa rin, ngunit hindi para sa dalawang mahabang salita. Ginamit ito para sa dalawang nagtatapos na bahagi ng dalawang mahabang salita. Tinatrato ng C ++ ang isang pangkat bilang isang entity. Kaya, hahanapin ng C ++ ang istante o tagabantay na agad na dumating pagkatapos ng libro. Ang output ng sumusunod na code ay naitugma:

bookshelf at hindi bookkeeper ang naitugma.

Ang icase at multiline regex_constants

icase

Ang pagtutugma ay case sensitive bilang default. Gayunpaman, maaari itong gawing case insensitive. Upang makamit ito, gamitin ang regex :: icase pare-pareho, tulad ng sa sumusunod na code:

Ang output ay naitugma. Kaya ang Feedback na may malaking maliit na 'F' ay naitugma ng feed na may maliit na 'f'. regex :: icase ay ginawang pangalawang argumento ng regex () konstruktor. Kung wala iyon, ang pahayag ay hindi makagawa ng isang tugma.

Multiline

Isaalang-alang ang sumusunod na code:

Ang output ay hindi tugma. Ang regex, ^. * $, Ay tumutugma sa target na string mula sa simula hanggang sa wakas. . * nangangahulugang anumang character maliban sa n, zero o higit pang beses. Kaya, dahil sa mga bagong character na character ( n) sa target, walang pagtutugma.

Ang target ay isang multiline string. Upang maitugma ng ‘.’ Ang bagong character na character, kailangang gawin ang pare-parehong regex :: multiline, ang pangalawang argumento ng regex () konstruksyon. Ang sumusunod na code ay naglalarawan nito:

Pagtutugma sa Buong Target na String

Upang maitugma ang buong target na string, na walang newline character ( n), maaaring magamit ang pagpapaandar na regex_match (). Ang pagpapaandar na ito ay naiiba mula sa regex_search (). Ang sumusunod na code ay naglalarawan nito:

May laban dito. Gayunpaman, tandaan na ang regex ay tumutugma sa buong target na string, at ang target na string ay walang anumang ‘ n’.

Ang tumutugma sa Object_results

Ang pagpapaandar ng regex_search () ay maaaring tumagal ng isang argument sa pagitan ng target at ng regex object. Ang argument na ito ay ang match_results object. Ang buong naitugmang (bahagi) na string at ang mga sub-string na tumutugma ay maaaring malaman kasama nito. Ang bagay na ito ay isang espesyal na array na may mga pamamaraan. Ang uri ng object na match_results ay cmatch (para sa mga string literals).

Pagkuha ng Mga Pagtutugma

Isaalang-alang ang sumusunod na code:

Ang target string ay may salitang babae. Ang output ay babae ', na tumutugma sa regex, w.m.n. Sa index zero, ang espesyal na array ay nagtataglay ng nag-iisang tugma, kung saan ang babae.

Sa mga pagpipilian sa klase, ang unang sub-string lamang na matatagpuan sa target, ay ipinadala sa espesyal na array. Ang sumusunod na code ay naglalarawan nito:

Ang output ay daga mula sa index zero. walang laman ang m [1] at m [2].

Sa mga kahalili, tanging ang unang sub-string na matatagpuan sa target, na ipinadala sa espesyal na array. Ang sumusunod na code ay naglalarawan nito:

Ang output ay kuneho mula sa index zero. walang laman ang m [1] at m [2].

Pagpapangkat

Kapag ang mga pangkat ay kasangkot, ang kumpletong pattern na tumutugma, napupunta sa cell zero ng espesyal na array. Ang susunod na nahanap na sub-string ay papunta sa cell 1; ang sumusunod na sub-string, napupunta sa cell 2; at iba pa. Ang sumusunod na code ay naglalarawan nito:

Ang output ay:

Tandaan na ang pangkat (nagbebenta) ay nauna sa pangkat (sel).

Posisyon ng Pagtutugma

Ang posisyon ng tugma para sa bawat sub-string sa cmatch array ay maaaring malaman. Nagsisimula ang pagbibilang mula sa unang karakter ng target na string, sa posisyon na zero. Ang sumusunod na code ay naglalarawan nito:

Tandaan ang paggamit ng posisyon ng pag-aari, kasama ang index ng cell, bilang isang pagtatalo. Ang output ay:

Maghanap at Palitan

Ang isang bagong salita o parirala ay maaaring mapalitan ang tugma. Ginagamit ang pagpapaandar ng regex_replace () para dito. Gayunpaman, sa oras na ito, ang string kung saan nangyayari ang kapalit ay ang string object, hindi ang literal na string. Kaya, ang string library ay kailangang isama sa programa. Paglalarawan:

Ang pagpapaandar ng regex_replace (), tulad ng naka-code dito, ay pumapalit sa lahat ng mga tugma. Ang unang argumento ng pagpapaandar ay ang target, ang pangalawa ay ang regex object, at ang pangatlo ay ang kapalit na string. Ang pagpapaandar ay nagbabalik ng isang bagong string, na kung saan ay ang target ngunit pagkakaroon ng kapalit. Ang output ay:

Narito ang aking babae. Nandun ang babae mo.

Konklusyon

Gumagamit ang regular na expression ng mga pattern upang tumugma sa mga substring sa target na string string. Ang mga pattern ay may mga metacharacter. Ang mga karaniwang ginagamit na pag-andar para sa mga regular na expression ng C ++ ay: regex_search (), regex_match () at regex_replace (). Ang isang regex ay isang pattern sa mga dobleng quote. Gayunpaman, ang mga pagpapaandar na ito ay kumukuha ng regex object bilang isang argument at hindi lamang ang regex. Ang regex ay dapat gawin sa isang regex object bago ito magamit ng mga pagpapaandar na ito.