שפת C++ מספקת מספר סוגי נתונים לעבודה כמו 'int', 'float', 'char', 'double', 'long double' וכו'. סוג הנתונים 'כפול' משמש למספרים המכילים נקודות עשרוניות למעלה ל-'15' או עבור הערכים המעריכיים. הוא יכול לשאת פי שניים יותר מידע ונתונים מאשר צף הנקרא סוג נתונים כפול. גודלו הוא בערך '8 בתים', הכפלת סוג הנתונים הצף.
אנו עשויים להתמודד עם אתגרים תוך כדי עבודה עם סוג הנתונים 'כפול'. איננו יכולים להדפיס ישירות את סוג הנתונים הכפול, ולכן אנו עשויים להשתמש בטכניקות מסוימות כדי להדפיס את הערך המלא של סוג הנתונים 'כפול'. אנו יכולים להשתמש בשיטת 'setpercision()' תוך כדי עבודה עם סוג הנתונים הכפול המכיל נקודות עשרוניות. במקרה השני של סוג הנתונים הכפול שיש לו ערכים אקספוננציאליים, נוכל להשתמש בפורמטים ה'קבועים' או ה'מדעיים'. כאן, נדון בהדפסה של סוגי נתונים כפולים ללא שימוש בטכניקה כלשהי ועל ידי שימוש בכל שלוש השיטות במדריך זה.
דוגמה 1:
קוד C++ נמצא כאן בו כלול קובץ הכותרת 'iostream' מכיוון שעלינו לעבוד עם הפונקציות המוצהרות בקובץ הכותרת הזה. לאחר מכן, אנו מציבים 'מרחב שמות std' כך שלא נצטרך להוסיף את מילת המפתח 'std' עם הפונקציות שלנו בנפרד. לאחר מכן, אנו מפעילים כאן את הפונקציה שהיא הפונקציה 'main()'. בהמשך, אנו מכריזים על משתנה 'כפול' עם השם 'var_a' ומקצים ערך נקודה עשרונית למשתנה זה. כעת, אנו רוצים להציג את הערך הכפול הזה, אז אנו משתמשים ב-'cout' כדי למקם את המשתנה הזה במקום שבו אנו מאחסנים את הערך הכפול. לאחר מכן, נוסיף 'החזר 0'.
קוד 1:
#includeבאמצעות מרחב שמות סטד ;
int רָאשִׁי ( בָּטֵל ) {
לְהַכפִּיל var_a = 7.9765455419016 ;
cout << 'הערך הכפול שהצבנו כאן = ' << var_a ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
עכשיו, שים לב כאן בתוצאה זו שהיא לא מדפיסה את הערך הכפול המלא שהכנסנו בקוד שלנו. אז זו הבעיה שעומדת בפנינו בזמן עבודה עם סוג הנתונים הכפול בתכנות C++.
דוגמה 2:
בדוגמה זו, נחיל את הפעולה האריתמטית על ערכי הנקודה העשרונית ולאחר מכן נציג את התוצאה כערך מסוג נתונים כפול. תחילה נוסיף את קובץ הכותרת 'bits/stdc++.h' הכולל את כל הספריות הסטנדרטיות. לאחר מכן, אנו מפעילים את ה-'main()' לאחר שימוש ב-'namespace std'. המשתנה 'a' מוצהר כאן עם סוג הנתונים 'כפול' ולאחר מכן הקצה '1.0/5000' למשתנה זה. כעת, הוא מחיל את פעולת החלוקה הזו על הנתונים ומאחסן את התוצאה במשתנה 'a' מסוג הנתונים 'כפול'. לאחר מכן, אנו מציגים את התוצאה המאוחסנת ב-'a' באמצעות 'cout'.
קוד 2:
#includeבאמצעות מרחב שמות סטד ;
int רָאשִׁי ( בָּטֵל ) {
לְהַכפִּיל א = 1.0 / 5000 ;
cout << 'הערך הכפול שלי הוא' << א ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
הנה התוצאה של ערך סוג הנתונים הכפול הנתון. אנחנו יכולים בקלות ליישם את הפעולות המתמטיות על הערכים שמחזירים את תוצאת סוג הנתונים הכפול ולהציג אותם בקוד C++ שלנו.
דוגמה 3: שימוש בשיטת Setprecision()
כאן, ניישם את שיטת 'setprecision'. אנו כוללים שני קובצי כותרת: 'iosteam' ו-'bits/stdc++.h'. לאחר מכן מתווסף 'מרחב השמות std', מה שחוסך מאיתנו את הצורך לכלול את מילת המפתח 'std' עם כל אחת מהפונקציות שלנו בנפרד. הפונקציה 'main()' נקראת מתחת לזה. המשתנה 'var_a' מוצהר כעת עם סוג הנתונים 'כפול' שיש בו ערך המכיל נקודה עשרונית.
מכיוון שאנו רוצים להציג את המספר המלא, אנו משתמשים בפונקציה 'setprecision()' במשפט 'cout'. אנו מעבירים את '15' כפרמטר של פונקציה זו. שיטה זו מסייעת בהגדרת מספר הערכים של הנקודה העשרונית בערך סוג הנתונים הכפול הזה. הדיוק שקבענו כאן הוא '15'. אז הוא מציג מספרים '15' של ערך הנקודה העשרונית. לאחר מכן, אנו שמים 'var_a' ב-'cout' זה לאחר שימוש בשיטת 'setprecision()' כדי להדפיס את ערך סוג הנתונים ה'כפול' הזה.
קוד 3:
#include#include
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( בָּטֵל ) {
לְהַכפִּיל var_a = 7.9765455419016 ;
cout << קבע דיוק ( חֲמֵשׁ עֶשׂרֵה ) << 'הערך הכפול שהצבנו כאן = ' << var_a ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
כאן, אנו יכולים לראות שהערך המלא שהזנו בקוד מוצג. הסיבה לכך היא שהשתמשנו בפונקציה 'setprecision()' בקוד שלנו והגדרנו את מספר הדיוק ל- '15'.
דוגמה 4:
ה-'iomanip' ו-'iostream' הם שני קובצי הכותרת. ה- 'iomanip' משמש מכיוון שהפונקציה 'setprecision()' מוצהרת בקובץ הכותרת הזה. לאחר מכן, מרחב השמות 'std' מוכנס ומפעיל את ה-'main()'. המשתנה הראשון מסוג הנתונים 'כפול' המוצהר כאן הוא 'dbl_1' ושם המשתנה השני הוא 'dbl_2'. אנו מקצים ערכים שונים לשני המשתנים המכילים נקודות עשרוניות בהם. כעת, אנו מיישמים את אותו מספר דיוק עבור שני הערכים על ידי שימוש בפונקציה 'setpercision()' והעברת '12' לכאן.
כעת, מספר הדיוק עבור שני הערכים מוגדר ל-'12', כלומר, ערכים אלה מציגים ערכי '12'. אנו משתמשים בפונקציית 'setprecision()' זו לאחר הצבת הפונקציה 'cout'. מתחת לזה, אנו מדפיסים את שני הערכים של סוג הנתונים 'כפול' עם 'cout'.
קוד 4:
#include#include
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
לְהַכפִּיל dbl_1 = 9.92362738239293 ;
לְהַכפִּיל dbl_2 = 6.68986442623803 ;
cout << קבע דיוק ( 12 ) ;
cout << 'מספר סוג כפול 1 = ' << dbl_1 << endl ;
cout << 'מספר סוג כפול 2 = ' << dbl_2 << endl ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
אנו עשויים לשים לב שהוא מציג 12 ערכים ומתעלם מכל שאר הערכים של ערך סוג הנתונים ה'כפול' הזה, כי אנחנו מגדירים את ערך הדיוק בקוד שלנו.
דוגמה 5:
כאן אנו מכריזים על שלושה משתנים: 'new_d1', 'new_d2' ו-'new_d3'. סוג הנתונים של כל שלושת הערכים הוא 'כפול'. אנו גם מקצים את הערכים לכל המשתנים הללו. כעת, אנו רוצים להגדיר ערכי דיוק שונים עבור כל שלושת המשתנים. הגדרנו '15' לערך המשתנה הראשון על ידי העברת '15' כפרמטר של הפונקציה 'setprecision()' בתוך ה-'cout'. לאחר מכן, אנו מגדירים '10' כערך הדיוק של ערך המשתנה השני והגדרנו '6' כמספר הדיוק עבור הערך השלישי הזה.
קוד 5:
#include#include
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
לְהַכפִּיל new_d1 = 16.6393469106198566 ;
לְהַכפִּיל new_d2 = 4.01640810861469 ;
לְהַכפִּיל new_d3 = 9.95340810645660 ;
cout << 'מספר סוג כפול בדיוק 15 = ' << קבע דיוק ( חֲמֵשׁ עֶשׂרֵה ) << new_d1 << endl ;
cout << 'מספר סוג כפול בדיוק 10 = ' << קבע דיוק ( 10 ) << new_d2 << endl ;
cout << 'מספר סוג כפול בדיוק 6 = ' << קבע דיוק ( 6 ) << new_d3 << endl ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
כל שלושת הערכים שונים כאן מכיוון שאנו מתאימים את ערכי הדיוק השונים עבור כולם. הערך הראשון מכיל מספרים '15' מאחר שהגדרנו את ערך הדיוק ל-'15'. הערך השני מכיל מספרים '10' בגלל ערך הדיוק של '10', והערך השלישי מציג כאן מספרי '6' מכיוון שערך הדיוק שלו מותאם ל- '6' בקוד.
דוגמה 6:
אנו מאתחלים כאן ארבעה משתנים: שניים מאותחלים עם ערכי הנקודה העשרונית והשניים האחרים מאותחלים עם הערכים האקספוננציאליים. לאחר מכן, אנו מיישמים את הפורמט 'הקבוע' על כל ארבעת המשתנים על ידי הצבתם בתוך ה-'cout'. מתחת לזה, אנו משתמשים בפורמט ה'מדעי' על משתנים אלו בנפרד על ידי הצבתם בתוך ה-'cout' לאחר שימוש במילת המפתח 'מדעית'.
קוד 6:
#include#include
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
לְהַכפִּיל my_dbl_1 = 7.7637208968554 ;
לְהַכפִּיל שלי_ex_1 = 776e+2 ;
לְהַכפִּיל my_dbl_2 = 4.6422657897086 ;
לְהַכפִּיל שלי_ex_2 = 464e+2 ;
cout << 'על ידי שימוש במילת המפתח הקבועה' << endl ;
cout << 'מספר סוג כפול ראשון = ' << תוקן << my_dbl_1 << endl ;
cout << 'מספר סוג כפול שני = ' << תוקן << שלי_ex_1 << endl ;
cout << 'מספר סוג כפול שלישי = ' << תוקן << my_dbl_2 << endl ;
cout << 'מספר סוג כפול רביעי = ' << תוקן << שלי_ex_2 << endl ;
cout << endl ;
cout << 'על ידי שימוש במילת המפתח המדעית:' << endl ;
cout << 'מספר סוג כפול ראשון = ' << מַדָעִי << my_dbl_1 << endl ;
cout << 'מספר סוג כפול שני = ' << מַדָעִי << שלי_ex_1 << endl ;
cout << 'מספר סוג כפול שלישי = ' << מַדָעִי << my_dbl_2 << endl ;
cout << 'מספר סוג כפול רביעי = ' << מַדָעִי << שלי_ex_2 << endl ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
תוצאה זו מציגה את הפלט לאחר החלת הפורמטים 'הקבועים' וה'מדעיים' על ערכי סוג הנתונים 'כפולים'. הפורמט 'הקבוע' מוחל על ארבעת הערכים הראשונים. על ארבעת הערכים האחרונים, הפורמט ה'מדעי' מוחל ומציג את התוצאה כאן.
סיכום
הרעיון של 'הדפסת נתונים כפולים' נדון בפירוט כאן. בדקנו את הטכניקות השונות להדפסת סוג הנתונים 'כפול' בתכנות C++. הדגמנו את שלוש הטכניקות השונות המסייעות לנו בהדפסת ערכי סוג הנתונים ה'כפולים'; אלה הם 'setprecision()', 'fixed' ו-'scientific'. בדקנו ביסודיות את כל הטכניקות במדריך זה.