דוגמה 1:
בקוד C++ זה, קבצי הכותרת 'iostream' ו-'cmath' כלולים. קובץ הכותרת 'iostream' מיועד לבצע את פעולות הקלט\פלט על ידי שימוש בפונקציות cin\cout מכיוון שפונקציות אלו מוגדרות בקובץ הכותרת 'iostream'. קובץ הכותרת 'cmath' נוסף כאן כדי לבצע את הפעולות המתמטיות בנתונים. 'מרחב השמות std' ממוקם לפני. לאחר מכן, נוסף קוד מנהל ההתקן שהוא 'main()'. מתחת לזה, אנו משתמשים ב-'num' עם סוג הנתונים 'צף'. הערך של 'num' שהגדרנו כאן הוא '4.6'.
לאחר מכן, נוסיף את הפונקציה 'cout()' שמדפיסה את הנתונים שהזנו בה. ראשית, אנו מציגים את מספר הצף שאותחלנו בעבר. לאחר מכן, אנו משתמשים בפונקציה 'floor()' ומעבירים את 'num' כארגומנט של פונקציית 'floor()' זו. אנו גם מדפיסים את התוצאה לאחר החלת הפונקציה 'floor()'.
קוד 1:
#include
#include
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( )
{
לָצוּף על אחד = 4.6 ;
cout << 'המספר הוא ' << על אחד << endl ;
cout << 'הקומה של המספר הזה היא:' << קוֹמָה ( על אחד ) << endl ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
בפלט זה, המספר הוא '4.6'. אבל כאשר אנו מיישמים את שיטת 'floor()', היא נותנת את התוצאה של '4'. זה מראה ששיטת 'floor()' מחזירה מספר הקטן או שווה למספר הנתון.
דוגמה 2:
כאן אנו כוללים שני קובצי כותרת בשם 'iostream' ו-'cmath'. לאחר מכן, אנו מניחים 'מרחב שמות std' ומצהירים על הפונקציה 'main()'. לאחר מכן, אנו מכריזים על ארבעה משתנים עם סוג נתונים 'צף'. משתנים אלה נקראים 'num_1', 'num_2', 'num_3' ו-'num_4'. אנו מקצים '4.9' ל-'num_1', '-6.4' ל-'num_2', '5.1' ל-'num_3', ו-'8' ל-'num_4'. לאחר מכן, אנו מיישמים את הפונקציה 'floor()' על המשתנה 'num_1' ומדפיסים את הערך כמו גם את התוצאה שקיבלנו לאחר החלת הפונקציה 'floor()' על מספר זה. באותו אופן, אנו מדפיסים את כל הערכים ואת התוצאה של הערכים הללו שקיבלנו מהפונקציה 'floor()' על ידי הצבתם בפונקציה זו כארגומנט שלה.
קוד 2:
#include#include
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( )
{
לָצוּף num_1, num_2, num_3, num_4 ;
מספר_1 = 4.9 ;
מספר_2 = - 6.4 ;
מספר_3 = 5.1 ;
מספר_4 = 8 ;
cout << 'המספר הראשון הוא' << מספר_1 << 'והרצפה שלו היא ' << קוֹמָה ( מספר_1 ) << endl ;
cout << 'המספר השני הוא' << מספר_2 << 'והרצפה שלו היא ' << קוֹמָה ( מספר_2 ) << endl ;
cout << 'המספר השלישי הוא' << מספר_3 << 'והרצפה שלו היא ' << קוֹמָה ( מספר_3 ) << endl ;
cout << 'המספר הרביעי הוא' << מספר_4 << 'והרצפה שלו היא ' << קוֹמָה ( מספר_4 ) << endl ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
הערך '4.9' מחזיר '4' לאחר החלת הפונקציה 'floor()'. לאחר מכן, אנו מכניסים '-6.4' לפונקציה 'קומה()' זו והיא מחזירה '-7' כפי שמוצג להלן. התוצאה של מספר '5.1' היא '5' לאחר החלת שיטת 'floor()'. אותה תוצאה מוצגת כאשר '8' מחזירה '8' כערך הרצפה:
דוגמה 3:
כאן, אנו מיישמים את הפונקציה 'floor()' על ערכי המספרים השלמים. ראשית, אנו מאתחלים את המשתנים השלמים בשם 'value_1' ו-'value_2'. ה-'value_1' מאותחל עם '5' וה-'value_2' מאותחל עם '-8'. לאחר מכן, נמקם את ה-'cout' שבו נוסיף את הפונקציה 'floor()' שבה נעביר את ה-'value_1' במשפט ה-'cout' הראשון. ב-'cout' הבא, אנו משתמשים ב-'floor()' שבו נעביר את ה-'value_2' כפרמטר. כעת, הוא מחיל את הפונקציה 'floor()' על הערכים הללו ומדפיס אותם על המסך.
קוד 3:
#include#include
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( )
{
int value_1, value_2 ;
value_1 = 5 ;
ערך_2 = - 8 ;
cout << 'המספר השלם הראשון הוא' << value_1 << 'והרצפה שלו היא ' << קוֹמָה ( value_1 ) << endl ;
cout << 'המספר השלם השני הוא' << ערך_2 << 'והרצפה שלו היא ' << קוֹמָה ( ערך_2 ) << endl ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
תוצאה זו מראה שהערך של '5' נותן '5' לאחר חישוב הפונקציה 'floor()' ו-'-8' נותן '-8' כערך לאחר החלת הפונקציה 'floor()'.
דוגמה 4:
כאן, אנו מיישמים את הפונקציה 'floor()' על הערכים של סוג הנתונים 'כפול'. אנו כוללים כאן גם את קובץ הכותרת 'iomanip' המסייע בשימוש בפונקציית 'setprecision()' מכיוון שפונקציה זו מוצהרת בקובץ הכותרת הזה. לאחר מכן, עלינו להשתמש בפונקציה זו בקוד שלנו. כעת, אנו מאתחלים את המשתנים 'd_1', 'd_2' ו-'d_3' עם הערכים. לאחר מכן, יש לנו את ה-'cout' שבו אנו מקלידים 'setprecision()' שעוזר לקבל את הערך המדויק של מספר סוג נתונים 'כפול' עם המספר הנדרש של מקומות עשרוניים. אנו מעבירים כאן את '10' כפרמטר שלו. לאחר מכן, אנו מדפיסים את הערכים, מיישמים את הפונקציה 'floor()' על הערכים הללו ומדפיסים אותם.
קוד 4:
#include#include
#include
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( )
{
לְהַכפִּיל d_1 = 4.99986399 , d_2 = - 6.9612499 , d_3 = 9.00320 , d_4 = 3,000000 ;
cout << קבע דיוק ( 10 ) << 'הערך הכפול הראשון הוא' << d_1 << ' והקומה היא: ' << קוֹמָה ( d_1 ) << endl ;
cout << קבע דיוק ( 10 ) << 'הערך הכפול השני הוא' << d_2 << ' והקומה היא: ' << קוֹמָה ( d_2 ) << endl ;
cout << קבע דיוק ( 10 ) << 'הערך הכפול השלישי הוא' << d_3 << ' והקומה היא: ' << קוֹמָה ( d_3 ) << endl ;
cout << קבע דיוק ( 10 ) << 'הערך הכפול הרביעי הוא' << d_4 << ' והקומה היא: ' << קוֹמָה ( d_4 ) << endl ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
הערכים שאנו מקבלים לאחר חישוב הפונקציה 'floor()' מוצגים כאן. החלנו את הפונקציה 'floor()' על ערכי סוג הנתונים הכפולים בקוד זה:
דוגמה 5:
לאחר הכללת כל שלושת קבצי הכותרות כאן, אנו מניחים את 'שם מרחב std' ואת ה-'main()'. לאחר מכן, ערך של '-0.000' מוכנס לפונקציה 'floor()' כפרמטר. אנו משתמשים גם ב-'cout()'. לאחר מכן, אנו שמים את 'INFINITY' כפרמטר של הפונקציה 'floor()'. מתחת לזה, אנו מוסיפים '-INFINITY' לפרמטר של הפונקציה 'floor()'. בסוף, אנו מכניסים 'NAN' כפרמטר שלו. כל פונקציות ה-'floor()' הללו מנוצלות בתוך המשפט 'cout'.
קוד 5:
#include#include
#include
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( )
{
cout << 'הערך הוא -0.000 והקומה היא' << קוֹמָה ( - 0.000 ) << endl ;
cout << 'הערך הוא INFINITY והקומה היא' << קוֹמָה ( אינסוף ) << endl ;
cout << 'הערך הוא -INFINITY והקומה היא' << קוֹמָה ( - אינסוף ) << endl ;
cout << 'הערך הוא NaN והקומה היא' << קוֹמָה ( IN ) << endl ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
הערך של '-0.000' מחזיר '-0' לאחר ביצוע הפונקציה 'floor()'. ה-'INFINITY' ו-'-INFINITY' מחזירות 'inf' ו-'-inf', בהתאמה, לאחר ביצוע הפונקציה 'floor()'. כמו כן, 'NAN' מחזירה 'nan' לאחר ביצוע הפונקציה 'floor()'.
סיכום
הפונקציה 'floor()' בתכנות C++ נידונה כאן ביסודיות. הסברנו שהפונקציה 'floor()' מחזירה את הערך הקטן או שווה למספר שניתן לאותה פונקציה כפרמטר. יישמנו פונקציה זו על מספרים שלמים, צפים ומספרים עם הקלדת נתונים כפולה במדריך זה. כל הדוגמאות נדונות כאן בפירוט.