C++ היא אחת משפות התכנות הפופולריות והותיקות ביותר המשמשות לפיתוח יישומים בעלי ביצועים גבוהים. הוא משמש בקרב מתכנתים מומחים ומפתחים מתחילים. הוא משמש בעיקר בפיתוח משחקים ומהווה אופציה אידיאלית לפיתוח מערכות הפעלה. בעת כתיבת קוד בשפת C++, אתה עלול להיתקל בהמרת נתונים מסוג אחד לאחר. במאמר זה תלמדו להמיר מחרוזת למספר שלם ארוך. זה די קשה להמיר מחרוזת לכל פורמט אחר. עם זאת, שפת התכנות C++ מספקת דרך מהירה ויעילה להמיר מחרוזות למספרים שלמים.
פונקציית stol ב-C++
ה-stol הוא פונקציה מובנית ב-C++ המסופקת בספריית std. זה ממיר מחרוזות למספרים שלמים ארוכים. הוא ממיר את תוכן המחרוזת למספר שלם של הבסיס שצוין ומחזיר ערך שלם ארוך. זה דורש שלושה פרמטרים, אחד הוא מחרוזת הקלט, השני הוא פרמטר האובייקט, והשלישי הוא הבסיס המספרי. התחביר של פונקציית stol ניתן להלן, תסתכל:
הפונקציה stol לוקחת שלושה פרמטרים: input_string, size ו-base. ה-'input_string' מייצג את מחרוזת הקלט שיש להמיר למספר שלם ארוך.
הפרמטר 'size' מייצג את האובייקט מסוג size_t הנושא את מיקום התו הבא במחרוזת הקלט אחרי הערך המספרי. זה יכול להיות מצביע null אם אין צורך להשתמש בו.
הפרמטר השלישי, הפרמטר 'בסיס' מייצג את הבסיס שבו יש לפרש את המחרוזת. לדוגמה, אם ניתן בסיס '2', המחרוזת תתפרש כמספר הבסיס 2 השלם. ערך ברירת המחדל של פרמטר הבסיס הוא 10 ואם 0 מסופק אז ערך הבסיס ייקבע לפי הפורמט ברצף. הפונקציה stol מחזירה את המספר השלם הארוך המייצג את ערך int של מחרוזת נתונה.
כעת, הבה נחקור כמה דוגמאות כדי להבין כיצד פועלת פונקציית stol ב-C++.
דוגמה מס' 1
בדוגמה זו, נספק מחרוזות עשרוניות והקסדצימליות כדי לבדוק כיצד פונקציית stol ממירה אותם למספרים שלמים עשרוניים והקסדצימליים.
ה-'dec = 123456789' הוא מחרוזת עשרונית ומומרת למספר שלם ארוך באמצעות הפונקציה stol stol(dec,&size). שימו לב שהבסיס אינו מסופק בפונקציה כפרמטר קלט, אשר כתוצאה מכך משתמש בבסיס ברירת המחדל 10 כדי להמיר את המחרוזת למספר עשרוני. עם זאת, להמרת המחרוזת ממספר הקסדצימלי למספר עשרוני, בסיס 16 מסופק כפרמטר הקלט stol(hex, nullptr, 16). כידוע, בסיס 16 מייצג מספר הקסדצימלי.
#include#include
#include
int רָאשִׁי ( )
{
סטד :: חוּט דצמבר = '123456789' ;
סטד :: חוּט hex = 'a2bf3c' ;
סטד :: חוּט :: סוג גודל גודל ;
ארוך lidec = סטד :: שולחן ( דצמבר, & גודל ) ;
ארוך lihex = סטד :: שולחן ( hex, nullptr , 16 ) ;
סטד :: cout << 'קלט מחרוזת עשרונית' << דצמבר << 'הומר ל-long int' << lidec << ' \n ' ;
סטד :: cout << 'קלט מחרוזת הקסדצימלית' << hex << 'הומר ל-long int' << lihex << ' \n ' ;
לַחֲזוֹר 0 ;
}
הנה הפלט הבא. שים לב שהמחרוזת העשרונית '123456789' הומרה למספר שלם עשרוני ארוך '123456789'. בעוד שהמחרוזת ההקסדצימלית 'a2bf3c' הומרה למספר הקסדצימלי '10665788'. להלן השלבים הנדרשים שתוכל לבצע כדי ללמוד כיצד ההמרה מתבצעת על ידי פונקציית stol:
( A2BF3C ) ₁₆ = ( 10 × 16 ⁵ ) + ( שתיים × 16 ⁴ ) + ( אחד עשר × 16 ³ ) + ( חֲמֵשׁ עֶשׂרֵה × 16 ² ) + ( 3 × 16 ¹ ) + ( 12 × 16 ⁰ ) = ( 10665788 ) ₁₀ 
דוגמה מס' 2
בדוגמה זו, נמיר מספר בינארי באמצעות הפונקציה stol. בואו נראה את הקוד למטה ונבין את פעולת הקוד. ה-'1010110110' ניתן כמחרוזת הקלט ובסיס 2 מסופק כפרמטר בסיס הקלט stol(bin,&size, 2), המייצג את המספר בפורמט בינארי. הפונקציה stol תמיר את המספר הבינארי למספר עשרוני על ידי ביצוע השלבים הבאים:
( 1010110110 ) ₂ = ( 1 × שתיים ⁹ ) + ( 0 × שתיים ⁸ ) + ( 1 × שתיים ⁷ ) + ( 0 × שתיים ⁶ ) + ( 1 × שתיים ⁵ ) + ( 1 × שתיים ⁴ ) + ( 0 × שתיים ³ ) + ( 1 × שתיים ² ) + ( 1 × שתיים ¹ ) + ( 0 × שתיים ⁰ ) = ( 694 ) ₁₀ #include#include
#include
int רָאשִׁי ( )
{
סטד :: חוּט פַּח = '1010110110' ;
סטד :: חוּט :: סוג גודל גודל ;
ארוך ליבין = סטד :: שולחן ( פַּח, & גודל, שתיים ) ;
סטד :: cout << 'קלט מחרוזת בינארית' << פַּח << 'הומר ל-long int' << ליבין << ' \n ' ;
לַחֲזוֹר 0 ;
}
כפי שניתן לראות שפונקציית stol החזירה את אותה תוצאה כמו תהליך ההמרה הבינארי לעשרוני הכללי.
דוגמה מס' 3
בדוגמה זו, אנו הולכים לראות מה קורה אם נבדוק את פונקציית stol עם קלט לא חוקי. מחרוזת של מספר תווים תסופק לפונקציה stol ו-0 יסופק כערך הבסיס כך שהפונקציה תקבע את בסיס המחרוזת באופן אוטומטי. הנה הקוד:
קבוצה של תווים מסופקת כמחרוזת קלט שאינה נקבעת על ידי ערכי בסיס כלשהם, כלומר, 10, 16, 2 וכו', כך שהפונקציה תחזיר ערך שגיאה.
#include#include
#include
int רָאשִׁי ( )
{
סטד :: חוּט chr = 'abcdefgh' ;
סטד :: חוּט :: סוג גודל גודל ;
ארוך str = סטד :: שולחן ( chr, nullptr , 0 ) ;
סטד :: cout << 'מחרוזת תווים קלט' << chr << 'הומר ל-long int' << str << ' \n ' ;
לַחֲזוֹר 0 ;
}
ראה את הפלט למטה. שימו לב שהמהדר העלה חריג 'invalid_argument' מכיוון שהפונקציה אינה מתייחסת למחרוזות שלא ניתן לקבוע עם ערך בסיס כלשהו.
דוגמה מס' 4
בדוגמה זו, נספק שילוב של קלט חוקי ולא חוקי כדי לראות את התוצאה של הפונקציה stol() .
מחרוזת הקלט היא שילוב של תווים חוקיים ולא חוקיים, '123xf25'. ה-'0' מסופק כבסיס קלט כך שהפונקציה קובעת את הבסיס של מחרוזת הקלט באופן אוטומטי בהתבסס על סוג התווים.
#include#include
#include
int רָאשִׁי ( )
{
סטד :: חוּט chr = '123xf25' ;
סטד :: חוּט :: סוג גודל גודל ;
ארוך str = סטד :: שולחן ( chr, nullptr , 0 ) ;
סטד :: cout << 'מחרוזת קלט' << chr << 'הומר ל-long int' << str << ' \n ' ;
לַחֲזוֹר 0 ;
}
הנה הפלט שמראה את פעולת פונקציית stol עם שילוב של קלט חוקי ולא חוקי:
שים לב שהפונקציה המירה את '123' למספר עשרוני '123' וזרקה את שאר המחרוזת מכיוון שהיא קיבלה קלט לא חוקי 'x'. המחרוזת שאחרי התו 'x' אינה מומרת על ידי הפונקציה stol, ומחזירה רק את התווים הראשונים של המחרוזת בתור long int.
סיכום
בפוסט זה, חקרנו את פונקציית ה-stol של שפת התכנות C++. בעזרת כמה דוגמאות שימושיות ופשוטות, למדנו כיצד פונקציית stol עובדת עם סוגים שונים של קלט. הפונקציה stol לוקחת שלושה פרמטרים, מחרוזת הקלט שאותה יש להמיר, פרמטר גודל המייצג את מיקום הפונקציה במחרוזת וערך הבסיס המייצג את הבסיס של מחרוזת הקלט. הוא מחזיר את ערך ה-int long של מחרוזת הקלט.