דוגמה 1:
קובץ הכותרת היחיד שאנו כוללים כאן הוא 'iostream' כדי להשתמש בפונקציות המוצהרות בקובץ הכותרת הזה. מתחת לזה, אנו מכניסים את מרחב השמות 'std'. לכן, זה מקל עלינו להשתמש בפונקציה מבלי להציב את ה-'std' הזה עם כל הפונקציות בכל פעם כשהן משמשות בקוד. לאחר מכן, אנו מפעילים את הפונקציה 'main()'.
לאחר מכן, אנו מאתחלים את ה-'my_name' וסוג הנתונים של המשתנה הוא 'string'. אנו מקצים 'Samuel' למשתנה זה ומאתחלים את המשתנה 'my_age'. סוג הנתונים של המשתנה 'my_age' הוא 'int' ואנו מקצים לו '24'. כעת, אנו רוצים להמיר את ה-'24' הזה למחרוזת. אז, אנו משתמשים בפונקציה 'to_string()' כאן. אנו מאתחלים משתנה נוסף בשם 'ageToString' עם סוג הנתונים 'מחרוזת'.
כאן, אנו משתמשים בפונקציה 'to_string()' ומקצים אותה למשתנה 'ageToString' הזה. אנו מעבירים את המשתנה 'my_age' המכיל את נתוני 'int' לפונקציית 'to_string()' זו כפרמטר. זה הופך את הערך השלם 'my_age' ל'מחרוזת'. הנתונים המומרים מאוחסנים במשתנה 'ageToString' ומוצגים באמצעות 'cout'.
קוד 1:
#include
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
מחרוזת my_name = 'סמואל' ;
int הגיל שלי = 24 ;
מחרוזת ageToString = to_string ( הגיל שלי ) ;
cout << 'אנחנו ממירים את המספר השלם למחרוזת.' << endl ;
cout << השם שלי + 'הוא' + ageToString + ' שנים' ;
}
תְפוּקָה:
הערך השלם מומר כעת לערך המחרוזת ומוצג כאן. הסיבה לכך היא שהקוד שלנו השתמש בפונקציה 'to_string()'.
דוגמה 2:
ה-'iostream' כלול ראשון, וה-'namespace std' מתווסף כאן. לאחר מכן, הפונקציה 'main()' נקראת כאן. המשתנה 'std_name' מאותחל. סוג הנתונים שלו מוגדר ל'מחרוזת'. אנו מקצים 'ג'יימס' למשתנה זה ואז מאתחלים את המשתנה 'סימנים'. למשתנה זה יש את סוג הנתונים 'צף' ואנו נותנים לו את הערך של '90.5'.
כעת, אנו רוצים להשתמש בפונקציה 'to_string()' כדי להפוך את ה-'90.5' הזה למחרוזת. אנו מאתחלים את משתנה סוג הנתונים 'string' הנקרא 'marksToString' וממקמים את הפונקציה 'to_string()'. אנו שולחים את המשתנה 'marks' שמחזיק את נתוני ה-'float' כארגומנט לשיטת 'to_string()'.
כאן, אנו מקצים את התוצאה של הפונקציה 'to_string()' למשתנה 'marksToString'. כעת זה משנה את ערך הציפה 'marks' לסוג הנתונים 'מחרוזת' ושמור אותו במשתנה 'marksToString'. הנתונים שעברו שינוי מוצגים לאחר מכן באמצעות 'cout'.
קוד 2:
#includeבאמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
מחרוזת std_name = 'ג'יימס' ;
לָצוּף סימנים = 90.5 ;
מחרוזת marksToString = to_string ( סימנים ) ;
cout << std_name + 'קיבל' + marksToString + 'סימנים' ;
}
תְפוּקָה:
ערך המחרוזת מומר מהערך הצף ומוצג כאן. זה נובע מהשיטה 'to_string()' המשמשת בקוד שלנו.
דוגמה 3:
כעת, אנו הופכים את ה'כפול' לסוג הנתונים 'מחרוזת'. ראשית, אנו מאתחלים את ה-'customer_name' של סוג הנתונים 'מחרוזת' בשם 'John'. לאחר מכן, נמקם את המשתנה מסוג נתונים 'כפול' שבו אנו מקצים את הערך '9980.5' למשתנה זה. כעת, אנו רוצים להמיר ערך זה שהוא סוג נתונים כפול לסוג הנתונים 'מחרוזת'.
למטרה זו, אנו משתמשים בשיטת 'to_string' כאן. אנו מאתחלים את המשתנה 'salaryToString' של סוג הנתונים 'string' וממקמים שם את שיטת 'to_string()'. אנו מעבירים את משתנה 'שכר' כפרמטר שלו. השכר מומר לסוג הנתונים 'מחרוזת' ונשמר במשתנה 'salaryToString'. כעת, אנו מדפיסים את ה-'customer_name' יחד עם ה-'salaryToString' על ידי שימוש ב-'cout'. סוג הנתונים של שני המשתנים הוא 'מחרוזת'.
קוד 3:
#includeבאמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
מחרוזת customer_name = 'ג'ון' ;
לְהַכפִּיל שכר = 9980.5 ;
string salaryToString = to_string ( שכר ) ;
cout << שם לקוח + ' יש ל ' + משכורתToString + ' שכר. ' ;
}
תְפוּקָה:
כאשר אנו מריצים קוד זה, אנו יכולים לראות את התוצאה שבה ערך סוג הנתונים 'כפול' מומר כעת לסוג הנתונים 'מחרוזת' ומוצג כאן יחד עם השם.
דוגמה 4:
כאן, אנו ממירים גם סוגי נתונים 'int' ו-'float' ל'מחרוזת'. לשם כך, אנו מאתחלים את המשתנה 'a' של סוג הנתונים 'int' עם הערך השלם של '81' ואת המשתנה 'b' של סוג הנתונים 'float' עם הערך הצף שהוא '72.9'.
בהמשך, אנו מאתחלים שני משתנים נוספים עם השמות 'firstStr' ו-'secondStr', בהתאמה, ומקצים כאן את שיטת 'to_string()' לשני המשתנים. כעת, אנו מעבירים את 'a' לפונקציית 'to_string()' הראשונה ואת 'b' לשיטת 'to_string()' השנייה. כעת, שני הערכים מומרים ל'מחרוזת' ומאוחסנים ב-'firstStr' ו-'secondStr', בהתאמה. לאחר מכן, אנו מדפיסים את שני משתני המחרוזת שקיבלנו לאחר החלת שיטת 'to_string()'.
קוד 4:
#include#include
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( )
{
int א = 81 ;
לָצוּף ב = 72.9 ;
מחרוזת firstStr = to_string ( א ) ;
מחרוזת secondStr = to_string ( ב ) ;
cout << 'ערך המחרוזת של המספר השלם a הוא:' << firstStr << endl ;
cout << 'ערך המחרוזת של ה-float b הוא:' << secondStr << endl ;
}
תְפוּקָה:
הערך השלם משתנה תחילה ל'מחרוזת'. לאחר מכן, הצוף משתנה גם ל'מחרוזת'. שני ערכי המחרוזת מוצגים כאן.
דוגמה 5:
כאן, אנחנו רוצים לשרשר את הערכים השלם או הצף עם המחרוזת אבל אנחנו לא עושים זאת ישירות. כעת, עלינו לשנות את המספר השלם כמו גם את ערכי הציפה במחרוזת. ראשית, אנו מיישמים שרשור וממקמים את שיטת 'to_string()' בה אנו מעבירים את '9.8'. אז זה משנה את המספר הצף הזה למחרוזת והשרשור נעשה כאן.
לאחר מכן, אנו מיישמים את השרשור הזה על הנתונים השלם והמחרוזת על ידי שינוי 'int' ל'מחרוזת'. אנו ממקמים את ערכי המספרים השלמים בשיטת 'to_string()'. עשינו את שני השרשורים על ידי שינוים לסוג הנתונים 'מחרוזת' ושמירה לאחר מכן במשתנים 's1' ו-'s2', בהתאמה. לאחר מכן, אנו מניחים את 's1' ו- 's2' בשיטת 'cout'. זה גם מציג את התוצאה שאחסנו במשתנים האלה לאחר ששינו אותם למחרוזות והחלת שרשור נתוני המחרוזות כאן.
קוד 5:
#include#include
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( )
{
מחרוזת s1 = 'ערך כוח המשיכה הוא' + to_string ( 9.8 ) ;
מחרוזת s2 = 'המספר האמיתי הוא' + to_string ( 4 + 8 + 9 + 10 + 14 ) + ' כאן' ;
cout << s1 << endl ;
cout << s2 << endl ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
ראשית, הערך הצף הופך ל'מחרוזת' ולאחר מכן, הערך השלם הופך ל'מחרוזת'. שני ערכי המחרוזת מוצגים כאן לאחר שרשור עם נתוני המחרוזת האחרים.
דוגמה 6:
כעת, אנו מקבלים את הקלט מהמשתמש של סוג הנתונים 'int' ומאחסנים אותו במשתנה 'x' כפי שאנו מכריזים על המשתנה 'x' של סוג הנתונים 'int' כאן. אנחנו מקבלים את הקלט הזה כאן בעזרת הפקודה 'cin'. כעת, אנו ממירים את הקלט הזה ל'מחרוזת' על ידי הצבת המשתנה 'x' בשיטת 'to_string()' ואז מציגים את התוצאה שאחסנו במשתנה 's'.
קוד 6:
#include#include
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( )
{
int איקס ;
cout << 'אנא הזן את המספר להמרתו למחרוזת' <> איקס ;
מחרוזת s = to_string ( איקס ) ;
cout << 'המספר השלם שהומר למחרוזת הוא' + ס << endl ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
לאחר הצגת ההודעה כאן, נזין '84' שהוא סוג הנתונים 'int' ונלחץ על 'Enter'. לאחר מכן, התוצאה שהומרת לסוג הנתונים 'מחרוזת' מוצגת מתחת לזה.
סיכום
שיטת 'to_string()' נחקרה לעומק במדריך זה. בדקנו את השימוש בשיטה זו בתכנות C++. למדנו ששיטה זו מסייעת בהמרת 'int', 'float', כמו גם את סוגי הנתונים 'כפולים' ל'מחרוזת'. הדגמנו מספר דוגמאות שבהן אנו משתמשים בשיטת 'to_string()' זו בקודים שלנו ומראים את פעולתה של שיטה זו במדריך זה. למדנו כאן ביסודיות שיטה זו.