Reguliarios išraiškos pagrindai naudojant C ++

Regular Expression Basics C



Apsvarstykite šį sakinį kabutėse:

- Čia mano vyras.

Ši eilutė gali būti kompiuterio viduje, ir vartotojas gali norėti sužinoti, ar joje yra žodis vyras. Jei jis turi žodį vyras, jis gali norėti pakeisti žodį vyras į moterį; kad eilutė turėtų būti tokia:







- Čia mano moteris.

Yra daug kitų panašių norų iš kompiuterio vartotojo; kai kurie yra sudėtingi. Įprasta išraiška, sutrumpinta, regex, yra šių problemų sprendimas kompiuteriui. „C ++“ yra su biblioteka, vadinama regex. Taigi, C ++ programa, skirta tvarkyti reguliarųjį reguliavimą, turėtų prasidėti taip:



#įtraukti

#įtraukti

naudojant vardų srities standartą;

Šiame straipsnyje paaiškinami reguliariosios išraiškos pagrindai naudojant C ++.



Straipsnio turinys

Reguliariosios išraiškos pagrindai

Reguliariai

Tokia eilutė kaip Čia yra mano žmogus. aukščiau yra tikslinė seka arba tikslinė eilutė arba tiesiog tikslas. žmogus, kurio buvo ieškoma, yra reguliarioji išraiška arba tiesiog regex.





Atitiktis

Sakoma, kad atitiktis atsiranda, kai randamas ieškomas žodis ar frazė. Po suderinimo gali būti pakeistas. Pavyzdžiui, po to, kai vyras yra aukščiau, jį gali pakeisti moteris.

Paprastas derinimas

Ši programa parodo, kaip derinamas žodis vyras.



#įtraukti

#įtraukti

naudojant vardų srities standartą;

tarptpagrindinis()
{

reguliarusis reguliavimas('vyras');
jei (regex_search(- Čia mano vyras.,reg))
kaina<< 'sutapo' <<endl;
Kitas
kaina<< 'neatitinka' <<endl;

grįžti 0;
}

Funkcija regex_search () grąžina „true“, jei yra atitiktis, ir „false“, jei neatitinka. Čia funkcijai naudojami du argumentai: pirmasis yra tikslinė eilutė, o antrasis - reguliaraus teksto objektas. Pati reguliarioji formulė yra „žmogus“ dvigubose kabutėse. Pirmasis pagrindinės () funkcijos teiginys sudaro reguliariojo reiškinio objektą. „Reguliarusis“ yra tipas, o „reg“ yra reguliaraus reguliavimo objektas. Aukščiau pateiktos programos išvestis yra „suderinta“, nes „vyras“ matomas tikslinėje eilutėje. Jei „žmogus“ nebūtų matomas taikinyje, regex_search () būtų grąžintas klaidingai, o išvestis būtų „neatitinkanti“.

Šio kodo išvestis neatitinka:

reguliarusis reguliavimas('vyras');
jei (regex_search('Čia mano kūrinys'.,reg))
kaina<< 'sutapo' <<endl;
Kitas
kaina<< 'neatitinka' <<endl;

Neatitinka, nes reguliariosios frazės „vyras“ nepavyko rasti visoje tikslinėje eilutėje „Čia yra mano kūrinys“.

Raštas

Taisyklinga išraiška, žmogus aukščiau, yra labai paprasta. Reguliariai paprastai nėra taip paprasta. Įprastos išraiškos turi metaženklus. Metaženklai yra simboliai, turintys ypatingą reikšmę. Metacharakteris yra simbolis apie simbolius. „C ++“ reguliariojo metraščio simboliai yra šie:

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

Reguliarioji formulė su metaženkliais arba be jų yra modelis.

Simbolių klasės

Laužtiniai skliaustai

Šablone gali būti simbolių laužtiniuose skliaustuose. Tokiu atveju tam tikra tikslinės eilutės vieta atitiktų bet kuriuos laužtinių skliaustų simbolius. Apsvarstykite šiuos tikslus:

'Katė yra kambaryje'.

„Šikšnosparnis yra kambaryje“.

„Žiurkė yra kambaryje“.

Reguliarioji formulė, [cbr] at atitiktų katę pirmame taikinyje. Tai atitiktų šikšnosparnį antrame taikinyje. Tai atitiktų žiurkę trečiame taikinyje. Taip yra todėl, kad katė, šikšnosparnis ar žiurkė prasideda „c“, „b“ arba „r“. Toliau pateiktas kodo segmentas tai iliustruoja:

reguliarusis reguliavimas(„[cbr] at“);
jei (regex_search('Katė yra kambaryje'.,reg))
kaina<< 'sutapo' <<endl;
jei (regex_search(„Šikšnosparnis yra kambaryje“.,reg))
kaina<< 'sutapo' <<endl;
jei (regex_search(„Žiurkė yra kambaryje“.,reg))
kaina<< 'sutapo' <<endl;

Išėjimas yra:

sutapo

sutapo

sutapo

Veikėjų asortimentas

Klasė, [cbr] pagal modelį [cbr], atitiktų kelis galimus tikslo simbolius. Tiksle jis atitiktų „c“, „b“ arba „r“. Jei taikinyje nėra „c“, „b“ ar „r“, o po to - „“, atitikčių nebus.

Kai kurios galimybės, tokios kaip „c“, „b“ arba „r“, yra diapazone. Skaitmenų diapazonas nuo 0 iki 9 turi 10 galimybių, o šablonas yra [0-9]. Mažųjų raidžių diapazonas nuo a iki z turi 26 galimybes, o šablonas yra [a-z]. Didžiųjų raidžių diapazonas, nuo A iki Z, turi 26 galimybes, o šablonas yra [A-Z]. - nėra oficialiai metaženklis, tačiau laužtiniuose skliaustuose jis nurodytų diapazoną. Taigi, atitiktis gaunama taip:

jei (regex_search(„ID6id“,reguliariai(„[0-9]“)))

kaina<< 'sutapo' <<endl;

Atkreipkite dėmesį, kaip reguliarusis sakinys buvo sukurtas kaip antrasis argumentas. Atitiktis įvyksta tarp skaitmens, 6 diapazone, nuo 0 iki 9 ir 6 tikslo ID6id. Aukščiau pateiktas kodas yra lygus:

jei (regex_search(„ID6id“,reguliariai(„[0123456789]“)))

kaina<< 'sutapo' <<endl;

Šis kodas sukuria atitiktį:

anglisp[] = „ID6iE“;

jei (regex_search(p,reguliariai(„[a – z]“)))

kaina<< 'sutapo' <<endl;

Atminkite, kad pirmasis argumentas čia yra eilutės kintamasis, o ne eilutės literalas. Atitikimas yra tarp „i“ [a-z] ir „i“ ID6iE.

Nepamirškite, kad diapazonas yra klasė. Modelio dešinėje arba kairėje gali būti teksto. Šis kodas sukuria atitiktį:

jei (regex_search(„ID2id yra ID “,reguliariai(„ID [0-9] ID“)))

kaina<< 'sutapo' <<endl;

Atitinka ID [0-9] ID ir ID2id. Likusi tikslinė eilutė, tai yra ID, šioje situacijoje neatitinka.

Žodis klasė, vartojama reguliariosios išraiškos objekte (regexes), iš tikrųjų reiškia rinkinį. Tai yra, vienas iš rinkinio simbolių turi atitikti.

Pastaba: brūkšnelis - yra metaženklis tik laužtiniuose skliausteliuose, nurodantis diapazoną. Tai nėra metaženklis, esantis reguliariajame lauke, už kvadratinių skliaustų ribų.

Neigimas

Klasė, apimanti diapazoną, gali būti paneigta. Tai reiškia, kad ne visi rinkinio (klasės) simboliai turi sutapti. Tai pažymima ^ meta simboliu klasės modelio pradžioje, iškart po atidarymo laužtinio skliausto. Taigi, [^0-9] reiškia simbolio atitikimą atitinkamoje taikinio vietoje, o tai nėra bet koks simbolis diapazone (nuo 0 iki 9 imtinai). Taigi šis kodas nesudarys atitikties:

jei (regex_search(„0123456789101112“,reguliariai(„[^ 0-9]“)))

kaina<< 'sutapo' <<endl;

Kitas

kaina<< 'neatitinka' <<endl;

Skaitmenį nuo 0 iki 9 galima rasti bet kurioje tikslinės eilutės pozicijoje, 0123456789101112 ,; taigi nėra atitikmens - neigimas.

Šis kodas sukuria atitiktį:

jei (regex_search(„ABCDEFGHIJ“,reguliariai(„[^ 0-9]“)))

kaina<< 'sutapo' <<endl;

Taikinyje ABCDEFGHIJ nebuvo rasta jokių skaitmenų; taigi yra rungtynės.

[a-z] yra diapazonas, esantis už [^a-z] ribų. Taigi [^a-z] yra [a-z] neigimas.

[A-Z] yra diapazonas, esantis už [^A-Z] ribų. Taigi [^A-Z] yra [A-Z] neigimas.

Yra ir kitų neigimų.

Atitinkami balti tarpai

„“ Arba t arba r arba n arba f yra tarpas. Toliau pateiktame kode reguliarusis reiškinys n atitinka tikslą „ n“:

jei (regex_search('Pirmoje eilutėje. r nAntra eilutė “.,reguliariai(' n')))

kaina<< 'sutapo' <<endl;

Atitinkantis bet kurį „WhiteSpace“ simbolį

Šablonas ar klasė, atitinkanti bet kurį tuščios vietos simbolį, yra [ t r n f]. Toliau pateiktame kode „“ atitinka:

jei (regex_search('vienas du',reguliariai('[ t r n f] ')))

kaina<< 'sutapo' <<endl;

Atitinkantis bet kokį tuščių vietų simbolį

Šablonas ar klasė, atitinkanti bet kurį ne tuščio tarpo simbolį, yra [^ t r n f]. Šis kodas sukuria atitiktį, nes taikinyje nėra tarpų:

jei (regex_search(„1234abcd“,reguliariai('[^ t r n f] ')))

kaina<< 'sutapo' <<endl;

Laikotarpis (.) Šablone

Šablono laikotarpis (.) Atitinka bet kurį simbolį, įskaitant save, išskyrus n, taikinyje. Rungtynės sudaromos tokiu kodu:

jei (regex_search(„1234abcd“,reguliariai(''. ')))

kaina<< 'sutapo' <<endl;

Šiame kode nėra atitinkančių rezultatų, nes tikslas yra n.

jei (regex_search(' n',reguliariai(''. ')))

kaina<< 'sutapo' <<endl;

Kitas

kaina<< 'neatitinka' <<endl;

Pastaba: simbolių klasėje su laužtiniais skliaustais taškas neturi ypatingos reikšmės.

Atitinkami pakartojimai

Simbolis arba simbolių grupė tikslinėje eilutėje gali atsirasti daugiau nei vieną kartą. Šiam kartojimui gali atitikti modelis. Metaženkliai,?, *, +Ir {} yra naudojami siekiant pakartoti tikslą taikinyje. Jei x yra dominantis simbolis tikslinėje eilutėje, tada metaženkliai turi tokią reikšmę:

x*:reiškia atitikimą„x“ 0ar daugiau kartų,i.Ir.,bet kokį skaičių kartų

x+:reiškia atitikimą„x“ 1ar daugiau kartų,i.Ir.,nors karta

x? :reiškia atitikimą„x“ 0arba1 laikas

x{n,}:reiškia atitikimą„x“bent n ir daugiau kartų.Pastabakablelis.

x{n} :rungtynės„x“lygiai n kartų

x{n,m}:rungtynės„x“bent n kartų,bet ne daugiau kaip m kartų.

Šie meta simboliai vadinami kiekybiniai rodikliai.

Iliustracijos

*

* Atitinka nulį ar daugiau kartų prieš tai buvusį simbolį arba ankstesnę grupę. o* tikslinės eilutės šuo atitinka „o“. Tai taip pat atitinka „oo“ knygoje ir išvaizdoje. Reguliarioji reikšmė, o* atitinka „boooo“, „The animal booooed“ .. Pastaba: o* atitinka kasimą, kur „o“ įvyksta nulį (ar daugiau) laiko.

+

+ 1 ar daugiau kartų atitinka ankstesnį simbolį arba ankstesnę grupę. Palyginkite jį su nuliu ar daugiau kartų *. Taigi reguliarioji formulė „e+“ atitinka „e“ valgymo vietoje, kur „e“ atsiranda vieną kartą. „e+“ taip pat atitinka „ee“ avis, kur „e“ pasitaiko daugiau nei vieną kartą. Pastaba: „e+“ nesutampa su „dig“, nes kasant „e“ nepasitaiko bent kartą.

?

The? atitinka ankstesnį simbolį arba ankstesnę grupę, 0 arba 1 kartą (ir ne daugiau). Taigi, e? sutampa kasti, nes „e“ įvyksta kasant, nulinis laikas. e? atitiktis, nes „e“ įvyksta rinkinyje vieną kartą. Pastaba: e? vis dar atitinka avis; nors avyse yra du „e“. Čia yra niuansas - žiūrėkite vėliau.

{n,}

Tai atitinka bent n eilės ankstesnio simbolio ar ankstesnės grupės pasikartojimų. Taigi reguliarioji formulė, e {2,} atitinka du „e“ taškus, avis ir tris „e“ tikslinėse avyse. e {2,} neatitinka rinkinio, nes rinkinyje yra tik vienas „e“.

{n}

Tai tiksliai atitinka n iš eilės pasikartojančius ankstesnius simbolius arba ankstesnes grupes. Taigi, reguliarioji formulė, e {2} sutampa su dviem „e“ tikslais, avimi. e {2} neatitinka rinkinio, nes rinkinyje yra tik vienas „e“. Na, e {2} atitinka du taškus, avis. Čia yra niuansas - žiūrėkite vėliau.

{n, m}

Tai atitinka kelis nuoseklius ankstesnio simbolio ar ankstesnės grupės pakartojimus, nuo n iki m imtinai. Taigi, e {1,3} nieko neatitinka kasinėjime, kuriame nėra „e“. Tai atitinka vieną „e“ rinkinį, du „e“ avis, tris „e“ avis ir tris „e“ avyje. Paskutinėse rungtynėse yra niuansų - žiūrėkite vėliau.

Atitinkama pakaitalas

Apsvarstykite šią tikslinę eilutę kompiuteryje.

Ūkyje yra įvairių dydžių kiaulių.

Programuotojas gali norėti sužinoti, ar šis taikinys turi ožką, triušį ar kiaulę. Kodas būtų toks:

anglisp[] = „Ūkyje yra įvairaus dydžio kiaulių“.;

jei (regex_search(p,reguliariai('ožka | triušis | kiaulė')))

kaina<< 'sutapo' <<endl;

Kitas

kaina<< 'neatitinka' <<endl;

Kodas sukuria atitiktį. Atkreipkite dėmesį į kintamojo simbolio, |. Gali būti dvi, trys, keturios ir daugiau parinkčių. C ++ pirmiausia bandys suderinti pirmąją alternatyvą, ožką, kiekvienoje tikslinės eilutės simbolio vietoje. Jei su ožka nepavyksta, ji bando kitą alternatyvą - triušį. Jei su triušiu nepavyksta, jis bando kitą alternatyvą - kiaulę. Jei kiaulė nepavyksta, C ++ pereina į kitą tikslo vietą ir vėl pradeda nuo pirmosios alternatyvos.

Aukščiau pateiktame kode kiaulė yra suderinta.

Atitinkanti pradžia arba pabaiga

Pradžia


Jei ^ yra reguliariosios reikšmės pradžioje, tada tikslinės eilutės pradžios tekstą galima suderinti su reguliariuoju žodžiu. Šiame kode tikslo pradžia yra abc, kuri atitinka:

jei (regex_search(„abc ir def“,reguliariai('^ abc')))

kaina<< 'sutapo' <<endl;

Šiame kode neatitinka atitikties:

jei (regex_search(„Taip, abc ir def“,reguliariai('^ abc')))

kaina<< 'sutapo' <<endl;

Kitas

kaina<< 'neatitinka' <<endl;

Čia abc nėra tikslo pradžioje.

Pastaba: „Circflex“ simbolis „^“ yra metaženklis reguliaraus žodžio pradžioje, atitinkantis tikslinės eilutės pradžią. Simbolių klasės pradžioje jis vis dar yra metažaidis, kur jis paneigia klasę.

Galas

Jei $ yra reguliariojo sakinio pabaigoje, tikslinės eilutės pabaigos tekstas gali atitikti reguliarųjį sakinį. Šiame kode tikslo pabaiga yra xyz, kuri atitinka:

jei (regex_search('uvw ir xyz',reguliariai(„xyz $“)))

kaina<< 'sutapo' <<endl;

Šiame kode neatitinka atitikties:

jei (regex_search(„uvw ir xyz final“,reguliariai(„xyz $“)))

kaina<< 'sutapo' <<endl;

Kitas

kaina<< 'neatitinka' <<endl;

Čia xyz nėra tikslo pabaigoje.

Grupavimas

Skliaustai gali būti naudojami simbolių grupavimui pagal modelį. Apsvarstykite šį reguliarųjį sakinį:

„koncertas (pianistas)“

Grupė čia yra pianistė, apsupta meta simbolių (ir). Tai iš tikrųjų yra pogrupis, o koncertas (pianistas) yra visa grupė. Apsvarstykite šiuos dalykus:

„Pianistas geras“

Čia pogrupis arba eilutė yra, pianistas yra geras.

Papildomos eilutės su bendrosiomis dalimis

Buhalteris yra žmogus, kuris rūpinasi knygomis. Įsivaizduokite biblioteką su buhalteriu ir knygų lentyna. Tarkime, kad kompiuteryje yra viena iš šių tikslinių eilučių:

„Biblioteka turi knygų lentyną, kuria žavisi.“;

'Štai buhalteris.';

„Buhalteris dirba su knygų lentyna.“;

Tarkime, kad programuotojo interesas nėra žinoti, kuris iš šių sakinių yra kompiuteryje. Vis dėlto jam įdomu sužinoti, ar bet kurioje kompiuterio tikslinėje eilutėje yra knygų lentyna ar buhalteris. Šiuo atveju jo reguliarioji formulė gali būti:

'knygų lentyna | buhalteris'.

Naudojant pakaitą.

Atkreipkite dėmesį, kad knyga, būdinga abiem žodžiams, buvo įvesta du kartus, dviem modelio žodžiais. Kad nereikėtų du kartus įvesti knygos, reguliarusis sakinys geriau būtų parašytas taip:

'knyga (lentyna | laikytojas)'

Čia grupė, lentyna | prižiūrėtojas Kintamoji metaženklė vis dar buvo naudojama, bet ne dviem ilgiems žodžiams. Jis buvo naudojamas dviejų ilgų žodžių dviem baigiamosioms dalims. C ++ grupę traktuoja kaip subjektą. Taigi, „C ++“ ieškos lentynos ar laikiklio, kuris ateis iškart po knygos. Šio kodo išvestis sutampa:

anglisp[] = „Bibliotekoje yra knygų lentyna, kuria žavisi“.;

jei (regex_search(p,reguliariai('knyga (lentyna | laikytojas)')))

kaina<< 'sutapo' <<endl;

buvo suderinta knygų lentyna, o ne buhalterė.

„Icase“ ir kelių eilučių regex_constants

icase

Atitiktis pagal numatytuosius nustatymus skiria didžiąsias ir mažąsias raides. Tačiau jis gali būti padarytas nejautrus didžiosioms ir mažosioms raidėms. Norėdami tai padaryti, naudokite konstantą regex :: icase, kaip nurodyta šiame kode:

jei (regex_search('Atsiliepimas',reguliariai('maitinti',reguliariai::icase)))

kaina<< 'sutapo' <<endl;

Išvestis yra suderinta. Taigi atsiliepimai su didžiosiomis raidėmis „F“ atitiko sklaidos kanalą su mažosiomis raidėmis „f“. regex :: icase buvo padarytas antruoju regex () konstruktoriaus argumentu. Be to, pareiškimas nesudarytų atitikmens.

Kelių linijų

Apsvarstykite šį kodą:

anglisp[] = “1 eilutė n2 eilutė n3 eilutė;

jei (regex_search(p,reguliariai('^. * $')))

kaina<< 'sutapo' <<endl;

Kitas

kaina<< 'neatitinka' <<endl;

Išvestis nesutampa. Reguliarusis žodis ^.*$ Atitinka tikslinę eilutę nuo pradžios iki pabaigos. .* reiškia bet kurį simbolį, išskyrus n, nulį ar daugiau kartų. Taigi, dėl tikslinės naujos eilutės simbolių ( n) neatitiko.

Tikslas yra kelių eilučių eilutė. Kad „.“ Atitiktų naujos eilutės simbolį, reikia padaryti pastovią regex :: multiline, antrąjį regex () konstrukcijos argumentą. Toliau pateiktas kodas tai iliustruoja:

anglisp[] = “1 eilutė n2 eilutė n3 eilutė;

jei (regex_search(p,reguliariai('^. * $',reguliariai::kelių eilučių)))

kaina<< 'sutapo' <<endl;

Kitas

kaina<< 'neatitinka' <<endl;

Atitinka visą tikslinę eilutę

Norint suderinti visą tikslinę eilutę, kurioje nėra naujos eilutės simbolio ( n), galima naudoti funkciją regex_match (). Ši funkcija skiriasi nuo regex_search (). Toliau pateiktas kodas tai iliustruoja:

anglisp[] = 'Pirmas Antras Trečias';

jei (regex_match(p,reguliariai('.*antra.*')))

kaina<< 'sutapo' <<endl;

Čia yra rungtynės. Tačiau atminkite, kad reguliarusis sakinys atitinka visą tikslinę eilutę, o tikslinėje eilutėje nėra „ n“.

Objektas „match_results“

Funkcija „regex_search ()“ gali priimti argumentą tarp taikinio ir reguliaraus teksto objekto. Šis argumentas yra „match_results“ objektas. Su ja gali būti žinoma visa suderinta (dalis) eilutė ir suderintos antrinės eilutės. Šis objektas yra ypatingas masyvas su metodais. „Match_results“ objekto tipas yra „cmatch“ (eilutės literalams).

Atitikimų gavimas

Apsvarstykite šį kodą:

anglisp[] = - Moteris, kurios ieškai!;

cmatch m;

jei (regex_search(p,m,reguliariai('w.m.n')))

kaina<<m[0] <<endl;

Tikslinėje eilutėje yra žodis moteris. Išvestis yra moteris “, kuri atitinka reguliariąją reikšmę, w.m.n. Esant nuliui indeksui, specialiame masyve yra vienintelė atitiktis - moteris.

Naudojant klasės parinktis, į specialųjį masyvą siunčiama tik pirmoji tikslinėje rasta antrinė eilutė. Toliau pateiktas kodas tai iliustruoja:

cmatch m;

jei (regex_search('Žiurkė, katė, šikšnosparnis!',m,reguliariai('[bcr] at')))

kaina<<m[0] <<endl;

kaina<<m[1] <<endl;

kaina<<m[2] <<endl;

Rezultatas yra žiurkė nuo indekso nulio. m [1] ir m [2] yra tušti.

Naudojant alternatyvas, į specialųjį masyvą siunčiama tik pirmoji tikslinėje rasta antrinė eilutė. Toliau pateiktas kodas tai iliustruoja:

jei (regex_search(- Triušis, ožka, kiaulė!,m,reguliariai('ožka | triušis | kiaulė')))

kaina<<m[0] <<endl;

kaina<<m[1] <<endl;

kaina<<m[2] <<endl;

Rezultatas yra triušis nuo indekso nulio. m [1] ir m [2] yra tušti.

Grupuotės

Kai dalyvauja grupės, visas modelis atitinka, patenka į specialaus masyvo nulinį langelį. Kita rasta antrinė eilutė patenka į 1 langelį; po antrinė eilutė eina į 2 langelį; ir taip toliau. Toliau pateiktas kodas tai iliustruoja:

jei (regex_search('Geriausias knygų pardavėjas šiandien!',m,reguliariai('knyga ((sel) (ler))')))

kaina<<m[0] <<endl;

kaina<<m[1] <<endl;

kaina<<m[2] <<endl;

kaina<<m[3] <<endl;

Išėjimas yra:

knygnešys

pardavėjas

ląstelė

skaityti

Atminkite, kad grupė (pardavėjas) yra prieš grupę (sel).

Rungtynių padėtis

Gali būti žinoma kiekvienos „Cmatch“ masyvo eilutės atitikimo vieta. Skaičiavimas pradedamas nuo pirmojo tikslinės eilutės simbolio, nulio pozicijoje. Toliau pateiktas kodas tai iliustruoja:

cmatch m;

jei (regex_search('Geriausias knygų pardavėjas šiandien!',m,reguliariai('knyga ((sel) (ler))')))

kaina<<m[0] << '->' <<m.poziciją(0) <<endl;

kaina<<m[1] << '->' <<m.poziciją(1) <<endl;

kaina<<m[2] << '->' <<m.poziciją(2) <<endl;

kaina<<m[3] << '->' <<m.poziciją(3) <<endl;

Atkreipkite dėmesį į pozicijos ypatybės naudojimą su ląstelių indeksu kaip argumentą. Išėjimas yra:

knygnešys->5

pardavėjas->9

ląstelė->9

skaityti->12

Ieškoti ir pakeisti

Atitiktį gali pakeisti naujas žodis ar frazė. Tam naudojama funkcija regex_replace (). Tačiau šį kartą eilutė, kurioje atliekamas pakeitimas, yra eilutės objektas, o ne eilutė. Taigi styginių biblioteka turi būti įtraukta į programą. Iliustracija:

#įtraukti

#įtraukti

#įtraukti

naudojant vardų srities standartą;

tarptpagrindinis()
{
eilutė str= 'Štai, ateina mano vyras. Štai tavo vyras. ';
eilutė newStr=regex_replace(p,reguliariai('vyras'), 'moteris');
kaina<<newStr<<endl;

grįžti 0;
}

Funkcija regex_replace (), kaip čia užkoduota, pakeičia visas atitiktis. Pirmasis funkcijos argumentas yra taikinys, antrasis - nuolatinės reikšmės objektas, o trečiasis - pakaitinė eilutė. Funkcija grąžina naują eilutę, kuri yra tikslas, bet turi pakeitimą. Išėjimas yra:

Čia ateina mano moteris. Štai tavo moteris.

Išvada

Reguliarioji išraiška naudoja šablonus, kad atitiktų tikslinės sekos eilutės antrines eilutes. Modeliai turi metaženklius. Dažniausiai naudojamos C ++ reguliariosios išraiškos funkcijos yra: regex_search (), regex_match () ir regex_replace (). Reguliarusis sakinys yra dvigubų kabučių modelis. Tačiau šios funkcijos regex objektą laiko argumentu, o ne tik regex. Prieš naudojant šias funkcijas, reguliarusis reiškinys turi būti paverstas reguliaraus reiškinio objektu.