Regulārās izteiksmes pamati C ++

Regular Expression Basics C



Apsveriet šādu teikumu pēdiņās:

'Šeit ir mans cilvēks.'

Šī virkne var būt datora iekšpusē, un lietotājs var vēlēties uzzināt, vai tajā ir vārds cilvēks. Ja tajā ir vārds vīrietis, viņš, iespējams, vēlas mainīt vārdu vīrietis uz sievieti; lai virkne būtu šāda:







'Šeit ir mana sieviete.'

Ir daudzas citas vēlmes, piemēram, šīs no datora lietotāja; daži ir sarežģīti. Regulārā izteiksme, saīsināta, regex, ir datora šo problēmu risināšanas priekšmets. C ++ nāk ar bibliotēku ar nosaukumu regex. Tātad, C ++ programmai, lai apstrādātu regex, vajadzētu sākt ar:



#iekļaut

#iekļaut

izmantojot nosaukumvietas std;

Šis raksts izskaidro regulārās izteiksmes pamatus C ++.



Raksta saturs

Regulārās izteiksmes pamati

Regulārā izteiksme

Stīga, piemēram, Šeit ir mans cilvēks. iepriekš ir mērķa secība vai mērķa virkne vai vienkārši mērķis. cilvēks, kas tika meklēts, ir regulārā izteiksme vai vienkārši regex.





Atbilstība

Sakritība notiek, kad tiek atrasts meklētais vārds vai frāze. Pēc saskaņošanas var notikt nomaiņa. Piemēram, pēc tam, kad vīrietis atrodas augšpusē, to var aizstāt ar sievieti.

Vienkārša saskaņošana

Šī programma parāda, kā tiek saskaņots vārds cilvēks.



#iekļaut

#iekļaut

izmantojot nosaukumvietas std;

intgalvenais()
{

regulārā izteiksme reģ('vīrietis');
ja (regex_search('Šeit ir mans cilvēks.',reģ))
izmaksas<< 'saskaņots' <<endl;
citādi
izmaksas<< 'neatbilst' <<endl;

atgriezties 0;
}

Funkcija regex_search () atgriež patiesu, ja ir atbilstība, un atgriež nepatiesu, ja neatbilstība nenotiek. Šeit funkcijai ir divi argumenti: pirmais ir mērķa virkne, bet otrais - regulārās izteiksmes objekts. Regulārā izteiksme pati par sevi ir “cilvēks”, pēdiņās. Pirmais paziņojums galvenajā () funkcijā veido regulārās izteiksmes objektu. Regulārā izteiksme ir veids, un reg ir regulārās izteiksmes objekts. Iepriekš minētās programmas izlaide ir “saskaņota”, jo mērķa virknē ir redzams “cilvēks”. Ja mērķī nebūtu redzams “cilvēks”, regex_search () būtu atgriezis nepatiesu un iznākums būtu “neatbilstošs”.

Šāda koda izvade nav atbilstoša:

regulārā izteiksme reģ('vīrietis');
ja (regex_search('Šeit ir mana padarīšana.',reģ))
izmaksas<< 'saskaņots' <<endl;
citādi
izmaksas<< 'neatbilst' <<endl;

Nav saskaņots, jo regulāro izteiksmi “man” nevarēja atrast visā mērķa virknē “Here is my making”.

Raksts

Regulārā izteiksme, cilvēks augstāk, ir ļoti vienkārša. Regulāri parasti nav tik vienkārši. Regulārajām izteiksmēm ir meta rakstzīmes. Meta rakstzīmes ir rakstzīmes ar īpašām nozīmēm. Meta raksturs ir raksturs par rakstzīmēm. C ++ regulārās izteiksmes metazīmes ir:

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

Regulārais teksts ar vai bez metarakstzīmēm ir modelis.

Rakstzīmju klases

Kvadrātiekavas

Modeļa kvadrātiekavās var būt rakstzīmes. Tādējādi konkrēta pozīcija mērķa virknē atbilstu kvadrātiekavu rakstzīmēm. Apsveriet šādus mērķus:

'Kaķis ir istabā.'

'Sikspārnis atrodas istabā.'

'Žurka ir istabā.'

Regulārā izteiksme, [cbr] at atbilstu kaķim pirmajā mērķī. Otrajā mērķī tas atbilstu nūjai. Tas atbilstu žurkām trešajā mērķī. Tas ir tāpēc, ka kaķis, sikspārnis vai žurka sākas ar “c”, “b” vai “r”. To ilustrē šāds koda segments:

regulārā izteiksme reģ('[cbr] at');
ja (regex_search('Kaķis ir istabā.',reģ))
izmaksas<< 'saskaņots' <<endl;
ja (regex_search('Sikspārnis atrodas istabā.',reģ))
izmaksas<< 'saskaņots' <<endl;
ja (regex_search('Žurka ir istabā.',reģ))
izmaksas<< 'saskaņots' <<endl;

Rezultāts ir šāds:

saskaņots

saskaņots

saskaņots

Rakstzīmju klāsts

Klase, [cbr] modelī [cbr], atbilstu vairākām iespējamām mērķa rakstzīmēm. Mērķī tas atbilstu “c”, “b” vai “r”. Ja mērķim nav “c”, “b” vai “r”, kam seko at, neatbilstība nebūtu.

Diapazonā pastāv dažas iespējas, piemēram, “c”, “b” vai “r”. Ciparu diapazonam no 0 līdz 9 ir 10 iespējas, un to paraugs ir [0-9]. Mazo burtu diapazonam no a līdz z ir 26 iespējas, un to paraugs ir [a-z]. Lielo burtu diapazonam no A līdz Z ir 26 iespējas, un to paraugs ir [A-Z]. - oficiāli nav meta raksturs, bet kvadrātiekavās tas norādītu diapazonu. Tātad, tiek izveidota atbilstība:

ja (regex_search('ID6id',regulārā izteiksme('[0-9]')))

izmaksas<< 'saskaņots' <<endl;

Ņemiet vērā, kā regulārais teikums ir veidots kā otrais arguments. Atbilstība notiek starp ciparu 6 diapazonā no 0 līdz 9 un 6 mērķa ID6id. Iepriekš minētais kods ir līdzvērtīgs:

ja (regex_search('ID6id',regulārā izteiksme('[0123456789]')))

izmaksas<< 'saskaņots' <<endl;

Šis kods rada atbilstību:

charlpp[] = 'ID6iE';

ja (regex_search(lpp,regulārā izteiksme('[a-z]')))

izmaksas<< 'saskaņots' <<endl;

Ņemiet vērā, ka pirmais arguments šeit ir virknes mainīgais, nevis virknes literālis. Atbilstība ir starp “i” [a – z] un “i” ID6iE.

Neaizmirstiet, ka diapazons ir klase. Modeļa labajā pusē vai kreisajā pusē var būt teksts. Šis kods rada atbilstību:

ja (regex_search('ID2id ir ID ',regulārā izteiksme('ID [0-9] id')))

izmaksas<< 'saskaņots' <<endl;

Atbilstība ir starp ID [0-9] id un ID2id. Pārējā mērķa virkne, kas ir ID, šajā situācijā nav saskaņota.

Kā lietots regulārās izteiksmes priekšmetā (regexes), vārda klase patiesībā nozīmē kopu. Tas ir, viens no komplekta varoņiem ir jāsaskaņo.

Piezīme: defise - ir metakrāsa tikai kvadrātiekavās, norādot diapazonu. Tas nav meta raksturs regulārajā izteiksmē ārpus kvadrātiekavām.

Noliegums

Klasi, kurā ietilpst diapazons, var noraidīt. Tas nozīmē, ka komplektā (klasē) esošajām rakstzīmēm nav jāsakrīt. Tas ir norādīts ar ^ rakstzīmi klases raksta sākumā, tūlīt pēc sākuma kvadrātiekavas. Tātad, [^0-9] nozīmē rakstzīmes saskaņošanu mērķa atbilstošajā pozīcijā, kas nav neviena rakstzīme diapazonā no 0 līdz 9 ieskaitot. Tātad šāds kods neradīs atbilstību:

ja (regex_search('0123456789101112',regulārā izteiksme('[^ 0-9]')))

izmaksas<< 'saskaņots' <<endl;

citādi

izmaksas<< 'neatbilst' <<endl;

Ciparu diapazonā no 0 līdz 9 var atrast jebkurā mērķa virknes pozīcijā, 0123456789101112 ,; tāpēc nav spēles - negācija.

Šis kods rada atbilstību:

ja (regex_search('ABCDEFGHIJ',regulārā izteiksme('[^ 0-9]')))

izmaksas<< 'saskaņots' <<endl;

Mērķī nevarēja atrast nevienu ciparu, ABCDEFGHIJ ,; tāpēc ir mačs.

[a-z] ir diapazons ārpus [^a-z]. Un tā [^a-z] ir [a-z] noliegums.

[A-Z] ir diapazons ārpus [^A-Z]. Un tā [^A-Z] ir [A-Z] noliegums.

Pastāv arī citas negācijas.

Atbilstošas ​​baltās atstarpes

“” Vai t vai r vai n vai f ir atstarpes rakstzīme. Šajā kodā regulārā izteiksme n atbilst mērķim “ n”:

ja (regex_search('No pirmās līnijas. r nOtrajā rindā. ”,regulārā izteiksme(' n')))

izmaksas<< 'saskaņots' <<endl;

Atbilst jebkurai atstarpes rakstzīmei

Modelis vai klase, kas atbilst jebkurai atstarpes rakstzīmei, ir [ t r n f]. Tālāk norādītajā kodā “” ir saskaņots:

ja (regex_search('viens divi',regulārā izteiksme('[ t r n f] ')))

izmaksas<< 'saskaņots' <<endl;

Atbilst jebkurai rakstzīmei bez atstarpēm

Modelis vai klase, kas atbilst jebkurai atstarpes zīmei, ir [^ t r n f]. Šis kods rada atbilstību, jo mērķī nav atstarpes:

ja (regex_search('1234abcd',regulārā izteiksme('[^ t r n f] ')))

izmaksas<< 'saskaņots' <<endl;

Periods (.) Patternā

Periods (.) Modelī atbilst jebkurai rakstzīmei, ieskaitot sevi, izņemot n mērķī. Atbilstība tiek veidota pēc šāda koda:

ja (regex_search('1234abcd',regulārā izteiksme(''. ')))

izmaksas<< 'saskaņots' <<endl;

Šajā kodā nav atbilstošu rezultātu, jo mērķis ir n.

ja (regex_search(' n',regulārā izteiksme(''. ')))

izmaksas<< 'saskaņots' <<endl;

citādi

izmaksas<< 'neatbilst' <<endl;

Piezīme. Rakstzīmju klasē ar kvadrātiekavām punktam nav īpašas nozīmes.

Atbilstoši atkārtojumi

Rakstzīme vai rakstzīmju grupa mērķa virknē var parādīties vairāk nekā vienu reizi. Šim atkārtojumam var atbilst modelis. Meta rakstzīmes,?, *, +Un {} tiek izmantotas, lai atbilstu mērķa atkārtojumam. Ja x ir interesējoša rakstzīme mērķa virknē, tad metarakstzīmēm ir šāda nozīme:

x*:nozīmē sakritību'x' 0vai vairāk reizes,i.Un.,jebkuru reižu skaitu

x+:nozīmē sakritību'x' 1vai vairāk reizes,i.Un.,vismaz vienreiz

x? :nozīmē sakritību'x' 0vai1 laiks

x{n,}:nozīmē sakritību'x'vismaz n vai vairāk reizes.Piezīmekomats.

x{n} :sakrīt'x'tieši n reizes

x{n,m}:sakrīt'x'vismaz n reizes,bet ne vairāk kā m reizes.

Šos meta rakstzīmes sauc kvantori.

Ilustrācijas

*

* Atbilst iepriekšējai rakstzīmei vai grupai, nulle vai vairāk reizes. o* atbilst “o” mērķa virknes sunim. Tas arī atbilst oo grāmatā un meklēšanā. Regulārā izteiksme, o* atbilst boooo dzīvniekā booooed .. Piezīme: o* atbilst dig, kur “o” notiek nulle (vai vairāk) reizes.

+

+ 1 vai vairākas reizes atbilst iepriekšējai rakstzīmei vai grupai. Salīdziniet to ar nulli vai vairāk reizes *. Tātad regulārā izteiksme e+ atbilst “e” ēdienam, kur “e” notiek vienu reizi. e+ atbilst arī ee aitām, kur “e” sastopams vairāk nekā vienu reizi. Piezīme: e+ nesakrīt ar dig, jo rakšanas laikā “e” nenotiek vismaz vienu reizi.

?

Vai? atbilst iepriekšējai rakstzīmei vai grupai, 0 vai 1 reizi (un ne vairāk). Tātad, e? sakrīt rakt, jo “e” notiek rakšanas, nulles laikā. e? atbilstības ir iestatītas, jo “e” ir sastopams komplektā vienu reizi. Piezīme: e? joprojām atbilst aitām; lai gan aitās ir divi “e”. Šeit ir kāda nianse - skatīt vēlāk.

{n,}

Tas atbilst vismaz n secīgiem iepriekšējās rakstzīmes vai grupas atkārtojumiem. Tātad regulārā izteiksme, e {2,}, atbilst abiem mērķa aitiem, aitām un trim e - burtiem mērķa aitās. e {2,} neatbilst kopai, jo kopai ir tikai viens “e”.

{n}

Tas precīzi atbilst n secīgiem iepriekšējās rakstzīmes vai grupas atkārtojumiem. Tātad regulārā izteiksme e {2} atbilst abiem mērķa aitiem. e {2} neatbilst kopai, jo kopai ir tikai viens “e”. Nu, e {2} atbilst diviem “e” mērķiem, ait. Šeit ir kāda nianse - skatīt vēlāk.

{n, m}

Tas atbilst vairākiem secīgiem iepriekšējās rakstzīmes vai iepriekšējās grupas atkārtojumiem jebkurā vietā no n līdz m ieskaitot. Tātad, e {1,3} neko neatbilst dig, kam nav “e”. Tas atbilst vienam “e” komplektā, diviem “e” aitām, trim “e” aitām un trim “e” aitām. Pēdējā mačā ir kāda nianse - skatīt vēlāk.

Atbilstoša alternatīva

Apsveriet šādu mērķa virkni datorā.

Saimniecībā ir dažāda lieluma cūkas.

Programmētājs var vēlēties uzzināt, vai šim mērķim ir kaza, trusis vai cūka. Kods būtu šāds:

charlpp[] = 'Saimniecībā ir dažāda lieluma cūkas.';

ja (regex_search(lpp,regulārā izteiksme('kaza | trusis | cūka')))

izmaksas<< 'saskaņots' <<endl;

citādi

izmaksas<< 'neatbilst' <<endl;

Kods rada atbilstību. Ņemiet vērā pārmaiņu rakstzīmes izmantošanu |. Var būt divas, trīs, četras un vairākas iespējas. C ++ vispirms mēģinās saskaņot pirmo alternatīvu, kazu, katrā rakstzīmju vietā mērķa virknē. Ja tas neizdodas ar kazu, tas izmēģina nākamo alternatīvu - trusi. Ja tas neizdodas ar trušiem, tas izmēģina nākamo alternatīvu - cūku. Ja cūka neizdodas, C ++ pāriet uz nākamo pozīciju mērķī un atkal sāk ar pirmo alternatīvu.

Iepriekš minētajā kodā cūka ir saskaņota.

Atbilstošs sākums vai beigas

Sākums


Ja ^ ir regulārās izteiksmes sākumā, tad mērķa virknes sākuma tekstu var saskaņot ar regulāro izteiksmi. Nākamajā kodā mērķa sākums ir abc, kas atbilst:

ja (regex_search('abc un def',regulārā izteiksme('^ abc')))

izmaksas<< 'saskaņots' <<endl;

Šajā kodā neatbilstība netiek veikta:

ja (regex_search('Jā, abc un def',regulārā izteiksme('^ abc')))

izmaksas<< 'saskaņots' <<endl;

citādi

izmaksas<< 'neatbilst' <<endl;

Šeit abc nav mērķa sākumā.

Piezīme. Cirkumfleksa rakstzīme “^” ir metavilkums regulārās izteiksmes sākumā, kas atbilst mērķa virknes sākumam. Tas joprojām ir meta raksturs rakstzīmju klases sākumā, kur tas noliedz klasi.

Beigas

Ja regulārās izteiksmes beigās ir $, tad mērķa virknes beigu tekstu var saskaņot ar regulāro izteiksmi. Šajā kodā mērķa beigas ir xyz, kas atbilst:

ja (regex_search('uvw un xyz',regulārā izteiksme('xyz $')))

izmaksas<< 'saskaņots' <<endl;

Šajā kodā neatbilstība netiek veikta:

ja (regex_search('uvw un xyz fināls',regulārā izteiksme('xyz $')))

izmaksas<< 'saskaņots' <<endl;

citādi

izmaksas<< 'neatbilst' <<endl;

Šeit xyz nav mērķa beigās.

Grupēšana

Iekavas var izmantot, lai grupētu rakstzīmes šablonā. Apsveriet šādu regulāro izteiksmi:

'koncerts (pianists)'

Grupa šeit ir pianiste, kuru ieskauj meta rakstzīmes (un). Patiesībā tā ir apakšgrupa, savukārt koncerts (pianists) ir visa grupa. Apsveriet sekojošo:

'Pianists ir labs'

Šeit apakšgrupa vai apakšstīga ir, pianists ir labs.

Apakšvirknes ar kopējām daļām

Grāmatvedis ir persona, kas rūpējas par grāmatām. Iedomājieties bibliotēku ar grāmatvedi un grāmatu plauktu. Pieņemsim, ka datorā ir viena no šīm mērķa virknēm:

'Bibliotēkā ir grāmatu plaukts, kas apbrīno.';

'Šeit ir grāmatvedis.';

'Grāmatvedis strādā ar grāmatplauktu.';

Pieņemsim, ka programmētāja interese nav zināt, kurš no šiem teikumiem atrodas datorā. Tomēr viņa interese ir zināt, vai grāmatplaukts vai grāmatvedis atrodas datora mērķa virknē. Šajā gadījumā viņa regulārā izteiksme var būt:

'grāmatu plaukts | grāmatvedis.'

Izmantojot pārmaiņus.

Ievērojiet, ka grāmata, kas ir kopīga abiem vārdiem, ir ierakstīta divreiz, divos modeļa vārdos. Lai izvairītos no grāmatas rakstīšanas divreiz, regulārā izteiksme būtu labāk uzrakstīta šādi:

'grāmata (plaukts | turētājs)'

Šeit grupa, plaukts | turētājs Maiņas meta raksturs joprojām ir izmantots, bet ne diviem gariem vārdiem. Tas ir izmantots divu garo vārdu divām beigu daļām. C ++ grupu uzskata par vienību. Tātad, C ++ meklēs plauktu vai turētāju, kas nāk tūlīt pēc grāmatas. Šāda koda izvade ir saskaņota:

charlpp[] = 'Bibliotēkā ir grāmatu plaukts, kuru apbrīno.';

ja (regex_search(lpp,regulārā izteiksme('grāmata (plaukts | turētājs)')))

izmaksas<< 'saskaņots' <<endl;

grāmatplaukts, nevis grāmatvedis ir saskaņots.

ICASE un daudzrindu regex_constants

icase

Atbilstība pēc noklusējuma ir reģistrjutīga. Tomēr to var padarīt nejutīgu pret reģistriem. Lai to panāktu, izmantojiet konstantu regex :: icase, kā norādīts šādā kodā:

ja (regex_search('Atsauksmes',regulārā izteiksme('barot',regulārā izteiksme::icase)))

izmaksas<< 'saskaņots' <<endl;

Rezultāts ir saskaņots. Tātad atsauksmes ar lielajiem burtiem “F” ir saskaņotas ar plūsmu ar mazajiem burtiem “f”. regex :: icase ir padarīts par otro regex () konstruktora argumentu. Bez tā paziņojums neradītu atbilstību.

Daudzrindu

Apsveriet šādu kodu:

charlpp[] = '1. rinda n2. līnija n3. līnija;

ja (regex_search(lpp,regulārā izteiksme('^. * $')))

izmaksas<< 'saskaņots' <<endl;

citādi

izmaksas<< 'neatbilst' <<endl;

Izlaide nav saskaņota. Regulārā izteiksme ^.*$ Atbilst mērķa virknei no sākuma līdz beigām. .* nozīmē jebkuru rakstzīmi, izņemot n, nulle vai vairākas reizes. Tātad mērķa jauno rindiņu rakstzīmju ( n) dēļ nebija atbilstības.

Mērķis ir daudzrindu virkne. Lai “.” Atbilstu jaunrindas rakstzīmei, ir jāizveido konstante regex :: multiline, kas ir otrais regex () konstrukcijas arguments. To ilustrē šāds kods:

charlpp[] = '1. rinda n2. līnija n3. līnija;

ja (regex_search(lpp,regulārā izteiksme('^. * $',regulārā izteiksme::daudzrindu)))

izmaksas<< 'saskaņots' <<endl;

citādi

izmaksas<< 'neatbilst' <<endl;

Atbilst visai mērķa virknei

Lai atbilstu visai mērķa virknei, kurai nav jaunrindas rakstzīmes ( n), var izmantot funkciju regex_match (). Šī funkcija atšķiras no regex_search (). To ilustrē šāds kods:

charlpp[] = 'pirmais otrais trešais';

ja (regex_match(lpp,regulārā izteiksme('.*otrais.*')))

izmaksas<< 'saskaņots' <<endl;

Šeit ir mačs. Tomēr ņemiet vērā, ka regulārā izteiksme atbilst visai mērķa virknei un mērķa virknei nav neviena “ n”.

Mērķis match_results

Funkcija regex_search () var izmantot argumentu starp mērķi un regulārās izteiksmes objektu. Šis arguments ir objekts match_results. Ar to var uzzināt visu saskaņoto (daļu) virkni un saskaņotās apakšvirknes. Šis objekts ir īpašs masīvs ar metodēm. Match_results objekta tips ir cmatch (virkņu literāļiem).

Spēļu iegūšana

Apsveriet šādu kodu:

charlpp[] = 'Sieviete, kuru jūs meklējāt!';

cmatch m;

ja (regex_search(lpp,m,regulārā izteiksme('w.m.n')))

izmaksas<<m[0] <<endl;

Mērķa virknē ir vārds sieviete. Rezultāts ir sieviete ”, kas atbilst regulārajai izteiksmei, w.m.n. Pie indeksa nulles īpašajā masīvā ir vienīgā atbilstība - sieviete.

Izmantojot klases opcijas, speciālajam masīvam tiek nosūtīta tikai pirmā mērķa apakšvirkne. To ilustrē šāds kods:

cmatch m;

ja (regex_search('Žurka, kaķis, sikspārnis!',m,regulārā izteiksme('[bcr] at')))

izmaksas<<m[0] <<endl;

izmaksas<<m[1] <<endl;

izmaksas<<m[2] <<endl;

Rezultāts ir žurka no indeksa nulles. m [1] un m [2] ir tukši.

Izmantojot alternatīvas, īpašajam masīvam tiek nosūtīta tikai pirmā mērķa apakšvirkne. To ilustrē šāds kods:

ja (regex_search('Trusis, kaza, cūka!',m,regulārā izteiksme('kaza | trusis | cūka')))

izmaksas<<m[0] <<endl;

izmaksas<<m[1] <<endl;

izmaksas<<m[2] <<endl;

Rezultāts ir trusis no indeksa nulles. m [1] un m [2] ir tukši.

Grupējumi

Kad tiek iesaistītas grupas, viss modelis tiek saskaņots un nonāk īpašā masīva nulles šūnā. Nākamā atrastā apakšvirkne nonāk šūnā 1; apakšvirkne, kas nonāk šūnā 2; un tā tālāk. To ilustrē šāds kods:

ja (regex_search('Labākais grāmatu pārdevējs šodien!',m,regulārā izteiksme('grāmata ((sel) (ler))')))

izmaksas<<m[0] <<endl;

izmaksas<<m[1] <<endl;

izmaksas<<m[2] <<endl;

izmaksas<<m[3] <<endl;

Rezultāts ir šāds:

grāmatu tirgotājs

pārdevējs

šūna

lasīt

Ņemiet vērā, ka grupa (pārdevējs) nāk pirms grupas (sel).

Spēles stāvoklis

Var zināt katras apakšvirknes atbilstības pozīciju masīvā cmatch. Skaitīšana sākas no mērķa virknes pirmās rakstzīmes nulles pozīcijā. To ilustrē šāds kods:

cmatch m;

ja (regex_search('Labākais grāmatu pārdevējs šodien!',m,regulārā izteiksme('grāmata ((sel) (ler))')))

izmaksas<<m[0] << '->' <<m.pozīciju(0) <<endl;

izmaksas<<m[1] << '->' <<m.pozīciju(1) <<endl;

izmaksas<<m[2] << '->' <<m.pozīciju(2) <<endl;

izmaksas<<m[3] << '->' <<m.pozīciju(3) <<endl;

Ņemiet vērā pozīcijas rekvizīta izmantošanu ar šūnu indeksu kā argumentu. Rezultāts ir šāds:

grāmatu tirgotājs->5

pārdevējs->9

šūna->9

lasīt->12

Meklēt un aizstāt

Atbilstību var aizstāt jauns vārds vai frāze. Šim nolūkam tiek izmantota funkcija regex_replace (). Tomēr šoreiz virkne, kurā notiek nomaiņa, ir virknes objekts, nevis virkne literāle. Tātad, virkņu bibliotēka ir jāiekļauj programmā. Ilustrācija:

#iekļaut

#iekļaut

#iekļaut

izmantojot nosaukumvietas std;

intgalvenais()
{
virkne str= 'Lūk, nāk mans vīrietis. Tur iet tavs cilvēks. ';
virkne newStr=regex_replace(lpp,regulārā izteiksme('vīrietis'), 'sieviete');
izmaksas<<newStr<<endl;

atgriezties 0;
}

Funkcija regex_replace (), kā šeit kodēta, aizstāj visas atbilstības. Funkcijas pirmais arguments ir mērķis, otrais ir regulārās izteiksmes objekts, bet trešais ir aizstāšanas virkne. Funkcija atgriež jaunu virkni, kas ir mērķis, bet kurai ir aizstāšana. Rezultāts ir šāds:

Šeit nāk mana sieviete. Tur iet tava sieviete.

Secinājums

Regulārā izteiksme izmanto modeļus, lai saskaņotu apakšvirknes mērķa secības virknē. Rakstiem ir metatīksti. C ++ regulārajām izteiksmēm parasti izmantotās funkcijas ir: regex_search (), regex_match () un regex_replace (). Regulārā izteiksme ir pēdiņās iekļauts modelis. Tomēr šīs funkcijas kā argumentu ņem regex objektu, nevis tikai regulāro izteiksmi. Regulārā izteiksme ir jāizveido par regulārās izteiksmes objektu, pirms šīs funkcijas to var izmantot.