Regulaaravaldise põhitõed C ++ keeles

Regular Expression Basics C

Kaaluge järgmist lauset jutumärkides:

'Siin on minu mees.'

See string võib olla arvuti sees ja kasutaja võib soovida teada, kas sellel on sõna mees. Kui sellel on sõna mees, võib ta soovida muuta sõna mees naiseks; nii et string peaks lugema:

'Siin on minu naine.'

Arvutikasutajalt on palju muid selliseid soove; mõned on keerulised. Regulaaravaldis, lühendatud, regex, on nende probleemide käsitlemise teema arvutis. C ++ -ga on kaasas teek nimega regex. Niisiis, C ++ programm regulaaravaldise haldamiseks peaks algama järgmiselt:



#kaasake

#kaasake

kasutades nimeruumi std;

See artikkel selgitab regulaaravaldise põhitõdesid C ++ keeles.



Artikli sisu

Regulaaravaldise alused

Regulaarne

String nagu Siin on minu mees. ülal on sihtjärjestus või sihtstring või lihtsalt sihtmärk. mees, mida otsiti, on regulaaravaldis või lihtsalt regex.

Sobiv

Vastavust öeldakse siis, kui otsitav sõna või fraas asub. Pärast sobitamist saab asendada. Näiteks pärast seda, kui mees asub ülalpool, saab selle asendada naisega.

Lihtne sobitamine

Järgmine programm näitab, kuidas sõna mees sobitatakse.



#kaasake

#kaasake

kasutades nimeruumi std;

intpeamine()
{

regulaaravaldis reg('mees');
kui (regex_search('Siin on minu mees.',reg))
maksma<< 'sobitatud' <<endl;
muidu
maksma<< 'ei sobi' <<endl;

tagasi 0;
}

Funktsioon regex_search () tagastab tõese, kui on vaste, ja tagastab vale, kui vastet ei leita. Siin võtab funktsioon kaks argumenti: esimene on sihtstring ja teine ​​on regulaaravaldise objekt. Regulaar ise on topeltjutumärkides „mees”. Funktsiooni main () esimene lause moodustab regulaaravaldise objekti. Regex on tüüp ja reg on regulaaravaldise objekt. Ülaltoodud programmi väljund on 'sobitatud', kuna sihtmärgis on näha 'mees'. Kui sihtmärgis poleks näha meest, oleks regex_search () tagastanud väärtuse vale ja väljund poleks sobitatud.

Järgmise koodi väljund ei sobi:

regulaaravaldis reg('mees');
kui (regex_search('Siin on minu tehtud.',reg))
maksma<< 'sobitatud' <<endl;
muidu
maksma<< 'ei sobi' <<endl;

Ei sobi, kuna regulaaravaldist „mees” ei leitud kogu sihtstringist „Siin on minu tegemine”.

Muster

Regulaaravaldis, mees eespool, on väga lihtne. Regexid pole tavaliselt nii lihtsad. Regulaaravaldistel on metamärgid. Metamärgid on erilise tähendusega tegelased. Meta -tegelane on tegelastest rääkiv tegelane. C ++ regulaaravaldiste metamärgid on järgmised:

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

Regulaar, metamärkidega või ilma, on muster.

Märkide klassid

Nurksulud

Mustris võib olla nurksulgudes märke. Sellega sobiks konkreetne sihtmärgi stringi asukoht mis tahes nurksulgude tähemärkidega. Kaaluge järgmisi eesmärke:

'Kass on toas.'

'Nahkhiir on toas.'

'Rott on toas.'

Regulaar, [cbr] at sobiks esimese sihtmärgi kassiga. See sobiks teise sihtmärgi kurikaga. See sobiks rotiga kolmandas sihtmärgis. Seda seetõttu, et kass, nahkhiir või rott algab tähega „c”, „b” või „r”. Seda illustreerib järgmine koodisegment:

regulaaravaldis reg('[cbr] at');
kui (regex_search('Kass on toas.',reg))
maksma<< 'sobitatud' <<endl;
kui (regex_search('Nahkhiir on toas.',reg))
maksma<< 'sobitatud' <<endl;
kui (regex_search('Rott on toas.',reg))
maksma<< 'sobitatud' <<endl;

Väljund on:

sobitatud

sobitatud

sobitatud

Tegelaste valik

Klass, [cbr] mustris [cbr], sobiks sihtmärgi mitme võimaliku märgiga. See sobiks sihtmärgis „c” või „b” või „r”. Kui sihtmärgil pole ühtegi c, b või r, millele järgneb at, siis vastet pole.

Vahemikus on mõned võimalused, näiteks „c”, „b” või „r”. Numbrivahemikul 0 kuni 9 on 10 võimalust ja selle muster on [0-9]. Väiketähtede vahemikus a kuni z on 26 võimalust ja selle muster on [a-z]. Suurtähtede vahemikus A kuni Z on 26 võimalust ja selle muster on [A-Z]. - ei ole ametlikult metamärk, kuid nurksulgudes näitab see vahemikku. Niisiis, vaste tekib järgmiselt:

kui (regex_search('ID6id',regulaaravaldis(„[0–9]”)))

maksma<< 'sobitatud' <<endl;

Pange tähele, kuidas regulaaravaldis on teise argumendina konstrueeritud. Sobivus toimub numbri 6 vahel vahemikus 0 kuni 9 ja 6 sihtmärgi ID6id vahel. Ülaltoodud kood on samaväärne:

kui (regex_search('ID6id',regulaaravaldis(„[0123456789]”)))

maksma<< 'sobitatud' <<endl;

Järgmine kood annab vaste:

süsilk[] = 'ID6iE';

kui (regex_search(lk,regulaaravaldis('[a-z]')))

maksma<< 'sobitatud' <<endl;

Pange tähele, et esimene argument on siin stringimuutuja, mitte string literal. Sobivus on „i” all [a – z] ja „i” ID6iE-s.

Ärge unustage, et vahemik on klass. Mustris võib olla vahemikust paremal või vasakul pool olev tekst. Järgmine kood annab vaste:

kui (regex_search(„ID2id on ID ',regulaaravaldis(„ID [0-9] id”)))

maksma<< 'sobitatud' <<endl;

Sobivus on ID [0-9] id ja ID2id vahel. Ülejäänud sihtstring, mis on ID, ei sobi selles olukorras.

Regulaaravaldises (regexes) kasutatud sõna klass tähendab tegelikult kogumit. See tähendab, et üks komplekti tegelastest peab sobima.

Märkus: sidekriips - on metamärk ainult nurksulgudes, mis näitab vahemikku. See ei ole metamärk regulaaravaldises, väljapoole nurksulge.

Eitus

Vahemikku sisaldava klassi saab eitada. See tähendab, et komplektis (klassis) olevad tegelased ei peaks ühtima. Seda tähistab ^ metamärk klassi mustri alguses, vahetult pärast ava nurksulge. Niisiis tähendab [^0-9] märgi sobitamist sihtmärgi sobivasse kohta, mis ei ole ükski märk vahemikus 0 kuni 9 (kaasa arvatud). Seega ei anna järgmine kood vastet:

kui (regex_search('0123456789101112',regulaaravaldis('[^ 0-9]')))

maksma<< 'sobitatud' <<endl;

muidu

maksma<< 'ei sobi' <<endl;

Numbri vahemikus 0 kuni 9 võib leida mis tahes sihtstringi positsioonist, 0123456789101112 ,; nii et vastet pole - eitus.

Järgmine kood annab vaste:

kui (regex_search('ABCDEFGHIJ',regulaaravaldis('[^ 0-9]')))

maksma<< 'sobitatud' <<endl;

Sihtmärgis ei leitud ühtegi numbrit, ABCDEFGHIJ ,; seega on matš.

[a-z] on vahemik väljaspool [^a-z]. Ja nii [^a-z] on [a-z] eitus.

[A-Z] on vahemik väljaspool [^A-Z]. Ja nii [^A-Z] on [A-Z] eitus.

On ka muid eiteid.

Sobivad tühjad tühikud

„” Või t või r või n või f on tühimärk. Järgmises koodis vastab regulaaravaldis n sihtmärgile „ n”:

kui (regex_search('Esimesest reast. r nTeisest reast. ',regulaaravaldis(' n')))

maksma<< 'sobitatud' <<endl;

Sobib tühikutega

Muster või klass, mis sobib tühikutega, on [ t r n f]. Järgmises koodis sobitatakse „”:

kui (regex_search('üks kaks',regulaaravaldis('[ t r n f] ')))

maksma<< 'sobitatud' <<endl;

Sobib mis tahes tühikutähega

Muster või klass, mis sobib mis tahes muu tühimärgiga, on [^ t r n f]. Järgmine kood loob vaste, kuna sihtmärgis pole tühikuid:

kui (regex_search('1234abcd',regulaaravaldis('[^ t r n f] ')))

maksma<< 'sobitatud' <<endl;

Periood (.) Mustris

Musterperiood (.) Vastab mis tahes sümbolile, sealhulgas iseenesele, välja arvatud n sihtmärgis. Vaste koostatakse järgmise koodiga:

kui (regex_search('1234abcd',regulaaravaldis(''. ')))

maksma<< 'sobitatud' <<endl;

Järgmisel koodil pole vastavaid tulemusi, kuna sihtmärk on n.

kui (regex_search(' n',regulaaravaldis(''. ')))

maksma<< 'sobitatud' <<endl;

muidu

maksma<< 'ei sobi' <<endl;

Märkus: nurksulgudega märgiklassi sees pole perioodil erilist tähendust.

Sobivad kordused

Märk või märkide rühm võib sihtstringi sees esineda rohkem kui üks kord. Selle kordusega võib sobida muster. Metamärke,?, *, +Ja {} kasutatakse sihtmärgi korduste sobitamiseks. Kui x on sihtstringi huvipakkuv märk, on metamärkidel järgmised tähendused:

x*:tähendab vastet'x' 0või mitu korda,i.Ja.,ükskõik mitu korda

x+:tähendab vastet'x' 1või mitu korda,i.Ja.,vähemalt korra

x? :tähendab vastet'x' 0või1 aega

x{n,}:tähendab vastet'x'vähemalt n või enam korda.Märgekoma.

x{n} :sobitada'x'täpselt n korda

x{n,m}:sobitada'x'vähemalt n korda,kuid mitte rohkem kui m korda.

Neid metamärke nimetatakse kvantorid.

Illustratsioonid

*

* Tähendab * eelmist märki või eelnevat rühma, null või enam korda. o* vastab sihtmärginööri koerale „o”. See sobib ka raamatus ja välimuses oo. Regulaar, o* vastab loole booooed boooo .. Märkus: o* vastab digile, kus „o” esineb null (või rohkem) korda.

+

+ Vastab eelnevale märgile või rühmale 1 või enam korda. Võrrelge seda null või enam korda *. Seega vastab regulaaravaldis e+ söömisel tähele „e”, kus „e” esineb üks kord. e+ sobib ka lammastega ee, kus „e” esineb rohkem kui üks kord. Märkus: e+ ei ühti digiga, sest digis ei esine „e” vähemalt üks kord.

?

Kas? vastab eelmisele või eelnevale rühmale, 0 või 1 kord (ja mitte rohkem). Niisiis, e? vastab digile, sest „e” esineb dig, null ajal. e? vasted seatud, kuna „e” esineb komplektis üks kord. Märkus: e? sobib ikka lammastega; kuigi lammastes on kaks tähte. Siin on nüanss - vaata hiljem.

{n,}

See vastab vähemalt n järjestikule eelneva märgi või rühma rühmale. Seega vastab regulaaravaldis e {2,} sihtmärgi kahele „lambale“ ja sihtmärgi lamba kolmele „e“ -le. e {2,} ei ühti komplektiga, sest komplektil on ainult üks „e”.

{n}

See vastab täpselt n järjestikusele kordusele eelnevas tähemärgis või eelnevas rühmas. Seega vastab regulaaravaldis e {2} sihtmärgi „e” kahele „lambale”. e {2} ei ühti komplektiga, kuna komplektil on ainult üks „e”. Noh, e {2} sobib sihtmärgi kahe tähega, lammas. Siin on nüanss - vaata hiljem.

{n, m}

See sobib mitme järjestikuse kordusega eelnevale tähemärgile või eelnevale rühmale kõikjal n kuni m (kaasa arvatud). Niisiis, e {1,3} ei vasta digile midagi, millel pole e -tähte. See vastab ühele 'e' komplektis, kahele 'e' lambale, kolmele 'e' lambale ja kolmele 'lambale'. Viimasel matšil on nüanss - vaata hiljem.

Sobiv vaheldus

Kaaluge arvutis järgmist sihtstringi.

Farmis on erineva suurusega sigu.

Programmeerija võib soovida teada, kas sellel sihtmärgil on kits, küülik või siga. Kood oleks järgmine:

süsilk[] = 'Farmis on erineva suurusega sigu.';

kui (regex_search(lk,regulaaravaldis('kits | jänes | siga')))

maksma<< 'sobitatud' <<endl;

muidu

maksma<< 'ei sobi' <<endl;

Kood loob vaste. Pange tähele vaheldumismärgi, | kasutamist. Valikuid võib olla kaks, kolm, neli ja rohkem. C ++ proovib esmalt sobitada esimese alternatiivi, kitse, sihtmärkstringi iga tähemärgi kohaga. Kui see kitsega ei õnnestu, proovib ta järgmist alternatiivi - küülikut. Kui see küülikuga ei õnnestu, proovib ta järgmist alternatiivi - siga. Kui siga ebaõnnestub, liigub C ++ sihtmärgi järgmisele positsioonile ja alustab uuesti esimese alternatiiviga.

Ülaltoodud koodis sobitatakse siga.

Sobiv algus või lõpp

Algus


Kui ^ on regulaaravaldise alguses, siis saab sihtstringi algteksti sobitada regulaaravaldisega. Järgmises koodis on sihtmärgi algus abc, mis sobib:

kui (regex_search('abc ja def',regulaaravaldis('^ abc')))

maksma<< 'sobitatud' <<endl;

Järgmises koodis vastendamist ei toimu:

kui (regex_search('Jah, abc ja def',regulaaravaldis('^ abc')))

maksma<< 'sobitatud' <<endl;

muidu

maksma<< 'ei sobi' <<endl;

Siin pole abc sihtmärgi alguses.

Märkus. Ümbrusjoone tähis „^” on metamärk regulaaravaldise alguses, mis vastab sihtstringi algusele. Tegelaskuju alguses on see ikkagi metategelane, kus see eitab klassi.

Lõpp

Kui $ on regulaaravaldise lõpus, saab sihtstringi lõputeksti sobitada regulaaravaldisega. Järgmises koodis on sihtmärgi lõpp xyz, mis sobib:

kui (regex_search('uvw ja xyz',regulaaravaldis('xyz $')))

maksma<< 'sobitatud' <<endl;

Järgmises koodis vastendamist ei toimu:

kui (regex_search('uvw ja xyz finaal',regulaaravaldis('xyz $')))

maksma<< 'sobitatud' <<endl;

muidu

maksma<< 'ei sobi' <<endl;

Siin pole xyz sihtmärgi lõpus.

Rühmitamine

Sulgudes saab mustreid rühmitada. Mõelge järgmisele regulaaravaldisele:

'kontsert (pianist)'

Siinne rühm on pianist, keda ümbritsevad metamärgid (ja). See on tegelikult alamrühm, samas kui kontsert (pianist) on kogu rühm. Kaaluge järgmist.

'(Pianist on hea)'

Siin on alamrühm või alamkeel, pianist on hea.

Alamstringid ühiste osadega

Raamatupidaja on inimene, kes hoolitseb raamatute eest. Kujutage ette raamatukogu, kus on raamatupidaja ja raamaturiiul. Oletame, et arvutis on üks järgmistest sihtmärkidest:

'Raamatukogul on raamaturiiul, mida imetletakse.';

'Siin on raamatupidaja.';

'Raamatupidaja töötab raamaturiiuliga.';

Oletame, et programmeerija huvi ei ole teada, milline neist lausetest on arvutis. Sellegipoolest on tema huvi teada, kas raamaturiiul või raamatupidaja on arvutis ükskõik millises sihtmärgis. Sel juhul võib tema regulaaravaldis olla järgmine:

'raamaturiiul | raamatupidaja.'

Vahelduse kasutamine.

Pange tähele, et mõlemale sõnale ühine raamat on trükitud kaks korda, mustri kahte sõna. Raamatu kaks korda tippimise vältimiseks tuleks regulaaravaldis paremini kirjutada järgmiselt:

'raamat (riiul | pidaja)'

Siin on rühm, riiul | pidaja Vahelduse metamärki on ikka kasutatud, kuid mitte kahe pika sõna jaoks. Seda on kasutatud kahe pika sõna kahe lõpuosa jaoks. C ++ käsitleb gruppi kui üksust. Niisiis, C ++ otsib riiulit või hoidjat, mis tuleb kohe pärast raamatut. Järgmise koodi väljund on sobitatud:

süsilk[] = 'Raamatukogul on raamaturiiul, mida imetletakse.';

kui (regex_search(lk,regulaaravaldis('raamat (riiul | pidaja)')))

maksma<< 'sobitatud' <<endl;

raamaturiiul ja mitte raamatupidaja on sobitatud.

ICase ja mitmerealine regex_constants

icase

Vastendamine on vaikimisi tõstutundlik. Selle võib aga muuta tõstutundetuks. Selle saavutamiseks kasutage konstanti regex :: icase, nagu järgmises koodis:

kui (regex_search('Tagasiside',regulaaravaldis('sööt',regulaaravaldis::icase)))

maksma<< 'sobitatud' <<endl;

Väljund on sobitatud. Nii et tagasiside suurtähtedega „F” on sobitatud vooga väiketähtedega „f”. regex :: icase on konstruktori regex () teine ​​argument. Ilma selleta ei annaks avaldus vastet.

Mitmerealine

Mõelge järgmisele koodile:

süsilk[] = 'rida 1 nrida 2 nrida 3 ';

kui (regex_search(lk,regulaaravaldis('^. * $')))

maksma<< 'sobitatud' <<endl;

muidu

maksma<< 'ei sobi' <<endl;

Väljund ei sobi kokku. Regulaar, ^.*$, Vastab sihtstringile algusest lõpuni. .* tähendab mis tahes märki, välja arvatud n, null või enam korda. Niisiis, sihtmärgis olevate uue rea märkide ( n) tõttu ei leitud vastet.

Sihtmärk on mitmerealine string. Selleks, et „.” Sobiks uue rea märgiga, tuleb teha konstant regex :: multiline, mis on regex () konstruktsiooni teine ​​argument. Seda illustreerib järgmine kood:

süsilk[] = 'rida 1 nrida 2 nrida 3 ';

kui (regex_search(lk,regulaaravaldis('^. * $',regulaaravaldis::mitmerealine)))

maksma<< 'sobitatud' <<endl;

muidu

maksma<< 'ei sobi' <<endl;

Kogu sihtmärkstringi sobitamine

Kogu sihtstringi sobitamiseks, millel pole uue rea märki ( n), saab kasutada funktsiooni regex_match (). See funktsioon erineb funktsioonist regex_search (). Seda illustreerib järgmine kood:

süsilk[] = 'esimene teine ​​kolmas';

kui (regex_match(lk,regulaaravaldis('.*teine.*')))

maksma<< 'sobitatud' <<endl;

Siin on vaste. Pidage siiski meeles, et regulaaravaldis vastab kogu sihtstringile ja sihtstringil pole ühtegi „ n”.

Objekt match_results

Funktsioon regex_search () võib võtta argumendi sihtmärgi ja regulaaravaldise objekti vahel. See argument on objekt match_results. Sellega saab teada kogu sobitatud (osa) stringi ja sobitatud alamstringid. See objekt on meetoditega spetsiaalne massiiv. Objekti match_results tüüp on cmatch (stringide literaalide puhul).

Vastete saamine

Mõelge järgmisele koodile:

süsilk[] = 'Naine, keda otsisite!';

cmatch m;

kui (regex_search(lk,m,regulaaravaldis('w.m.n')))

maksma<<m[0] <<endl;

Sihtstringis on sõna naine. Väljund on naine ”, mis vastab regexile, w.m.n. Nullindeksi juures on erimassiivil ainus vaste, milleks on naine.

Klassivalikute puhul saadetakse spetsiaalsesse massiivi ainult sihtmärgist leitud esimene alamstring. Seda illustreerib järgmine kood:

cmatch m;

kui (regex_search('Rott, kass, nahkhiir!',m,regulaaravaldis('[bcr] kell')))

maksma<<m[0] <<endl;

maksma<<m[1] <<endl;

maksma<<m[2] <<endl;

Väljund on indeks nullist rott. m [1] ja m [2] on tühjad.

Alternatiivide korral saadetakse spetsiaalsesse massiivi ainult sihtmärgist leitud esimene alamstring. Seda illustreerib järgmine kood:

kui (regex_search('Jänes, kits, siga!',m,regulaaravaldis('kits | jänes | siga')))

maksma<<m[0] <<endl;

maksma<<m[1] <<endl;

maksma<<m[2] <<endl;

Väljund on jänes indeksist null. m [1] ja m [2] on tühjad.

Rühmitused

Kui rühmad on kaasatud, läheb kogu muster kokku ja läheb spetsiaalse massiivi lahtrisse null. Järgmine leitud alamstring läheb lahtrisse 1; järgnev alamstring läheb lahtrisse 2; ja nii edasi. Seda illustreerib järgmine kood:

kui (regex_search('Parim raamatumüüja täna!',m,regulaaravaldis('raamat ((sel) (ler))')))

maksma<<m[0] <<endl;

maksma<<m[1] <<endl;

maksma<<m[2] <<endl;

maksma<<m[3] <<endl;

Väljund on:

raamatumüüja

müüja

kamber

loe

Pange tähele, et grupp (müüja) tuleb grupi (sel) ette.

Matši positsioon

Cmatchi massiivi iga alamstringi vaste asukoht on teada. Loendamine algab sihtstringi esimesest tähemärgist, positsioonil null. Seda illustreerib järgmine kood:

cmatch m;

kui (regex_search('Parim raamatumüüja täna!',m,regulaaravaldis('raamat ((sel) (ler))')))

maksma<<m[0] << '->' <<m.positsiooni(0) <<endl;

maksma<<m[1] << '->' <<m.positsiooni(1) <<endl;

maksma<<m[2] << '->' <<m.positsiooni(2) <<endl;

maksma<<m[3] << '->' <<m.positsiooni(3) <<endl;

Pange tähele argumendina positsiooni atribuudi kasutamist koos lahtriindeksiga. Väljund on:

raamatumüüja->5

müüja->9

kamber->9

loe->12

Otsige ja asendage

Vastet võib asendada uus sõna või fraas. Selleks kasutatakse funktsiooni regex_replace (). Kuid seekord on string, kus asendamine toimub, stringi objekt, mitte string literal. Niisiis, keelte kogu tuleb programmi lisada. Illustratsioon:

#kaasake

#kaasake

#kaasake

kasutades nimeruumi std;

intpeamine()
{
string str= 'Siin, mu mees tuleb. Seal läheb su mees. ';
string newStr=regex_replace(lk,regulaaravaldis('mees'), 'naine');
maksma<<newStr<<endl;

tagasi 0;
}

Siin kodeeritud funktsioon regex_replace () asendab kõik vasted. Funktsiooni esimene argument on sihtmärk, teine ​​on regulaaravaldise objekt ja kolmas asendustring. Funktsioon tagastab uue stringi, mis on sihtmärk, kuid millel on asendus. Väljund on:

Siit tuleb mu naine. Seal läheb su naine.

Järeldus

Regulaaravaldis kasutab mustreid sihtjärjestuse stringi alamstringide sobitamiseks. Mustritel on metamärgid. Tavaliselt kasutatavad C ++ regulaaravaldiste funktsioonid on: regex_search (), regex_match () ja regex_replace (). Regulaar on topeltjutumärkides olev muster. Kuid need funktsioonid võtavad argumendina regex -objekti ja mitte ainult regulaaravaldist. Regulaaravaldisest tuleb teha regulaaravaldis, enne kui need funktsioonid seda kasutada saavad.