ייצוג מספרים במחשב
00001101. לחישוב: 1 כפול 2 בחזקת 0, ועוד 1 כפול 2 בחזקת 2, ועוד 1 כפול 2 בחזקת 3, כלומר 1 + 4 + 8 = 13.sbyte שומר מ-128- עד 127, כי הביט השמאלי שמור לסימן. לכן טיפוס שמסוגל לערכים שליליים מכיל פחות ערכים חיוביים.0xFF הוא 255, הערך המקסימלי של בית.byte.MaxValue ו-sbyte.MinValue מציגים את הגבולות של הטיפוס.פרקי ההרצאה: ייצוג מספרים במחשב
תמלול ההרצאה: ייצוג מספרים במחשב
הטקסט המלא של הדקות הראשונות בהרצאה «ייצוג מספרים במחשב» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
אנחנו מגיעים לנושא בו אנחנו הולכים לראות כיצד המחשב שומר בדיוק את המידע שלנו בתוך משתנים בזיכרון. הנושא הזה נקרא ייצוג מספרים במחשב.
עכשיו, למה חשוב לנו לדעת איך המחשב שומר את המידע שאנחנו נותנים לו בזיכרון שלו, הרי זה פעולות פנימיות שהוא מבצע. הסיבה היא כי אם אנחנו נדע בדיוק מה הוא עושה כאשר הוא שומר את המידע בזיכרון, יהיה לנו המון מידע לגבי זה ונוכל להבין הרבה דברים לגבי זה.
לדוגמה, נוכל להבין כמה אנחנו יכולים לשמור מבחינת מספרים לדוגמה אם יש לנו משתנה מסוג בייט או משתנה מסוג אינטג'ר. נוכל לדעת כמה תווים שונים אנחנו יכולים לשמור בתוך משתנה צ'אר.
למה לפעמים ישנה גלישה של זיכרון במחשב ועוד כל מיני דברים בנוגע לזה. בשביל להבין איך המחשב שומר את המידע אנחנו צריכים להכיר שפה שנקראת שפה בינארית. שפה בינארית בעצם זה ייצוג מספרים על ידי שתי ספרות בלבד.
המחשב שומר מספרים על ידי שפה בינארית. קודם כל, כאשר אנחנו מדברים על מתמטיקה, ואנחנו מתקשרים על ידי מספרים במתמטיקה, אז אנחנו יודעים שיש לנו עשר ספרות. הסיבה שהמתמטיקה של המין האנושי מכילה עשר ספרות זה בגלל שלמין האנושי יש עשר אצבעות.
אז מאוד קל לא לחשב עם הקונספט של עשר ספרות. אבל כל מספר יכול להיות מיוצג על ידי מספר שונה של ספרות, כלומר, אותו מספר אנחנו יכולים לייצג על ידי 10 ספרות, על ידי 11 ספרות, על ידי 2 ספרות, על ידי 30 ספרות וכולי.
זה לא משנה כמה ספרות יש במתמטיקה, עדיין אנחנו יכולים לייצג מספר. אם יש לנו לדוגמה 30 תפוחים, אנחנו יכולים לרשום 30 תפוחים על ידי 3,0, ואז זה אומר שאנחנו מייצגים את המספר 30 תפוחים בייצוג דצימלי, זה לא ייצוג של המתמטיקה הרגילה.
יכולים אבל לייצג אותו על ידי כל סוג אחר של מתמטיקה, כלומר על ידי ספרות אחרות. אז קודם כל אנחנו צריכים להבין את השפה הבינארית.
לצורך כך בואו נפתח פה איזושהי טבלה. נגדיר פה איזושהי טבלה, בעמודה השמאלית נגדיר דצימל, בעמודה האמצעית דינארי, ואת העמודה הזאת אנחנו נשמור לשלב מאוחר יותר.
אנחנו רוצים לספור בשיטה דצימלית. דצימלית זה אומר שיש לנו 10 ספרות. אז מה בעצם אנחנו עושים? אז אנחנו רוצים לייצג את הספרה 0, והיא פשוט 0.
לאחר מכן עומדת הספרה 1, 2, 3, 4, 5, 6, 7, 8, 9. ופה נגמרו לנו הספרות. מה אנחנו עושים? אז כולנו יודעים שאנחנו הולכים לרשום 1, 0.
אבל מה בעצם עשינו כאן? 0 יכול להיות מיוצג על ידי 0, 0. 1 יכול להיות מיוצג על ידי 1, 0, או יותר דיוק 0, 1. לאחר מכן 0, 2, 0, 3 וכולי, ועדיין אנחנו מקבלים את הספרות 0, אבל אם אנחנו עכשיו רוצים לקחת את הספרה הבאה בתור אז בעצם אפשר להגיד שסיימנו לרשום 0 ואז את הספרה,
0 ואז את הספרה וכולי ואנחנו עכשיו לוקחים את הספרה הבאה כ-1 ומתחילים לרשום 1 ואז הספרה 0, 1 ואז הספרה 1, 1 ואז הספרה 2 וכולי, 3, 1, 4, בואו נשלים את זה, יש לנו פה טבלה 1, 5, 1,
1, 6, 1, 7, 1, 8, 1, 9 וסיימנו בעצם את הספרה 1. אז אנחנו יכולים לקחת את הספרה הבאה בתור שהיא 2 ולהתחיל לרשום 2 ולספור מההתחלה 2, 0, 2, 1, 2, 2 וכו'.
אז אנחנו יודעים שככה אנחנו בעצם סופרים עם 10 ספרות. למה אני מראה לכם את זה? כי זאת בדיוק השיטה שבה אנחנו סופרים בכל שיטה של מספר אחר של ספרות שקיימות.
אוקיי, אז אם אנחנו נמצאים בעולם הבינארי ויש לנו רק שתי ספרות, הספרות יהיו כמובן 0 ו-1. ופה סיימנו סבב 1.
אבל מה זה אומר 0? זה אומר שיש לנו 0,0 ו-1 זה אומר שיש לנו 0,1. אז זה נראה כאילו שסיימנו את הסבב הזה עם ה-0, ועכשיו אנחנו יכולים להתחיל סבב עם 1.
1,0 ולאחר מכן 1,1. ברירות פעם סיימנו. אז אנחנו יכולים להחליט בעצם שזה כאילו שיש לנו אפסים פה. אפס אפס אפס אפס אפס אפס אפס אחד וכולי. אז אנחנו יכולים עכשיו לקחת את האחד לשים אותו פה ויש לנו אפס אפס אחד אפס אחד אחד אפס אחד אחד ואז סיימנו סבב נוסף.
כאן אנחנו יכולים להגיד שבעצם כולם מתחילים באפס ולכן כאן בגלל שאין לנו יותר מקום לשים אחדים האחד קופץ לצד שמאל והכל אפסים.
בדיוק כמו שהיה לנו תשע תשע תשע ואז אחד היה קופץ וכולם אפסים. הספר הבא אחרי 999 זה 1000. אוקיי, אז בואו נמשיך, יש לנו 1001, 1010, 1011, 1100, לאחר מכן 1101, 1110 ולבסוף 1111.
כאן בעצם רשמנו את כל הספרות מ-0 עד 15 בבסיס דצימאלי, זה נקרא בסיס 10, וכאן רשמנו את כל הספרות מ-0 עד 15 אבל בבסיס בינארי זה אומר מ-0 עד 1111 שזה 15 בבסיס סימאלי.
בואו ניפטר משאר השורות שיש לנו אנחנו לא נצטרך אותן ונראה מה זאת העמודה הזאת. בגלל שקשה להסתכל ולהבין מה קורה בכל הספרות בייצוג בינארי אז אנחנו יכולים לייצג עם עוד ייצוג שנקרא ייצוג הקסא דצימאלי.
נהוג לקרוא לזה הקס. סוג הקס הדצימלי אומר יש לנו סך הכל 16 ספרות ולכן אנחנו יכולים לייצג את המספרים 0 עד 15 עם ספרה אחת והספרות הן 0, 1, 2, 3, 4, 5, 6, 7, 8, 9.
כאן סיימנו את הספרות הרגילות אז יש לנו a, b, c, d, e, f. כך לדוגמה אם אנחנו אומרים את הספרה d, זאת ממש ספרה בבסיס הקסה אנחנו מתכוונים ל-1101 בבינארי או למספר 13 בדצימלי.
זאת אומרת שאנחנו יכולים להגיד שיש לנו 13 תפוחים או 1101 תפוחים או D תפוחים וזה יהיה אותו מספר של תפוחים אנחנו פשוט צריכים להבין באיזה בסיס אנחנו מדברים כרגע אז העולם תמיד מדבר בבסיס דצימלי אבל מחשבים מדברים תמיד בבסיס בינארי בסיס הקסה זה בכדי שאנחנו המתכנתים נוכל להבין יותר טוב
איך לקרוא בסיס בינארי על ידי זה שאנחנו מייצגים את המספרים בבסיס בינארי על ידי ספרות של הקסה אוקיי בואו נסדר טיפה את כל הסיפור הזה יש לנו כאן את הטבלה הזאת ואנחנו יכולים לראות מה בעצם קורה כאשר אנחנו פותחים משתנה במחשב אז כאשר אנחנו פותחים משתנה לדוגמה בואו נלך ונפתח בית n1 ואנחנו רוצים עכשיו להכניס לתוך n1 איזשהו
מספר בואו נוסיף את המספר נכניס את המספר 13 מה בעצם קיים בתוך n1 אם אנחנו נדפיס אותו אנחנו כמובן נראה את המספר 13 מפני שכאשר אנחנו מציגים אז המחשב מציג לנו אותם בבסיס דצימלי.
אבל איך המחשב שמר את המספר 13 בתוך הזיכרון n1, בתוך תא הזיכרון n1? מה שהמחשב עשה הוא היה חייב להפוך את המספר 13 מדצימלי לבינארי והסיבה היא כי המידע נשמר בתוך זיכרון שהזיכרון עצמו מכיל רכיבים שנקראים טרנזיסטורים.
הטרנזיסטור יכול לשמור אחד משני ערכים או 0-1 לוגי. הוא עושה את זה על ידי שמירת שני מתחים חשמליים שונים, משהו כמו 0.3 מיליוולט מול 0.5 מיליוולט, משהו בסגנון, וכך המחשב יכול לדעת מה הערכים שיש לו.
הזיכרון בנוי מהרכיבים האלה. כל סיבית כזאת או כל ספרה כזאת בעצם נקראת סיבית בעברית, ביט באנגלית וביט מסוגל לשמור או 0 או 1 על ידי טרנזיסטור אחד ויחיד.
כאשר אנחנו פותחים תא זיכרון אנחנו פותחים בבת אחת תפולות של 8 ביטים. הבית הכי קטן שאפשר לפתוח או תא זיכרון הכי קטן שניתן לפתוח בפישאר זה תא מסוג בית והוא בעצם גודלו 8 ביטים בלבד וזה נקרא בית 8 ביטים ובית.
אז אם אנחנו עכשיו נלך ונייצר פה איזושהי טבלה שתתאר לנו בדיוק שמונה ביטים: 1, 2, 3, 4, 5, 6, 7, 8. אנחנו נוכל לראות שיש לנו כאן בעצם תרשים שמייצג לנו בית אחד שנפתח בזיכרון עם שמונה ביטים.
לכל ביט יש אינדקס כאשר הביט השמאלית ביותר נחשבת כביט החשובה ביותר, זה נקרא Most Significant Bits והביט הימנית נחשבת הביט הפחות חשובה, ביט ואנחנו יכולים לתת להם אינדקסים יש לנו פה שבע שש חמש ארבע שלוש שתיים אחד ואפס והאינדקסים של הסיביות השונות הם חשובים בשביל לחשב את המספר אז כעת יש לנו בית אחד שנפתח
בזיכרון שמוגדר משמונה ביטים כאשר כל ביט יכול לקבל או אפס או אחד תחשבו שיש למחשב פה שמונה טרנזיסטורים שכל טרנזיסטור יכול להחזיק שני מתחים וכך הוא יכול לייצג מספר בשפה בינארית.
אז אם אנחנו הכנסנו בתוכנית כאן את המספר 13, מה בעצם נכנס כאן? אז 13, אם אנחנו מסתכלים עליו, 13 היה בדצימלי.
אם אנחנו עוברים לבינארי, שזה מה שהמחשב מכניס לזיכרון, אנחנו רואים שזה 1101. אבל רגע, יש לנו פה 8 ביטים.
אז מה שהמחשב עושה הוא משלים אפסים מצד שמאל, וזה בעצם נותן לו את אותו המספר. יש לנו פה 0, 0, 0.
לאחר מכן אנחנו רואים שאנחנו מתחילים את המספר עצמו 1101. וזה בדיוק מה שהמחשב שומר בזיכרון כאשר אנחנו מכניסים את המספר 13. איך המחשב יכול לחשב בחזרה שזה 13?
ויש נוסחה מאוד פשוטה שהמחשב יכול לעבוד איתה בכדי להגיד לנו ש-1101 זה בעצם 13. והנוסחה אומרת דבר כזה decimal number שווה ל-first beat כפול time בחזקת first index של הביט ועוד second beat כפול 2 בחזקת second ועוד כולה וכולה וכולה עד שאנחנו מגיעים ל-nth full time שזה בעצם
הבסיס כי יש לנו שתי ספרות בחזקת nth index. בואו נחשב את זה, מה יש לנו בעצם? יש לנו first bit שזה 1 כפול 2 בחזקת 0 ועוד 0 נכון, אנחנו מגיעים בדיוק לפה כפול 2 בחזקת 1 ועוד 1 כפול 2 בחזקת 2 לאחר מכן יש לנו עוד פעם 1 כפול 2 בחזקת 3 לאחר מקרן יש לנו 0 כפול 2
בחזקת 4, 0 כפול 2 בחזקת 5, 0 כפול 2 בחזקת 6 ולבסוף 0 כפול 2 בחזקת 7. כל הדבר הזה אנחנו יכולים להסתכל עליו ולהגיד אם יש לנו 0 כפול משהו אנחנו יכולים פשוט להתעלם מזה מפני ש-0 כפול כל דבר שווה 0 ובואו נוריד את האפסים כל מה ש-0 פשוט נוריד אותו ויש לנו בעצם הורדה של כל אלה.
מה שנשאר לנו זה 1 כפול 2 בחזקת 0 ועוד 1 כפול 2 בחזקת 2 ועוד 1 כפול 2 בחזקת 3. 2 בחזקת 0 זה 1 אז יש לנו 1 כפול 1 ועוד 1 כפול 2 בחזקת 2 ו4 ועוד 1 כפול 2 בחזקת 3 ו8. 1 כפול כל מספר שווה 1 ולכן יש לנו 1 ועוד 4 ועוד 8. זה שווה ל-13.
בעצם מה שרציתי להראות כאן זה שאנחנו יכולים פשוט לקחת את החזקות של 2 של איפה יש 1 אם יש פה 1 וחזקה של 2, 2 חזקת 0 ו-0 זה 1 ואנחנו לוקחים 1 ועוד 4 ועוד 8 וכולי ואז מגיעים למספר.
כאן אנחנו רואים שעל ידי ייצוג בינארי המחשב הצליח לשמור 13. כך המחשב יכול לשמור כל מספר אבל מה המספר המקסימלי שניתן להכניס בתוך בית אחד?
הרי אנחנו רוצים גם להצליח להרוויח משהו מכל הסיפור הזה שאנחנו יודעים את זה. אז המספר המקסימלי כמובן יהיה מספר שהוא הכל אחדים. בואו ניקח את כל הסיפור הזה, נעתיק, נדביק לפה ונשנה פשוט את כל מקום לאחד ונחשוב מה בדיוק יש לנו פה.
כאן אנחנו רואים שיש לנו את המספר הבא 2 בחזקת 0 ועוד 2 בחזקת 1 ועוד 2 בריבוע ועוד 2 בחזקת 3 ועוד 2 בחזקת 4 ועוד 2 בחזקת 5 ועוד 2 בחזקת 6 ועוד 2 בחזקת 7 ועוד 2 בחזקת 8 ליתר דיוק 2 בחזקת 7 זה הערך הסופי.
ואם אנחנו נחשב את כל החזקות האלה ביחד אנחנו נגיע ל-255. 255 זה הערך המקסימלי שניתן להחזיק בתוך בית אחד. אם אנחנו נחזור לתוכנית וננסה להכניס לתוך הבית הזה 255 אנחנו נראה שאין לנו שום בעיה ואכן אנחנו מצליחים לעשות את זה.
אבל אם אנחנו ננסה להכניס 256 אנחנו כבר עכשיו הולכים לחטוף שגיאת קומפילציה והמערכת לא מוכנה לעשות את זה בגלל שהיא יודעת שהמקסימום יכול להיות 256. אוקיי, אז כבר אנחנו רואים איך ניתן לחשב את הגבול העליון של הטיפוסים השונים שקיימים לנו.
בואו נחזיר את זה ל-13. יש לנו טיפוס נתונים שנקרא sbyte. s זה קיצור של signed. כלומר, אם אנחנו עכשיו פותחים n2 ואנחנו מכניסים לדוגמה 128, אז אנחנו רואים שיש לנו בעיה להכניס אפילו 128.
למה? מפני שsbyte תופס בזיכרון גם כן byte אחד, אבל אם הסוגים השונים של המספרים השלמים שקיימים, לדוגמה byte, sbyte, int, long, short, מסוגלים להחזיק גם ערכים שליליים, לדוגמה s-bite, זה אומר שה-most significant bit שלהם,
ה-cb הזאת, שמורה בשביל הסימן. והיא אומרת דבר כזה: אם אני 0, אז המספר שיש בכל המשתנה הוא חיובי. אם אני 1, המספר שיש בכל המשתנה הוא שלילי.
ובגלל שאיבדנו cb אחת, אז אנחנו בעצם משחקים פה רק עם 7 cb ולא עם 8 cb, מספר מתקצץ בחצי זאת אומרת שאם יש לנו טיפוס נתונים שמסוגל להיות שלילי טיפוס נתונים שמסוגל לשמור מספרים שלמים הכוונה שמסוגל להיות שלילי כמו sbyte אז המקסימום שלו זה פלוס מינוס חצי מהערכים שיכולים להיכנס
בתוך בית זאת אומרת בית יכול להכיל 0 עד 255. s-byte יכול להכיל מינוס 128 עד פלוס 127 וזאת הסיבה ש-128 לא יכול להיכלל בתוך s-byte זה פלוס 255. כאן אנחנו רואים למה מספרים שמסוגלים להחזיק או יותר נכון טיפוסים שמסוגלים להחזיק ערכים שליליים יכולים להחזיק פחות מטיפוסים שמסוגלים להחזיק ערכים חיוביים
בלבד. אינט מסוגל להחזיק גם שלילי גם חיובי. U-Int מסוגל להחזיק רק חיובי כי הוא Unsigned Integer.
אז כמובן שטווח הערכים הוא מ-0 אבל הוא פי שתיים מהמקסימום שאינט יכול להחזיק. בכל מקרה יש לנו אפשרות להסתכל על בייט נקודה מקס ואליו או מין ואליו ולראות בדיוק את הערכים האלה.
לדוגמה אם אנחנו נדפיס בייט נקודה מין ואליו ובייט נקודה מקס ואליו אנחנו הולכים לראות בעצם את הגבולות של בייט ואנחנו רואים 0 עד 255. אם אנחנו הולכים להדפיס sbyte.min value ואת sbyte.max value אנחנו הולכים לראות מינוס 128 עד 127 שבייסיקלי זה בדיוק אותו הטווח אבל הוא בין שלילי לחיובי.