אינט הוא מספר שלם כמו 47 ללא נקודה עשרונית. אינך יכול ללדת 4.5 תינוקות או לולאה 32.9 פעמים. אתה יכול לקבל 25.76 $ אם אתה משתמש במרחף. לכן כשאתה יוצר את התוכנית שלך, עליך להחליט באיזה סוג להשתמש.
זה מה שעושות כמה שפות תסריטים? מכיוון שזה לא יעיל, צפים תופסים יותר זיכרון ובאופן כללי הם איטיים יותר מאשר אינץ '. כמו כן, אינך יכול בקלות להשוות בין שני צפים כדי לראות אם הם שווים כמו שאתה יכול עם אינץ '.
כדי לתפעל מספרים צריך לאחסן אותם בזיכרון. מכיוון שניתן לשנות בקלות את הערך, זה נקרא משתנה.
ה מהדר שקורא את התוכנית שלך וממיר אותה לקוד מכונה צריך לדעת איזה סוג זה הוא, כלומר אם זה אינט או צף, אז לפני שהתוכנית שלך משתמשת במשתנה, עליך להכריז זה.
תבחין כי משתנה הדלפק מוגדר כ- 0. זהו אתחול אופציונלי. זה תרגול טוב מאוד לאתחל משתנים. אם לא תאתחל ואז תשתמש בהם בקוד מבלי שקבעת ערך התחלתי, המשתנה יתחיל בערך אקראי שעשוי 'לשבור' את הקוד שלך. הערך יהיה מה שהיה בזיכרון בעת טעינת התוכנית.
מה המספר הגדול ביותר שיכול לאחסן בחנות?. ובכן, זה תלוי בסוג של מעבד אך בדרך כלל זה מקובל כ- 32 ביטים. מכיוון שהוא יכול להכיל ערכים שליליים כמעט כמו חיוביים, טווח הערכים הוא +/- 2
-32 ל -232 או -2,147,483,648 עד +2,147,483,647.זה מיועד לחתום, אבל יש גם לא חתום int שמחזיק אפס או חיובי. יש לו טווח של 0 עד 4,294,967,295. רק תזכור - נמלים לא חתומים לא צריכים שלט (כמו + או -1) לפניהם מכיוון שהם תמיד חיוביים או 0.
יש סוג אינט קצר יותר, שנקרא במקרה מקוצר int שמשתמש ב- 16 סיביות (2 בתים). זה מכיל מספרים בטווח -32768 עד +32767. אם אתה משתמש בסבך גדול של אינץ ', אתה יכול לחסוך זיכרון באמצעות קלטות קצרות. זה לא יהיה מהיר יותר, למרות שהוא מחצית הגודל. מעבד 32 סיביות שואפים ערכים מהזיכרון בבלוקים של 4 בתים בכל פעם. כלומר 32 סיביות (מכאן השם - מעבד 32 סיביות!). אז השגת 16 סיביות עדיין דורשת אחזור של 32 סיביות.
יש 64 סיביות ארוכות יותר שנקראת ארוך ארוך בסי. ישנם מהדרים C ++ שאינם תומכים בסוג זה ישירות להשתמש בשם חלופי - למשל גם בורלנד וגם מיקרוסופט משתמשים _int64. זה כולל טווח של -9223372036854775807 עד 9223372036854775807 (חתום) ו- 0 עד 18446744073709551615 (לא חתום).
אלא אם כן אתם מבצעים תכנות מדעית עם מספרים גדולים או קטנים מאוד, תוכלו להשתמש בכפולות רק לדיוק רב יותר. הצפות טובות ל 6 ספרות של דיוק, אך הכפולות מציעות 15.
קחו למשל את המספר 567.8976523. זהו ערך צף תקף. אבל אם נדפיס אותה באמצעות הקוד הזה למטה, תוכלו לראות חוסר דיוק מופיע. למספר יש 10 ספרות אך הוא מאוחסן במשתנה לציפה עם שש ספרות בלבד של דיוק.
ראה אודות קלט ופלט לפרטים על אופן פעולתו של קוט ואיך להשתמש ברמת דיוק. דוגמה זו מגדירה את דיוק הפלט ל 8 ספרות. למרבה הצער הצופים יכולים להחזיק רק 6 וכמה מהדרים יעבירו אזהרה לגבי המרת כפול לציפה. כשאתה מפעיל, זה מדפיס 567.89764
אם תשנה את הדיוק ל -15, הוא יודפס כ- 567.897644042969. הבדל לא קטן! כעת העבירו את הנקודה העשרונית שתיים שמאלה כך שהערך הוא 5.678976523 והפעל מחדש את התוכנית. הפעם זה פלט 5.67897653579712. זה מדויק יותר אך עדיין שונה.
אם תשנה את סוג הערך לכפול ואת הדיוק ל -10 הוא ידפיס את הערך בדיוק כפי שהוגדר. ככלל, הצפות שימושיות למספרים קטנים ולא שלמים, אך עם יותר מ- 6 ספרות, עליך להשתמש בכפולים.
כתיבת תוכנות מחשב לא תועיל מאוד אם לא היית יכול לעשות חיבור, חיסור וכו '. להלן דוגמא 2.
כמו גם תוספת, אתה יכול לעשות חיסור, כפל וחלוקה. פשוט השתמש ב- + לתוספת, - לחיסור, * לכפל ו / לחלוקה.
עם צפים אין לך שליטה על מספר הנקודות העשרוניות המוצגות אלא אם תגדיר את הדיוק כפי שמוצג קודם.
כעת ניתן להגדיר רוחב, יישור, מספר מקומות עשרוניים ושלטים על ידי קוט חפץ ו iomanip כולל פונקציות קבצים.
אלפי מפרידים הם קצת יותר מסובכים. הם מוגדרים ממקומם של מחשב אישי. אזור מכיל מידע הרלוונטי למדינה שלך - כמו סמלי מטבעות ונקודה עשרונית ואלפי מפרידים. בבריטניה ובארה"ב המספר 100.98 משתמש בנקודה עשרונית. כנקודה עשרונית בעוד שבמדינות אירופה מסוימות מדובר בפסיק, אז 5,70 אירו פירושו מחיר של 5 אירו ו -70 סנט.
יוצר אובייקט mpunct שזו התייחסות ל מונע כספי כיתת תבניות. זה כולל מידע על האזור שצוין - במקרה שלנו, ה- אלפי_סט () השיטה מחזירה את התו המשמש לאלפי מפרידים.
הערה נראה שיש פערים בין מהדרים שונים באשר לאופן cout.imbue מתנהג. תחת Visual C ++ 2005 Express Edition, זה כלל מפרידים. אבל אותו קוד עם Microsoft Visual C ++ 6.0 לא!
אם אתה משתמש באחד משני מצבי העיצוב האלה דרך cout.setf לאחר מכן דיוק() קובע את מספר המקומות העשרוניים אחרי הנקודה העשרונית (לא את המספר הכולל של הספרות) אך אתה מאבד את אלפי העיצוב. כמו כן נגררים אפסים (כפי שהופעלו על ידי ios_base:: נקודת תצוגה ) הופכים אוטומטית ללא צורך נקודת תצוגה.
הייתם מצפים למשהו כמו ערך של 11.0909090909. למעשה, הערך הוא 11. למה זה? בגלל ה ביטוי בצד ימין (ידוע כ ערך) הוא מספר שלם / מספר שלם. אז הוא משתמש בחשבון מספר שלם שזורק את החלק השבר ומקצה 11 ל- f. משנה את זה ל
ב- C אין סוג כזה כמו bool. ביטויים ב- C התבססו על כך שאפס הוא שקר או שאינו אפס נכון. ב- C ++ הסוג bool יכול לקחת את הערכים נכון או שקר. ערכים אלה עדיין שווים ל- 0 ו -1. איפשהו במהדר שיהיה לו
או לפחות זה מתנהג כך! שני השורות שלמטה תקפות ללא הליהוק, כך שמאחורי הקלעים, גלגלים ממירים באופן מרומז לאינטס ואפילו ניתן להגדיל אותם או לפרוס אותם אם כי זהו תרגול רע מאוד.
ה- if עדיין יעשה את ה- if כיוון שהמשתנה הרע הוא לא אפס אבל זה קוד רע ויש להימנע ממנו. תרגול טוב הוא להשתמש בהם כפי שהם נועדו. אם (! v) הוא C ++ תקף אבל אני מעדיף את המפורש יותר אם (v! = 0). עם זאת, זה עניין של טעם, לא חייב לעשות הנחיה.
עדיף למהדר לתפוס שגיאות בזמן ההרכבה מאשר למשתמש בזמן ההפעלה