דוגמה 1:
במצב זה, עלינו לעבוד עם מחרוזות ונתוני קלט או פלט, כך שקובצי הכותרת 'iostream' ו-'string' מסופקים. לפיכך, קבצי כותרות אלה צריכים להיכלל כאן. לאחר מכן, איננו צריכים יותר לכלול את ה-'std' הזה עם כל פונקציה באופן עצמאי בקוד שלנו, כי כבר כללנו את 'שם-space std' בעזרת מילת המפתח 'using'. כאן נקראת הפונקציה 'main()'. לאחר מכן, המשתנה 'מחרוזת' בשם 'originalString' מאותחל עם מחרוזת כלשהי. לאחר מכן, אנו מאתחלים משתנה 'מחרוזת' נוסף בשם 'מילה' עם C++.
כעת, מתחת לזה, אנו משתמשים ב-'cout' ומדפיסים את המחרוזת המקורית. לאחר מכן, אנו מכריזים על 'int Result' וממקמים את הפונקציה 'contains()' כדי לבדוק אם ה-'originalString' מכיל את ה'מילה' או לא. אנו מניחים 'אם' מתחתיו,. אנו מעבירים את ה'תוצאה' ל'אם'. אם המחרוזת המקורית מכילה את המחרוזת המשנה, היא מציגה את ההצהרה שהוספנו אחרי 'if'. במקרה שבו המחרוזת אינה מכילה את המחרוזת המשנה, ההצהרה שמוצגת לאחר 'else' תוצג.
קוד 1:
#include#include
באמצעות מרחב שמות std ;
int רָאשִׁי ( )
{
מחרוזת originalString = 'אני אוהב תכנות C++' ;
מילת מחרוזת = 'C++' ;
cout << 'המחרוזת היא =' << OriginalString << endl << endl ;
int תוֹצָאָה = OriginalString. מכיל ( מִלָה ) ;
אם ( תוֹצָאָה )
{
cout << 'המילה שנמצאה במחרוזת שהיא = ' << מִלָה << endl ;
}
אַחֵר
{
cout << 'המילה לא נמצאה במחרוזת' << endl ;
}
לַחֲזוֹר 0 ;
}
תְפוּקָה:
תוצאה זו מראה שתת המחרוזת שאנו מוצאים במחרוזת המקורית בעזרת הפונקציה contains() נמצאת בתוך המחרוזת המקורית ומוצגת כאן.
דוגמה 2:
ה-'iostream' וה-'string' הם קובצי הכותרת שייבאנו בקוד זה. מרחב השמות 'std' כלול גם הוא. לאחר מכן, main() נקרא כאן. לאחר מכן, אנו מאתחלים את המשתנה 'מחרוזת' שנקרא 'str_1' על ידי הוספת כמה נתוני מחרוזת. להלן, אנו מאתחלים את המשתנה 'מחרוזת' הנקרא 'str_2' עם 'גשם'.
מתחת לזה, אנו מדפיסים את המחרוזת המקורית באמצעות הפונקציה 'cout'. כדי לקבוע אם 'str_2' קיים ב-'str_1' או לא, אנו מכריזים על 'int Outcome' ומכניסים את המתודה contains() כאן. למטה, אנו מניחים את ה'אם' ומעבירים את ה'תוצאה' ל'אם'. אנו מוסיפים את המשפט 'cout' לאחר העיבוד של 'if' אם המחרוזת המקורית כוללת את המחרוזת המשנה. אחרת, הצהרת 'cout' שמגיעה אחרי 'אחר' תוצג.
קוד 2:
#include#include
באמצעות מרחב שמות std ;
int רָאשִׁי ( )
{
מחרוזת str_1 = 'מזג האוויר קריר בחוץ' ;
מחרוזת str_2 = 'גֶשֶׁם' ;
cout << 'המחרוזת היא =' << str_1 << endl << endl ;
int תוֹצָאָה = str_1. מכיל ( str_2 ) ;
אם ( תוֹצָאָה )
{
cout << 'המילה שנמצאה במחרוזת שהיא = ' << str_2 << endl ;
}
אַחֵר
{
cout << 'המילה לא נמצאה במחרוזת' << endl ;
}
לַחֲזוֹר 0 ;
}
תְפוּקָה:
זה יוצר שהמחרוזת המשנה שאנו מוצאים במחרוזת המקורית בעזרת שימוש בפונקציה contains() לא נמצאת בתוך המחרוזת המקורית ומוצגת כאן כתוצאה מכך.
דוגמה 3:
אנו מייבאים את קובצי הכותרת 'iostream' ו-'string' בקוד זה. לאחר מכן, מתחת לזה, אנו משתמשים ב-'Namespace std'. לאחר מכן, main() מופעל כאן. כעת, אנו מאתחלים את שני המשתנים של סוג הנתונים 'string' עם השמות 'myString_1' ו-'myString_2', בהתאמה, ומקצים את המחרוזת המקורית ממנה אנו רוצים למצוא את המחרוזת המשנה למשתנה 'myString_1' והמחרוזת המשנה מוקצית. למשתנה 'myString_2'.
לאחר מכן, אנו מציגים את המחרוזת המקורית על ידי הכנסת 'myString_1' במשפט 'cout' ולאחר מכן הצבת 'if' שבה אנו משתמשים בשיטת 'contains()' הבודקת אם המחרוזת הנתונה מכילה את המחרוזת המשנה. אם המחרוזת המשנה קיימת במחרוזת המקורית, בעזרת 'cout', אנו מעבדים את התוצאה.
אנו מציבים שתי הצהרות 'cout' שבהן האחת ממוקמת אחרי 'אם' והשנייה מתווספת אחרי החלק 'אחר'. אם המחרוזת המקורית מכילה את המחרוזת המשנה, ה-'cout' אחרי 'if' יעובד. אם המחרוזת המשנה לא נמצאת או שלמחרוזת המקורית אין את המחרוזת המשנה, ה-'cout' אחרי 'else' יעובד.
קוד 3:
#include#include
באמצעות מרחב שמות std ;
int רָאשִׁי ( )
{
מחרוזת myString_1 = 'היי! שלום עולם' ;
מחרוזת myString_2 = 'שלום' ;
cout << 'המחרוזת השלמה היא' << myString_1 << endl ;
אם ( myString_1. מכיל ( myString_2 ) ) {
cout << 'המחרוזת שנמצאה =' << myString_2 << endl ;
}
אַחֵר {
cout << 'המחרוזת לא נמצאת כאן' << endl ;
}
לַחֲזוֹר 0 ;
}
תְפוּקָה:
תוצאה זו מדגימה שתת המחרוזת שאנו מחפשים בתוך המחרוזת המקורית באמצעות המתודה contains() ממוקמת בתוך המחרוזת המקורית והיא מוצגת כאן.
דוגמה 4:
קובצי הכותרת 'iostream' ו-'string' מיובאים לקוד זה. הפונקציה main() נקראת כאן לאחר שאנו משתמשים ב-'namespace std' שמתחתיו. האתחולים של שני המשתנים מסוג הנתונים 'מחרוזת' נקראים 's_1' ו-'s_2', בהתאמה. המחרוזת המקורית שממנה אנו רוצים לגלות את המחרוזת משנה מוקצית כעת למשתנה 's_1', והמחרוזת המשנה ניתנת למשתנה 's_2'. המחרוזת המקורית מוצגת לאחר מכן על ידי הוספת 's_1' להצהרת 'cout'.
לאחר מכן, נוסיף את פסקת 'if' שבה אנו משתמשים בשיטת contains() כדי לקבוע אם המחרוזת שסופקה מכילה את המחרוזת המשנה. אנו מעבדים את הפלט באמצעות 'cout' אם המחרוזת המשנה קיימת במחרוזת המקורית. מתווספות שתי הצהרות 'cout', אחת אחרי 'אם' ואחרת אחרי החלק 'אחר' של הקוד. ה-'cout' שלאחר 'if' מוצג אם המחרוזת המשנה קיימת במחרוזת המקורית. אחרת, ה-'cout' אחרי 'else' יוצג אם לא ניתן לאתר את המחרוזת המשנה במחרוזת המקורית.
קוד 4:
#include#include
באמצעות מרחב שמות std ;
int רָאשִׁי ( )
{
מחרוזת s_1 = 'היי! אני ג'ק כאן' ;
מחרוזת s_2 = 'פיטר' ;
cout << 'המחרוזת השלמה היא =' << s_1 << endl ;
אם ( s_1. מכיל ( s_2 ) ) {
cout << 'המחרוזת שנמצאה =' << s_2 << endl ;
}
אַחֵר {
cout << 'המחרוזת לא נמצאה =' << s_2 << endl ;
}
לַחֲזוֹר 0 ;
}
תְפוּקָה:
כפי שניתן לראות מתוצאה זו, המחרוזת המשנה שחיפשנו בתוך הטקסט המקורי באמצעות המתודה contains() לא נמצאת בקוד.
דוגמה 5:
כאן, נשתמש בספריית 'הדחף' ונמצא אם המחרוזת מכילה את המחרוזת המשנה או לא. בשיטת 'בוסט' זו, אנו משתמשים גם בפונקציה contains() . לכן, אנו כוללים גם את קובץ הכותרת 'boost/algorithm/string.hpp' יחד עם קובצי הכותרת 'iostream' ו-'string' בקוד זה. לאחר מכן נמקם את ה-'std' ונפעיל את השיטה main() כאן.
לאחר מכן, אנו מכריזים על המשתנים שהם 'StringData1' ו- 'StringData2' מסוג הנתונים 'מחרוזת' ומאתחלים כאן את נתוני המחרוזת. המשתנה 'c_result' של סוג הנתונים 'bool' מאותחל עם ה-'boost::algorithm::contains()' ואנו מעבירים את 'StringData1' ו-'StringData2' לפונקציה הזו. זה גם מוצא את המחרוזת המשנה במחרוזת המקורית ומאחסן את התוצאה הבוליאנית במשתנה 'c_result'.
כעת, אנו ממקמים את ה-'c_result==1' ב-'if' למטה. אם הערך הבוליאני של 'c_result' הוא '1', ההצהרה אחרי 'if' מוצגת. אחרת, הוא נע לעבר החלק 'אחר' ומדלג על ההצהרה שנמצאת אחרי 'אם' ומציג את ההצהרה של החלק 'אחר'.
קוד 5:
#include#include
#include
באמצעות מרחב שמות std ;
int רָאשִׁי ( ) {
מחרוזת StringData1 = 'התוכנית הראשונה שלי' ;
מחרוזת StringData2 = 'ראשון' ;
bool c_result = לְהַגבִּיר :: אַלגוֹרִיתְם :: מכיל ( StringData1 , StringData2 ) ;
אם ( c_result == 1 )
{
cout << 'המיתר ' << ''' << StringData1 << ''' << 'מכיל' << StringData2 << endl ;
}
אַחֵר
{
cout << 'המילה הנתונה אינה קיימת במחרוזת.' ;
}
לַחֲזוֹר 0 ;
}
תְפוּקָה:
המחרוזת המשנה נמצאת כעת במחרוזת המקורית שאנו יכולים לראות בתוצאה זו.
סיכום
בדקנו בפירוט את שיטת contains() שסופקה על ידי שפת C++. הזכרנו גם שהפונקציה contains() זמינה רק ב-'C+++ 23'. בדקנו האם הפונקציה contains() מסייעת למצוא את המחרוזת המשנה במחרוזת המקורית או אם היא מסייעת בבדיקה אם המחרוזת מכילה את המחרוזת משנה או לא ורינדרנו את התוצאה בהתאם.