הפונקציה charAt() היא בעלת ערך ושימושית מאוד לגישה ולטפל בתווים במחרוזת. אבל איך נוכל לבצע את אותה פונקציה ב-C++? הפונקציה string::at() מאפשרת את אותה פונקציונליות בשפת התכנות C++. במאמר זה, נתעמק בפעולת הפונקציה string::at() על ידי מתן דוגמאות פשוטות ומדויקות שיעזרו לכם להבין את הפונקציונליות של פונקציית string::at() בצורה יעילה.
Java String CharAt()
ב-Java, שיטת charAt() של המחלקה 'String' היא פונקציה מאוד נפוצה ויעילה. שיטה זו ממלאת תפקיד חשוב במניפולציה של מחרוזת על ידי מתן גישה לכל תו במחרוזת על סמך מיקומי האינדקס שלו. הבנת התחביר והפונקציונליות של charAt() חיונית לטיפול יעיל במחרוזות בתוכניות Java. להלן התחביר של הפונקציה charAt() של Java:
תחביר:
פּוּמְבֵּי לְהַשְׁחִיר charAt ( int אינדקס )
הפונקציה charAt() לוקחת פרמטר אחד כמספר שלם, אינדקס, המציין את המיקום של התו הרצוי. סוג ההחזר של פונקציה זו הוא char. הבה נסתכל על דוגמה של הפונקציה charAt() כדי להבין כיצד היא פועלת במהירות:
כיתה ציבורית ראשי {
פּוּמְבֵּי סטָטִי בָּטֵל רָאשִׁי ( חוּט [ ] args ) {
מחרוזת Char_at = 'בדיקת CharA' ;
לְהַשְׁחִיר charone = Char_at. charAt ( 0 ) ;
לְהַשְׁחִיר chartwo = Char_at. charAt ( 5 ) ;
לְהַשְׁחִיר charthree = Char_at. charAt ( 8 ) ;
מערכת. הַחוּצָה . println ( 'תו במדד 0: ' + charone ) ;
מערכת. הַחוּצָה . println ( 'תו במדד 5: ' + chartwo ) ;
מערכת. הַחוּצָה . println ( 'תו במדד 8: ' + charthree ) ;
}
}
בדוגמה זו, נעשה שימוש במחרוזת 'Testing CharAt' והפונקציה charAt() מיושמת כדי לקבל את התווים באינדקס 0, 5 ו-8. התווים המתאימים 'T', 'n' ו-'C' ב- האינדקסים שצוינו מודפסים למסוף. ראה את תמונת הפלט הבאה:
כפי שאתה יכול לראות בפלט, הפונקציה charAt() מאחזרת את התווים באינדקס 0, 5 ו-8 והם מודפסים על המסוף. אם אנחנו צריכים לעבוד בשפת התכנות C++, אנחנו משתמשים בפונקציה 'string::at'. פונקציה דומה ל-charAt() ב-C++ היא הפונקציה 'string::at' שמבצעת את אותה פונקציה.
מחרוזת C++::at() - שווה ערך לפונקציית Java CharAt()
בשפת התכנות C++, הפונקציה string::at() מקבילה ל-charAt() של Java. התחביר של הפונקציה string::at() הוא כדלקמן:
לְהַשְׁחִיר & str. בְּ- ( int אינדקס )בדומה לקלט ופלט של שיטת charAt(), הפונקציה str.at() לוקחת פרמטר שלם המייצג את האינדקס של התו שצריך לאתר. אחרי אותו אינדקס מבוסס 0, תופיע הפונקציה str.at() . האינדקס גדל ב-1 עבור התווים הבאים. התוצאה של הפונקציה str.at() היא מסוג char מה שאומר שהיא מחזירה char. כדי להמחיש את השימוש בפונקציה str.at(), שקול את הדוגמה הבאה:
#include#include
באמצעות מרחב שמות std ;
int רָאשִׁי ( ) {
string str = 'בדיקת CharA' ;
לְהַשְׁחִיר charone = str. בְּ- ( 0 ) ;
לְהַשְׁחִיר chartwo = str. בְּ- ( 5 ) ;
לְהַשְׁחִיר charthree = str. בְּ- ( 8 ) ;
cout << 'תו במדד 0: ' << charone << endl ;
cout << 'תו במדד 5: ' << chartwo << endl ;
cout << 'תו במדד 8: ' << charthree << endl ;
לַחֲזוֹר 0 ;
}
בדוגמה זו, אנו בוחרים ליישם את אותו קוד באמצעות הפונקציה str.at() ב-C++ אותה אנו מיישמים באמצעות הפונקציה charAt() ב-Java. שוב נוצרת מחרוזת 'Testing CharAt' והפונקציה str.at() מיושמת כדי לקבל את התו באינדקס 0, 5 ו-8 המייצגים את התו הראשון, הרביעי והשביעי, בהינתן האינדקס המבוסס על 0 של C++. לאחר מכן, הדמות מאוחסנת במשתנים Charone, Chartwo ו- Chartree ומודפסת למסוף. הבה ניישם עוד דוגמה אחת שמדגימה את פעולת הפונקציה str.at() ביתר פירוט. תסתכל על הקוד הבא:
#includeבאמצעות מרחב שמות std ;
int רָאשִׁי ( ) {
string strng = 'str.at() הדרכה' ;
ל ( int אני = 0 ; אני < strng. אורך ( ) ; אני ++ ) {
cout << 'הדמות במחרוזת באינדקס' << אני << 'הוא ='
<< strng. בְּ- ( אני ) << endl ;
}
לַחֲזוֹר 0 ;
}
בדוגמה זו, אנו מכריזים ומאתחלים משתנה מחרוזת בשם 'strng' עם הערך 'str.at() tutorial'. לאחר מכן, אנו משתמשים בלולאה 'for' עבור איטרציה במחרוזת דרך כל תו. בתוך הלולאה, אנו מציגים כל תו מחרוזת עם האינדקס שלו. הפלט של תוכנית זו מציג כל תו במחרוזת 'str.at() tutorial' יחד עם האינדקס המתאים לו. השיטה strng.at(i) משמשת כדי לקבל את התו באינדקס שצוין במהלך כל איטרציה של הלולאה.
ניתן להשתמש בפונקציה str.at() כדי לקבל את האינדקס של התו הספציפי במחרוזת. הפונקציה str.at() מחזירה את האינדקס של התו הראשון המותאם במחרוזת. כדי להדגים זאת, אנו מיישמים את הדוגמה הבאה. תסתכל על הקוד הבא:
#include#include
באמצעות מרחב שמות std ;
int רָאשִׁי ( ) {
string strng = 'str.at() הדרכה' ;
ל ( int אני = 0 ; אני < strng. גודל ( ) ; אני ++ ) {
אם ( strng. בְּ- ( אני ) == 't' ) {
cout << 'האינדקס של 't' הוא = ' << אני << endl ;
לשבור ;
}
}
לַחֲזוֹר 0 ;
}
קוד C++ זה מדגים תוכנית שמחפשת את ההופעה הראשונה של התו 't' במחרוזת נתונה ומדפיסה את האינדקס שלה. משתנה מחרוזת עם הערך 'str.at() tutorial' מוצהר ומאוחל. באמצעות לולאת 'for', אנו חוזרים במחרוזת דרך כל תו כדי למצוא את המופע הראשון של התו 't'.
התנאי 'אם' משמש כדי להשוות כל תו במחרוזת עם התו שנבחר כדי לבדוק אם הוא 't'. כאשר התו הראשון תואם במחרוזת, האינדקס של אותו תו מודפס למסוף והפונקציה יוצאת מהלולאה באמצעות 'break'. תוכנית זו נותנת את האינדקס של ההופעה הראשונה של התו 't' במחרוזת. אם 't' לא נמצא במחרוזת, הלולאה תושלם מבלי להדפיס דבר.
השוואת מחרוזת C++::at() עם Java CharAt()
בעוד ששתי הפונקציות, charAt() ב-Java ו-str.at ב-C++, משרתות את אותה מטרה בסיסית, הפונקציה str.at() ב-C++ מהירה בהרבה מהפונקציה charAt() ב-Java. הוא מספק גישה לתווים לפי אינדקס והופך אותו לבחירה אופטימלית עבור מצבים שבהם הביצועים הופכים קריטיים. ההיבט השני הראוי לציון של הפונקציה str.at() ב-C++ הוא היעילות שלה. מפתחים שעוברים מ-Java ל-C++ או עובדים על פרויקטים הכוללים גם C++ וגם Java יכולים להפיק תועלת מהבנת היבטי היעילות הללו.
סיכום
לסיכום, הבנת המניפולציה של מחרוזת C++ כרוכה בהיכרות עם הפונקציה string::at(), החלופה ל-charAt() של Java. הדוגמאות המאוירות מדגימות את השימוש המעשי בפונקציות charAt() ו-str.at() כאחד, המאפשרות למפתחים לגשת לתווים ספציפיים במהירות וביעילות. היעילות של הפונקציה str.at() ב-C++ משפרת עוד יותר את הצורך שלה, מה שהופך אותה לפונקציה חשובה עבור משימות מניפולציה של מחרוזות. בין אם אתם עוברים משפת Java לשפת C++ או עומדים ליצור פרויקט C++ מסובך, הבנה מוצקה של הפונקציות הללו היא חובה כדי לטפל ביעילות וביעילות במחרוזות בתוכנות שלכם.