יסודות ביטוי רגיל ב- C ++

Regular Expression Basics C

שקול את המשפט הבא במרכאות:

'הנה האיש שלי.'

מחרוזת זו עשויה להיות בתוך המחשב, והמשתמש ירצה לדעת אם יש בה את המילה גבר. אם יש בה את המילה גבר, ייתכן שהוא ירצה לשנות את המילה גבר לאישה; כך שהמחרוזת צריכה לקרוא:



'הנה האישה שלי.'

ישנם רצונות רבים אחרים כמו אלה של משתמש המחשב; חלקם מורכבים. ביטוי רגיל, מקוצר, regex, הוא נושא הטיפול במחשבים אלה. C ++ מגיע עם ספרייה בשם regex. אז, תוכנית C ++ להתמודדות עם regex צריכה להתחיל ב:



#לִכלוֹל

#לִכלוֹל

באמצעות מרחב שמות std;

מאמר זה מסביר את יסודות הביטוי הרגיל ב- C ++.



תוכן המאמר

יסודות ביטוי רגיל

Regex

מחרוזת כמו כאן האיש שלי. למעלה הוא רצף היעד או מחרוזת המטרה או פשוט, יעד. האדם, שחיפשו אותו, הוא הביטוי הרגיל, או פשוט, regex.

תוֹאֵם

אומרים שהתאמה מתרחשת כאשר המילה או הביטוי שאותו מחפשים נמצא. לאחר ההתאמה, ניתן לבצע החלפה. לדוגמה, לאחר שהגבר ממוקם למעלה, ניתן להחליף אותו על ידי אישה.

התאמה פשוטה

התוכנית הבאה מראה כיצד מתאימה המילה גבר.



#לִכלוֹל

#לִכלוֹל

באמצעות מרחב שמות std;

intרָאשִׁי()
{

regex reg('איש');
אם (regex_search('הנה האיש שלי.',reg))
עֲלוּת<< 'תואם' <<endl;
אַחֵר
עֲלוּת<< 'לא מתאים' <<endl;

לַחֲזוֹר 0;
}

הפונקציה regex_search () מחזירה true אם יש התאמה ומחזירה false אם לא מתרחשת התאמה. כאן, הפונקציה לוקחת שני ארגומנטים: הראשון הוא מחרוזת המטרה, והשני הוא אובייקט regex. הרקס עצמו הוא 'גבר', במרכאות כפולות. המשפט הראשון בפונקציה הראשית () יוצר את אובייקט regex. Regex הוא סוג, ו- reg הוא אובייקט regex. הפלט של התוכנית לעיל 'תואם', כפי ש'אדם 'נראה במחרוזת המטרה. אם 'גבר' לא היה נראה במטרה, regex_search () היה מחזיר שווא, והפלט היה 'לא תואם'.

הפלט של הקוד הבא אינו תואם:

regex reg('איש');
אם (regex_search('הנה העשייה שלי'.,reg))
עֲלוּת<< 'תואם' <<endl;
אַחֵר
עֲלוּת<< 'לא מתאים' <<endl;

לא תואם כי לא ניתן היה למצוא את ה'גבר 'הרגסי בכל מחרוזת היעד, 'הנה העשייה שלי'.

תבנית

הביטוי הרגיל, האדם למעלה, פשוט מאוד. רג 'רג' הם בדרך כלל לא כל כך פשוטים. לביטויים רגילים יש מטא -דמויות. מטא -דמויות הן דמויות בעלות משמעויות מיוחדות. מטא -דמות היא דמות העוסקת בדמויות. מטא -תווים של reg+ C ++ הם:

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

Regex, עם או בלי מטא -תווים, הוא דפוס.

שיעורי דמויות

סוגריים מרובעים

דפוס יכול להכיל תווים בתוך סוגריים מרובעים. עם זאת, מיקום מסוים במחרוזת היעד יתאים לכל אחת מהתווים של הסוגריים המרובעים. שקול את המטרות הבאות:

'החתול נמצא בחדר'.

'העטלף נמצא בחדר.'

'החולדה נמצאת בחדר'.

ה- regex, [cbr] ב יתאים את החתול ליעד הראשון. זה יתאים עטלף למטרה השנייה. זה יתאים לחולדה במטרה השלישית. הסיבה לכך היא שחתול או עטלף או חולדה מתחילים ב- 'c' או 'b' או 'r'. קטע הקוד הבא ממחיש זאת:

regex reg('[cbr] ב-');
אם (regex_search('החתול נמצא בחדר'.,reg))
עֲלוּת<< 'תואם' <<endl;
אם (regex_search('העטלף נמצא בחדר.',reg))
עֲלוּת<< 'תואם' <<endl;
אם (regex_search('החולדה נמצאת בחדר'.,reg))
עֲלוּת<< 'תואם' <<endl;

הפלט הוא:

תואם

תואם

תואם

מגוון דמויות

המחלקה, [cbr] בתבנית [cbr], תתאים למספר תווים אפשריים במטרה. זה יתאים ל- 'c' או 'b' או 'r' במטרה. אם היעד אינו מכיל 'c' או 'b' או 'r', ואחריו ב-, לא תהיה התאמה.

כמה אפשרויות כמו 'c' או 'b' או 'r' קיימות בטווח. לטווח הספרות, 0 עד 9 יש 10 אפשרויות, והתבנית לכך היא [0-9]. טווח האותיות הקטנות, א עד ז, כולל 26 אפשרויות, והתבנית לכך היא [א-ז]. טווח האותיות האותיות, A עד Z, ​​כולל 26 אפשרויות, והתבנית לכך היא [A-Z]. - אינו רשמית מטא -אופי, אך בתוך סוגריים מרובעים, הדבר יצביע על טווח. אז, הדברים הבאים מייצרים התאמה:

אם (regex_search('ID6id',regex('[0-9]')))

עֲלוּת<< 'תואם' <<endl;

שים לב כיצד בניית ה- regex כטענה השנייה. ההתאמה מתרחשת בין הספרה, 6 בטווח, 0 עד 9, לבין 6 ביעד, ID6id. הקוד הנ'ל שווה ל:

אם (regex_search('ID6id',regex('[0123456789]')))

עֲלוּת<< 'תואם' <<endl;

הקוד הבא מייצר התאמה:

לְהַשְׁחִירעמ[] = 'ID6iE';

אם (regex_search(עמ,regex('[א-ז]')))

עֲלוּת<< 'תואם' <<endl;

שים לב שהטענה הראשונה כאן היא משתנה מחרוזת ולא המחרוזת מילולית. ההתאמה היא בין 'i' ב- [a-z] ו- 'i' ב- ID6iE.

אל תשכח כי טווח הוא מחלקה. יכול להיות טקסט מימין לטווח או משמאל לטווח בתבנית. הקוד הבא מייצר התאמה:

אם (regex_search('ID2id הוא תעודת זהות ',regex(מזהה 'מזהה [0-9]')))

עֲלוּת<< 'תואם' <<endl;

ההתאמה היא בין מזהה [0-9] לבין מזהה ID2id. שאר מחרוזת היעד, היא מזהה, אינה תואמת במצב זה.

כפי שהוא משמש בנושא הביטוי הרגיל (regexes), משמעות המילה class היא למעשה קבוצה. כלומר, אחת הדמויות בסט היא התאמה.

הערה: המקף - הוא מטא -דמות רק בתוך סוגריים מרובעים, המציין טווח. הוא אינו מטא -אופי ברגקס, מחוץ לסוגריים המרובעים.

שְׁלִילָה

ניתן לשלול שיעור כולל טווח. כלומר, לא אחת הדמויות במערך (המחלקה) צריכה להתאים. זה מסומן עם ^ metacharacter בתחילת תבנית המחלקה, ממש אחרי הסוגר המרובע הפותח. אז, [^0-9] פירושו התאמת הדמות במיקום המתאים במטרה, שאינה תו כלשהו בטווח, 0 עד 9 כולל. אז הקוד הבא לא ייצור התאמה:

אם (regex_search('0123456789101112',regex('[^ 0-9]')))

עֲלוּת<< 'תואם' <<endl;

אַחֵר

עֲלוּת<< 'לא מתאים' <<endl;

ניתן למצוא ספרה בטווח 0 עד 9 בכל אחת ממיקומי מחרוזת המטרה, 0123456789101112 ,; כך שאין התאמה - שלילה.

הקוד הבא מייצר התאמה:

אם (regex_search('ABCDEFGHIJ',regex('[^ 0-9]')))

עֲלוּת<< 'תואם' <<endl;

לא נמצאה ספרה במטרה, ABCDEFGHIJ ,; אז יש התאמה.

[a-z] הוא טווח מחוץ [^a-z]. וכך [^א-ז] היא השלילה של [א-ז].

[A-Z] הוא טווח מחוץ [^A-Z]. וכך [^א-ז] היא השלילה של [א-ז].

קיימות שלילות אחרות.

מרחבים לבנים תואמים

'' או t או r או n או f הוא תו רווח לבן. בקוד הבא, regex, n תואם את ' n' ביעד:

אם (regex_search('משורה אחת. r nמשורה שנייה '.,regex(' n')))

עֲלוּת<< 'תואם' <<endl;

התאמה לכל תו מרחב לבן

התבנית או המחלקה שיתאימו לכל תו שטח לבן הם, [ t r n f]. בקוד הבא, '' תואם:

אם (regex_search('אחת שתיים',regex('[ t r n f] ')))

עֲלוּת<< 'תואם' <<endl;

התאמה לכל תו שאינו מרחב לבן

התבנית או המעמד המתאימים לכל תו רווח שאינו לבן הוא, [^ t r n f]. הקוד הבא מייצר התאמה כיוון שאין מרחב לבן ביעד:

אם (regex_search('1234abcd',regex('[^ t r n f] ')))

עֲלוּת<< 'תואם' <<endl;

התקופה (.) בתבנית

התקופה (.) בתבנית תואמת כל תו הכולל את עצמו, למעט n, במטרה. התאמה מופקת בקוד הבא:

אם (regex_search('1234abcd',regex('.')))

עֲלוּת<< 'תואם' <<endl;

אין תוצאות תואמות בקוד הבא מכיוון שהיעד הוא n.

אם (regex_search(' n',regex('.')))

עֲלוּת<< 'תואם' <<endl;

אַחֵר

עֲלוּת<< 'לא מתאים' <<endl;

הערה: בתוך מחלקת תווים עם סוגריים מרובעים, לתקופה אין משמעות מיוחדת.

החזרות תואמות

תו או קבוצת תווים יכולים להופיע יותר מפעם אחת בתוך מחרוזת היעד. דפוס יכול להתאים לחזרה זו. המטא -תווים,?, *, +ו- {} משמשים להתאמה של החזרה ביעד. אם x הוא תו של עניין במחרוזת המטרה, אז למטא -תווים יש את המשמעויות הבאות:

איקס*:פירושו התאמה'איקס' 0או יותר פעמים,אני.וכן.,כל מספר פעמים

איקס+:פירושו התאמה'איקס' 1או יותר פעמים,אני.וכן.,לפחות פעם אחת

איקס? :פירושו התאמה'איקס' 0אוֹ1 זְמַן

איקס{נ,}:פירושו התאמה'איקס'לפחות n או יותר פעמים.הערההפסיק.

איקס{נ} :התאמה'איקס'פעמים n בדיוק

איקס{נ,M}:התאמה'איקס'לפחות n פעמים,אך לא יותר מ- פעמים.

מטא -דמויות אלה נקראות כימות.

איורים

*

ה- * תואם את התו הקודם או את הקבוצה הקודמת, אפס או יותר פעמים. o* תואם 'o' בכלב של מחרוזת המטרה. זה גם תואם oo בספר ובמראה. Regex, o* תואם boooo ב בעלי החיים booooed .. הערה: o* התאמות dig, כאשר 'o' מתרחשת זמן אפס (או יותר).

+

ה- + תואם את התו הקודם או את הקבוצה הקודמת, פעם אחת או יותר. בניגוד לזה עם אפס או יותר פעמים עבור *. אז regex, e+ תואם את 'e' באכילה, כאשר 'e' מתרחש פעם אחת. e+ תואם גם ee בכבשים, כאשר 'e' מופיע יותר מפעם אחת. הערה: e+ לא יתאים לחפירה מכיוון שבחפירה, 'e' אינו מתרחש לפחות פעם אחת.

?

ה ? תואם את הדמות הקודמת או את הקבוצה הקודמת, 0 או פעם אחת (ולא יותר). אז, ה? התאמות חופרות כי 'e' מופיע בחפירה, זמן אפס. ה? התאמות שנקבעו מכיוון 'e' מופיע בסט, פעם אחת. הערה: ה? עדיין תואם כבשים; למרות שיש שני 'e' בכבשים. יש כאן ניואנס - ראה בהמשך.

{n,}

זה תואם לפחות n חזרות רצופות של דמות קודמת או קבוצה קודמת. אז regex, e {2,} תואם את שני ה- e במטרה, הכבשים ושלושת ה- e בכבשת המטרה. e {2,} אינו תואם קבוצה, כי לסט יש רק 'e'.

{n}

זה תואם בדיוק n חזרות רצופות של דמות קודמת או קבוצה קודמת. אז regex, e {2} תואם את שני ה- e ביעד, כבשים. e {2} אינו תואם קבוצה מכיוון שלמערך יש רק 'e'. ובכן, e {2} תואם שני 'e' במטרה, כבשה. יש כאן ניואנס - ראה בהמשך.

{n, m}

זה תואם מספר חזרות רצופות של דמות קודמת או קבוצה קודמת, בכל מקום בין n ל- m, כולל. אז e {1,3} לא תואם דבר בחפירה, שאין לה 'e'. הוא תואם את ה'א 'בסט, את שני ה'כבשים', את שלושת ה'כבשה ושלוש 'ה' בכבשה. יש ניואנס במשחק האחרון - ראה בהמשך.

חלופה תואמת

שקול את מחרוזת היעד הבאה במחשב.

בחווה יש חזירים בגדלים שונים.

המתכנת ירצה לדעת אם למטרה זו יש עז או ארנב או חזיר. הקוד יהיה כדלקמן:

לְהַשְׁחִירעמ[] = 'בחווה יש חזירים בגדלים שונים'.;

אם (regex_search(עמ,regex('עז | ארנב | חזיר')))

עֲלוּת<< 'תואם' <<endl;

אַחֵר

עֲלוּת<< 'לא מתאים' <<endl;

הקוד מייצר התאמה. שימו לב לשימוש בתו החלופה, |. יכולות להיות שתיים, שלוש, ארבע ואפשרויות נוספות. C ++ ינסה תחילה להתאים את החלופה הראשונה, עז, בכל מיקום תו במחרוזת המטרה. אם זה לא מצליח עם עז, הוא מנסה את האלטרנטיבה הבאה, ארנב. אם זה לא מצליח עם ארנב, הוא מנסה את האלטרנטיבה הבאה, חזיר. אם חזיר נכשל, אז C ++ עובר למיקום הבא במטרה ומתחיל שוב בחלופה הראשונה.

בקוד לעיל, חזיר מותאם.

התאמה בין התחלה או סוף

התחלה


אם ^ נמצא בתחילת regex, ניתן להתאים את הטקסט ההתחלתי של מחרוזת היעד לפי regex. בקוד הבא, ההתחלה של היעד היא abc, שתואם:

אם (regex_search('abc ו- def',regex('^ abc')))

עֲלוּת<< 'תואם' <<endl;

לא מתקיימת התאמה בקוד הבא:

אם (regex_search('כן, abc ו- def',regex('^ abc')))

עֲלוּת<< 'תואם' <<endl;

אַחֵר

עֲלוּת<< 'לא מתאים' <<endl;

כאן, abc אינה בתחילת המטרה.

הערה: התו של הסיבוב, '^', הוא מטא -אופי בתחילת ה- regex, התואם את תחילת מחרוזת המטרה. הוא עדיין מטא -דמות בתחילת מחלקת התווים, שם הוא שולל את המעמד.

סוֹף

אם $ נמצא בסוף regex, ניתן להתאים את טקסט הסיום של מחרוזת היעד לפי regex. בקוד הבא, סוף היעד הוא xyz, המתואם:

אם (regex_search('uvw ו- xyz',regex('xyz $')))

עֲלוּת<< 'תואם' <<endl;

לא מתקיימת התאמה בקוד הבא:

אם (regex_search('uvw ו- xyz final',regex('xyz $')))

עֲלוּת<< 'תואם' <<endl;

אַחֵר

עֲלוּת<< 'לא מתאים' <<endl;

כאן, xyz אינו בסוף המטרה.

הַקבָּצָה

ניתן להשתמש בסוגריים לקיבוץ דמויות בתבנית. שקול את הרקס -ביטוי הבא:

'קונצרט (פסנתרן)'

הקבוצה כאן היא פסנתרנית מוקפת במטא -דמויות (ו). למעשה מדובר בקבוצת משנה, בעוד קונצרט (פסנתרן) הוא כל החבורה. שקול את הדברים הבאים:

'(הפסנתרן טוב)'

כאן, תת-הקבוצה או מחרוזת המשנה היא, פסנתרן הוא טוב.

מחרוזות משנה עם חלקים נפוצים

מנהל חשבונות הוא אדם שדואג לספרים. תארו לעצמכם ספרייה עם מנהל חשבונות ומדף ספרים. נניח שאחת ממחרוזות היעד הבאות נמצאת במחשב:

'לספרייה יש מדף ספרים שמעריצים אותו.';

'הנה מנהל החשבונות.';

'מנהל החשבונות עובד עם מדף הספרים.';

נניח שהאינטרס של המתכנת הוא לא לדעת איזה מהמשפטים האלה נמצא במחשב. ובכל זאת, האינטרס שלו הוא לדעת אם מדף ספרים או מנהל ספרים קיים בכל מחרוזת המטרה במחשב. במקרה זה, regex שלו יכול להיות:

'מדף ספרים | מנהל חשבונות.'

שימוש בסירוגין.

שימו לב שהספר, המשותף לשתי המילים, הוקלד פעמיים, בשתי המילים בתבנית. כדי להימנע מהקלדת ספר פעמיים, הרקס יהיה כתוב טוב יותר כך:

'ספר (מדף | שומר)'

כאן הקבוצה, המדף | שומר המטא -אופי החליפין עדיין בשימוש, אך לא במשך שתי מילים ארוכות. הוא שימש את שני חלקי הסיום של שתי המילים הארוכות. C ++ מתייחס לקבוצה כישות. אז, C ++ יחפש מדף או שומר שיגיע מיד לאחר הספר. הפלט של הקוד הבא תואם:

לְהַשְׁחִירעמ[] = 'לספרייה יש מדף ספרים שמעריצים אותו'.;

אם (regex_search(עמ,regex('ספר (מדף | שומר)')))

עֲלוּת<< 'תואם' <<endl;

מדף הספרים ולא מנהל החשבונות תואמו.

ה- regase_constants של icase ו- multi -line

icase

ההתאמה תלויה ברישיות כברירת מחדל. עם זאת, ניתן להפוך אותו לחסר רגישות. כדי להשיג זאת, השתמש בקבוע regex :: icase, כמו בקוד הבא:

אם (regex_search('מָשׁוֹב',regex('הזנה',regex::icase)))

עֲלוּת<< 'תואם' <<endl;

הפלט תואם. אז משוב עם רישיות 'F' הותאם לפיד עם 'f' באותיות קטנות. regex :: icase הופך לטיעון השני של הבונה regex (). בלי זה, ההצהרה לא תייצר התאמה.

Multiline

שקול את הקוד הבא:

לְהַשְׁחִירעמ[] = 'שורה 1 nשורה 2 nשורה 3 ';

אם (regex_search(עמ,regex('^. * $')))

עֲלוּת<< 'תואם' <<endl;

אַחֵר

עֲלוּת<< 'לא מתאים' <<endl;

הפלט אינו תואם. ה- regex, ^.*$, תואם את מחרוזת היעד מתחילתה ועד סופה. .* פירושו כל תו למעט n, אפס או יותר פעמים. לכן, בגלל התווים החדשים ( n) ביעד, לא הייתה התאמה.

המטרה היא מחרוזת מרובת שורות. על מנת ש'. 'יתאים לדמות הליין החדשה, יש לבצע את regex הקבוע :: ריבוי שורות, הטיעון השני של הבנייה regex (). הקוד הבא ממחיש זאת:

לְהַשְׁחִירעמ[] = 'שורה 1 nשורה 2 nשורה 3 ';

אם (regex_search(עמ,regex('^. * $',regex::רב קו)))

עֲלוּת<< 'תואם' <<endl;

אַחֵר

עֲלוּת<< 'לא מתאים' <<endl;

התאמת מחרוזת המטרה השלמה

כדי להתאים את כל מחרוזת היעד, שאין לה את התו קו חדש ( n), ניתן להשתמש בפונקציה regex_match (). פונקציה זו שונה מ- regex_search (). הקוד הבא ממחיש זאת:

לְהַשְׁחִירעמ[] = 'ראשון שני שלישי';

אם (regex_match(עמ,regex('.*שְׁנִיָה.*')))

עֲלוּת<< 'תואם' <<endl;

יש כאן התאמה. עם זאת, שים לב שהרגקס תואם את כל מחרוזת היעד, ולמחרוזת היעד אין ' n'.

אובייקט match_results

הפונקציה regex_search () יכולה לקחת ויכוח בין היעד לאובייקט regex. טיעון זה הוא אובייקט match_results. ניתן להכיר איתו את כל המחרוזת (החלק) המותאמת ואת מחרוזות המשנה המותאמות. אובייקט זה הוא מערך מיוחד עם שיטות. סוג האובייקט match_results הוא cmatch (עבור מילולי מחרוזות).

קבלת התאמות

שקול את הקוד הבא:

לְהַשְׁחִירעמ[] = 'האישה שחיפשת!';

cmatch מ;

אם (regex_search(עמ,M,regex('w.m.n')))

עֲלוּת<<M[0] <<endl;

במחרוזת המטרה יש את המילה אישה. התפוקה היא אישה ', המתאימה לרגקס, w.m.n. במדד אפס, המערך המיוחד מחזיק בהתאמה היחידה שהיא אישה.

עם אפשרויות מחלקה, רק מחרוזת המשנה הראשונה שנמצאת במטרה נשלחת למערך המיוחד. הקוד הבא ממחיש זאת:

cmatch מ;

אם (regex_search('החולדה, החתול, העטלף!',M,regex('[bcr] ב-')))

עֲלוּת<<M[0] <<endl;

עֲלוּת<<M[1] <<endl;

עֲלוּת<<M[2] <<endl;

התפוקה היא חולדה מהמדד אפס. מ [1] ו- m [2] ריקים.

עם חלופות, רק מחרוזת המשנה הראשונה שנמצאת במטרה נשלחת למערך המיוחד. הקוד הבא ממחיש זאת:

אם (regex_search('הארנב, העז, החזיר!',M,regex('עז | ארנב | חזיר')))

עֲלוּת<<M[0] <<endl;

עֲלוּת<<M[1] <<endl;

עֲלוּת<<M[2] <<endl;

התפוקה היא ארנב מהמדד אפס. מ [1] ו- m [2] ריקים.

קיבוצים

כאשר מעורבות קבוצות, הדפוס השלם תואם, נכנס לתא אפס של המערך המיוחד. מחרוזת המשנה הבאה שנמצאת נכנסת לתא 1; מחרוזת המשנה הבאה, נכנסת לתא 2; וכן הלאה. הקוד הבא ממחיש זאת:

אם (regex_search('מוכר הספרים הטוב ביותר היום!',M,regex('מוכר ספרים))')))

עֲלוּת<<M[0] <<endl;

עֲלוּת<<M[1] <<endl;

עֲלוּת<<M[2] <<endl;

עֲלוּת<<M[3] <<endl;

הפלט הוא:

מוכר ספרים

מוֹכֵר

תָא

לקרוא

שים לב שהקבוצה (המוכר) באה לפני הקבוצה (sel).

עמדת המשחק

ניתן לדעת את מיקום ההתאמה עבור כל מחרוזת משנה במערך ה- cmatch. הספירה מתחילה מהתו הראשון של מחרוזת המטרה, במיקום אפס. הקוד הבא ממחיש זאת:

cmatch מ;

אם (regex_search('מוכר הספרים הטוב ביותר היום!',M,regex('מוכר ספרים))')))

עֲלוּת<<M[0] << '->' <<M.עמדה(0) <<endl;

עֲלוּת<<M[1] << '->' <<M.עמדה(1) <<endl;

עֲלוּת<<M[2] << '->' <<M.עמדה(2) <<endl;

עֲלוּת<<M[3] << '->' <<M.עמדה(3) <<endl;

שימו לב לשימוש במאפיין המיקום, עם אינדקס התא, כארגומנט. הפלט הוא:

מוכר ספרים->5

מוֹכֵר->9

תָא->9

לקרוא->12

חפש והחליף

מילה או ביטוי חדשים יכולים להחליף את ההתאמה. הפונקציה regex_replace () משמשת לשם כך. עם זאת, הפעם, המחרוזת שבה ההחלפה מתרחשת היא אובייקט המחרוזת, ולא המחרוזת מילולית. לכן, ספריית המיתרים חייבת להיכלל בתוכנית. אִיוּר:

#לִכלוֹל

#לִכלוֹל

#לִכלוֹל

באמצעות מרחב שמות std;

intרָאשִׁי()
{
string str= 'הנה, מגיע האיש שלי. הנה איש שלך. ';
מחרוזת newStr=regex_replace(עמ,regex('איש'), 'אִשָׁה');
עֲלוּת<<newStr<<endl;

לַחֲזוֹר 0;
}

הפונקציה regex_replace (), כפי שהיא מקודדת כאן, מחליפה את כל ההתאמות. הטיעון הראשון של הפונקציה הוא המטרה, השני הוא אובייקט regex, והשלישי הוא מחרוזת ההחלפה. הפונקציה מחזירה מחרוזת חדשה, שהיא היעד אך בעלת ההחלפה. הפלט הוא:

הנה באה האישה שלי. הנה האישה שלך.

סיכום

הביטוי הרגיל משתמש בדפוסים להתאמת מצעים במחרוזת רצף היעד. לדפוסים יש דמויות מטא. הפונקציות הנפוצות לביטויים רגילים של C ++ הן: regex_search (), regex_match () ו- regex_replace (). Regex הוא תבנית במרכאות כפולות. עם זאת, פונקציות אלה לוקחות את אובייקט regex כטיעון ולא רק את regex. יש להפוך את regex לאובייקט regex לפני שפונקציות אלה יכולות להשתמש בו.