Dasar-dasar Ekspresi Reguler dalam C++

Regular Expression Basics C

Perhatikan kalimat berikut dalam tanda kutip:

'Ini laki-laki saya.'

String ini mungkin ada di dalam komputer, dan pengguna mungkin ingin tahu apakah ada kata man. Jika ada kata pria, dia mungkin ingin mengubah kata pria menjadi wanita; sehingga string harus membaca:



'Ini wanita saya.'

Masih banyak keinginan lain seperti ini dari pengguna komputer; beberapa kompleks. Ekspresi Reguler, disingkat, regex, adalah subjek penanganan masalah ini oleh komputer. C++ dilengkapi dengan perpustakaan yang disebut regex. Jadi, program C++ untuk menangani regex harus dimulai dengan:



#termasuk

#termasuk

menggunakan namespace std;

Artikel ini menjelaskan Dasar-dasar Ekspresi Reguler di C++.



Isi Artikel

Dasar-dasar Ekspresi Reguler

ekspresi reguler

String seperti Here is my man. di atas adalah urutan target atau string target atau sederhananya, target. man, yang dicari, adalah ekspresi reguler, atau sederhananya, regex.

Cocok

Pencocokan dikatakan terjadi ketika kata atau frase yang dicari berada. Setelah pencocokan, penggantian dapat dilakukan. Misalnya, setelah laki-laki berada di atas, maka dapat digantikan oleh perempuan.

Pencocokan Sederhana

Program berikut menunjukkan bagaimana kata man dicocokkan.



#termasuk

#termasuk

menggunakan namespace std;

ke dalamutama()
{

regex('pria');
jika (regex_search('Ini laki-laki saya.',reg))
biaya<< 'cocok' <<akhir;
lain
biaya<< 'tidak cocok' <<akhir;

kembali 0;
}

Fungsi regex_search() mengembalikan true jika ada kecocokan dan mengembalikan false jika tidak ada kecocokan yang terjadi. Di sini, fungsi mengambil dua argumen: yang pertama adalah string target, dan yang kedua adalah objek regex. Regex itu sendiri adalah 'man', dalam tanda kutip ganda. Pernyataan pertama dalam fungsi main() membentuk objek regex. Regex adalah tipe, dan reg adalah objek regex. Output program di atas adalah 'cocok', karena 'man' terlihat di string target. Jika 'man' tidak terlihat di target, regex_search() akan mengembalikan false, dan outputnya akan menjadi 'not match'.

Output dari kode berikut tidak cocok:

regex('pria');
jika (regex_search('Ini buatan saya.',reg))
biaya<< 'cocok' <<akhir;
lain
biaya<< 'tidak cocok' <<akhir;

Tidak cocok karena regex 'man' tidak dapat ditemukan di seluruh string target, 'Ini buatan saya.'

Pola

Ekspresi reguler, man di atas, sangat sederhana. Regex biasanya tidak sesederhana itu. Ekspresi reguler memiliki metakarakter. Metakarakter adalah karakter dengan arti khusus. Metacharacter adalah karakter tentang karakter. Metakarakter C++ regex adalah:

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

Sebuah regex, dengan atau tanpa metakarakter, adalah sebuah pola.

Kelas Karakter

Kurung Persegi

Pola dapat memiliki karakter dalam tanda kurung siku. Dengan ini, posisi tertentu dalam string target akan cocok dengan karakter tanda kurung siku mana pun. Pertimbangkan target berikut:

'Kucing itu ada di dalam kamar.'

'Kelelawar ada di dalam ruangan.'

'Tikus itu ada di dalam kamar.'

Regex, [cbr]at akan cocok dengan cat di target pertama. Itu akan cocok dengan kelelawar di target kedua. Itu akan cocok dengan tikus di target ketiga. Ini karena, kucing atau kelelawar atau tikus dimulai dengan 'c' atau 'b' atau 'r'. Segmen kode berikut menggambarkan hal ini:

regex('[cbr]di');
jika (regex_search('Kucing itu ada di dalam kamar.',reg))
biaya<< 'cocok' <<akhir;
jika (regex_search('Kelelawar ada di dalam ruangan.',reg))
biaya<< 'cocok' <<akhir;
jika (regex_search('Tikus itu ada di dalam kamar.',reg))
biaya<< 'cocok' <<akhir;

Outputnya adalah:

cocok

cocok

cocok

Rentang Karakter

Kelas, [cbr] dalam pola [cbr], akan cocok dengan beberapa kemungkinan karakter dalam target. Itu akan cocok dengan 'c' atau 'b' atau 'r' di target. Jika target tidak memiliki 'c' atau 'b' atau 'r', diikuti oleh at, tidak akan ada kecocokan.

Beberapa kemungkinan seperti 'c' atau 'b' atau 'r' ada dalam rentang. Rentang angka, 0 hingga 9 memiliki 10 kemungkinan, dan polanya adalah [0-9]. Rentang huruf kecil, a sampai z, memiliki 26 kemungkinan, dan polanya adalah [a-z]. Rentang huruf besar, A hingga Z, memiliki 26 kemungkinan, dan polanya adalah [A-Z]. – tidak secara resmi merupakan metakarakter, tetapi di dalam tanda kurung siku, ini akan menunjukkan rentang. Jadi, berikut ini menghasilkan kecocokan:

jika (regex_search('ID6id',ekspresi reguler('[0-9]')))

biaya<< 'cocok' <<akhir;

Perhatikan bagaimana regex telah dibangun sebagai argumen kedua. Kecocokan terjadi antara digit, 6 di kisaran, 0 hingga 9, dan 6 di target, ID6id. Kode di atas setara dengan:

jika (regex_search('ID6id',ekspresi reguler('[0123456789]')))

biaya<< 'cocok' <<akhir;

Kode berikut menghasilkan kecocokan:

arangP[] = 'ID6iE';

jika (regex_search(P,ekspresi reguler('[a-z]')))

biaya<< 'cocok' <<akhir;

Perhatikan bahwa argumen pertama di sini adalah variabel string dan bukan literal string. Kecocokan antara 'i' di [a-z] dan 'i' di ID6iE.

Jangan lupa bahwa rentang adalah kelas. Bisa ada teks di sebelah kanan rentang atau di kiri rentang dalam pola. Kode berikut menghasilkan kecocokan:

jika (regex_search('ID2id adalah ID',ekspresi reguler('ID[0-9]id')))

biaya<< 'cocok' <<akhir;

Kecocokan antara ID[0-9]id dan ID2id. String target lainnya, adalah ID, tidak cocok dalam situasi ini.

Seperti yang digunakan dalam subjek ekspresi reguler (regex), kata kelas sebenarnya berarti satu set. Artinya, salah satu karakter dalam set adalah untuk mencocokkan.

Catatan: Tanda hubung – adalah metakarakter hanya di dalam tanda kurung siku, yang menunjukkan rentang. Ini bukan karakter meta di regex, di luar tanda kurung siku.

Penyangkalan

Kelas yang termasuk rentang dapat dinegasikan. Artinya, tidak ada karakter di set (kelas) yang harus cocok. Ini ditunjukkan dengan metakarakter ^ di awal pola kelas, tepat setelah tanda kurung siku pembuka. Jadi, [^0-9] berarti mencocokkan karakter pada posisi yang sesuai di target, yang bukan sembarang karakter dalam rentang, termasuk 0 hingga 9. Jadi kode berikut tidak akan menghasilkan kecocokan:

jika (regex_search('0123456789101122',ekspresi reguler('[^ 0-9]')))

biaya<< 'cocok' <<akhir;

lain

biaya<< 'tidak cocok' <<akhir;

Digit dalam rentang 0 hingga 9 dapat ditemukan di salah satu posisi string target, 0123456789101112,; jadi tidak ada kecocokan – negasi.

Kode berikut menghasilkan kecocokan:

jika (regex_search('ABCDEFGHIJ',ekspresi reguler('[^ 0-9]')))

biaya<< 'cocok' <<akhir;

Tidak ada angka yang ditemukan pada target, ABCDEFGHIJ,; jadi ada kecocokan.

[a-z] adalah rentang di luar [^a-z]. Jadi [^a-z] adalah negasi dari [a-z].

[A-Z] adalah rentang di luar [^A-Z]. Jadi [^A-Z] adalah negasi dari [A-Z].

Negasi lain ada.

Pencocokan Spasi Putih

' ' atau atau atau atau f adalah karakter spasi putih. Dalam kode berikut, regex, cocok dengan ' ' di target:

jika (regex_search('Dari baris satu.R Dari baris dua.',ekspresi reguler(' ')))

biaya<< 'cocok' <<akhir;

Mencocokkan Karakter Spasi Apapun

Pola atau kelas yang cocok dengan karakter spasi putih adalah, [ f]. Dalam kode berikut, ' ' cocok:

jika (regex_search('satu dua',ekspresi reguler('[TR F] ')))

biaya<< 'cocok' <<akhir;

Mencocokkan Karakter Non-spasi apa pun

Pola atau kelas yang cocok dengan karakter spasi non-putih adalah, [^ f]. Kode berikut menghasilkan kecocokan karena tidak ada spasi kosong di target:

jika (regex_search('1234abcd',ekspresi reguler('[^TR F] ')))

biaya<< 'cocok' <<akhir;

Periode (.) dalam Pola

Titik (.) dalam pola cocok dengan karakter apa pun termasuk karakter itu sendiri, kecuali , di target. Kecocokan dihasilkan dalam kode berikut:

jika (regex_search('1234abcd',ekspresi reguler('.')))

biaya<< 'cocok' <<akhir;

Tidak ada hasil yang cocok dalam kode berikut karena targetnya adalah .

jika (regex_search(' ',ekspresi reguler('.')))

biaya<< 'cocok' <<akhir;

lain

biaya<< 'tidak cocok' <<akhir;

Catatan: Di dalam kelas karakter dengan tanda kurung siku, titik tidak memiliki arti khusus.

Pengulangan yang Cocok

Sebuah karakter atau sekelompok karakter dapat muncul lebih dari satu kali dalam string target. Sebuah pola bisa cocok dengan pengulangan ini. Karakter meta, ?, *, +, dan {} digunakan untuk mencocokkan pengulangan dalam target. Jika x adalah karakter yang diinginkan dalam string target, maka karakter meta memiliki arti sebagai berikut:

x*:berarti cocok'x' 0atau lebih kali,Saya.Dan.,berapa kali

x+:berarti cocok'x' 1atau lebih kali,Saya.Dan.,setidaknya sekali

x? :berarti cocok'x' 0atau1 waktu

x{n,}:berarti cocok'x'setidaknya n kali atau lebih.Catatankoma.

x{n} :cocok'x'tepat n kali

x{n,M}:cocok'x'setidaknya n kali,tapi tidak lebih dari m kali.

Metakarakter ini disebut quantifier.

Ilustrasi

*

Tanda * cocok dengan karakter sebelumnya atau grup sebelumnya, nol kali atau lebih. o* cocok dengan 'o' di anjing dari string target. Ini juga cocok dengan buku dan pencarian. Regex, o* cocok dengan boooo di The animal booooed.. Catatan: o* cocok dengan penggalian, di mana 'o' muncul nol (atau lebih) waktu.

+

Tanda + cocok dengan karakter sebelumnya atau grup sebelumnya, 1 kali atau lebih. Bandingkan dengan nol kali atau lebih untuk *. Jadi regex, e+ cocok dengan 'e' di makan, di mana 'e' muncul satu kali. e+ juga cocok dengan ee pada domba, di mana 'e' muncul lebih dari satu kali. Catatan: e+ tidak akan cocok dengan dig karena dalam dig, 'e' tidak muncul setidaknya sekali.

?

NS ? cocok dengan karakter sebelumnya atau grup sebelumnya, 0 atau 1 kali (dan tidak lebih). Jadi, e? cocok dig karena 'e' muncul di dig, nol waktu. e? cocok dengan set karena 'e' muncul di set, satu kali. Catatan: e? masih cocok dengan domba; meskipun ada dua 'e' pada domba. Ada nuansa di sini – lihat nanti.

{n,}

Ini cocok dengan setidaknya n pengulangan berturut-turut dari karakter sebelumnya atau grup sebelumnya. Jadi ekspresi reguler, e{2,} cocok dengan dua 'e' di target, domba, dan tiga 'e di domba target. e{2,} tidak cocok dengan set, karena set hanya memiliki satu 'e'.

{n}

Ini cocok dengan tepat n pengulangan berturut-turut dari karakter sebelumnya atau grup sebelumnya. Jadi ekspresi reguler, e{2} cocok dengan dua 'e di target, domba. e{2} tidak cocok dengan set karena set hanya memiliki satu 'e'. Nah, e{2} cocok dengan dua 'e' di target, domba. Ada nuansa di sini – lihat nanti.

{n,m}

Ini cocok dengan beberapa pengulangan berurutan dari karakter sebelumnya atau grup sebelumnya, di mana saja dari n hingga m, inklusif. Jadi, e{1,3} tidak cocok dengan apa pun dalam penggalian, yang tidak memiliki 'e'. Ini cocok dengan satu 'e' di set, dua 'e' di domba, tiga 'e di domba, dan tiga 'e di domba. Ada nuansa di pertandingan terakhir – lihat nanti.

Pencocokan Alternatif

Pertimbangkan string target berikut di komputer.

Peternakan memiliki babi dengan ukuran berbeda.

Pemrogram mungkin ingin tahu apakah target ini memiliki kambing atau kelinci atau babi. Kode akan menjadi sebagai berikut:

arangP[] = 'Peternakan itu memiliki babi dengan ukuran berbeda-beda.';

jika (regex_search(P,ekspresi reguler('kambing|kelinci|babi')))

biaya<< 'cocok' <<akhir;

lain

biaya<< 'tidak cocok' <<akhir;

Kode menghasilkan kecocokan. Perhatikan penggunaan karakter silih berganti, |. Bisa ada dua, tiga, empat, dan lebih banyak pilihan. C++ pertama-tama akan mencoba mencocokkan alternatif pertama, kambing, pada setiap posisi karakter dalam string target. Jika tidak berhasil dengan kambing, ia mencoba alternatif berikutnya, kelinci. Jika tidak berhasil dengan kelinci, ia mencoba alternatif berikutnya, babi. Jika pig gagal, maka C++ pindah ke posisi berikutnya dalam target dan mulai dengan alternatif pertama lagi.

Dalam kode di atas, babi dicocokkan.

Pencocokan Awal atau Akhir

Awal


Jika ^ berada di awal regex, maka teks awal dari string target dapat dicocokkan dengan regex. Dalam kode berikut, awal dari target adalah abc, yang cocok:

jika (regex_search('abc dan def',ekspresi reguler('^ abc')))

biaya<< 'cocok' <<akhir;

Tidak ada pencocokan yang terjadi dalam kode berikut:

jika (regex_search('Ya, abc dan def',ekspresi reguler('^ abc')))

biaya<< 'cocok' <<akhir;

lain

biaya<< 'tidak cocok' <<akhir;

Di sini, abc tidak berada di awal target.

Catatan: Karakter sirkumfleksa, '^', adalah karakter meta di awal regex, cocok dengan awal string target. Itu masih merupakan metakarakter di awal kelas karakter, di mana ia meniadakan kelas.

Akhir

Jika $ berada di akhir regex, maka teks akhir dari string target dapat dicocokkan dengan regex. Dalam kode berikut, akhir dari target adalah xyz, yang cocok:

jika (regex_search('uvw dan xyz',ekspresi reguler('xyz$')))

biaya<< 'cocok' <<akhir;

Tidak ada pencocokan yang terjadi dalam kode berikut:

jika (regex_search('uvw dan xyz final',ekspresi reguler('xyz$')))

biaya<< 'cocok' <<akhir;

lain

biaya<< 'tidak cocok' <<akhir;

Di sini, xyz tidak berada di akhir target.

Pengelompokan

Tanda kurung dapat digunakan untuk mengelompokkan karakter dalam suatu pola. Perhatikan regex berikut:

'konser (pianis)'

Grup di sini adalah pianis yang dikelilingi oleh metakarakter ( dan ). Ini sebenarnya adalah sub-grup, sedangkan konser (pianis) adalah keseluruhan grup. Pertimbangkan hal berikut:

'(Pianis itu baik)'

Di sini, sub-grup atau sub-string adalah, pianis itu bagus.

Sub-string dengan Bagian Umum

Pembukuan adalah orang yang mengurus buku. Bayangkan sebuah perpustakaan dengan pemegang buku dan rak buku. Misalnya salah satu dari string target berikut ini ada di komputer:

'Perpustakaan memiliki rak buku yang dikagumi.';

'Ini pembukuannya.';

'Pembukuan bekerja dengan rak buku.';

Asumsikan bahwa minat programmer bukanlah untuk mengetahui kalimat mana yang ada di komputer. Namun, minatnya adalah untuk mengetahui apakah rak buku atau pemegang buku ada di string target apa pun yang ada di komputer. Dalam hal ini, regex-nya dapat berupa:

'rak buku | pemegang buku.'

Menggunakan pergantian.

Perhatikan bahwa buku, yang umum untuk kedua kata, telah diketik dua kali, dalam dua kata dalam pola. Untuk menghindari mengetik buku dua kali, regex akan lebih baik ditulis sebagai:

'buku(rak|penjaga)'

Di sini, grup, rak|penjaga Metakarakter alternatif masih digunakan, tetapi tidak untuk dua kata yang panjang. Ini telah digunakan untuk dua bagian akhir dari dua kata yang panjang. C++ memperlakukan grup sebagai entitas. Jadi, C++ akan mencari rak atau keeper yang datang segera setelah buku. Output dari kode berikut cocok:

arangP[] = 'Perpustakaan memiliki rak buku yang dikagumi.';

jika (regex_search(P,ekspresi reguler('buku(rak|penjaga)')))

biaya<< 'cocok' <<akhir;

rak buku dan bukan pemegang buku telah dicocokkan.

icase dan multiline regex_constants

icase

Pencocokan peka huruf besar/kecil secara default. Namun, itu dapat dibuat peka huruf besar-kecil. Untuk mencapai ini, gunakan konstanta regex::icase, seperti pada kode berikut:

jika (regex_search('Masukan',ekspresi reguler('memberi makan',ekspresi reguler::icase)))

biaya<< 'cocok' <<akhir;

Outputnya cocok. Jadi Umpan Balik dengan huruf besar 'F' telah dicocokkan dengan feed dengan huruf kecil 'f'. regex::icase telah dijadikan argumen kedua dari konstruktor regex(). Tanpa itu, pernyataan tidak akan menghasilkan kecocokan.

Multiline

Perhatikan kode berikut:

arangP[] = 'baris 1 baris 2 baris 3';

jika (regex_search(P,ekspresi reguler('^. * $')))

biaya<< 'cocok' <<akhir;

lain

biaya<< 'tidak cocok' <<akhir;

Outputnya tidak cocok. Regex, ^.*$, cocok dengan string target dari awal hingga akhir. .* berarti karakter apa pun kecuali , nol kali atau lebih. Jadi, karena karakter baris baru ( ) di target, tidak ada yang cocok.

Targetnya adalah string multiline. Agar '.' cocok dengan karakter baris baru, konstanta regex::multiline harus dibuat, argumen kedua dari konstruksi regex(). Kode berikut menggambarkan hal ini:

arangP[] = 'baris 1 baris 2 baris 3';

jika (regex_search(P,ekspresi reguler('^. * $',ekspresi reguler::banyak baris)))

biaya<< 'cocok' <<akhir;

lain

biaya<< 'tidak cocok' <<akhir;

Mencocokkan Seluruh String Target

Untuk mencocokkan seluruh string target, yang tidak memiliki karakter baris baru ( ), fungsi regex_match() dapat digunakan. Fungsi ini berbeda dari regex_search(). Kode berikut menggambarkan hal ini:

arangP[] = 'pertama kedua ketiga';

jika (regex_match(P,ekspresi reguler('.*kedua.*')))

biaya<< 'cocok' <<akhir;

Ada kecocokan di sini. Namun, perhatikan bahwa ekspresi reguler cocok dengan seluruh string target, dan string target tidak memiliki ' '.

Objek match_results

Fungsi regex_search() dapat mengambil argumen di antara target dan objek regex. Argumen ini adalah objek match_results. Seluruh string (bagian) yang cocok dan sub-string yang cocok dapat diketahui dengannya. Objek ini adalah array khusus dengan metode. Jenis objek match_results adalah cmatch (untuk literal string).

Mendapatkan Pertandingan

Perhatikan kode berikut:

arangP[] = 'Wanita yang Anda cari!';

cocok m;

jika (regex_search(P,M,ekspresi reguler('w.m.n')))

biaya<<M[0] <<akhir;

String target memiliki kata wanita. Outputnya adalah woman', yang sesuai dengan regex, w.m.n. Pada indeks nol, array khusus menampung satu-satunya kecocokan, yaitu wanita.

Dengan opsi kelas, hanya sub-string pertama yang ditemukan di target, yang dikirim ke larik khusus. Kode berikut menggambarkan hal ini:

cocok m;

jika (regex_search('Tikus, kucing, kelelawar!',M,ekspresi reguler('[bcr]di')))

biaya<<M[0] <<akhir;

biaya<<M[1] <<akhir;

biaya<<M[2] <<akhir;

Outputnya adalah tikus dari indeks nol. m[1] dan m[2] kosong.

Dengan alternatif, hanya sub-string pertama yang ditemukan di target, yang dikirim ke larik khusus. Kode berikut menggambarkan hal ini:

jika (regex_search('Kelinci, kambing, babi!',M,ekspresi reguler('kambing|kelinci|babi')))

biaya<<M[0] <<akhir;

biaya<<M[1] <<akhir;

biaya<<M[2] <<akhir;

Outputnya adalah kelinci dari indeks nol. m[1] dan m[2] kosong.

Pengelompokan

Saat grup terlibat, pola lengkapnya cocok, masuk ke sel nol dari larik khusus. Sub-string berikutnya yang ditemukan masuk ke sel 1; sub-string berikut, masuk ke sel 2; dan seterusnya. Kode berikut menggambarkan hal ini:

jika (regex_search('Penjual buku terbaik hari ini!',M,ekspresi reguler('buku ((sel) (ler))')))

biaya<<M[0] <<akhir;

biaya<<M[1] <<akhir;

biaya<<M[2] <<akhir;

biaya<<M[3] <<akhir;

Outputnya adalah:

penjual buku

penjual

sel

Baca

Perhatikan bahwa grup (penjual) datang sebelum grup (sel).

Posisi Pertandingan

Posisi kecocokan untuk setiap sub-string dalam larik kecocokan dapat diketahui. Penghitungan dimulai dari karakter pertama string target, pada posisi nol. Kode berikut menggambarkan hal ini:

cocok m;

jika (regex_search('Penjual buku terbaik hari ini!',M,ekspresi reguler('buku ((sel) (ler))')))

biaya<<M[0] << '->' <<M.posisi(0) <<akhir;

biaya<<M[1] << '->' <<M.posisi(1) <<akhir;

biaya<<M[2] << '->' <<M.posisi(2) <<akhir;

biaya<<M[3] << '->' <<M.posisi(3) <<akhir;

Perhatikan penggunaan properti posisi, dengan indeks sel, sebagai argumen. Outputnya adalah:

penjual buku->5

penjual->9

sel->9

Baca->12

Cari dan Ganti

Kata atau frasa baru dapat menggantikan kecocokan. Fungsi regex_replace() digunakan untuk ini. Namun, kali ini, string tempat penggantian terjadi adalah objek string, bukan string literal. Jadi, perpustakaan string harus disertakan dalam program. Ilustrasi:

#termasuk

#termasuk

#termasuk

menggunakan namespace std;

ke dalamutama()
{
string str= 'Di sini, datang laki-laki saya. Ini dia laki-lakimu.';
string baruStr=regex_replace(P,ekspresi reguler('pria'), 'wanita');
biaya<<baruStr<<akhir;

kembali 0;
}

Fungsi regex_replace(), seperti yang dikodekan di sini, menggantikan semua kecocokan. Argumen pertama dari fungsi adalah target, yang kedua adalah objek regex, dan yang ketiga adalah string pengganti. Fungsi mengembalikan string baru, yang merupakan target tetapi memiliki penggantinya. Outputnya adalah:

Ini dia wanitaku. Ini dia wanitamu.

Kesimpulan

Ekspresi reguler menggunakan pola untuk mencocokkan substring dalam string urutan target. Pola memiliki metakarakter. Fungsi yang umum digunakan untuk ekspresi reguler C++, adalah: regex_search(), regex_match() dan regex_replace(). Regex adalah pola dalam tanda kutip ganda. Namun, fungsi-fungsi ini mengambil objek regex sebagai argumen dan bukan hanya regex. Regex harus dibuat menjadi objek regex sebelum fungsi ini dapat menggunakannya.