טכניקות להיפוך מחרוזת בתכנות C++
בהתאם למפרטי הקוד שאנו מפתחים, קיימות מספר טכניקות ליישום היפוך מחרוזת בתכנות C++. טכניקות אלו הן:
- שימוש בשיטת 'reverse()'.
- שימוש בשיטת 'strrev()'.
- ניצול לולאת 'עבור'.
- ניצול לולאת 'בזמן'.
- שימוש בקונסטרוקטור
דוגמה 1:
ראשית, אנו מייבאים שלושה קובצי כותרת נפרדים שהם 'אלגוריתם', 'iostream' ו-'מחרוזת'. עלינו לכלול את קובצי הכותרות הללו כדי שנשתמש בפונקציות המוגדרות בהם. קובץ הכותרות 'אלגוריתם' כולל מספר רב של פונקציות מובנות לאיתור, מיון, ספירה, שינוי וכו' העומדות לרשותנו.
לאחר מכן, ה- 'iostream' מספק פונקציות להזנה או פלט של הנתונים, וקובץ הכותרת 'מחרוזת' כלול מכיוון שהוא מספק את הפונקציות הדרושות בזמן העבודה עם נתוני המחרוזת. מתחת לקובצי הכותרות הללו, אנו מוסיפים את מרחב השמות 'std'. כאן אנו מפעילים את הפונקציה 'main()'.
לאחר מכן, אנו מניחים את סוג הנתונים 'מחרוזת' ומאתחלים כאן את ה-'originalStr' עם כמה נתוני מחרוזת. לאחר מכן, נדפיס את המחרוזת הזו. לאחר מכן, אנו משתמשים בשיטת 'reverse()' המסייעת בהיפוך המחרוזת. בשיטת 'reverse()' זו, אנו מוסיפים את 'begin()' ו-'end()' יחד עם המשתנה 'originalStr'. כעת, אנו מדפיסים גם מחרוזת הפוכה זו שאנו מקבלים לאחר החלת שיטת 'reverse()'.
קוד 1:
#include <אלגוריתם>
#include
#include
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( )
{
מחרוזת originalStr = 'היפוך מחרוזת בתכנות C++' ;
cout << 'המחרוזת המקורית!' << endl ;
cout << originalStr << endl << endl ;
לַהֲפוֹך ( originalStr. התחל ( ) , originalStr. סוֹף ( ) ) ;
cout << 'המחרוזת הפוכה!' << endl ;
cout << originalStr ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
המחרוזת ההפוכה שאנו מקבלים לאחר החלת שיטת 'reverse()' בקוד שלנו מוצגת כעת יחד עם המחרוזת המקורית.
דוגמה 2:
אנו כוללים תחילה את קבצי הכותרת ולאחר מכן מניחים את 'מרחב השמות std'. לאחר מכן, בשיטת 'main()', אנו מאתחלים את מערך התווים על ידי הצבת סוג הנתונים 'char' עם שם המשתנה 'Org_str' ומקלידים כאן את המחרוזת שברצוננו להפוך. לאחר מכן, אנו מעבדים את ה-'Org_str' הזה בעזרת 'cout'.
מתחת לזה, אנו משתמשים בשיטת 'strrev()' כדי להפוך את המחרוזת ולהעביר את 'Org_str' כפרמטר בפונקציה זו. כעת, המחרוזת מתהפכת כאן. לאחר מכן, אנו גם מעבדים את המיתר ההפוך בעזרת 'cout'.
קוד 2:
#include#include
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( )
{
לְהַשְׁחִיר Org_str [ ] = 'תוכנית היפוך מחרוזת' ;
cout << Org_str << endl << endl ;
strrev ( Org_str ) ;
cout << 'מחרוזת הפוכה' << endl ;
cout << Org_str ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
כאן מוצגות המחרוזות המקוריות וההפוכות שהשגנו משימוש בשיטת 'strrev()' בקוד שלנו.
דוגמה 3:
במקרה זה, קבצי הכותרות נכללים לפני הוספת 'מרחב השמות std'. לאחר מכן, ה-'main()' מופעל והמשתנה המחרוזת מתווסף בשם 'myOrgStr' ומתחיל עם נתוני המחרוזת.
לאחר מכן, אנו מכריזים גם על המשתנה 'int' 'a' ומעבדים את המחרוזת 'myOrgStr' באמצעות 'cout'. מתחת לזה, אנו משתמשים בלולאת 'for' שבה אנו מאתחלים את המשתנה 'a' עם 'myOrgStr.length() – 1' ולאחר מכן מניחים תנאי שהוא 'a >= 0' ומפחיתים אותו בערך של 'a' '. פעולה זו הופכת את המחרוזת שלנו ומאחסנת אותה ב-'myOrgStr[a]' וגם מציגה אותה כאשר אנו מניחים את 'myOrgStr[a]' בתוך ה-'cout'.
קוד 3:
#include#include
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( )
{
מחרוזת myOrgStr = 'שלום עולם!' ;
int א ;
cout << myOrgStr << endl << endl ;
cout << 'מחרוזת הפוכה' <= 0 ; א -- )
{
cout << myOrgStr [ א ] ;
}
לַחֲזוֹר 0 ;
}
תְפוּקָה:
זה מעבד גם את המחרוזות המקוריות וגם את המחרוזות ההפוכות שקיבלנו דרך הקוד שלנו בשיטת הלולאה 'for'.
דוגמה 4:
כאן, אנו מייבאים את קובץ הכותרת 'bits/stdc++.h' כך שלא נצטרך לייבא את קבצי הכותרת האחרים מכיוון שקובץ הכותרת הזה מכיל את כל ההגדרות של הפונקציה. לאחר מכן, נקליד את 'מרחב השמות std'. כאן, אנו יוצרים פונקציה בשם 'Rev()' בה נעביר את 'string& myString' כארגומנט של פונקציה זו. אנו יוצרים את הפונקציה הזו כאן כדי להפוך את המחרוזת.
בפונקציה זו, אנו מניחים את המשתנה 'S_len' מסוג הנתונים 'int' ומאתחלים אותו עם הפונקציה 'length()' על ידי הצבת 'myString' עם זה. לאחר מכן, יש לנו משתנה נוסף שהוא 'no' מסוג הנתונים 'int' ואתחול אותו עם 'S_len-1'.
מתחת לזה, מאתחל משתנה אחד נוסף ששמו 'a' מסוג הנתונים 'int'. כאן אנו משתמשים בלולאה 'while()' ומוסיפים 'a <= no' כתנאי. לאחר מכן, אנו משתמשים בשיטת 'swap()'. שיטת 'swap()' זו מסייעת בהחלפת נתוני המחרוזת ולאחר מכן מאתחלת את 'no' עם ה-'no -1'. אנו גם מאתחלים את 'a' עם 'a+1'.
לאחר מכן אנו מפעילים את ה-'main()' כאן בו אנו מאתחלים את המשתנה 'myString' עם נתוני המחרוזת ומדפיסים את המחרוזת הזו. לאחר מכן, אנו קוראים לפונקציה 'Rev()' שיצרנו בקוד הזה ונשים את 'myString' כפרמטר של הפונקציה הזו שהופכת את המחרוזת ואז מציגים את המחרוזת ההפוכה.
קוד 4:
#includeבאמצעות מרחב שמות סטד ;
בָּטֵל לְהַאִיץ ( חוּט & myString )
{
int S_len = myString. אורך ( ) ;
int לא = S_len - 1 ;
int א = 0 ;
בזמן ( א <= לא ) {
לְהַחלִיף ( myString [ א ] ,myString [ לא ] ) ;
לא = לא - 1 ;
א = א + 1 ;
}
}
int רָאשִׁי ( )
{
מחרוזת myString = 'אני אוהב תכנות' ;
cout << myString << endl ;
cout << ' \n מחרוזת הפוכה' << endl ;
לְהַאִיץ ( myString ) ;
cout << myString ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
כאן, אנו מציגים גם את המחרוזת המקורית וגם את המחרוזת ההפוכה שקיבלנו על ידי שימוש בלולאת 'while()' ובשיטת 'swap()' בתוך הפונקציה שיצרנו בקוד שלנו.
דוגמה 5:
אנו מייבאים את קובץ הכותרת 'bits/stdc++.h' עם כל הגדרות הפונקציה. לכן, איננו צריכים לייבא קבצי כותרות אחרים. לאחר מכן, נזין את 'מרחב השמות std' ונקרא ל-'main()' כאן. לאחר מכן, יש לנו משתנה 'נתונים' מסוג הנתונים 'מחרוזת' ואתחול אותו עם המחרוזת שברצוננו להפוך.
אנו מעבדים את המחרוזת המקורית הזו לפני שהופכים אותה על ידי הצבת המשתנה 'data' ב-'cout'. מתחת לזה, אנו מאתחלים משתנה נוסף שהוא 'revStr' מאותו סוג נתונים 'מחרוזת'. לאחר מכן, אנו משתמשים ב-'rbegin()' ו-'rend()' שהם האיטרטורים ההפוכים שאנו מוסיפים להיפוך המחרוזת כאן. המחרוזת ההפוכה נשמרת כעת במשתנה 'revStr' שממוקם ב-'cout' כדי להדפיס כאן את המחרוזת ההפוכה.
קוד 5:
#לִכלוֹלבאמצעות מרחב שמות סטד ;
int רָאשִׁי ( )
{
נתוני מחרוזת = 'C++ היא שפת התכנות הטובה ביותר' ;
cout << נתונים << endl << endl ;
מחרוזת revStr = חוּט ( נתונים. rbegin ( ) , נתונים. עושה ( ) ) ;
cout << revStr << endl ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
המחרוזת שהוספנו לקוד מוצגת כאן לראשונה. לאחר מכן, המחרוזת ההפוכה שהשגנו על ידי שימוש באיטרטורים ההפוכים מוצגת בקטע הבא:
סיכום
המושג 'היפוך מחרוזות' בתכנות C++ נדון במאמר זה, שבו חקרנו טכניקות מרובות להיפוך המחרוזת. בדקנו את כל השיטות שעוזרות להפוך את המחרוזת ב-C++ בפירוט והפכנו את המחרוזת בקודי C++ שלנו. במאמר זה, הצגנו את המחרוזות המקוריות וההפוכות בקודים שלנו.