ג כיצד להמיר int לצוף


תשובה 1:

ראשית, אם החלק הלא-חלקי של המצוף ניתן לייצג כ- int, קיימת המרה משתמעת ש"מתעגלת לכיוון אפס "(כלומר, מפילה את החלק):

int r (צף f) { תוצאה int = f;תוצאת החזרה; // אתה יכול פשוט לכתוב "להחזיר f;" במקום זאת.}

שים לב שאם int אינו יכול לייצג את התוצאה, "התנהגות אינה מוגדרת" (מה שאומר שהתוכנית שלך רשאית לעשות כל דבר מבחינת התקן).

אם זה לא העיגול הרצוי, ישנם מספר פונקציות ספרייה סטנדרטיות המוצהרות שיכול לעשות את הטריק. ראשית הפשוטים יותר:

  • תקרה / קומה עגולה למעלה או למטה בהתאמה. התוצאה עדיין צפה, אתה יכול להשתמש בהמרה הגלומה שתוארה לעיל כדי לקבל int.
  • roundf, שמתעגל לערך המספר השלם הקרוב ביותר, אלא שהמקרה .5 מעוגל מאפס (לכן 1.5F מעוגל ל- 2.0F, אך -3.5F מעוגל ל- -4.0F).
  • lroundf ו- llroundf, הדומים ל- roundf, אך מייצרים תוצאה ארוכה או ארוכה בהתאמה. אם לא ניתן לייצג את התוצאה התיאורטית על ידי סוג התוצאה, התוצאה בפועל אינה מוגדרת (כלומר, זה יכול להיות ערך "כלשהו" מאותו סוג). errno עשוי להיות מוגדר ל- EDOM או ERANGE.
  • truncf, הדומה להמרה המשתמעת שתוארה לעיל, למעט התוצאה היא עדיין ציפה.

יש פונקציות עיגול נוספות (גם ב ) שהתנהגות העגול שלה נקבעת על ידי "כיוון עיגול נוכחי" שנקבע על ידי קריאה למשטח העבר (פונקציה המוצהרת ב , כותרת העוסקת במגוון הגדרות ב"סביבת הנקודה הצפה "). הטיעון לפונקציה זו חייב להיות הערך של אחד המקרואים הסטנדרטיים FE_DOWNWARD, FE_TONEAREST, FE_TOWARDZERO או FE_UPWARD, אך כל אחד מאותם מאקרו עשוי להיות לא מוגדר אם מצב העיגול המתאים אינו זמין. באפשרותך לאחזר את מצב העיגול הנוכחי באמצעות העבר (). הפונקציות שלוקחות זאת בחשבון הן:

  • nearbyintf ו- rintf, שהם כמו roundf מלבד המקרה .5 עוקב אחר כיוון העגול הנוכחי (ו- rintf עשוי להעלות חריג של נקודה צפה המצביע על תוצאה "לא מדויקת").
  • lrintf ו- llrintf, הדומים ל-intintf, אך מייצרים תוצאה ארוכה או ארוכה בהתאמה. אם לא ניתן לייצג את התוצאה התיאורטית על ידי סוג התוצאה, התוצאה בפועל אינה מוגדרת (כלומר, זה יכול להיות ערך "כלשהו" מאותו סוג). errno עשוי להיות מוגדר ל- EDOM או ERANGE.

תשובה 2:

הדרך הפשוטה ביותר היא int x = (int) (f + 0.5); זה עובד לרוב למספרים חיוביים. למספרים שליליים ניתן לחסר 0.5. אוֹ

הגדר פונקציית ערך מוחלטת ופונקציה עגולה:

# הגדר ABS (X) ((X> = 0)? X: - (x))#def עגול (X) (X> = 0)? (int) (X + 0.5): (int) - (ABS (X) +0.5)int x = ROUND (f);

אלגוריתמי

הדרך האלגוריתמית לעגל מתמטית היא: 1. להחליט כמה מקומות עשרוניים לקחת כמשמעותיים (n) 2. חלק את המספר ב- 10 ^ {- n}. (מ ') 3. קח את תוצאת המספר השלם הקרוב ביותר. (צף עגול למקום של 1). (ש) 4. הכפל את m * q כדי לקבל את המספר המעוגל. (z) 5. להמיר למספר שלם: אם החלק השבר הוא> 0.5, חתוך את החלק השבר והוסף 1. אחר קוצר את החלק השבר.

מדוע לעשות זאת? מכיוון שהברירת המחדל של C היא לעגל את החלק השבר, לא משנה כמה הוא קרוב ל- 1. אז אתה צריך לחלק את המספר בכמות זעירה כדי לקחת בחשבון את הספרות המשמעותיות. על ידי עיגול תוצאת הביניים תטפל בשגיאות עיגול.

באופן כללי עבור: מספרים חיוביים: אם המספר מימין לעשרוני (המקום העשירי) הוא> = 5 עגול עד הספרה הגבוהה הבאה, אחרת נחתך. מספרים שליליים: אם המספר מימין לעשרון (המקום העשירי) הוא <= 5 חתוך, אחרת לעגל את המספר לספרה השלילית הבאה. זה מטפל במקרה הקצה של בדיוק .5 חיובי או שלילי.

/ * דוגמאות, טובות ורעות * /int x;לצוף f, m, n, p, z; // טוב f = -13.486;n = .01; // שני מקומותm = f / n; // m = -1348.6מ '= תקרה (מ'); // m = -1348.0z = m / n; // z = -13.48x = (int) z; // x = -13// טובf = 0.501; n = 0.1; // מקום אחדm = f / n; // m = 5.01מ '= תקרה (מ'); // m = 6.0z = m / n; // z = .6x = (int) z; // x = 1// רע f = 13.486;n = תקרה (ו); // n = 14.000// רעf = -13.486;n = floorf (f); // n = -14.000// רע בגלל חוסר עקביותf = 0.50; n = תקרה (ו); // n = 1.0n = floorf (f); // n = 0.0f = -0.50; n = תקרה (ו); // n = 0.0n = floorf (f); // n = -1.0// עדיין לא טוב f = 0.50;n = 0.1; // מקום 1m = f / n; // m = 5.0מ '= תקרה (מ'); // m = 5.0z = m / n; // z = 0.5x = (int) z; // x = 0 לא כל כך טוב// נסה את roundf f = 0.5;m = עגול (ו); // m = 1.0p = roundf (-f) // m = -1.0f = -0.5;m = עגול (ו); // m = -1.0p = roundf (-f) // m = 1.0

תשובה 3:

אתה יכול לעשות זאת באמצעות יציקת סוג. התחביר הוא-

דוגמא:

לצוף x;

x = 3.14;

int y;

y = (int) x;

printf ("% d", y);

תְפוּקָה:

3

מה באמת קרה? אסביר זאת על ידי אנלוגיה מפורסמת.

תחשוב על דלי מלא לחלוטין במים. עכשיו נניח שיש לך ספל. מהם המים המרביים שתוכלו להוציא מהדלי? תשובה- ספל.

כאן הדלי צף (4 בתים), והספל הוא int (2 בתים). יציקת סוג היא תהליך המילוי, והמים (נתונים) הולכים לאיבוד תוך כדי כך.

מקווה שזה עוזר;)


תשובה 4:

לא ניתן להמיר כל מספר צף למספר שלם. אך ניתן להמיר מספר שלם לצוף באמצעות הפורמט שלו

מפרט

שמוצג בדוגמה שלהלן ניתן להעביר לצוף למשתנה מסוג שלם. לאחר שהערך מועבר למשתנה שלם הוא מומר לערך צף.

#לִכלוֹל

מספר ריק (int e)

{

printf ("% d", e);

}

int main ()

{

לצוף c = 9.0000;

מספר (ג);

}

בדוגמה לעיל העברנו ערך צף למשתנה שלם. התפוקה של התוכנית הנ"ל תהיה 9.


תשובה 5:

ישנן מספר גישות לעיגול. עיין בפונקציות הספרייה האלה, שהיו זמינות מאז C99:

  • roundf, המחזיר צף שהוא הערך האינטגרלי הקרוב ביותר לארגומנט, כאשר מקרים באמצע הדרך מעוגלים מאפס.
  • floorf, שמתעגל כלפי מטה, ומחזיר את הערך האינטגרלי הגדול ביותר שאינו גדול מהוויכוח.
  • ceilf, שמתעגל כלפי מעלה, ומחזיר את הערך האינטגרלי הקטן ביותר שאינו פחות מהוויכוח.
  • בקרבת מקום intf, שמתעגל לערך אינטגרלי, תוך שימוש בכיוון העיגול שצוין על ידי fegetround (שמחזיר ערך המציין את מצב כיוון העיגול, כמפורט בסביבת הנקודה הצפה הנוכחית).

כל אחת מהפונקציות הללו מקבלת ארגומנט float ומחזירה תוצאת float, שאותה תוכל להעביר ל- int.


תשובה 6:

הפונקציה round () במתמטיקה.ה תעבוד. הדברים הבאים צריכים להיאסף ולעבוד בסדר גמור (אם כי לא ממש הידורתי אותו):

#לִכלוֹל / * ייבא את אב הטיפוס לסיבוב () ממתמטיקה * סיבוב כפול (כפול); * /#לִכלוֹל int main () { לצוף i = 5.4, j = 5.6; / * כל אחד מהבאים מטיל באופן מרומז את המצוף לכפול * עבור הפרמטר ואז התוצאה הכפולה יכולה להיות בבטחה* יצוק ל- int ללא אובדן דיוק. ברור שאתה * אולי תרצה להשתמש זמן רב במקום int אבל זה יהיה תלוי * בטווח הצפוי שלך. * /int ii = (int) עגול (i); / * שמות משתנים חרידים אבל זו רק דוגמה. * / int jj = (int) עגול (j);/ * כעת הדפיס את הערכים. * / printf ("סיבוב של% f הוא% f שהוא גם% d \ n", i, סיבוב (i), ii); printf ("סיבוב של% f הוא% f שהוא גם% d \ n", j, עגול (j), jj); החזר 0;}

הדוגמה שונה מ:

C - פונקציה עגולה ()

.


תשובה 7:

כדי להמיר מספר צף למספר שלם, עליכם להשתמש בהטלת סוג (Typecasting, או סוג המרה, היא שיטה לשינוי ישות מסוג נתונים אחד למשנהו).

#לִכלוֹל ריק ראשי () { לצוף var1 = 3.141592653589793238; int var2;var2 = (int) var1; // typecasting (המרת float למספר שלם) printf ("ערך שלם:% d", var2);}

תְפוּקָה


תשובה 8:

תשובה: (int)

אתה יכול פשוט להשתמש ב- cast (int) כדי להמיר float למספר שלם.

ככה

your_variable = (int) your_variable

מה זה התפקיד של (int)?

זה אומר למהדר שאתה רוצה להתייחס לערך שהוחזר על ידי malloc כמצביע למספר שלם.


תשובה 9:
לצוף a = 2.33;int b = (int) a;printf ("% d", b);

התפוקה תהיה: 2


תשובה 10:

יציקה מסוג אוטומטי מתרחשת כאשר,

  • שני הסוגים תואמים
  • סוג היעד גדול יותר מסוג המקור

דוגמא :

מבחן כיתה ציבורית{ ראשי סטטי ציבורי ריק (מחרוזת [] טוענת) { int i = 100; ארוך l = i; // אין צורך בהטלת סוג מפורשתלצוף f = l; // אין צורך בהטלת סוג מפורשת System.out.println ("ערך Int" + i); System.out.println ("ערך ארוך" + l); System.out.println ("ערך צף" + f); } }

פלט:

ערך Int 100ערך ארוך 100ערך צף 100.0

תשובה 11:

ובכן, אתה יכול להשתמש בשתי פונקציות, "רצפה ()" ו- "תקרה ()" כדי להמיר ערך צף למספר שלם. דוגמא:-

לצוף a = 3.5;

int b = רצפה (a); // זה יקבע "b" ל -3

int b = ceil (a); // זה יקבע את "b" ל -4