‫קורס יסודות התכנות בשפת ‪C‬‬

‫פרק ‪14‬‬
‫סיביות‪/‬ביטים ובתים ‪Bits & Bytes‬‬

‫שייקה בילו‬
‫יועץ ומרצה בכיר למדעי המחשב וטכנולוגית מידע‬
‫מומחה למערכות מידע חינוכיות‪ ,‬אקדמיות ומנהליות‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪1‬‬ ‫‪Shayke Bilu‬‬
 ‫חזרה ‪ -‬רשימות מקושרות‬
‫‪2‬‬

‫‪ ‬ידוע לכל מתכנת כי במערכות רבות קיימת תחלופה תכופה של‬

‫אובייקטים (מחיקה והוספה בקצב מהיר)‪.‬‬
‫‪ ‬למשל במערכת לניהול ספרים בספריה‪ ,‬מערכת לרישום סטודנטים‬
‫באוניברסיטה‪ ,‬מערכת מעקב במצלמות כביש ‪ ,6‬מערכות ניווט וכו'‪.‬‬
‫‪ ‬במידה ומייצגים את הנתונים באמצעות מערך‪ ,‬יש להעתיק את‬
‫כל המערך מחדש כל פעם כשצריך להוסיף משהו‪ ,‬ו‪"-‬לצופף"‬
‫את כל המערך כשצריך למחוק משהו מהאמצע‪.‬‬
‫‪ ‬זה לא יעיל‪.‬‬
‫‪ ‬זה לא נוח‪.‬‬
‫‪ ‬זה לא סביר‪.‬‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 ‫חזרה ‪ -‬רשימות מקושרות‬
‫‪3‬‬

‫‪ ‬לעבודה עם רשימות גדולות שיש בהן שינויים תכופים‬

‫משתמשים ברשימה מקושרת במקום להשתמש במערך‪.‬‬
‫‪ ‬בניגוד למערך‪ ,‬שהוא אוסף של תאים רצופים‪ ,‬רשימה מקושרת‬
‫היא אוסף של תאים לא רצופים‪ ,‬שכל אחד מהם כולל גם מצביע‬
‫לתא שאחריו ברשימה‪.‬‬
‫‪ ‬כפי שאמרנו‪ ,‬זה מקל מאוד על ביצוע תוספות ומחיקות‪ ,‬בלי צורך לשנות‬
‫את שאר תאי הרשימה‪.‬‬
‫‪ ‬כדי לעבור על הרשימה מספיק להחזיק מצביע לתא הראשון‬
‫שלה‪ ,‬וממנו להתקדם לתא הבא‪ ,‬וכן הלאה‪.‬‬
‫‪ ‬המוסכמה היא שהתא האחרון ברשימה מצביע על ‪.NULL‬‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 ‫חזרה ‪ -‬רשימה מקושרת של מספרים‬
‫‪4‬‬

‫שדה מידע‬ ‫שדה מידע‬ ‫שדה מידע‬ ‫שדה מידע‬

‫התחלת‬ ‫סוף‬
‫רשימה‬ ‫‪3‬‬ ‫‪5‬‬ ‫‪7‬‬ ‫‪9‬‬ ‫רשימה‬

‫מצביע‬ ‫מצביע‬ ‫מצביע‬ ‫מצביע‬

‫לעומת מערך‪:‬‬
‫‪3 5 7 9‬‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 ‫חזרה ‪ -‬הוספת איברים לרשימה‬
‫‪5‬‬

‫‪ ‬מעצם טבעה של רשימה מקושרת (שיש בה תוספות ומחיקות)‪,‬‬

‫מספר האיברים בה לא ידוע מראש ואין עליו חסם‪.‬‬
‫‪ ‬אנחנו נדרשים להוסיף איברים במהלך ריצת התוכנית‪.‬‬
‫‪ ‬תוספת איבר לרשימה מקושרת תיעשה בעזרת הקצאה דינאמית‬
‫שלו‪ .‬הקצאה דינאמית של איבר אחד נעשית במקרה זה ע"י‪:‬‬
‫;‪Item *ptr‬‬
‫;))‪ptr = (Item *) malloc (sizeof(Item‬‬
‫‪ ‬נתאר פונקציה להוספת איבר כזה לרשימה‪.‬‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬

 ‫חזרה ‪ -‬מימוש רשימות מקושרות ב‪C-‬‬
‫‪6‬‬

‫‪ ‬בניגוד למערך‪ ,‬רשימה מקושרת איננה טיפוס משתנה שקיים‬

‫בשפת ‪.C‬‬
‫‪ ‬כדי לשמור נתונים ברשימה מקושרת‪ ,‬עלינו לבנות אותה‬
‫בעצמנו‪ ,‬ולממש בעצמנו את הפעולות אותן נבקש לבצע על‬
‫איבריה (כמו הוספת איבר‪ ,‬מחיקת איבר‪ ,‬חיפוש איבר‪ ,‬וכו')‪.‬‬
‫‪ ‬לעינו להקפיד כי האיבר האחרון ברשימה מצביע ל‪NULL -‬‬
‫ואילו האיבר הראשון מצביע לשני אחרת אין לנו בעצם רימה‬
‫מקושרת‪.‬‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬

 ‫חזרה ‪ -‬מימוש רשימות מקושרות ב‪C-‬‬
‫‪7‬‬

‫‪ ‬רשימה מקושרת היא למעשה פשוט אוסף האיברים שלה‬

‫(שמחוברים ביניהם)‪.‬‬
‫‪ ‬צריך להראות איך לממש איבר אחד ברשימה ואיך לקשר את‬
‫האיברים‪.‬‬
‫‪ ‬כפי שאמרנו קודם‪ ,‬כדי לעבוד עם רשימה מקושרת יספיק לשמור‬
‫את כתובת האיבר הראשון שלה‪ ,‬כי ממנו אפשר להתקדם‬
‫לאחרים‪.‬‬
‫‪ ‬קיימות רשימות מקושרות דו כיווניות וסיבוביות בהן האיבר‬
‫האחרון מצביע על הראשון וכך נוצר מעגל איברים‪.‬‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 ‫חזרה ‪ -‬מימוש רשימות מקושרות ב‪C-‬‬
‫‪8‬‬

‫‪ ‬איבר ברשימה ייוצג על‪-‬ידי מבנה שיכיל לפחות שני שדות‪:‬‬

‫שדה אחד יכיל מידע‪.‬‬ ‫‪‬‬
‫שני יכיל מצביע לאיבר הבא‪.‬‬ ‫‪‬‬

‫‪ ‬אז עבור הדוגמא של רשימת מספרים שלמים נגדיר איבר ע"י‪:‬‬

‫‪typedef struct Item‬‬
‫{‬ ‫‪3‬‬
‫;‪int data‬‬ ‫‪data next‬‬
‫;‪struct Item *next‬‬
‫;‪}Item‬‬
‫השדה ‪ data‬יכיל את המספר שהאיבר מכיל‪.‬‬ ‫‪‬‬
‫השדה ‪ next‬יכיל מצביע לאיבר הבא ברשימה‪( .‬אם אין איבר נוסף‪ ,‬כלומר זה‬ ‫‪‬‬
‫האיבר האחרון‪ ,‬אז ערך המצביע הזה יהיה ‪)NULL‬‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 ‫חזרה ‪ -‬מציאת איבר ברשימה‬
‫‪9‬‬

‫)‪Item *Find(Item *head, int value‬‬

‫הפונקציה מקבלת מצביע לראש הרשימה וערך מבוקש‬
‫{‬
‫כל עוד לא הגענו לסוף ולא מצאנו את‬
‫;‪Item *check = head‬‬ ‫הערך המבוקש – מתקדמים ברשימה‪.‬‬
‫=! ‪while ((check != NULL) && (check->data‬‬
‫))‪value‬‬ ‫כשהגענו לערך המבוקש או‬
‫;‪check = check->next‬‬ ‫לסוף‪ ,‬מחזירים מצביע למקום‬
‫שהגענו אליו‬
‫;‪return check‬‬
‫}‬ ‫(באופן דומה יכולנו לחפש את האיבר הראשון שמקיים תנאי כלשהו)‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬

 ‫חזרה ‪ -‬שחרור רשימה מקושרת‬
‫‪10‬‬

‫‪ ‬בסיום השימוש ברשימה נרצה לשחרר את כל הזיכרון שהיא‬

‫משתמשת בו‪.‬‬
‫‪ ‬בשונה ממערך שהוקצה דינאמית‪ free ,‬של ראש הרשימה משחרר רק את‬
‫האיבר הראשון‪.‬‬
‫‪ ‬כל אחד מאיברי הרשימה הוקצה ע"י ‪ malloc‬נפרד‪ ,‬ו‪ free -‬משחרר את‬
‫מה שהוקצה בפקודת ‪ malloc‬אחת בדיוק‪.‬‬
‫‪ ‬נכתוב פונקציה שמקבלת מצביע לראש הרשימה ועוברת‬
‫ומשחררת את כל האיברים שהוקצו על ידי פונקציית ההוספה‪.‬‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬

 11

?‫שאלות על השעור הקודם‬

SCE-Chapter-14-Bits and Bytes Shayke Bilu

 ‫סיביות ובתים ‪Bits and Bytes -‬‬
‫‪12‬‬

‫‪ ‬נושאים‬
‫‪ ‬מבוא לסיביות ובתים‬
‫‪ ‬מדוע להשתמש בסיביות וביטים? מדוע לא בסיס ‪?10‬‬
‫‪ ‬ייצוג מידע בינארי ‪ /‬הקסה‪-‬דצימלי‬
‫‪‬ייצוג של בתים‬
‫‪‬מספרים‬
‫‪‬תווים ומחרוזות‬
‫‪‬פקודות )‪(instructions‬‬
‫‪ ‬פעולות ברמת הביטים‬
‫‪‬לוגיקה בוליאנית‬
‫‪ ‬כיצד הדבר נראה בתוכניות ‪? C‬‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 ‫מבוא לסיביות ובתים – ‪Bits and Bytes‬‬
‫‪13‬‬

‫‪ ‬זיכרון של מחשבים‪ ,‬ושל מיקרו‪-‬בקרים‪ ,‬הוא למעשה‬

‫רצף אחד ארוך של ביטים‪" :‬תאים" זעירים שכל אחד‬
‫מהם יכול להיות באחד משני מצבים מוגדרים מראש‬
‫(מצבים אותם אנחנו מכנים "‪ "0‬ו‪ .)"1"-‬כל משתנה‪ ,‬כל‬
‫ערך שאנחנו מציינים בתוכנה שלנו הוא בסופו של דבר‬
‫קטע קצר על פני הרצף הזה‪.‬‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬

 ‫מבוא לסיביות ובתים – ‪Bits and Bytes‬‬
‫‪14‬‬

‫‪ ‬רוב שפות התכנות המודרניות עושות מאמצים להסתיר‬

‫את העובדה הזאת‪ ,‬אבל היא נדרשת כשעובדים עם מיקרו‪-‬‬
‫בקרים‪.‬‬
‫‪ ‬נושא הביטים מתחלק לשני תת‪-‬נושאים עיקריים‪ :‬ייצוג‬
‫בינארי‪ ,‬ולוגיקה בוליאנית והם נושאים טכניים‪ .‬אף על פי‬
‫כן‪ ,‬מבין כל הנושאים שניים אלה הנושאים הכי קריטיים‪.‬‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬

 ‫מבוא לסיביות ובתים – ‪Bits and Bytes‬‬
‫‪15‬‬

‫‪ ‬ביטים כמייצגי מספרים‪:‬‬

‫ביט הוא תא שיכול להכיל ‪ 0‬או ‪ .1‬אם ניקח רצף קצר של‬
‫ביטים ממקום אקראי בזיכרון‪ ,‬נראה משהו דומה לזה‪:‬‬
‫‪ .0111001010011010‬מה זה אומר?‬
‫איך דבר כזה מתורגם למספרים שאנחנו מכירים?‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬

 ‫מבוא לסיביות ובתים – ‪Bits and Bytes‬‬
‫‪16‬‬

‫‪ ‬כשאנחנו כותבים מספר בבסיס עשר היומיומי והמוכר‪,‬‬

‫הספרה הימנית ביותר היא "ספרת האחדות"‪ ,‬והיא יכולה‬
‫להיות בטווח ‪.0-9‬‬
‫‪ ‬הספרה שמשמאלה היא באותו טווח‪ ,‬אך המשמעות שלה‬
‫אחרת‪ :‬זו כבר "ספרת העשרות"‪ ,‬שמוכפלת בעשר‪.‬‬
‫הספרה הבאה מוכפלת במאה‪ ,‬זאת שאחריה באלף וכך‬
‫הלאה‪.‬‬
‫‪ ‬נכתוב את המכפילים הללו אחד אחרי השני‪:‬‬
‫‪… – 1,000,000 – 100,000 – 10,000 – 1,000 – 100 – 10 – 1‬‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 ‫מבוא לסיביות ובתים – ‪Bits and Bytes‬‬
‫‪17‬‬

‫‪ ‬לא צריך להיות גאון במתמטיקה כדי לזהות שכל‬

‫המספרים האלה הם חזקות של ‪:10‬‬
‫‪… – 106 – 105 -104 – 103 – 102 – 101 – 100‬‬
‫‪ ‬כלומר‪ ,‬כל ספרה מוכפלת למעשה בעשר‪-‬בחזקת‪-‬‬
‫המיקום‪-‬שלה‪ ,‬כאשר ספירת המיקומים מתחילה מאפס‪.‬‬
‫לדוגמה‪ ,‬אם המספר הוא ‪ ,321‬הספרה ‪ 1‬שנמצאת‬
‫במיקום אפס תוכפל בעשר בחזקת אפס (=‪.)1‬‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬

 ‫מבוא לסיביות ובתים – ‪Bits and Bytes‬‬
‫‪18‬‬

‫‪ ‬כל זה טוב ויפה אם הטווח של כל ספרה הוא אכן ‪,0-9‬‬

‫כלומר שיש עשר אופציות לכל ספרה‪ .‬מה נעשה אם‬
‫יגבילו אותנו לשתי אופציות בלבד‪ ,‬בטווח ‪ ?0-1‬במקום‬
‫בסיס עשר‪ ,‬שעובד עם חזקות של עשר‪ ,‬אנחנו עוברים‬
‫בלית ברירה לבסיס שתיים (בינארי)‪ ,‬שעובד באותה‬
‫שיטה רק עם חזקות של שתיים‪:‬‬
‫‪… – 2 6 – 25 - 24 – 23 – 22 – 2 1 – 20‬‬
‫‪ ‬נבצע את החישובים בשיטה העשרונית ונקבל‬
‫‪64 – 32 – 16 – 8 – 4 – 2 – 1‬‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 ‫מבוא לסיביות ובתים – ‪Bits and Bytes‬‬
‫‪19‬‬

‫‪ ‬זאת אומרת‪ ,‬כדי לפענח מספר שנכתב בבסיס בינארי‪,‬‬

‫נכפיל את הספרה הימנית ביותר ב‪ ,1-‬את זו שמשמאלה‬
‫ב‪ ,2-‬את הבאה בתור ב‪ 4-‬וכן הלאה‪ ,‬ונחבר הכל ביחד‪.‬‬
‫לדוגמה‪ ,‬כמה יוצא המספר הבינארי הבא?‬
‫‪01111011‬‬
‫אם קיבלתם ‪ ,123‬כל הכבוד‪ .‬אם לא‪ ,‬להלן התרגיל‪:‬‬
‫)‪123=(1*1)+(1*2)+(0*4)+(1*8)+(1*16)+(1*32)+(1*64)+(0*128‬‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 ‫מבוא לסיביות ובתים – ‪Bits and Bytes‬‬
‫‪20‬‬

‫‪ ‬בכל שפות התכנות‪ ,‬יחידת הנתונים הבסיסית ביותר היא‬

‫הבייט ))‪ (byte‬שכולל שמונה ביטים‪.‬‬

‫‪ ‬מה טווח המספרים שאפשר לייצג באמצעות בייט אחד?‬

‫במילים אחרות‪ ,‬כמה זה ‪ 00000000‬וכמה זה‬
‫‪?11111111‬‬

‫‪ ‬אחסוך לכם את החישוב הפעם‪ :‬התשובות הן ‪ 0‬ו‪.255-‬‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 ‫מבוא לסיביות ובתים – ‪Bits and Bytes‬‬
‫‪21‬‬

‫‪ ‬נניח שיש לנו משתנה מטיפוס בייט שערכו ‪ ,255‬ואנחנו‬

‫מוסיפים לו אחד‪ ,‬מתמטית‪ ,‬זה כמו להוסיף ‪ 1‬ל‪ .999-‬כל‬
‫הספרות מתאפסות‪ ,‬ונוסף לנו ‪ 1‬משמאל‪.‬‬
‫‪ ‬אבל מכיוון שהבייט מגביל אותנו ל‪ 8-‬ביטים ואין אפשרות‬
‫להוסיף ‪ 1‬משמאל‪ ,‬אנחנו נשארים עם ביטים שכולם אפסים‬
‫בלבד‪.‬‬
‫‪ ‬חזרנו לאפס! אם נוסיף ‪ 2‬ל‪ 255-‬נקבל ‪ ,1‬וכן הלאה‪ .‬באותו‬
‫אופן‪ ,‬אם ננסה להפחית ‪ 1‬מבייט שערכו אפס (יש לזכור כי‬
‫בייט אינו יכול לקבל ערכים שליליים) נחזור ל‪.255-‬‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬

 ‫מדוע מחשבים לא עובדים בבסיס ‪? 10‬‬
‫‪22‬‬

‫‪ ‬המחשב האלקטרוני הראשון ‪ ENIAC‬השתמש ב‪10 -‬‬

‫שפורפרות ואקום לכל ספרה‪ ,‬סרבול אדיר ובזבוז זמן‬
‫וחשמל‪.‬‬
‫‪ ‬קושי טכני הנובע מקושי לאגור ולהעביר מידע‬
‫דרוש דיוק גבוה כדי לקודד ‪ 10‬רמות שונות של אינפורמציה‬ ‫‪‬‬
‫על מוליך אחד‪.‬‬
‫‪ ‬מסובך לבצע חישובים לוגיים‬
‫חיבור‪ ,‬חיסור‪ ,‬כפל‪ ,‬חילוק‪ ,‬העלאה בחזקה והוצאת שורש ו‪...‬‬ ‫‪‬‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬

 ‫ייצוג בינארי‬
‫‪23‬‬

‫‪ ‬מימוש בחומרה‬
‫‪ ‬קל לאגור עם אלמנטים ‪bi-stable‬‬
‫‪ ‬העברה אמינה גם כשהמוליכים לא אמינים ומדויקים‬

‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬

‫‪3.3V‬‬
‫‪2.8V‬‬
‫‪0.5V‬‬
‫‪0.0V‬‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬

 ‫ייצוג בינארי‬
‫‪24‬‬

‫‪ ‬ייצוג בינארי (בסיס ‪)2‬‬

‫‪111011011011012‬‬ ‫‪ ‬נייצג את ‪ 1521310‬עם‬

‫‪ ‬בהמשך נלמד איך מייצגים שברים‪:‬‬

‫‪1.11011011011012 X 213‬‬ ‫‪ ‬נייצג את ‪ 1.5213 X 104‬עם‬

‫‪ 13‬סיביות‬

‫‪1.0011001100110011[0011]…2‬‬ ‫‪ ‬נייצג את ‪ 1.2010‬עם‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬

 ‫ייצוג מספרים בבסיסים שונים‬
25

:hexadecimal ‫ ייצוג‬
16 ‫בסיס‬ 

‘A’ - ‘F’ ‫ ואותיות‬9 -0 ‫ספרות‬ 

:‫ כך‬FA1D37B16 ‫ כתוב‬C – ‫ ב‬

‫ או‬0xFA1D37B 

0xfa1d37b 

SCE-Chapter-14-Bits and Bytes Shayke Bilu

 ‫ייצוג מספרים בבסיסים שונים‬
‫‪26‬‬

‫דצימאלי‬ ‫ייצוג בינארי‬ ‫הקס‪-‬דצימאלי‬

‫‪0‬‬ ‫‪0000‬‬ ‫‪0‬‬
‫‪1‬‬ ‫‪0001‬‬ ‫‪1‬‬
‫‪2‬‬ ‫‪0010‬‬ ‫‪2‬‬
‫‪3‬‬ ‫‪0011‬‬ ‫‪3‬‬
‫‪4‬‬ ‫‪0100‬‬ ‫‪4‬‬
‫‪5‬‬ ‫‪0101‬‬ ‫‪5‬‬
‫‪6‬‬ ‫‪0110‬‬ ‫‪6‬‬
‫‪7‬‬ ‫‪0111‬‬ ‫‪7‬‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 ‫ייצוג מספרים בבסיסים שונים‬
‫‪27‬‬

‫דצימאלי‬ ‫ייצוג בינארי‬ ‫הקס‪-‬דצימאלי‬

‫‪8‬‬ ‫‪1000‬‬ ‫‪8‬‬
‫‪9‬‬ ‫‪1001‬‬ ‫‪9‬‬
‫‪10‬‬ ‫‪1010‬‬ ‫‪A‬‬
‫‪11‬‬ ‫‪1011‬‬ ‫‪B‬‬
‫‪12‬‬ ‫‪1100‬‬ ‫‪C‬‬
‫‪13‬‬ ‫‪1101‬‬ ‫‪D‬‬
‫‪14‬‬ ‫‪1110‬‬ ‫‪E‬‬
‫‪15‬‬ ‫‪1111‬‬ ‫‪F‬‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 ‫ טווח של ערכי בתים‬:‫דוגמה‬
28

‫ סיביות‬8 = ‫ בית‬
:‫ אפשרויות תצוגת מספרים לפי בסיסים‬

1. Binary: from 000000002 to 111111112

2. Decimal: from 010 to 25510

3. Hexadecimal: from 0016 to FF16

SCE-Chapter-14-Bits and Bytes Shayke Bilu

 29

?‫שאלות‬

SCE-Chapter-14-Bits and Bytes Shayke Bilu

 ‫מילים )‪(machine words‬‬
‫‪30‬‬

‫‪ ‬לכל מחשב יש 'רוחב מילה'‬

‫‪ ‬הגודל המוקצה למידע מסוג ‪( integer‬כולל כתובות)‪.‬‬
‫‪ ‬רוב המחשבים המתקדמים היום כבר עובדים עם פס‬
‫כתובות ברוחב ‪ 64‬סיביות (‪ 8‬בתים)‬
‫‪ ‬מרחב הכתובות ‪ 18  1.8 X 1019‬הקסה בתים‪.‬‬
‫‪ ‬מרחב הכתובת נמדד בהקסה ולא בג'יגה כמו ברוחב פס של ‪32‬‬
‫סיביות שהגביל את המרחב ל‪4.3GB -‬‬
‫‪ ‬רוחב פס זה מספיק בהחלט‪ ,‬כרגע‪ ,‬לתנועה מרובת מידע‬
‫במערכות הן של מחשבים מרובי ליבות והן אחרים‪.‬‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬

 ‫ארגון הזיכרון לפי בתים‬
‫‪31‬‬

‫תוכניות מתייחסות לכתובות 'מדומות' (וירטואליות)‬ ‫•‬

‫באופן אבסטרקטי‪:‬‬ ‫•‬
‫מערך גדול של בתים‬ ‫‪.1‬‬
‫בפועל ממומש עם היררכיה שלמה של סוגי זיכרונות‬ ‫‪.2‬‬
‫מהדר )‪ + (compiler‬רכיבי חומרה קובעים את המיפוי‬ ‫‪.3‬‬
‫לזיכרון הפיזי‪.‬‬
‫נראה את ייצוג הכתובות במערך זה‪.‬‬ ‫‪.4‬‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬

 ‫ייצוג מידע‬
32

:C ‫ גודל בבתים של אובייקטים שונים של‬

C Data Type Compaq Alpha Typical 32bit/64bit Intel IA32
int 4 4 4
long int 8 4 4
char 1 1 1
short 2 2 2
float 4 4 4
double 8 8 8
long double 8 8 10/12
char * 8 4 4
SCE-Chapter-14-Bits and Bytes Shayke Bilu
 ‫סידור המידע‬
33

‫ ניתן לסדר את הבתים בתוך מלים מימין לשמאל או‬

...‫להפך‬
‫ מה מקובל ? אין הסכמה‬
 Sun’s, Mac’s are “Big Endian” machines

‫( בכתובת הגבוהה‬least significant byte( ‫ הבית הימני‬

 Alphas, PC’s are “Little Endian” machines

‫ הבית הימני בכתובת הנמוכה‬

SCE-Chapter-14-Bits and Bytes Shayke Bilu
 ‫דוגמה‬
34

Big Endian 
‫ הבית הימני בכתובת הגבוהה‬
Little Endian 
‫ הבית הימני בכתובת הנמוכה‬
x = 0x01234567 
.‫ בתים‬4 ‫ יש ייצוג ב‬x ‫ למשתנה‬
0x100 ‫&) היא‬x ‫ (כלומר‬x ‫ נניח שהכתובת של‬
Big 0x100 0x101 0x102 0x103

Endian 01 23 45 67
Little 0x100 0x101 0x102 0x103

Endian 67 45 23 01
SCE-Chapter-14-Bits and Bytes Shayke Bilu
 ‫כיצד נראה איך המידע מיוצג‬
35

:‫ תוכנית להדפסת ייצוג בבתים‬

#include <stdio.h>
Printf directives:
#define SIZE 10
%p: Print pointer
void show_bytes(int start[])
%x: Print Hexadecimal
{
int i;
for (i = 0; i < SIZE; i++)
printf("0x%p\t0x%.2x\n", start+i, start[i]);
printf("\n");
}
SCE-Chapter-14-Bits and Bytes Shayke Bilu
 ‫כיצד נראה איך המידע מיוצג‬
36

:‫ תוכנית להדפסת ייצוג בבתים‬

int main()
{
int start[SIZE]={0,1,2,3,4,5,6,7,8,9};
show_bytes(start,SIZE);
return 0;
}

SCE-Chapter-14-Bits and Bytes Shayke Bilu

 ‫ייצוג פקודות מכונה‬
‫‪37‬‬

‫‪ ‬פקודות מקודדות כבתים‬

‫‪ ‬מחשבי ‪ RISC‬כגון ‪ Sun‬משתמשים באוסף קטן של‬
‫פקודות‪:‬‬
‫‪ 4 ‬בתים מספיקים לייצוג כל הפקודות‪.‬‬
‫‪ ‬מחשבי ‪ CISC‬כגון ה ‪ PC -‬משתמשים בקבוצה גדולה‬
‫של הוראות‪:‬‬
‫‪‬נעזרים בגודל משתנה של פקודה‪.‬‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬

 ‫ייצוג פקודות‬
‫‪38‬‬

‫)‪int sum(int x, int y‬‬ ‫לכל פקודה יש קוד מספרי‬

‫{‬ ‫‪Sun sum PC sum‬‬
‫;‪return x+y‬‬ ‫‪81‬‬ ‫‪55‬‬
‫}‬ ‫‪C3‬‬ ‫‪89‬‬
‫‪ • E0‬דוגמה זאת מתורגמת למספר פקודות בסיסיות בשפת‬ ‫‪E5‬‬
‫מכונה‪.‬‬ ‫‪08‬‬ ‫‪8B‬‬
‫‪ • 90‬בדוגמה זאת מחשבי ‪ Alpha, Sun‬משתמשים ב ‪4‬‬ ‫‪45‬‬
‫בתים‪.‬‬ ‫‪02‬‬ ‫‪0C‬‬
‫‪ • 00‬בדוגמה זאת מחשבי ‪ PC‬משתמשים בפקודות‬ ‫‪03‬‬
‫‪09‬‬ ‫‪45‬‬
‫באורכים של ‪ 1,2,3‬בתים‪.‬‬ ‫‪08‬‬
‫מחשבים שונים משתמשים בפקודות שונות וקידוד שונה של הפקודות‪.‬‬
‫‪89‬‬
‫אין סיכוי לתאימות!‬ ‫‪EC‬‬
‫‪ 5D‬קידוד הפקודה ‪sum‬‬ ‫‪C3‬‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 39

?‫שאלות‬

SCE-Chapter-14-Bits and Bytes Shayke Bilu

 ‫מה עכשיו ?‬
‫‪40‬‬

‫עכשיו‪ ,‬כשראינו שאת כל סוגי המידע שהמחשב משתמש בהם‪,‬‬ ‫‪‬‬

‫ניתן לייצג על ידי שימוש בתווים ‪ 0‬ו ‪... ,1‬‬
‫נרצה לראות איך המחשב יכול לבצע חישובים עם מידע זה‪.‬‬ ‫‪‬‬
‫לשם כך‪ ,‬עלינו להיזכר בלוגיקה פסוקית‪.‬‬ ‫‪‬‬
‫לוגיקה פסוקית == לוגיקה בוליאנית מבוססת על מצבי אמת‬ ‫‪‬‬
‫שקר ובדיקתם ביחס שבין שני איברים ומעלה ע"י התנאים‬
‫הבוליאניים הבאים‪:‬‬
‫וגם ‪ And -‬‬
‫או ‪ Or -‬‬
‫או בלעדי ‪ Xor -‬‬
‫שלילה ‪ Not -‬‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 )‫לוגיקה פסוקית (בוליאנית‬
41

19 - ‫ במאה ה‬George Bool ‫ פותחה על ידי‬

0 - ‫ ו 'שקר' כ‬1 – ‫ נקודד 'אמת' כ‬
And Or
& 0 1 | 0 1
0 0 0 0 0 1
1 0 1 1 1 1

Not Exclusive-Or (Xor)

! ^ 0 1
0 1 0 0 1
1 0 1 1 0
SCE-Chapter-14-Bits and Bytes Shayke Bilu
‫נשווה אלגברה בוליאנית לאלגברה אריתמטית‬
‫‪42‬‬

‫‪ ‬נציב ’|‘ = ’‪ ‘+‬ו ’&‘ = ’*‘‪.‬‬

‫‪ ‬תרגיל‪ :‬עבור כל אחד מהביטויים הבאים – קבעו אם‬
‫הביטוי המקביל נכון‪.‬‬
‫‪ ‬קומוטטיביות(תכונה של פעולות בינאריות) ‪:‬‬
‫‪A|B = B|A A+B = B+A‬‬
‫‪A&B = B&A A*B = B*A‬‬
‫‪ ‬אסוציאטיביות (תכונה של פעולה בינארית המיישמת את חוק‬
‫הקיבוץ)‪:‬‬
‫)‪(A + B) + C = A + (B + C‬‬
‫)‪(A * B) * C = A * (B * C‬‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 ‫פעולות על סיביות‬
‫‪43‬‬

‫‪ ‬שפת ‪ C‬מאפשרת לבצע פעולות על סיביות ( ‪bitwise‬‬

‫‪ ,)operations‬שהן פעולות על הסיביות של האופרנדים‪:‬‬
‫‪ ‬פעולת ‪ AND‬המסומנת על‪-‬ידי האופרטור &‪.‬‬
‫‪ ‬פעולת ‪ OR‬המסומנת על‪-‬ידי האופרטור |‪.‬‬
‫‪ ‬פעולת ‪ NOT‬המסומנת על‪-‬ידי האופרטור ~‪.‬‬
‫‪ ‬פעולת ‪ XOR‬המסומנת על‪-‬ידי האופרטור ^ ‪.‬‬
‫‪ ‬פעולת הזזה שמאלה המסומנת על‪-‬ידי האופרטור >> ‪.‬‬
‫‪ ‬פעולת הזזה ימינה המסומנת על‪-‬ידי האופרטור << ‪.‬‬
‫‪ ‬כל האופרטורים הפועלים על סיביות הם אופרטורים בינאריים‬
‫(המצפים לקבל שני אופרנדים)‪ ,‬למעט האופרטור ‪ NOT‬שהוא‬
‫אופרטור(המצפה לקבל אופרנד אחד)‪.‬‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 ‫הפעולה ‪AND‬‬
‫‪44‬‬

‫‪ ‬הפעולה ‪ AND‬על סיביות מסומנת על‪-‬ידי &‪ ,‬והיא דומה‬

‫לפעולה ‪ AND‬הבוליאנית המסומנת על‪-‬ידי &&‪.‬‬
‫‪0&0=0‬‬
‫‪0&1=0‬‬
‫‪ ‬טבלת האמת של הפעולה &‪:‬‬
‫‪1&0=0‬‬
‫‪1&1=1‬‬
‫‪ ‬כלומר‪ ,‬פעולת & בין שתי סיביות תחזיר ‪ 0‬אם לפחות אחת‬
‫מהסיביות היא ‪ ;0‬ותחזיר ‪ 1‬רק אם שתי הסיביות הן ‪.1‬‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬

 ‫הפעולה ‪AND‬‬
‫‪45‬‬

‫‪ ‬אם נבחן את טבלת האמת של הפעולה ‪ ,AND‬נבחין‬

‫בתכונות הבאות‪:‬‬
‫‪ ‬כשמפעילים על סיבית מסוימת ‪ b‬את הפעולה & עם‬
‫סיבית ‪ ,1‬אז הסיבית לא משתנה‪.‬‬
‫‪b&1=b‬‬
‫‪ ‬כשמפעילים על סיבית מסוימת ‪ b‬את הפעולה & עם‬
‫סיבית ‪ ,0‬אז הסיבית מתאפסת‪.‬‬
‫‪b&0=0‬‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 ‫הפעולה ‪AND‬‬
‫‪46‬‬

‫‪ ‬המסקנה היא שניתן להשתמש בפעולה & על מנת ל ַמסֵך ( ‪to‬‬

‫‪ )mask‬סיבית מסוימת‪ ,‬ולבודד אותה משאר הייצוג של‬
‫המספר‪.‬‬
‫‪ ‬לדוגמא‪ :‬נניח שבמשתנה ‪ num‬מאוחסן מס' שלם‪ ,‬ואנחנו‬
‫מעוניינים לדעת מהי הסיבית הרביעית מימין‪ .‬הנה קטע קוד‬
‫מתאים‪:‬‬
‫)‪if (num & 8 != 0‬‬
‫;)”הסיבית הרביעית מימין היא דלוקה“( ‪printf‬‬
‫‪else‬‬
‫;)”הסיבית הרביעית מימין היא כבויה“( ‪printf‬‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 ‫הפעולה ‪OR‬‬
‫‪47‬‬

‫‪ ‬הפעולה ‪ OR‬על סיביות מסומנת על‪-‬ידי |‪ ,‬והיא דומה לפעולה‬

‫‪0|0=0‬‬ ‫‪ OR‬הבוליאנית המסומנת על‪-‬ידי ||‪.‬‬
‫‪0|1=1‬‬ ‫‪ ‬טבלת האמת של הפעולה |‪:‬‬
‫‪1|0=1‬‬
‫‪1|1=1‬‬
‫‪ ‬כלומר‪ ,‬פעולת | בין שתי סיביות תחזיר ‪ 1‬אם לפחות אחת‬
‫מהסיביות היא ‪ ;1‬ותחזיר ‪ 0‬רק אם שתי הסיביות הן ‪.0‬‬
‫‪ ‬מה יהיה הפלט של קטע הקוד הבא‪:‬‬
‫;‪int num = 72 | 184‬‬
‫;)‪printf (“%d”, num‬‬ ‫פלט יהיה‪.248 :‬‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 ‫הפעולה ‪OR‬‬
‫‪48‬‬

‫‪ ‬אם נבחן את טבלת האמת של הפעולה ‪ ,OR‬נבחין‬

‫בתכונות הבאות‪:‬‬
‫‪ ‬כשמפעילים על סיבית מסוימת ‪ b‬את הפעולה | עם‬
‫סיבית ‪ ,1‬אז הסיבית נדלקת‪.‬‬
‫‪b|1=1‬‬
‫‪ ‬כשמפעילים על סיבית מסוימת ‪ b‬את הפעולה | עם‬
‫סיבית ‪ ,0‬אז הסיבית נותרת ללא שינוי‪.‬‬
‫‪b|0=b‬‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 ‫הפעולה ‪OR‬‬
‫‪49‬‬

‫‪ ‬המסקנה היא שניתן להשתמש בפעולה | על מנת להדליק‬

‫סיביות מבוקשות‪ ,‬מבלי לשנות סיביות אחרות‪.‬‬
‫‪ ‬לדוגמא‪ :‬נניח שבמשתנה ‪ num‬מאוחסן מס' שלם‪ ,‬ואנחנו‬
‫מעוניינים להדליק את הסיבית הרביעית מימין‪.‬‬
‫‪ ‬הנה הוראה מתאימה‪:‬‬
‫;‪num = num | 8‬‬

‫‪ ‬קיימת גם ההוראה המקוצרת =&‪.‬‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬

 ‫הפעולה ‪OR‬‬
‫‪50‬‬

‫‪ ‬תכונות נוספות של הפעולה ‪:OR‬‬

‫‪ ‬כשמפעילים על סיבית מסוימת ‪ b‬את הפעולה | עם‬
‫עצמה‪ ,‬אז הסיבית לא משתנה‪.‬‬
‫‪b|b=b‬‬
‫‪ ‬כשמפעילים על סיבית מסוימת ‪ b‬את הפעולה | עם‬
‫הסיבית ההפוכה‪ ,‬אז הסיבית נדלקת‪.‬‬
‫‪b | ~b = 1‬‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬

 OR ‫הפעולה‬
51

:‫ מה יהיה הפלט של קטע הקוד הבא‬

int num1=11;
int num2=num1 | num1, num3=num2 & num2;
printf (“%d %x %o\n”, num2, num2, num2);
printf (“%d %x %o\n”, num3,num3,num3);

SCE-Chapter-14-Bits and Bytes Shayke Bilu

 ‫הפעולה ‪NOT‬‬
‫‪52‬‬

‫‪ ‬הפעולה ‪ NOT‬על סיביות מסומנת על‪-‬ידי ~‪ ,‬והיא זהה‬

‫לפעולה ‪ NOT‬הבוליאנית המסומנת על‪-‬ידי !‪.‬‬
‫‪ ‬טבלת האמת של הפעולה ~‪:‬‬
‫‪~0 = 1‬‬
‫‪~1 = 0‬‬

‫‪ ‬כלומר‪ ,‬כשמבצעים פעולת ~ על סיבית‪ ,‬היא מתהפכת‪,‬‬

‫כלומר‪ ,‬ערכה הופך מאפס לאחד‪ ,‬או מאחד לאפס‪.‬‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬

 ‫הפעולה ‪NOT‬‬
‫‪53‬‬

‫‪ ‬מה יהיה הפלט של קטע הקוד הבא‪:‬‬

‫;‪int num = 72‬‬
‫;)‪printf (“%d”, ~num‬‬
‫הפלט במקרה זה יהיה ‪.-73‬‬
‫‪ ‬ומה יהיה הפלט אם נרשום ‪ %u‬במקום ‪?%d‬‬
‫‪ ‬הפלט יהיה ‪( 65,463‬בהנחה שגודלו של ‪ int‬הוא ‪ 2‬בתים‬
‫ולא ‪ 4‬בתים)‪.‬‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬

 NOT ‫הפעולה‬
54

. ~~b == b ‫ ברור שמתקיים‬

:‫מורגן‬-‫ אז מתקיימים גם חוקי דה‬,‫ הן סיביות‬b-‫ ו‬a ‫ אם‬
~(a & b) == ~a | ~b
~(a | b) == ~a & ~b
?‫ מה יהיה הפלט של קטע הקוד הבא‬
char num = 13;
printf (“%d %d”, num &~num,num| ~num);

SCE-Chapter-14-Bits and Bytes Shayke Bilu

 ‫הפעולה ‪XOR‬‬
‫‪55‬‬

‫‪ ‬הפעולה ‪ )exclusive or( XOR‬מסומנת על‪-‬ידי ^‪.‬‬

‫טבלת האמת של הפעולה ‪'( XOR‬או' מוציא) זהה‬
‫לטבלת האמת של הפעולה ‪'( OR‬או' מכיל)‪ ,‬למעט‬
‫במקרה ששני האופרנדים הם ‪ .1‬במקרה כזה – ‪XOR‬‬
‫‪0^0=0‬‬ ‫תחזיר ‪.0‬‬
‫‪0^1=1‬‬
‫‪ ‬טבלת האמת של הפעולה ^‪:‬‬
‫‪1^0=1‬‬
‫‪1^1=0‬‬
‫‪ ‬כלומר‪ ,‬פעולת ^ בין שתי סיביות תחזיר ‪ 1‬אם הסיביות‬
‫הן שונות זו מזו‪ ,‬ותחזיר ‪ 0‬אם הן זהות‪.‬‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 XOR ‫הפעולה‬
56

:‫ מה יהיה הפלט של קטע הקוד הבא‬

unsigned int num = 72 ^ 184;
printf (“%u”, num);

.240 ‫ כלומר הפלט יהיה‬

SCE-Chapter-14-Bits and Bytes Shayke Bilu

 ‫הפעולה ‪XOR‬‬
‫‪57‬‬

‫‪ ‬אם נבחן את טבלת האמת של הפעולה ‪ ,XOR‬נבחין‬

‫בתכונות הבאות‪:‬‬
‫‪ ‬כשמפעילים על סיבית מסוימת ‪ b‬את הפעולה ^ עם‬
‫סיבית ‪ ,1‬אז הסיבית מתהפכת‪.‬‬
‫‪b ^ 1 = ~b‬‬
‫‪ ‬כשמפעילים על סיבית מסוימת ‪ b‬את הפעולה ^ עם‬
‫סיבית ‪ ,0‬אז הסיבית נותרת ללא שינוי‪.‬‬
‫‪b^0=b‬‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 XOR ‫הפעולה‬
58

?‫ מה יהיה הפלט של קטע הקוד הבא‬

int num1 = 72;
int num2 = num1 ^ -1;
printf (“%d %u”, num2, num2);

. ^= ‫ =| קיימת גם הפקודה‬, &= ‫ בדומה לפעולות‬

SCE-Chapter-14-Bits and Bytes Shayke Bilu

 ‫הפעולה ‪XOR‬‬
‫‪59‬‬

‫‪ ‬תכונות נוספות של הפעולה ‪:XOR‬‬

‫‪ ‬כשמפעילים על סיבית מסוימת ‪ b‬את הפעולה ^ עם‬
‫עצמה‪ ,‬אז הסיבית מתאפסת‪.‬‬
‫‪b^b=0‬‬
‫‪ ‬כשמפעילים על סיבית מסוימת ‪ b‬את הפעולה ^ עם‬
‫הסיבית ההפוכה‪ ,‬אז הסיבית נדלקת‪.‬‬
‫‪b ^ ~b = 1‬‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 XOR ‫הפעולה‬
60

:‫ מה יהיה הפלט של קטע הקוד הבא‬

int num = 11;
int num2=num1^num1,num3=num1^~num1;
printf (“%d %d”, num2, num3);

‫כתבו הוראה אחת בלבד ההופכת (~) את הסיבית שלישית‬

:num ‫מימין של המשתנה‬
num = num ^ 4;

SCE-Chapter-14-Bits and Bytes Shayke Bilu

 XOR ‫הפעולה‬
61

‫ הוא על מנת לממש‬XOR ‫ שימוש מעניין בפעולה‬

:‫ אך ללא שימוש במשתנה עזר‬,)swap( ‫פונקציית החלפה‬
void swap (int *num1, int *num2)
{
*num1 = *num1 ^ *num2;
*num2 = *num1 ^ *num2;
*num1 = *num1 ^ *num2;
}
SCE-Chapter-14-Bits and Bytes Shayke Bilu
 XOR ‫הפעולה‬
62

:‫ידי שימוש בהוראות המקוצרות‬-‫ או על‬

void swap (int *num1, int *num2)
{
*num1 ^= *num2;
*num2 ^= *num1;
*num1 ^= *num2;
}

SCE-Chapter-14-Bits and Bytes Shayke Bilu

 ‫הזזה‬
‫‪63‬‬

‫‪ ‬בשפת ‪ C‬קיימים אופרטורים המאפשרים להזיז את סיביות‬

‫הביטוי ימינה ושמאלה‪.‬‬
‫‪ ‬זהו האופרטור >> (המבצע הזזה בסיביות שמאלה) והאופרטור‬
‫<< (המבצע הזזה בסיביות ימינה)‪ .‬למקומות שיתפנו ייכנסו‬
‫אפסים‪.‬‬
‫‪ ‬שני האופרטורים מקבלים שני אופרנדים‪:‬‬
‫‪ ‬האופרנד השמאלי זהו הביטוי שאת הסיביות שלו יש להזיז‪.‬‬
‫‪ ‬האופרנד הימני זהו מס' ההזזות שצריך לבצע‪.‬‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬

 ‫הזזה‬
64

?‫ מה יהיה הפלט של קטע הקוד הבא‬

printf (“%d”, 7 << 2);
?‫ מה מבצע קטע הקוד הבא‬
int count = 0;
scanf (“%d”, &a);
while (a != 0)
{
count += a & 1;
a=a>>1; /* a >>= 1 :‫* אפשר היה לרשום בקיצור‬/
}
printf (“%d”, count);
SCE-Chapter-14-Bits and Bytes Shayke Bilu
 ‫הזזה‬
‫‪65‬‬

‫‪ ‬מה לדעתכם יהיה הפלט של קטע התכנית הבא?‬

‫‪ ‬האם זה יהיה הפלט בכל סביבת עבודה?‬
‫‪ ‬ניתן להשתמש באופרטורים של הזזה על מנת‬
‫לממש ביעילות כפל בחזקות של שתיים או חלוקה‬
‫>‪#include <stdio.h‬‬ ‫בחזקות של שתיים‪:‬‬
‫)(‪int main‬‬ ‫‪ a = a << k ‬יכפיל את ‪ a‬פי ‪.2k‬‬
‫{‬ ‫‪ a = a >> k ‬יחלק את ‪ a‬פי ‪.2k‬‬
‫;)‪printf ("%x", -1 << 4‬‬
‫;‪return 0‬‬
‫}‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
‫נשווה אלגברה בוליאנית לאלגברה אריתמטית‬
66

‫ המשך‬... 
A * (B + C) = A * B + A * C .1

A+ 0 = A .2

A|A = A .3

A&1 = A .4

A*0 = 0 .5

A | (B & C) = (A | B) & (A | C) .6

– (– A) = A .7

A+AA .8

SCE-Chapter-14-Bits and Bytes Shayke Bilu

‫נשווה אלגברה בוליאנית לאלגברה אריתמטית‬
67

‫ המשך‬... 
A&A = A .1

A | (A & B) = A .2

A & (A | B) = A .3

A | !A = 1 .4

A | !A  0 .5

SCE-Chapter-14-Bits and Bytes Shayke Bilu

 ‫עוד מספר התמרות בין אופרטורים‬
68

DeMorgan ‫ חוקי‬
A & B = !(!A | !B)
A | B = !(!A & !B)
:& ‫ על ידי | ְו‬xor 

A ^ B = (!A & B) | (A & !B)

A ^ B = (A | B) & !(A & B)

SCE-Chapter-14-Bits and Bytes Shayke Bilu

 ^ - ‫ & ו‬:‫מספר זהויות‬
69

‫ מצא את הזהויות השגויות‬:‫ תרגיל‬

1. A^B = B^A
2. A&B = B&A
3. (A ^ B) ^ C = A ^ (B ^ C)
4. (A & B) & C = A & (B & C)
5. A & (B ^ C) = (A ^ B) & (A ^ C)
6. A^0 = 0
7. A& 1 = A
8. A& 0= 0
9. A^A = A
SCE-Chapter-14-Bits and Bytes Shayke Bilu
 ‫חיבור וקטורים של ביטים‬
70

01001101 +
10000100
------------
11010001

0010101 +
1101100
------------
0000001
SCE-Chapter-14-Bits and Bytes Shayke Bilu
 ‫מביטים לוקטורים של ביטים‬
‫‪71‬‬

‫‪ ‬פעולות על וקטורים של ביטים‬

‫‪ ‬פעולות מבוצעות לחוד עבור כל ביט )‪(bitwise‬‬
‫& ‪and‬‬ ‫^ ‪xor‬‬
‫‪01101001‬‬ ‫‪01101001‬‬
‫‪& 01010101‬‬ ‫‪^ 01010101‬‬
‫‪01000001‬‬ ‫‪00111100‬‬
‫| ‪or‬‬
‫‪01101001‬‬ ‫! ‪not‬‬
‫‪| 01010101‬‬ ‫‪! 01010101‬‬
‫‪01111101‬‬ ‫‪10101010‬‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 ‫ייצוג וחישוב על קבוצות‬
72

{0,…, w–1} ‫ יכול לייצג תתי קבוצות של‬w ‫ וקטור ביטים ברוחב‬:‫ ייצוג‬
aj = 1 if j  A
01101001 { 0, 3, 5, 6 }
76543210
01010101 { 0, 2, 4, 6 }
76543210
‫ פעולות‬
& Intersection 01000001 { 0, 6 }
| Union 01111101 { 0, 2, 3, 4, 5, 6 }
^ Symmetric difference 00111100 { 2, 3, 4, 5 }
! Complement 10101010 { 1, 3, 5, 7 }

SCE-Chapter-14-Bits and Bytes Shayke Bilu

 ‫פעולות על ביטים ב‪C -‬‬
‫‪73‬‬

‫זכרו‪:‬‬ ‫‪ ‬הפקודות ^ ‪ &, |, !,‬קיימות ב ‪C -‬‬

‫‪416=01002‬‬ ‫‪ ‬רלבנטי לכל ה‪:integers -‬‬
‫‪116=00012‬‬ ‫‪long, int, short, char‬‬ ‫‪‬‬
‫מופעל על המספר בייצוגו הבינארי‬ ‫‪‬‬
‫מופעל בנפרד על כל ביט‬ ‫‪‬‬
‫דוגמאות על משתנה מסוג ‪:char‬‬ ‫‪‬‬
‫‪‬‬ ‫>‪~0x41 --‬‬ ‫‪0xBE‬‬
‫‪‬‬ ‫‪~010000012‬‬ ‫‪--> 101111102‬‬
‫‪‬‬ ‫>‪~0x00 --‬‬ ‫‪0xFF‬‬
‫‪‬‬ ‫‪~000000002‬‬ ‫‪--> 111111112‬‬
‫‪‬‬ ‫‪0x69 & 0x55‬‬ ‫>‪--‬‬ ‫‪0x41‬‬
‫‪‬‬ ‫‪011010012 & 010101012 --> 010000012‬‬
‫‪‬‬ ‫‪0x69 | 0x55‬‬ ‫>‪--‬‬ ‫‪0x7D‬‬
‫‪‬‬ ‫‪011010012 | 010101012 --> 011111012‬‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 ‫פעולות " ִזי ַזה" )‪(shifting‬‬
‫‪74‬‬

‫‪x << y‬‬ ‫הזזה שמאלה‪:‬‬ ‫•‬

‫הזז וקטור ‪ x‬שמאלה ב ‪ y‬מקומות‬ ‫•‬

‫זרוק ביטים משמאל ומלא ב – ‪ 0‬מימין‬ ‫•‬

‫‪x >> y‬‬ ‫הזזה ימינה‪:‬‬ ‫•‬

‫הזז וקטור ‪ x‬ימינה ב ‪ y‬מקומות‬ ‫•‬

‫זרוק ביטים מימין‬ ‫•‬

‫שני מקרים‪:‬‬ ‫•‬
‫• הזזה לוגית )‪ :(logical shift‬מלא ב‪ 0 -‬משמאל‬
‫• הזזה אריתמטית )‪ :(arithmetic shift‬שכפל הספרה השמאלית‬
‫)‪ .(msb‬משתמשים בזה בייצוג ‪ 2’s complement‬שעוד נלמד‪.‬‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 i- ‫כיצד נגלה את הביט ה‬
75

:int x ‫ ערך הסיבית הימנית של‬

int res;
res = x & 1;

.‫ מקובל להשתמש במסכות‬

:‫ מימין‬k + 1 -‫ מציאת הסיבית ה‬
int mask;
mask = 1 << k;
res = (x & mask) != 0;

SCE-Chapter-14-Bits and Bytes Shayke Bilu

 ‫ובניגוד לכך‪ :‬פעולות לוגיות ב ‪C -‬‬
‫‪76‬‬

‫‪ ‬פעולות לוגיות ב – ‪:&&, ||, ! C‬‬

‫‪ ‘0’ ‬מייצג שקר‪ '1' ,‬אמת‬
‫‪ ‬כל מספר שונה מ – ‪ 0‬הוא 'אמת'‬
‫‪ ‬פעולה בוליאנית תמיד מחזירה ‪ 0‬או ‪1‬‬
‫‪ ‬דוגמאות על משתנה מסוג ‪:char‬‬
‫‪‬‬ ‫‪!0x41‬‬ ‫>‪--‬‬ ‫‪0x00‬‬
‫‪‬‬ ‫‪!0x00‬‬ ‫>‪--‬‬ ‫‪0x01‬‬
‫‪‬‬ ‫>‪!!0x41 --‬‬ ‫‪0x01‬‬
‫‪‬‬ ‫‪0x69 && 0x55‬‬ ‫>‪--‬‬ ‫‪0x01‬‬
‫‪‬‬ ‫‪0x69 || 0x55‬‬ ‫>‪--‬‬ ‫‪0x01‬‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 ‫סיביות וביטים – סיכום ביניים‬
‫‪77‬‬

‫‪ ‬הכל זה סיביות ובתים‪...‬‬

‫‪ ‬מספרים‪ ,‬תוכניות‪ ,‬טקסט‬
‫‪ ‬מחשבים שונים משתמשים בייצוגים שונים‬
‫‪ ‬רוחב מילה‪ ,‬סדר בתים‪ ,‬ייצוג‬
‫‪ ‬לוגיקה פסוקית מהווה כלי יסודי בהבנת פעולות המחשב‬
‫‪ ‬מצד אחד‪ ,‬היא מאפשרת חישובים מעל וקטורים של‬
‫ביטים‬
‫‪ ‬מצד שני‪ ,‬ניתן לממש אותה בחומרה‪.‬‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 78

?‫שאלות‬

SCE-Chapter-14-Bits and Bytes Shayke Bilu

 ‫ייצוג מספרים במחשב‬
‫‪79‬‬

‫‪ ‬כל פריט מידע במחשב נשמר כרצף של ביטים‬

‫‪ ‬ביט יכול לקבל אך ורק את הערכים ‪ 0‬או ‪1‬‬
‫‪ ‬רצף של שמונה ביטים מהווה בית )‪ (byte‬שהיא יחידת‬
‫הזיכרון הקטנה ביותר בעלת כתובת‬
‫‪ ‬בשפת ‪ C‬מוגדרים אופרטורים לעבודה עם ביטים‪.‬‬
‫‪ ‬עבודה עם ביטים נעשית על משתנים המייצגים מספרים‬
‫שלמים בלבד!!! )‪(char, short, int, long‬‬
‫‪ ‬ניתן להשתמש גם בגרסת המשתנה ה‪ unsigned-‬של כל אחד‬
‫מהם‪.‬‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 ‫ייצוג מספרים בבסיסים שונים‬
‫‪80‬‬

‫‪ ‬מספרים במחשב מיוצגים על בסיס ‪( 2‬בסיס בינארי)‬

‫‪ ‬ניתן להתייחס למספר בייצוג אוקטלי (בסיס ‪ )8‬ע"י‬
‫הוספת ‪ 0‬לפני המספר‪.‬‬
‫‪ ‬לדוגמה המספר ‪ 042‬באוקטלי מייצג את המספר ‪34‬‬
‫בבסיס עשרוני‬
‫‪ ‬תו המרה רלבנטי הוא ‪%o‬‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬

 ‫פעולות חישוב על ביטים‬
‫‪81‬‬

‫‪ ‬ניתן להתייחס למספר בייצוג הקסדצימלי (בסיס ‪ )16‬ע"י הוספת‬

‫‪ 0x‬לפני המספר‪ .‬לדוגמה המספר ‪ 0x42‬מייצג את המספר ‪66‬‬
‫בבסיס עשרוני‪.‬‬
‫‪ ‬תו המרה רלבנטי הוא ‪( %x‬או ‪ %X‬לקבלת אותיות גדולות)‬

‫‪ ‬על מנת להשתמש באופרטורים של ביטים נדרש לייצג את‬

‫המספר בייצוג בינארי‬
‫‪ ‬פעולות חישוב על ביטים מבוצעות ביט מול ביט‬
‫‪ ‬בדרך כלל עדיף להשתמש בגרסת ‪ unsigned‬של המשתנה‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬

 ‫המרה מבינארי לעשרוני‬
‫‪82‬‬

‫‪ ‬אלגוריתם המרה של מספר בבסיס בינארי למספר בבסיס עשרוני‪:‬‬

‫‪ ‬לכל ספרה בייצוג יש "משקל" שהוא ‪ 2‬בחזקת האינדקס של מיקומה‬
‫במספר (אינדקס מתחיל מימין ומהערך ‪)0‬‬
‫‪8‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫אינדקס‬

‫‪256‬‬ ‫‪128‬‬ ‫‪64‬‬ ‫‪32‬‬ ‫‪16‬‬ ‫‪8‬‬ ‫‪4‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫משקל‬
‫‪28‬‬ ‫‪27‬‬ ‫‪26‬‬ ‫‪25‬‬ ‫‪24‬‬ ‫‪23‬‬ ‫‪22‬‬ ‫‪21‬‬ ‫‪20‬‬ ‫חישוב‬

‫‪ ‬כפול כל ספרה במשקלה המתאים עפ"י מיקומה בייצוג‬

‫הבינארי‪ ,‬הערך של המספר העשרוני הוא סכום המכפלות‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 ‫המרה מבינארי לעשרוני‬
‫‪83‬‬

‫‪ ‬לדוגמה‪ ,‬הייצוג הבינארי הבא‪:‬‬

‫‪00001101‬‬
‫‪ ‬המיקומים הם‪:‬‬
‫‪128=0 ,64 =0 , 32=0 ,16=0 ,8=1 ,4=1 ,2=0 ,1=1‬‬
‫‪ ‬הייצוג הנ"ל מייצג את המספר ‪:13‬‬
‫= ‪1*1+0*2+1*4+1*8+0*16+0*32+0*64+0*128‬‬
‫= ‪1*1 + 1*4 + 1*8‬‬
‫‪1+4+8 = 13‬‬

‫כתוב תוכנית המייצרת מספר דצימלי‪ ,‬בבסיס ‪ ,10‬ממספר בינארי הנקלט כמחרוזת‪.‬‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬

 ‫המרה מעשרוני לבינארי‬
‫‪84‬‬

‫‪ ‬אלגוריתם המרה של מספר בבסיס עשרוני למספר בבסיס‬

‫בינארי‪:‬‬
‫‪ ‬כל עוד המספר אינו ‪0‬‬
‫‪ ‬חלק את המספר ב‪2-‬‬
‫‪ ‬שמור את השארית‬
‫‪ ‬הייצוג הבינארי של המספר‪ ,‬משמאל לימין‪ ,‬הוא אוסף‬
‫השאריות מהסוף להתחלה‪.‬‬
‫‪ ‬כאשר יש מצב שחלק מהספרות חסרות‪ ,‬הן מקבלות את‬
‫הערך ‪.0‬‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 ‫המרה מעשרוני לבינארי‬
‫‪85‬‬

‫‪ ‬לדוגמה – המספר ‪ 8‬בייצוג בינארי הוא‪00001000 :‬‬

‫מספר‬ ‫שארית‬
‫‪8‬‬ ‫‪0‬‬
‫‪4‬‬ ‫‪0‬‬
‫‪2‬‬ ‫‪0‬‬
‫‪1‬‬ ‫‪1‬‬
‫‪0‬‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 ‫ייצוג אוקטלי (בסיס ‪)8‬‬
‫‪86‬‬

‫‪ ‬בבסיס אוקטלי קיימות רק ‪ 8‬ספרות‪ ,‬הספרות ‪0-7‬‬

‫‪ ‬כל ספרה בבסיס אוקטלי מיוצגת ע"י ‪ 3‬ספרות בינאריות‬
‫וזאת עפ"י הטבלה המוצגת בשקף הבא‬
‫‪ ‬בהמרה של מספר מבינארי לאוקטלי – כל ‪ 3‬ספרות‬
‫בייצוג הבינארי הופכות לספרה אחת בייצוג האוקטלי‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬

 ‫ייצוג אוקטלי (בסיס ‪)8‬‬
‫‪87‬‬

‫ייצוג בינארי‬ ‫ספרה‬ ‫‪ ‬לדוגמה הייצוג הבינארי‬

‫‪000‬‬ ‫‪0‬‬ ‫של המספר‪00001101 :‬‬
‫‪001‬‬ ‫‪1‬‬ ‫הוא המספר ‪ 15‬בבסיס אוקטלי‪.‬‬
‫‪010‬‬ ‫‪2‬‬ ‫‪ ‬בהמרה מאוקטלי לעשרוני‬
‫‪011‬‬ ‫‪3‬‬ ‫ניתן להשתמש בשיטת סכום‬
‫‪100‬‬ ‫‪4‬‬ ‫המשקלים כאשר משקלי הספרות‬
‫‪101‬‬ ‫‪5‬‬ ‫הם (‪ 64 ,8 ,1‬וכו')‬
‫‪110‬‬ ‫‪6‬‬
‫‪111‬‬ ‫‪7‬‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 ‫ייצוג הקסה‪-‬דצימלי (בסיס ‪)16‬‬
‫‪88‬‬

‫‪ ‬בבסיס הקסה‪-‬דצימלי קיימות ‪ 16‬ספרות‪,‬‬

‫הספרות ‪ 0-9‬והספרות ‪A-F‬‬
‫‪ ‬כל ספרה בבסיס הקסה‪-‬דצימלי מיוצגת ע"י ‪ 4‬ספרות‬
‫בינאריות עפ"י הטבלה הבאה‪:‬‬
‫‪ ‬בהמרה מבינארי להקסה‪-‬דצימלי – כל ‪ 4‬ספרות בייצוג‬
‫הבינארי הופכות לספרה אחת בייצוג ההקסה‪-‬דצימלי‬
‫‪ ‬בהמרה מהקסה‪-‬דצימלי לבינארי – כל ספרה מיוצגת‬
‫ע"י רביעיית הספרות הבינאריות‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬

 ‫ייצוג הקסה‪-‬דצימלי (בסיס ‪)16‬‬
‫‪89‬‬

‫‪ ‬לדוגמה הייצוג הבינארי‪:‬‬

‫‪11100011‬‬
‫‪ ‬הוא המספר ‪E3‬‬
‫‪ ‬בבסיס הקסה‪-‬דצימלי (‪)0xE3‬‬
‫‪ ‬בהמרה מהקסה‪-‬דצימלי לעשרוני ניתן להשתמש בשיטת‬
‫‪ ‬סכום המשקלים‪ ,‬כאשר משקלי הספרות הם‪:‬‬
‫(‪ 256 ,16 ,1‬וכו')‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬

 90

?‫שאלות‬

SCE-Chapter-14-Bits and Bytes Shayke Bilu

 ‫רשימת האופרטורים‬
‫‪91‬‬

‫דוגמא‬ ‫הסבר‬ ‫משמעות‬ ‫סימן‬

‫אופרטור‬
‫‪2&3=2‬‬ ‫‪ AND‬ביט התוצאה יהיה ‪ 1‬אם ורק אם שני הביטים‬ ‫&‬
‫המקבילים בפעולה שווים ל‪1-‬‬
‫‪2|3=3‬‬ ‫ביט התוצאה יהיה ‪ 1‬אם לפחות אחד משני‬ ‫‪OR‬‬ ‫|‬
‫הביטים המקבילים בפעולה שווה ל‪1-‬‬

‫‪2^3=1‬‬ ‫ביט התוצאה יהיה ‪ 1‬אם ורק אם בדיוק אחד‬ ‫‪XOR‬‬ ‫^‬
‫משני הביטים המקבילים בפעולה שווה ל‪1-‬‬
‫(כלומר הביטים שונים זה מזה)‬

‫‪ ‬ניתן להשתמש באופרטורים הבאים לקיצור‪^= ,|= ,&= :‬‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 ‫רשימת האופרטורים‬
‫‪92‬‬

‫דוגמא‬ ‫הסבר‬ ‫משמעות‬ ‫סימן‬

‫אופרטור‬
‫מזיז את הביטים של משתנה המקור (האופרנד ‪2<<1=4‬‬ ‫‪Shift Left‬‬ ‫>>‬
‫השמאלי) מספר צעדים שמאלה (עפ"י ערך‬
‫האופרנד מימין)‪ .‬הפעולה מאפסת את התאים‬
‫שנותרו ריקים מימין‪ .‬הפעולה שקולה לכפל פי ‪.2‬‬

‫מזיז את הביטים של משתנה המקור (האופרנד ‪2>>1=1‬‬ ‫‪Shift Right‬‬ ‫<<‬

‫השמאלי) מספר צעדים ימינה (עפ"י ערך האופרנד‬
‫מימין)‪.‬‬
‫אלגוריתם מילוי התאים הריקים הוא תלוי מערכת‪.‬‬
‫הפעולה שקולה לחלוקה פי ‪.2‬‬
‫‪!2=253‬‬ ‫מחליף את ערך של הביט‪ 1 :‬והופך אותו ל‪0-‬‬ ‫‪Complement‬‬ ‫!‬
‫במקרה הפוך גורם ל‪ 0 -‬להפוך ל‪1-‬‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬

 ‫טבלאות פעולה‬
93

XOR OR AND
Bit 1 Bit 2 ^ (xor) Bit 1 Bit 2 | (or) Bit 1 Bit 2 & (and)
0 0 0 0 0 0 0 0 0

0 1 1 0 1 1 0 1 0

1 0 1 1 0 1 1 0 0

1 1 0 1 1 1 1 1 1

SCE-Chapter-14-Bits and Bytes Shayke Bilu

 ‫שימוש במסכות )‪(mask‬‬
‫‪94‬‬

‫‪ ‬נהוג לייצר מסכות שישמשו להדלקה או כיבוי של ביט‪:‬‬

‫‪ ‬יכולה להכיל ‪ 1‬במיקום אותו נרצה להאיר‬
‫‪ ‬בעזרת שימוש באופרטור ‪ )&( AND‬בין המספר הרצוי והמסכה‪ ,‬נוכל‬
‫לדעת מהו הביט הנמצא במספר במיקום הרצוי‬
‫‪ ‬לדוגמה‬
‫‪00001101 & 00001000 = 00001000 ‬‬
‫‪00000101 & 00001000 = 00000000 ‬‬
‫‪ ‬מכך נסיק‪:‬‬
‫‪ ‬אם התוצאה שהתקבלה היא ‪ ,0‬סימן שהביט הרצוי היה ‪0‬‬
‫‪ ‬אם התוצאה שהתקבלה שונה מ‪ ,0-‬סימן שהביט הרצוי היה ‪1‬‬
‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬
 ‫דוגמה לפונקציה להדפסת ייצוג בינארי‬
95
void printBits(unsigned int number)
{
unsigned int mask = 1<<31, result; int i;
for(i=0;i<32;i++)
}
result = number & mask;
if(result)
putchar('1');
else
putchar('0');
mask >>=1;
{
{
SCE-Chapter-14-Bits and Bytes Shayke Bilu
 ‫דוגמה לפונקציה להדפסת ייצוג עשרוני‬
96
void printNum(char mis[])
}
int i,sum=0,place=1;
for(i=31;i>=0;i--)
}
if(mis[i] == '1')
sum+= (place);
place*=2;
{
printf("The number is: %d",sum);
{
SCE-Chapter-14-Bits and Bytes Shayke Bilu
 ‫דוגמה לתוכנית הראשית‬
97

int main()
}
int num; char mis[32];
printf("Enter integer number:\n");
scanf("%d",&num);
printBits(num);
printf("Enter binary number:\n");
scanf("%s",&mis);
printBits(mis);
return 0;
}
SCE-Chapter-14-Bits and Bytes Shayke Bilu
 98

‫תרגילים‬

SCE-Chapter-14-Bits and Bytes Shayke Bilu

 ‫תרגילים‬
‫‪99‬‬

‫‪ .1‬כתוב פונקציה המקבלת מספר ומדפיסה את הייצוג הבינארי של‬

‫המספר ולהיפך הבחירה איזו המרה תבוצע ע"י בחירת המפעיל‪.‬‬
‫‪ .2‬כתוב פונקציה המקבלת מספר ומחזירה ‪ 1‬אם הוא מתחלק ב‪0( 2-‬‬
‫אם לא)‪ .‬יש להשתמש בייצוג בינארי ובאופרטורים של ביטים‪.‬‬
‫‪ .3‬כתוב פונקציה המקבלת מספר שלם‪ ,‬הפונקציה מעלה את המספר‬
‫‪ 2‬בחזקת המספר השלם שנקלט‪.‬‬
‫עבור המספר ‪ 3‬תחזיר התוכנית את התוצאה ‪ , 8‬שהיא ‪.23‬‬
‫עבור המספר ‪ 5‬הפונקציה תחזיר את המספר ‪ 32‬שהוא ‪25‬‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬

 ‫תרגילים‬
‫‪100‬‬

‫‪ .4‬כתוב פונקציה המקבלת מספר שלם או תו ומחזירה כמה אחדות‬

‫מופיעות בייצוג הבינארי שלו‪ .‬יש לדאוג להתאים את הפונקציה‬
‫לסוג המשתנה )‪(unsigned char/int‬‬
‫‪ .5‬כתוב פונקציה המקבלת מספר בן ‪ 5‬ספרות ומדפיסה את הייצוג‬
‫ההקסה‪-‬דצימלי של המספר‪.‬‬
‫‪ .6‬כתוב תוכנית המזיזה משתנה מסוג ‪ 4 int‬ביטים ימינה‪.‬‬
‫הדפס את המספר לפני ואחרי ההזזה‪ .‬מה ערכי ארבעת הביטים‬
‫השמאליים ביותר (שמולאו ע"י אלגוריתם ההזזה)?‬
‫בדוק את התשובה על משתנים ‪signed/unsigned‬‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬

 ‫ לדוגמא‬4 ‫פתרון תרגיל‬
101

void countOne(unsigned int num)

{
int i, res=0;
unsigned int mask=1, check;
for(i=0;i<sizeof(int)*8;i++)
{
check= mask & num;
if(check)
res++;
mask<<=1;
}
printf("The number has %d 1's in binary.\n",res);
}

SCE-Chapter-14-Bits and Bytes Shayke Bilu

 ‫תרגילים‬
‫‪102‬‬

‫‪ .7‬כתוב תוכנית המקבלת ‪ 2‬משתנים מסוג ‪unsigned char‬‬

‫ואורזת אותם בתוך ‪ unsigned short‬אחד‪.‬‬
‫כלומר‪ ,‬הבית השמאלי בתוצאה יהיה המספר הראשון והבית‬
‫הימני יכיל את המספר השני‪.‬‬
‫‪ .8‬כתוב את הפונקציה ההופכית‪ ,‬המפרקת מספר מסוג ‪ short‬ל‪2-‬‬
‫מספרים מסוג ‪ .char‬הפונקציה מקבלת ‪ 2‬פרמטרים‪ :‬המספר‬
‫הארוז ומספר נוסף המציין את מיקום המספר הרצוי (‪ 1‬יסמן‬
‫את המספר השמאלי ו‪ 2-‬את המספר הימני)‪ .‬הפונקציה תחזיר‬
‫את המספר המבוקש מסוג ‪. unsigned char‬‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬

 ‫דוגמא אחרת לתוכנית המרה בין בסיסים‬
103

#include <stdio.h>
void main(void)
}
char base_digits[16] = {,'0' ,'1' ,'2' ,'3' ,'4' ,'5' ,'6' ,'7'
,'8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
int converted_number[64];
long int number_to_convert;
int next_digit, base, index=0;

/* get the number and base */

printf("Enter number and desired base: ");
scanf("%ld %i", &number_to_convert, &base);
SCE-Chapter-14-Bits and Bytes Shayke Bilu
 ‫דוגמא אחרת לתוכנית המרה בין בסיסים‬
104
/* convert to the indicated base */
while (number_to_convert != 0)
}
converted_number[index] = number_to_convert % base;
number_to_convert = number_to_convert / base;
++index;
{
/* now print the result in reverse order */
--index; /* back up to last entry in the array */
printf("\nConverted Number = ");
for( ; index>=0; index--) /* go backward through array */
}
printf("%c", base_digits[converted_number[index]]);
{
printf("\n");
{
SCE-Chapter-14-Bits and Bytes Shayke Bilu
 ‫תרגילים‬
105
‫ עליך לעבור על הפונקציה בהנחה כי‬.‫לפניך פונקציה המבצעת משימה מסוימת‬ .9
.‫ ולרשום מה יודפס בסופה‬Y=6 -‫ ו‬X=10 ‫המספרים שנקטו בראש הפונקציה הם‬
#include <stdio.h>
void Print(int x, int d)
{
char buffer[33];
int i=0;
for (;d>0;d--)
}
buffer[i++] = '0'+ (x & 1);
x >>= 1;
{
while(index >0 )
printf("%c",buffer[--i]);
{
SCE-Chapter-14-Bits and Bytes Shayke Bilu
 ‫תרגילים‬
106
‫ עליך לעבור על התוכנית‬.‫ לפניך תוכנית הכוללת פונקציה המבצעת משימה מסוימת‬.10
.‫ולרשום מה יודפס בסופה‬
int mystery(unsigned char bits)
}
int total=0, i;
for(i=1;i<=bits;i++){
bits<<=2;
total++;}
return (total);
{
int main()
}
unsigned int number=8;
printf(“The answer is: %d\n", mystery(number<<1));
{
SCE-Chapter-14-Bits and Bytes Shayke Bilu
 ‫סיביות וביטים ‪ -‬סיכום‬
‫‪107‬‬

‫‪ ‬מדוע ביטים? מהם סיביות? משמעות ייצוג מידע‬

‫‪ ‬ייצוג מידע בינארי ‪ /‬הקסה‪-‬דצימלי ‪ /‬אוקטאלי‬
‫‪ ‬ייצוג של בתים‬
‫‪ ‬מספרים‬
‫‪ ‬תווים ומחרוזות‬
‫‪ ‬פקודות )‪(instructions‬‬
‫‪ ‬פעולות ברמת הביטים‬
‫‪ ‬לוגיקה בוליאנית‪ ,‬יחסי ‪or, and, not, xor‬‬
‫‪ ‬הזזות ימינה ושמאלה של ביטים והמשמעות של זה‪.‬‬
‫‪ ‬כיצד נכתוב זאת בתוכניות ‪? C‬‬

‫‪SCE-Chapter-14-Bits and Bytes‬‬ ‫‪Shayke Bilu‬‬

 108

?‫שאלות‬

SCE-Chapter-14-Bits and Bytes Shayke Bilu