ב-C++, יש לנו את סוג נתוני המחרוזת ויכולים להחיל את הפונקציות השונות כדי לבצע את המשימות השונות עם המחרוזות. אנו יכולים לבדוק אם המחרוזת המשנה קיימת בתוך המחרוזת המקורית. אנו יכולים גם לומר שהמחרוזת מכילה את המחרוזת המשנה. במדריך זה נלמד את הטכניקות המסייעות לנו למצוא את 'המחרוזת מכילה את המחרוזת המשנה'. הפונקציות 'find()' ו-'strstr()' עוזרות לנו לבצע משימה זו בתכנות C++.
דוגמה 1:
ה-'iostream' וה-'string' הם קובצי הכותרת הכלולים כאן מכיוון שאנו צריכים לעבוד עם המחרוזות וגם צריכים להזין או להפיק את הנתונים. אז, אנחנו חייבים לכלול את קובצי הכותרות האלה כאן. לאחר מכן, אנו כוללים את 'מרחב השמות std' בעזרת מילת המפתח 'משתמש'. אז, אנחנו לא צריכים לשים את ה-'std' הזה עם כל הפונקציות בנפרד בקוד שלנו. לאחר מכן, הפונקציה 'main()' מופעלת כאן.
כעת, אנו מכריזים על המחרוזת 'str_1' ומקצים כמה נתוני מחרוזת למשתנה זה. לאחר מכן, אנו גם מאתחלים משתנה נוסף בשם 'str_2' מסוג הנתונים 'string' ומקצים 'like' למשתנה 'str_2' זה. מתחת לזה, אנו משתמשים במילת המפתח 'bool' כדי לתת תוצאות נכונות או שגויות. אנו מאתחלים את 'stringHasStr' עם סוג הנתונים 'bool' הזה ומשתמשים בפונקציה 'find()'. זה מחפש את 'מחרוזת מכילה את המחרוזת המשנה'. 'str_1' היא המחרוזת השלמה ו-'str_2' היא המחרוזת המשנה.
כאן, אנו גם מוסיפים את מילת המפתח 'npos' המשמשת כדי להראות שאין התאמות במחרוזת זו. הוא בודק אם המחרוזת מכילה מחרוזת משנה ומאחסן את התוצאה במשתנה bool 'stringHasStr' הזה.
לאחר מכן, אנו מתקדמים לכיוון התנאי 'אם' ומעבירים את המשתנה 'stringHasStr' הזה למצב 'אם' זה. אם התוצאה המאוחסנת במשתנה bool זה היא 'true', ההצהרה שאחרי תנאי 'if' זה משמשת כאשר אנו משתמשים ב-'cout' ומציגים את המחרוזת שנמצאת כאן. אבל אם התוצאה 'שקר' מאוחסנת במשתנה bool זה, החלק השני מופעל ומציג שהמחרוזת לא נמצאת כאן.
קוד 1:
#include#include
שימוש במרחב שמות std;
int main ( )
{
מחרוזת str_1 = 'אני אוהב שפת תכנות C++' ;
מחרוזת str_2 = 'כמו' ;
bool stringHasStr = str_1.find ( str_2 ) ! = מחרוזת::npos;
אם ( stringHasStr ) {
cout << 'אנחנו מוצאים את המחרוזת כאן שהיא' << str_2 << endl;
}
אַחֵר {
cout << 'המחרוזת לא נמצאה' << endl;
}
לַחֲזוֹר 0 ;
}
תְפוּקָה:
פלט נתון זה גורם לכך שהמחרוזת מכילה את המחרוזת המשנה ומציגה אותה כאן. אנו בודקים זאת על ידי שימוש בפונקציה 'find()'.
דוגמה 2:
אנו כוללים כאן שלושה קובצי כותרת שהם 'iostream', 'string' ו-'cstring'. לאחר מכן, הפעל את ה-'main()' לאחר הצבת ה-'namespace std'. המחרוזת 'new_str' מוצהרת כעת וחלק מנתוני המחרוזת מוקצים.
לאחר מכן, אנו מאתחלים משתנה שני מסוג הנתונים 'מחרוזת' בשם 'sub_str' ונותנים לו את הערך 'מאוד'. לאחר מכן, אנו מניחים את 'const char*'. לכן, שינוי ערך המצביע כך שיצביע על המיקום השני בזיכרון הוא בלתי אפשרי. אנו מכריזים על המשתנה 'FindingStr' כמצביע 'const char*' הזה כאן. אנו מאתחלים אותו בשיטת 'strstr()' ומעבירים את שתי המחרוזות יחד עם הפונקציה 'c_str()' שהופכת מחרוזת למערך תווים שמסתיים בערך null. שיטת 'strstr()' זו מסייעת בבדיקה אם המחרוזת 'new_str' מכילה את תת המחרוזת 'sub_str' או לא. לאחר מכן, יש לנו 'אם' שבו נוסיף את ה-'FindingStr'. אם הוא מוצא את המחרוזת המשנה במקור, ההצהרה אחרי 'if' מבוצעת במקום בו אנו משתמשים ב-'cout'. אם המחרוזת המשנה לא נמצאת, היא נעה ישירות לכיוון החלק 'אחר' ומדפיסה את התוצאה שממוקמת אחרי החלק 'אחר'.
קוד 2:
#include#include
#include
שימוש במרחב שמות std;
int main ( )
{
מחרוזת new_str = 'יורד גשם בחוץ ומזג האוויר נעים מאוד'. ;
מחרוזת sub_str = 'מאוד' ;
const char * FindingStr = strstr ( new_str.c_str ( ) , sub_str.c_str ( ) ) ;
אם ( FindingStr ) {
cout << 'אנחנו מוצאים את המחרוזת והמחרוזת היא:' << sub_str << endl;
}
אַחֵר {
cout << 'מחרוזת לא נמצאה' << endl;
}
לַחֲזוֹר 0 ;
}
תְפוּקָה:
אנו עשויים לשים לב שהמחרוזת הנתונה מכילה את המחרוזת המשנה מכיוון שהיא מציגה את ההצהרה שהוספנו אחרי 'if' ומדפיסה את המחרוזת המשנה כאן. אנו בודקים זאת על ידי שימוש בפונקציה 'strstr()'.
דוגמה 3:
אנו מאתחלים כאן שני משתני מחרוזת: 'myNewStr' ו-'mySubStr'. לאחר מכן, אנו מקצים כמה נתוני מחרוזת ומצהירים על שני משתנים שלמים: 'posOfStr' ו-'indexOfStr'.
מתחת לזה, אנו משתמשים בלולאת 'while()' ומקצים את משתנה הפונקציה 'find()' למשתנה 'indexOfStr' בתוך לולאת 'while()' זו. אנו מעבירים שני משתנים לפונקציית 'find()' זו שהם 'mySubStr' ו-'posOfStr'. לאחר מכן, אנו מניחים את מילת המפתח 'npos' אשר בודקת שהתוצאה של הפונקציה 'מצא' אינה שווה ל-'npos'. לאחר מכן, אנו משתמשים ב-'cout' שמגדיל את ערך האינדקס באחד ומאחסן אותו במשתנה 'posOfStr'.
קוד 3:
#include#include
שימוש במרחב שמות std;
int main ( ) {
מחרוזת myNewStr = 'אנחנו מוצאים את המחרוזת כאן' ;
מחרוזת mySubStr = 'חוּט' ;
int posOfStr = 0 ;
int indexOfStr;
בזמן ( ( indexOfStr = myNewStr.find ( mySubStr, posOfStr ) ) ! = מחרוזת::npos ) {
cout << 'מחרוזת המשנה היא' << ''' << mySubStr << ''' << 'נמצא במספר אינדקס:' << indexOfStr << endl;
posOfStr = indexOfStr + 1 ;
}
לַחֲזוֹר 0 ;
}
תְפוּקָה:
כאן, זה מראה שהמחרוזת הנתונה מכילה את המחרוזת המשנה ומספר האינדקס של המחרוזת הזו הוא '19' שמוצג גם בתוצאה זו.
דוגמה 4:
בקוד זה, אנו כוללים את קובץ הכותרת 'bits/stdc++.h'. כעת, איננו צריכים לכלול קובצי כותרות אחרים מכיוון שהם מכילים את כל הספריות הנדרשות. לאחר הפעלת ה-'main()', אנו מאתחלים את המשתנים 'org_str' ו-'sub_str' מסוג הנתונים 'מחרוזת'. לאחר מכן, נוסיף את התנאי 'if' שבו אנו משתמשים בפונקציה 'strstr()'. פונקציה זו מחפשת לראות אם המחרוזת הנתונה מכילה את המחרוזת המשנה הרצויה. לאחר מכן, נוסיף משפט 'cout' כדי להדפיס שמחרוזת המשנה נמצאת כאן. לאחר מכן, אנו שמים גם את החלק 'else' שמתבצע רק כאשר תנאי ה'אם' אינו מתקיים או שתת המחרוזת לא נמצאת במחרוזת.
לאחר מכן, אנו מכריזים על המשתנה 'sub_str2' ומקצים כאן נתוני מחרוזת. לאחר מכן התנאי 'אם' מוכנס, והפונקציה 'strstr()' משמשת. שיטה זו מחפשת אם המחרוזת שסופקה מכילה את המחרוזת המשנה המבוקשת או לא. התוצאה מודפסת כאן באמצעות הפקודה 'cout'. אנו כוללים גם קטע 'אחר' שמופעל רק אם התנאי 'אם' אינו מתקיים או אם לא ניתן לאתר את המחרוזת המשנה במחרוזת.
קוד 4:
#includeשימוש במרחב שמות std;
int main ( ) {
מחרוזת org_str = 'שפת תכנות C++' ;
מחרוזת sub_str = 'תכנית' ;
אם ( strstr ( org_str.c_str ( ) ,sub_str.c_str ( ) ) )
{
cout << 'מחרוזת המשנה כאן היא' << ''' << sub_str << ''' << 'נוכח ב' << org_str << endl;
}
אַחֵר {
cout << 'מחרוזת משנה אינה קיימת במחרוזת.' << endl;
}
מחרוזת sub_str2 = 'ג'אווה' ;
אם ( strstr ( org_str.c_str ( ) ,sub_str2.c_str ( ) ) )
{
cout << 'מחרוזת המשנה כאן היא' << ''' << sub_str2 << ''' << 'נוכח ב' << org_str << endl;
}
אַחֵר {
cout << 'מחרוזת משנה אינה קיימת במחרוזת זו.' << endl;
}
לַחֲזוֹר 0 ;
}
תְפוּקָה:
התוצאה של הפונקציה 'strstr()' הראשונה מראה שהמחרוזת מכילה את המחרוזת, אבל התוצאה השנייה של הפונקציה 'strstr()' מראה שתת המחרוזת אינה קיימת במחרוזת.
סיכום
המושג 'מחרוזת מכילה את המחרוזת' נבדק ביסודיות במדריך זה. בדקנו שתי שיטות המסייעות בחיפוש אם 'המחרוזת מכילה את המחרוזת המשנה'. הסברנו את הפונקציות 'find()' כמו גם את הפונקציות 'strstr()' ש-C++ מספק כאן במדריך זה לביצוע משימה זו. אנו מדגים בעזרת דוגמאות ייחודיות בהן למדנו כיצד להשתמש בפונקציות הללו כדי לבדוק האם 'המחרוזת מכילה את המחרוזת המשנה' בה.