דוגמה 1: תוכנית של בינארי עד עשרוני באמצעות לולאת 'While'.
יש לנו תוכנית הבאה להמיר את המספר מבינארי לעשרוני. בתוך התוכנית, אנו משתמשים בלולאת 'בזמן' להמרה בינארית לעשרוני.
#include#include
באמצעות מרחב שמות סטד ;
int conversionOfBin ( ארוך ארוך ) ;
int רָאשִׁי ( ) {
ארוך ארוך על אחד ;
cout << 'נדרש מספר בינארי:' ;
אֲכִילָה >> על אחד ;
cout << על אחד << ' בבינארי = ' << conversionOfBin ( על אחד ) << 'בעשרוני' ;
לַחֲזוֹר 0 ;
}
int conversionOfBin ( ארוך ארוך על אחד ) {
int כך = 0 , איקס = 0 , היתרה ;
בזמן ( על אחד ! = 0 ) {
היתרה = על אחד % 10 ;
על אחד / = 10 ;
דצמבר + = היתרה * פאו ( 2 , איקס ) ;
++ איקס ;
}
לַחֲזוֹר כך ;
}
כאן, אנו מגדירים את קובץ הכותרת 'iostream' עבור זרמי הקלט והפלט ואת ה-'cmath' כדי להשתמש בפונקציה המתמטית בתוכנית. לאחר מכן, אנו מגדירים את הפונקציה ConversionOfBin() שבה הפרמטר מסוג 'long long' מועבר. לאחר מכן, יש לנו קריאה לפונקציה main() כדי להפעיל את התוכנית. אנו מכריזים על משתנה בין סוג ארוך בשם 'num' בתוך הפונקציה main() .
לאחר מכן, הפונקציה ConversionOfBin() ממירה את המספר הבינארי הקלט למספר העשרוני. לשם כך, יש לנו את ההגדרה של הפונקציה ConversionOfBin() לאחר קוד מנהל ההתקן. הפונקציה ConversionOfBin() מועברת עם המשתנה 'num' בעל המספר הבינארי. לאחר מכן, אנו קוראים ללולאת 'בזמן' כדי להפוך את המספר הבינארי ב-'num' לערך עשרוני. לפני כן, אנו מאתחלים את המשתנים 'deci', 'x' ו-'שארית' עם הערך '0'.
בתוך לולאת 'while', פעולת החלוקה מתנהלת כדי לייצג את הערך הימני ביותר של המספר הבינארי. תוצאות החלוקה נשמרות במשתנה 'שארית'. לאחר מכן, נוסיף את התוצאות של השאר ואת תוצאות ההספק למשתנה 'deci'. המשתנה 'x' ממשיך להעריך את העוצמה הפעילה של 2.
התוצאות של המרת המספרים הבינאריים שצוינו לערכים עשרוניים מושגות במסוף C++:
דוגמה 2: תוכנית של בינארי עד עשרוני באמצעות לולאת 'עבור'.
השינוי מבינארי לעשרוני הושג באמצעות לולאת 'while'. עם זאת, אנו יכולים גם להשתמש בשיטת הלולאה 'ל' כדי להפוך את הסיביות הבינאריות למספר העשרוני.
#include
#include
int רָאשִׁי ( ) {
סטד :: חוּט פַּח ;
סטד :: cout << 'הזן מספר בינארי:' ;
סטד :: אֲכִילָה >> פַּח ;
int דצמבר = 0 ;
int baseIs = 1 ;
ל ( int א = פַּח. אורך ( ) - 1 ; א >= 0 ; א -- ) {
אם ( פַּח [ א ] == '1' ) {
דצמבר + = baseIs ;
}
baseIs * = 2 ;
}
סטד :: cout << 'תוצאות בעשרוניות: ' << דצמבר << סטד :: endl ;
לַחֲזוֹר 0 ;
}
כאן, אנו מתחילים עם תוכנית הפונקציה main() שבה יש לנו את המשתנה 'std::string' שהוא 'bin' כדי לאחסן את המספר הבינארי שהוזן על ידי המשתמש בהנחיה. בתחילה, ההנחיה תבקש מהמשתמש להזין את המספר הבינארי באמצעות המשפט 'cout'. לאחר מכן, הפקודה 'cin' תקרא את המספר הבינארי הזה. לאחר מכן, אנו מאתחלים את המשתנה 'dec' עם הערך '0' ואת המשתנה 'baseIs' עם הערך '1' כדי לקבל את המקבילה העשרונית.
לאחר מכן, אנו קוראים ללולאה 'for' אשר עוברת על כל מספר של הבינארי שצוין מימין לשמאל. בתוך הלולאה, יש לנו תנאי 'אם' כדי לוודא אם המספר הבינארי הוא 1. אם הוא 1, הערך העשרוני מתווסף למשתנה 'dec'. למשתנה 'baseIs' יש את העוצמה של 2 להכפיל עם 1 בכל איטרציה.
הערך של המספר הבינארי והמרתו לערך עשרוני מוצגים במסך ההנחיה:
דוגמה 3: תוכנית של מחרוזת בינארית לעשרונית
ערך המחרוזת הבינארית מוגדר כעת כדי להמיר את ערכו לערך העשרוני. היישום הבא נעשה כדי להפוך את ערך המחרוזת הבינארית לערך עשרוני:
#include#include
באמצעות מרחב שמות סטד ;
int binToDec ( מחרוזת val )
{
ערך מחרוזת = val ;
int ערך_עשרוני = 0 ;
int base_value = 1 ;
int רק = ערך. אורך ( ) ;
ל ( int M = רק - 1 ; M >= 0 ; M -- ) {
אם ( val [ M ] == '1' )
ערך_עשרוני + = base_value ;
base_value = base_value * 2 ;
}
לַחֲזוֹר ערך_עשרוני ;
}
int רָאשִׁי ( )
{
מחרוזת val = '11100101' ;
cout << binToDec ( val ) << endl ;
}
כאן, אנו מתחילים ביצירת פונקציית BinToDec() להמרה של ספרות בינאריות לערכים עשרוניים. הפונקציה BinToDec() לוקחת את הארגומנט 'val' מסוג המחרוזת. בתוך הפונקציה BinToDec() אנו מאתחלים את המשתנה 'value' עם המשתנה 'val' המייצג שהערך של המשתנה 'val' יאוחסן במשתנה 'value'. לאחר מכן, אנו מכריזים על משתנה חדש, 'decimal_value', אשר מוקצה לו ערך של 0.
באופן דומה, המשתנה 'base_value' מוגדר ומאותחל עם הערך של 1. לאחר מכן, נגדיר את המשתנה 'len' שבו נקראת הפונקציה length() כדי לקבל את אורך המספר הבינארי. לאחר האתחול של המשתנה, יש לנו איטרציה של לולאה 'for'. לולאת 'עבור' חוזרת על כל ספרה של מספר בינארי מימין לשמאל.
לאחר מכן, יש לנו פונקציה main() שבה המספר הבינארי מצוין כערך מחרוזת למשתנה 'val' המומר לערך העשרוני כפי שאנו קוראים לפונקציה BinToDec(val) עם הפקודה 'cout'.
הערך הבינארי מסוג מחרוזת מומר כעת לערך העשרוני כפי שמוצג ברשימה הבאה:
דוגמה 4: תוכנית של בינארי עד עשרוני באמצעות מחלקת Bitset
בנוסף, נוכל להמיר את המספר הבינארי למספר העשרוני על ידי הגדרת מחלקת ה-'bitset' של C++ בתוכנית. הוא מספק את הפונקציות שבאמצעותן הליך ההמרה פשוט מאוד.
#include#include
int רָאשִׁי ( ) {
סטד :: חוּט binaryIs ;
סטד :: cout << 'אנא ספק מספר בינארי:' ;
סטד :: אֲכִילָה >> binaryIs ;
סטד :: bitset < 64 > בינארי ( binaryIs ) ;
לא חתום ארוך מספר עשרוני = בינארי. יותר מדי זמן ( ) ;
סטד :: cout << 'מספר עשרוני: ' << מספר עשרוני << סטד :: endl ;
לַחֲזוֹר 0 ;
}
כאן, אנו מגדירים את ספריית ה-'bitset' של C++ בכותרת, מה שעוזר מאוד כאשר עובדים עם ערכים בינאריים. לאחר מכן, יש לנו הגדרת פונקציה main() שבה אנו משתמשים ב-'std::string' כדי להכריז על המשתנה 'binaryIs'. המשתנה 'binaryIs' מאחסן את הערך של binary במחרוזת. לאחר מכן, אנו מבקשים מהמשתמש להוסיף את המספר הבינארי בהנחיה על ידי המשתמש והוא נקרא באמצעות הפקודה 'cin'. לאחר מכן, אנו מתאימים את גודל הביטים שיכול להיות 64 סיביות שלמים. לאחר מכן, הפונקציה to_ulong() נקראת מהמחלקה 'bitset' לתוך המשתנה 'decimalNumber'. הפונקציה to_ulong() ממירה את קבוצת הביטים לסוג נתונים ארוך ללא סימן. לבסוף, אנו משתמשים בפקודה 'cout' כדי להדפיס את הערך העשרוני של הערך הבינארי שניתן על ידי המשתמש.
הערך הבינארי שסופק על ידי המשתמש מומר כעת לערך העשרוני:
סיכום
לסיכום, כיסינו את השיטות להמרת ערך בינארי לערך עשרוני. השתמשנו בלולאת 'for', לולאת 'while' וגישות ה-bitset להמרה בינארית לעשרוני. גישות אלו הופכות את המספרים הבינארים למערכות עשרוניות, מה שמקל על קריאה והבנה.