‫אבני היסוד של‬

‫תוכנית ב‪C -‬‬

‫אלי לייבה‬
‫למה חשוב ללמוד מחשבים?‬

‫‪2‬‬
‫© ‪Keren Kalif‬‬
‫ביחידה זו נלמד‪:‬‬
‫בסיסי מספרים‪:‬‬
‫• בינארי (‪ ,)2‬אוקטאלי (‪ ,)8‬הקסה‪-‬דצימאלי (‪)16‬‬
‫הדפסה למסך‬
‫קבלת נתונים מהמשתמש‬
‫מבנה זיכרון התוכנית‬
‫הגדרת משתנים‬
‫טיפוסי משתנים‬
‫השמת ערך למשתנים‬
‫קבועים‬
‫הפקודה ‪flushall‬‬
‫הפקודה ‪system‬‬
‫בסיס עשרוני (דצימלי)‬
‫בסיס הינו שיטת ספירה‬
‫בבסיס בייצוג עשרוני (השיטה הטבעית לנו) קיימות ‪ 10‬ספרות‪ 0 :‬עד ‪9‬‬
‫לכן אנו אומרים שהן מיוצגות בבסיס ‪10‬‬
‫• נקרא גם בסיס דצימלי‬

‫כל מספר שלם ניתן לייצג כסכום של ערכים בחזקות של ‪10‬‬

‫• דוגמא‪:‬‬
‫‪100 *7 + 101*5 + 102 *8 + 103*2 =2857‬‬

‫‪4‬‬
‫© ‪Keren Kalif‬‬
‫ייצוג מספרים בבסיס בינארי ‪-‬‬
‫הגדרות‬
‫בבסיס הבינארי קיימות ‪ 2‬ספרות בלבד‪ :‬הספרות ‪ 0‬ו‪1-‬‬
‫• לכן גם נקרא בסיס ‪2‬‬
‫דוגמאות למספרים בבסיס בינארי‪1110010 ,1010 :‬‬
‫נמספר את מיקום הספרות מימין לשמאל‬
‫• מספר הספרה הימנית ביותר יהיה ‪0‬‬
‫• מספר הספרה השמאלית ביותר במספר בן ‪ n‬ספרות יהיה ‪n-1‬‬
‫‪0 1 2 3 4 5‬‬

‫דוגמא‪101011 :‬‬
‫הספרות במיקום ‪ 0,1,3,5‬הן ‪ 1‬והספרות במיקום ‪ 2,4‬הן ‪0‬‬

‫‪5‬‬
‫© ‪Keren Kalif‬‬
 ‫ייצוג מספרים בבסיס בינארי – חישוב ערך‬
‫עשרוני של מספר בינארי (מבסיס ‪ 2‬ל‪)10 -‬‬
‫ערכו של מספר המיוצג בבסיס עשרוני הוא סכום חזקות של ‪:10‬‬
‫‪102 101 100‬‬

‫‪1 7 3 = 1*102 + 7*101 + 3*100 = 173‬‬

‫הספרה ‪ d‬במיקום ה‪ k-‬מוסיפה לסכום‪( d*10k :‬כלומר אם ‪ d==0‬הספרה לא‬
‫תורמת לסכום)‬
‫ובדומה‪ ,‬ערכו של מספר המיוצג בבסיס בינארי הינו סכום של חזקות של ‪2‬‬
‫(הספרה ‪ d‬במיקום ה‪ k-‬מוסיפה לסכום ‪)d*2k‬‬
‫‪2 0 21 22 23 2 4‬‬ ‫דוגמא‪:‬‬

‫‪11001 = 1*24 + 1*23 + 0*22 + 0*21 + 1*20 =25‬‬

‫הביט הכי שמאלי נקרא ‪ MSB‬משום שהוא הכי משמעותי לסכום‬

‫הביט הכי ימני נקרא ‪ LSB‬משום שהוא הכי פחות משמעותי לסכום‬ ‫‪6‬‬
‫© ‪Keren Kalif‬‬
‫ייצוג מספרים בבסיס בינארי – חישוב ערך‬
‫בינארי של מספר עשרוני (מבסיס ‪ 10‬ל‪)2 -‬‬
‫ראינו כיצד בהינתן מספר בייצוג בינארי ניתן להמירו לייצוגו‬
‫העשרוני‬
‫כעת נראה כיצד בהינתן מספר בייצוג עשרוני ניתן להמירו לייצוגו‬
‫הבינרי (כפי שהמחשב מכיר)‬
‫כל עוד המספר אינו ‪ 0‬נחלקו ב‪ 2 -‬ואת השארית נשרשר לתוצאה‬
‫משמאל‪:‬‬
‫• דוגמא עבור ‪:23‬‬
‫‪1 0111‬‬
‫•‬ ‫)‪23/2 = 11 (1‬‬
‫•‬ ‫)‪11/2 = 5 (1‬‬
‫בקרה‪:‬‬
‫•‬ ‫)‪5/2 = 2 (1‬‬ ‫‪24 23 22 21 20‬‬
‫•‬ ‫)‪2/2 = 1 (0‬‬ ‫=‪1 0 1 1 1‬‬
‫•‬ ‫)‪1/2 = 0 (1‬‬ ‫‪1*24 + 0*23 + 1*22 + 1*21 + 1*20 =23‬‬

‫‪7‬‬
‫© ‪Keren Kalif‬‬
‫ייצוג מספרים בבסיס בינארי – חישוב‬
‫ערך בינארי של מספר עשרוני (‪)2‬‬
‫• דוגמא עבור ‪:26‬‬
‫•‬ ‫)‪26/2 = 13 (0‬‬ ‫‪1 1010‬‬
‫•‬ ‫)‪13/2 = 6 (1‬‬
‫בקרה‪:‬‬
‫•‬ ‫)‪6/2 = 3 (0‬‬ ‫‪24 23 22 21 20‬‬
‫•‬ ‫)‪3/2 = 1 (1‬‬ ‫=‪1 1 0 1 0‬‬
‫•‬ ‫)‪1/2 = 0 (1‬‬ ‫‪1*24 + 1*23 + 0*22 + 1*21 + 0*20 =26‬‬

‫‪8‬‬
‫© ‪Keren Kalif‬‬
‫טווח המספרים שניתן לייצג ע"י ספרות‬
‫בינאריות – מספרים חיוביים‬
‫ע"י מספר עשרוני בעל ‪ 3‬ספרות ניתן לייצג ‪ )103=( 1000‬מספרים שונים‬
‫(‪)999...0‬‬
‫ובאופן כללי‪ ,‬מספר עשרוני בעל ‪ k‬ספרות יכול לייצג ‪ 10k‬מספרים שונים (‪10k-...0‬‬
‫‪)1‬‬
‫ובדומה‪ ,‬ע"י מספר בינארי בעל ‪ k‬ספרות ניתן לייצג ‪ 2k‬מספרים שונים (‪,)2k-1…0‬‬
‫•‬ ‫‪000‬‬ ‫‪= 0*22 + 0*21 + 0*20 = 0‬‬
‫•‬ ‫‪001‬‬ ‫‪= 0*22 + 0*21 + 1*20 = 1‬‬ ‫למשל עבור ‪:k=3‬‬
‫•‬ ‫‪010‬‬ ‫‪= 0*22 + 1*21 + 0*20 = 2‬‬
‫•‬ ‫‪011‬‬ ‫‪= 0*22 + 1*21 + 1*20 = 3‬‬
‫•‬ ‫‪100‬‬ ‫‪= 1*22 + 0*21 + 0*20 = 4‬‬
‫•‬ ‫‪101‬‬ ‫‪= 1*22 + 0*21 + 1*20 = 5‬‬
‫•‬ ‫‪110‬‬ ‫‪= 1*22 + 1*21 + 0*20 = 6‬‬
‫•‬ ‫‪111‬‬ ‫‪= 1*22 + 1*21 + 1*20 = 7‬‬

‫‪9‬‬
‫© ‪Keren Kalif‬‬
‫טווח המספרים שניתן לייצג ע"י ספרות‬
‫בינאריות – מספרים שליליים‬
‫ניתן לייצג ‪ 2k‬מספרים ע"י ‪ K‬ספרות בינאריות‬
‫בייצוג מספרים שלמים חיוביים ייוצגו המספרים ‪2k-1…0‬‬
‫בייצוג מספרים שלמים חיוביים ושליליים ייוצגו המספרים‬
‫‪-2k-1….2k-1-1‬‬
‫• למשל עבור ‪k=3: -23-1…23-1-1‬‬
‫‪22-1…22-‬‬
‫‪3…4-‬‬
‫סה"כ ‪ )23( 8‬מספרים‬

‫‪10‬‬
‫© ‪Keren Kalif‬‬
‫טווח המספרים שניתן לייצג ע"י ספרות‬
‫בינאריות – מספרים שליליים‬
‫מאחר והמחשב מכיר רק ‪ 0‬ו‪ ,1-‬ואינו מכיר את הסימן ‪,-‬‬
‫צריך אינדיקציה לכך שהמספר שלילי‪ .‬אינדיקציה זו היא‬
‫שהספרה הכי שמאלית תהייה תמיד ‪ ,1‬ואז נותרו לנו ‪k-1‬‬
‫ספרות לייצוג המספר‬
‫• דוגמא‪ :‬עבור ייצוג מספר עם ‪ 4‬סיביות‪:‬‬
‫• ‪ 3‬בבינארית זה ‪0011‬‬
‫• ‪ -3‬בבינארית זה ‪1101‬‬

‫‪11‬‬
‫© ‪Keren Kalif‬‬
‫יצוג מספר שלילי בבינארי‬
‫נשתמש בשיטת המשלים ל‪:2 -‬‬ ‫‪‬‬

‫‪ ‬נמצא את יצוגו הבינארי של המספר החיובי‬

‫‪ ‬נוסיף ‪ 0‬מוביל משמאלו‬
‫‪ ‬נהפוך כל סיבית (‪ 0‬ל‪ ,1 -‬ו‪ 1-‬ל‪)0 -‬‬
‫‪ ‬נוסיף ‪ 1‬לתוצאה‬
‫‪ ‬לבסוף נוסיף את הסיבית ‪ 1‬משמאל למספר‬
‫דוגמא‪ :‬המספר ‪-7‬‬ ‫‪‬‬

‫‪0111‬‬ ‫‪ 7 ‬בבינארי ‪ 0 +‬מוביל ‪:‬‬

‫‪1000‬‬ ‫‪ ‬לאחר הפיכת הסיביות‪:‬‬
‫‪+‬‬ ‫‪1‬‬ ‫‪ ‬הוספת ‪ 1‬לתוצאה‪:‬‬
‫‪1001‬‬ ‫‪‬‬
‫‪1‬‬ ‫‪ ‬הוספת הסיבית ‪ 1‬משמאל למספר‪:‬‬
‫‪12‬‬
‫© ‪Keren Kalif‬‬
‫סיכום בסיס בינארי‬

http://rlv.zcache.com/binary_joke_sticker-
r52fa63b95dac463787549589a29f5366_v9waf_8byvr_324.jpg
13
Keren Kalif ©
‫סיכום בסיס בינארי‬

‫‪14‬‬
‫© ‪Keren Kalif‬‬
‫ייצוג מספרים בבסיס ‪ - 8‬הגדרות‬
‫בבסיס ‪( 8‬אוקטאלי) משתמשים ב‪ 8 -‬ספרות כדי לספור‪:‬‬
‫הספרות ‪0-7‬‬
‫דוגמאות למספרים בבסיס ‪7502 ,12536 :8‬‬
‫נמספר את מיקום הספרות מימין לשמאל‬
‫מספר הספרה הימנית ביותר יהיה ‪0‬‬
‫מספר הספרה השמאלית ביותר במספר בן ‪ n‬ספרות יהיה‬
‫‪n-1‬‬
‫‪0 1 2 3 4 5‬‬

‫דוגמא‪121604 :‬‬

‫‪15‬‬
‫© ‪Keren Kalif‬‬
‫ייצוג מספרים בבסיס ‪ – 8‬חישוב ערך‬
‫עשרוני של מספר אוקטאלי (מ‪ 8 -‬ל‪)10 -‬‬

‫ראינו כי ערכו של מספר המיוצג בבסיס עשרוני הוא סכום חזקות של ‪:10‬‬
‫‪102 101 100‬‬

‫‪1 7 3 = 1*102 + 7*101 + 3*100 = 173‬‬

‫הספרה ‪ d‬במיקום ה‪ k-‬מוסיפה לסכום‪( d*10k :‬כלומר אם ‪ d=0‬הספרה‬
‫לא תורמת לסכום)‬
‫ובדומה‪ ,‬ערכו של מספר המיוצג בבסיס ‪ 8‬הינו סכום של חזקות של ‪8‬‬
‫(הספרה ‪ d‬במיקום ה‪ k-‬מוסיפה לסכום ‪)d*8k‬‬
‫‪80 81 82 83‬‬ ‫דוגמא‪:‬‬
‫‪4 2 5 6 = 4*83 + 2*82 + 5*81 + 6*80 =2222‬‬

‫‪16‬‬
‫© ‪Keren Kalif‬‬
‫ייצוג מספרים בבסיס ‪ – 8‬חישוב ערך‬
‫אוקטאלי של מספר עשרוני (מ‪ 10 -‬ל‪)8 -‬‬

‫ראינו כיצד בהינתן מספר בייצוג אוקטאלי ניתן להמירו‬

‫לייצוגו העשרוני‬
‫כעת נראה כיצד בהינתן מספר בייצוג עשרוני ניתן להמירו‬
‫לייצוגו בבסיס האוקטלי‬
‫כל עוד המספר אינו ‪ 0‬נחלקו ב‪ 8 -‬ואת השארית נשרשר‬
‫לתוצאה משמאל‪:‬‬
‫‪1‬‬ ‫‪73‬‬
‫• דוגמא עבור ‪:123‬‬
‫)‪• 123/8 = 15 (3‬‬ ‫בקרה‪:‬‬
‫‪82 81 80‬‬
‫)‪• 15/8 = 1 (7‬‬
‫‪7 1 3 = 1*82 + 7*81 + 3*80= 123‬‬
‫)‪• 1/8 = 0 (1‬‬

‫‪17‬‬
‫© ‪Keren Kalif‬‬
‫ייצוג מספרים בבסיס ‪- 16‬‬
‫הגדרות‬
‫בבסיס ‪( 16‬הקסה‪-‬דצימלי) משתמשים ב‪ 16 -‬תווים כדי‬
‫לספור‪ :‬הספרות ‪ 0-9‬והאותיות ‪A-F‬‬
‫דוגמאות למספרים בבסיס ‪1DE2510, ABCDEF :16‬‬
‫נמספר את מיקום הספרות מימין לשמאל‬
‫מספר הספרה הימנית ביותר יהיה ‪0‬‬
‫מספר הספרה השמאלית ביותר במספר בן ‪ n‬ספרות יהיה‬
‫‪n-1‬‬
‫‪0 1 2 3 4 5‬‬

‫דוגמא‪1B19F4 :‬‬

‫‪18‬‬
‫© ‪Keren Kalif‬‬
‫ייצוג מספרים בבסיס ‪ – 16‬חישוב ערך‬
‫עשרוני של מספר הקסה‪-‬דצימאלי (מ‪16 -‬‬
‫ל‪)10 -‬‬

‫ראינו כי‪ ,‬ערכו של מספר המיוצג בבסיס עשרוני הוא סכום חזקות של ‪:10‬‬
‫‪102 101 100‬‬

‫‪1 7 3 = 1*102 + 7*101 + 3*100 = 173‬‬

‫הספרה ‪ d‬במיקום ה‪ k-‬מוסיפה לסכום‪( d*10k :‬כלומר אם ‪ d=0‬הספרה‬
‫לא תורמת לסכום)‬
‫ובדומה‪ ,‬ערכו של מספר המיוצג בבסיס ‪ 16‬הינו סכום של חזקות של ‪16‬‬
‫(הספרה ‪ d‬במיקום ה‪ k-‬מוסיפה לסכום ‪)d*16k‬‬
‫‪160 161 162 163‬‬ ‫דוגמא‪:‬‬
‫‪4 D 5 E = 4*163 + 13*162 + 5*161 + 14*160 =19806‬‬

‫‪19‬‬
‫© ‪Keren Kalif‬‬
‫ייצוג מספרים בבסיס ‪ – 16‬חישוב ערך‬
‫הקסה‪-‬דצימאלי של מספר עשרוני (מ‪10 -‬‬
‫ל‪)16 -‬‬

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

‫להמירו לייצוגו העשרוני‬
‫כעת נראה כיצד בהינתן מספר בייצוג עשרוני ניתן להמירו‬
‫לייצוגו בבסיס הקסה‪-‬דצימאלי‬
‫כל עוד המספר אינו ‪ 0‬נחלקו ב‪ 16 -‬ואת השארית נשרשר‬
‫‪7B‬‬
‫לתוצאה משמאל‪:‬‬
‫• דוגמא עבור ‪:123‬‬
‫)‪• 123/16 = 7 (11‬‬ ‫בקרה‪:‬‬
‫‪161 160‬‬
‫)‪• 7/16 = 0 (7‬‬ ‫‪7 B = 7*161 + 11*160 = 123‬‬

‫‪20‬‬
‫© ‪Keren Kalif‬‬
 ‫לוח שנה של מתכנתים‬
7DA = 2010

21
http://bokov.net/pics/img/programmer_calendar.png Keren Kalif ©
‫ובאופן כללי‪ :‬מעבר מבסיס ‪ N‬לבסיס ‪10‬‬
‫מעבר מבסיס ‪( 2‬בינארי) לבסיס ‪( 10‬עשרוני)‪:‬‬
‫‪1310 = 20*1 + 21*0 + 22*1 + 23*1 = 11012‬‬

‫מעבר מבסיס ‪( 8‬אוקטאלי) לבסיס ‪( 10‬עשרוני)‪:‬‬

‫‪17110 = 80*3 + 81*5 + 82*2=2538‬‬

‫מעבר מבסיס ‪( 16‬הקסה‪-‬דצימלי) לבסיס ‪(10‬עשרוני)‪:‬‬

‫‪1FA16 = 1*162 + 15*161 + 10*160 = 50610‬‬

‫‪22‬‬
‫© ‪Keren Kalif‬‬
‫ובאופו כללי‪ :‬מעבר מבסיס ‪ 10‬לבסיס ‪N‬‬
‫יהיה ‪ X‬מספר עשרוני‪.‬‬
‫יהיה‪ n‬הבסיס אליו רוצים להעביר את ‪.X‬‬

‫כל עוד ‪ X‬אינו ‪:0‬‬ ‫‪.1‬‬

‫‪ )a‬חלק את ‪ X‬ב ‪ n‬ורשום את השארית‬

‫‪23‬‬
‫© ‪Keren Kalif‬‬
‫המרה מבסיס ‪ 2‬ל‪16 -‬‬
‫כל ‪ 4‬סיביות (מה‪ LSB -‬ל‪ )MSB -‬ייצגו ספרה בבסיס ‪:16‬‬ ‫‪‬‬

‫למשל‪ ,‬עבור‪0 1 1 0 1 0 1 1 0 1 0 :‬‬ ‫‪‬‬

‫‪3‬‬ ‫‪5‬‬ ‫‪A‬‬

‫בקרה‪011010110102 = 85810 :‬‬ ‫‪‬‬

‫‪16‬‬ ‫‪A35 = 85810‬‬

‫המעבר מבסיס ‪ 2‬ל‪ 8 -‬זהה‪ ,‬רק כל ‪ 3‬סיביות ייצגו ספרה‬

‫‪24‬‬
‫© ‪Keren Kalif‬‬
‫המרה מבסיס ‪ 16‬ל‪2 -‬‬
‫כל ספרה תיוצג ע"י ‪ 4‬סיביות‪:‬‬ ‫‪‬‬
‫‪3‬‬ ‫‪5‬‬ ‫‪A‬‬ ‫למשל‪ ,‬עבור‪:‬‬ ‫‪‬‬

‫‪0011 0101 1010‬‬

‫בקרה‪011010110102 = 85810 :‬‬ ‫‪‬‬

‫‪16‬‬ ‫‪A35 = 85810‬‬

‫המעבר מבסיס ‪ 8‬ל‪ 2 -‬זהה‪ ,‬רק כל ספרה תיוצג ע"י ‪ 3‬סיביות‬

‫‪25‬‬
‫© ‪Keren Kalif‬‬
‫השוואה בין ערכים בבסיסים‬
‫שונים‬
‫‪30E16 = 78210 = 14168 = 11000011102‬‬ ‫‪‬‬

‫ניתן לראות שככל שיש יותר ספרות בבסיס‪ ,‬כך צריך פחות‬ ‫‪‬‬
‫ספרות על‪-‬מנת לייצג ערך של מספר מסויים‬
‫‪ ‬הסיבה היא כי כל מיקום תורם יותר לסכום‬

‫‪26‬‬
‫© ‪Keren Kalif‬‬
‫כתיבת תוכנית ראשונה ב‪C -‬‬
‫ספריה המכילה פקודות‬
‫בסיסיות אשר המחשב מכיר‬ ‫כל תוכנית ב‪ C -‬תראה כך‪:‬‬

‫>‪#include <stdio.h‬‬

‫)(‪void main‬‬
‫במקום ‪ 3‬נקודות נשים‬
‫{‬ ‫את אוסף הפקודות שנרצה‬
‫…‬ ‫שהתוכנית תבצע‬
‫}‬
‫‪ main‬היא פונקציה המורצת עם הרצת התוכנית‬
‫• בכל תוכנית תהייה פונקצית ‪ main‬אחת בדיוק‬

‫‪27‬‬
‫© ‪Keren Kalif‬‬
‫הדפסה למסך‬
‫אחת הפקודות שהמחשב מכיר היא הדפסה למסך‬

‫>‪#include <stdio.h‬‬

‫)(‪void main‬‬ ‫הרצה של התוכנית הזו תדפיס‬

‫{‬ ‫למסך את המחרוזת‬
‫;)”!‪printf(“Hello World‬‬ ‫‪!Hello World‬‬
‫}‬

‫‪28‬‬
‫© ‪Keren Kalif‬‬
 ‫הדפסה למסך (‪)2‬‬
‫>‪#include <stdio.h‬‬
‫הרצה של תוכנית זו תדפיס‬
‫)(‪void main‬‬ ‫למסך את המחרוזת‬
‫{‬ ‫‪6 is a number‬‬
‫;)”‪printf(“6 is a number‬‬
‫}‬ ‫דרך נוספת לכתוב תוכנית זו‪:‬‬

‫>‪#include <stdio.h‬‬
‫מציין שבחלק זה‬
‫במחרוזת יהיה מספר‬
‫)(‪void main‬‬ ‫דצימלי‪ ,‬במקרה זה ‪6‬‬
‫{‬
‫;)‪printf(“%d is a number”, 6‬‬
‫}‬ ‫‪29‬‬
‫© ‪Keren Kalif‬‬
‫קבלת קלט מהמשתמש‬

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

‫שראינו עבור כל מספר שתקבל ממי שיריץ את התוכנית (המשתמש)‬

‫לשם כך עלינו ללמוד את הדברים הבאים‪:‬‬

‫• כיצד מקבלים מידע מהמשתמש‬
‫• היכן מאחסנים מידע זה‬
‫• כיצד מדפיסים מידע זה‬

‫‪30‬‬
‫© ‪Keren Kalif‬‬
‫קבלת קלט מהמשתמש (‪)2‬‬
‫פקודה נוספת שהמחשב מכיר היא קריאת נתון מהשתמש‬
‫>‪#include <stdio.h‬‬

‫)(‪void main‬‬ ‫פירוש הפקודה ‪:scanf‬‬

‫{‬ ‫אחסן את הערך שיתקבל‬
‫;‪int x‬‬
‫מהמשתמש במשתנה הנקרא ‪x‬‬
‫;)‪scanf(“%d”, &x‬‬
‫}‬ ‫מה זה ‪?x‬‬
‫• ‪ x‬הוא השם של המקום שבו נאכסן את הערך המתקבל מהמשתמש‬
‫• & מציין לנו איפה נמצא מקום זה‬
‫מה זה ‪?d%‬‬
‫• ציון שהנתון אותו אנו קוראים הוא מספר דצימלי‬
‫כדי להקצות עבורנו מקום זה עלינו להגדיר משתנה‬
‫מה זה ‪ ?int‬נראה בהמשך‬
‫‪31‬‬
‫© ‪Keren Kalif‬‬
‫אחסון ערכים‬
‫כאשר מריצים תוכנית נרצה לשמור ערכים מסוימים כדי שישמשו אותנו בפקודות‬
‫בהמשך‬
‫כאשר התוכנית רצה‪ ,‬היא מקבלת שטח בזיכרון בו היא יכולה לאחסן ערכים אלו‪.‬‬
‫שטח זה נקרא מחסנית (‪)stack‬‬
‫המחסנית מורכבת מתאים‪ ,‬ולכל תא יש כתובת‬
‫כל תא נקרא ‪( byte‬בייט)‬
‫יש משתנים שערכם מאוחסן בבייט אחד‪ ,‬ויש‬
‫‪100‬‬
‫‪0‬‬ ‫משתנים שערכם מאוחסן ביותר (נראה בהמשך)‬
‫‪100‬‬
‫‪1‬‬
‫‪100‬‬
‫‪2‬‬
‫‪100‬‬
‫‪3‬‬
‫‪100‬‬
‫‪4‬‬
‫‪100‬‬
‫‪5‬‬ ‫‪32‬‬
‫© ‪Keren Kalif‬‬
‫אחסון ערכים (‪)2‬‬
‫>‪#include <stdio.h‬‬ ‫‪int:x‬‬
‫‪4‬‬ ‫‪1000‬‬

‫‪1004‬‬
‫)(‪void main‬‬
‫‪1008‬‬
‫{‬
‫‪1012‬‬
‫;‪int x‬‬
‫‪1016‬‬
‫;)‪scanf(“%d”, &x‬‬
‫}‬ ‫‪1020‬‬

‫בתוכנית זו הגדרנו את המשתנה ‪ ,x‬ולכן התוכנית מקצה תא במחסנית‬

‫למשתנה זה‬
‫כאשר המשתמש יקליד מספר‪ ,‬המספר יכנס לתוך התא המוקצה עבור ‪x‬‬

‫‪33‬‬
‫© ‪Keren Kalif‬‬
‫הדפסת ערכו של משתנה‬
‫>‪#include <stdio.h‬‬ ‫‪int:x‬‬
‫‪4‬‬ ‫‪1000‬‬

‫‪1004‬‬

‫)(‪void main‬‬ ‫‪1008‬‬

‫{‬ ‫‪1012‬‬

‫;‪int x‬‬ ‫‪1016‬‬

‫;)“ ‪printf(“Please enter a number:‬‬ ‫‪1020‬‬

‫;)‪scanf(“%d”, &x‬‬ ‫לאחר הקלדת ‪4‬‬

‫;)‪printf(“%d is a number”, x‬‬

‫}‬
‫פקודת ההדפסה מדפיסה את התוכן של התא המוקצה עבור המשתנה ‪ x‬ולכן יודפס‬
‫למסך ‪is a number 4‬‬
‫כדי שהתוכנית שלנו תהייה ידידותית נציג הודעה מתאימה‬

‫‪34‬‬
‫© ‪Keren Kalif‬‬
‫טיפוסי משתנים‬
‫בתוכנית הקודמת ראינו כיצד קולטים מהמשתמש מספר שלם‬
‫ניתן לקלוט גם מספר עשרוני‪ ,‬מספר שלילי או תו‬
‫אבל צריך לידע את המחשב עם איזה סוג של נתונים אנחנו רוצים לעבוד‬
‫בתוכנית הגדרנו‪:‬‬
‫>‪#include <stdio.h‬‬

‫)(‪void main‬‬
‫{‬
‫;‪int x‬‬
‫;)‪scanf(“%d”, &x‬‬
‫}‬

‫כאשר כתבנו את השורה ‪ ;int x‬הגדרנו משתנה שמכיל מספרים שלמים‬

‫‪35‬‬
‫© ‪Keren Kalif‬‬
‫טיפוסי משתנים ‪DATA‬‬
‫‪TYPES‬‬

‫ישנם סוגים שונים של משתנים הנבדלים ב‪:‬‬

‫• בתוכן אותו הם יכולים להכיל (שלם‪ ,‬עשרוני‪ ,‬תו‪ ,‬שליליים)‬
‫• בכמות ה‪ byte -‬שהמשתנה תופס בזיכרון‪ ,‬ומכאן טווח הערכים שמשתנה‬
‫מהטיפוס יכול להכיל‬

‫שימו לב‪:‬‬
‫• טווח הערכים של טיפוסים מסוימים יכול להיות שונה ממערכת הפעלה‬
‫אחת לאחרת‬

‫‪36‬‬
‫© ‪Keren Kalif‬‬
C -‫טיפוסי נתונים ב‬
Definition Size Range
char byte 1 -27…27-1
(-128..127)
)’!’,’a’, ‘A’, ‘6‘( ‫תו‬
int bytes 4 231-1…231-

)-3,7,8234( ‫מספר שלם‬

float bytes 4
)5.2 ,-89 ,3.6( ‫מספר ממשי‬
double bytes 8
)5.2 ,-89 ,3.6( ‫מספר ממשי‬

37
Keren Kalif ©
C (2) -‫טיפוסי נתונים ב‬
Definition Size Range
short bytes 2 215-1 …215-
‫מספר שלם‬ (-32,768…32,767)

long bytes 8 263-1…263-

‫מספר שלם‬
unsigned int bytes 4 232-1…0
‫מספר שלם חיובי‬
unsigned short bytes 2 216-1…0
‫מספר שלם חיובי‬ (0….65535)

unsigned long bytes 8 264-1…0

‫מספר שלם חיובי‬
unsigned char byte 1 28-1…0
‫תו חיובי בלבד‬ (0…255(
38
Keren Kalif ©
http://www.ynet.co.il/articles/0,7340,L-4599213,00.html :‫לקוח מתוך‬ 39
Keren Kalif ©
 ‫הגדרת משתנים בתוכנית‬
int: n1
byte 4 -‫ מורכב מ‬int
4
1000
void main()
double: n2
{ 5.2 1004

int n1 = 4; char: ch
‘f’ 1012
double n2 = 5.2;
short: n3
7
char ch = ‘f’; 1013

short n3 = 7, n4 = 77; short: n4 77 1byte 1015

-‫ מורכב מ‬char
unsigned int n5 = 234234; uint: n5 234234
1017
int n6 = -11;
int: n6 -11
} 1021

?‫למה ההפרש בין הכתובות שונה‬

‫• כי כל סוג משתנה תופס כמות שונה של בייטים‬

:‫הגדרת משתנים‬
<type> <var name>[=init value][,<var name2>…]; 40
Keren Kalif ©
‫אתחול והשמת משתנים‬
‫)(‪void main‬‬ ‫כאשר מגדירים משתנה ערכו הוא זבל‪,‬‬
‫{‬ ‫אלא אם הוא אותחל עם הגדרתו‬
‫;‪int x, y‬‬
‫פעולת השמה היא נתינת ערך למשתנה‪:‬‬
‫;‪int z = 9‬‬
‫<‪>variable> = <expression‬‬
‫;‪x = 5‬‬
‫; ‪y = x*3‬‬ ‫נקרא גם‪:‬‬
‫;‪x = y = 17‬‬ ‫‪L-Value = R-Value‬‬
‫}‬ ‫• ראשית מתבצע חישוב הביטוי שמימין ואז ערכו‬
‫מושם לתוך המשתנה שמשמאל‬
‫‪int:‬‬
‫‪int: xx‬‬ ‫‪17‬‬
‫‪5int: x‬‬
‫???‬ ‫‪5‬‬
‫‪1000‬‬
‫‪1000‬‬ ‫‪1000‬‬

‫‪int:‬‬
‫‪int: yy‬‬ ‫‪15int: y‬‬
‫‪17‬‬
‫???‬ ‫???‬
‫‪1004‬‬
‫‪1004‬‬ ‫‪1004‬‬

‫‪int:‬‬
‫‪int: zz‬‬ ‫‪9int: z‬‬ ‫‪9‬‬ ‫‪41‬‬
‫‪1008‬‬
‫‪1008‬‬ ‫‪1008‬‬
‫© ‪Keren Kalif‬‬
‫ייצוג בינארי‬
‫אבל מחשב מכיר רק את ‪ 0‬ו‪( 1 -‬יש חשמל או אין חשמל)‪ .‬לכן הזיכרון לא‬
‫באמת נראה כך‪..‬‬
‫• בכל תא זיכרון יש קומבינציה של ‪ 0‬ו‪ 1-‬המייצגות את הערך הנמצא בתוך‬
‫התא‬
‫‪00000100‬‬
‫‪00000000‬‬
‫‪4‬‬
‫‪int: n1‬‬
‫‪00000000‬‬
‫‪00000000‬‬ ‫‪1000‬‬ ‫• כל ‪ byte‬מורכב מ‪ 8-‬יחידות‬
‫‪00011000‬‬
‫‪00000000‬‬
‫בסיסיות הנקראות ‪( bit‬סיבית)‬
‫‪24‬‬
‫‪int: n2‬‬ ‫‪00000000‬‬
‫‪00000000‬‬ ‫‪1004‬‬
‫‪1004‬‬
‫• ‪ bit‬מכיל ‪ 0‬או ‪1‬‬
‫‪10101011‬‬
‫‪11111111‬‬
‫‪-85‬‬
‫‪11111111‬‬
‫‪int : n3‬‬
‫‪11111111‬‬ ‫‪1008‬‬
‫‪1008‬‬

‫‪1012‬‬
‫‪1012‬‬

‫‪42‬‬
‫© ‪Keren Kalif‬‬
‫אז כאשר המחשב רואה ‪ 111‬איך הוא‬
‫יודע אם הכוונה ל‪ 7 -‬או ל‪?-8 -‬‬
‫לפי הטיפוס שהמשתנה הוגדר‪ :‬אם הוגדר כ‪ unsigned -‬כל הסיביות‬
‫משמשות לערכים‬
‫אם הוגדר כ‪( signed -‬לא צריך לציין) אז הסיבית השמאלית תמיד תוקצה‬
‫לטובת הסימן (‪ 0‬חיובי‪ 1 ,‬שלילי‪ ,‬ולכן יש לנו סיבית אחת פחות לייצוג‬
‫ערכים)‬

‫‪binary‬‬ ‫‪signed‬‬ ‫‪unsigned‬‬

‫‪00000111‬‬ ‫‪7‬‬ ‫‪7‬‬
‫‪10000111‬‬ ‫‪121-‬‬ ‫‪135‬‬
‫‪11111111‬‬ ‫‪1-‬‬ ‫‪255‬‬
‫‪43‬‬
‫© ‪Keren Kalif‬‬
‫תוכנית ב‪ – C -‬סיכום ביניים‬
‫כפי שראינו‪ ,‬קוד ב‪ C -‬הוא קובץ טקסט הכתוב מאוסף מילים מסוימות‬
‫באנגלית‬
‫יש מילים מסוימות שהן פקודות מוכרות למחשב‬
‫המחשב אינו יודע אנגלית‪ ,‬אלא רק מכיר את הספרות ‪ 0‬ו‪( 1-‬בינארית) ולכן‬
‫עלינו לתרגם עבורו את הקוד שלנו‪ ,‬בתהליך הנקרא קומפילציה‬
‫לאחר תהליך הקומפילציה יש תהליך שנקרא ‪ link‬המייצר קובץ שאותו‬
‫ניתן להריץ ומבצע את הפקודות שכתבנו‬

‫‪44‬‬
‫© ‪Keren Kalif‬‬
‫הגדרת קבועים‬
#include <stdio.h>

void main()
{
float price;
float totalPrice;

printf("Please enter the product’s price: ");

scanf("%f", &price);
totalPrice = price + (price*0.17);
printf("Total price including %.2f%% taxes is %.2f\n",
17.0, totalPrice);
}

45
Keren Kalif ©
 ‫הגדרת קבועים (‪)2‬‬
‫>‪#include <stdio.h‬‬

‫)(‪void main‬‬
‫{‬
‫;‪float price‬‬
‫;‪float totalPrice‬‬ ‫ע"י שימוש במשתנה התוכנית יותר‬
‫;‪float TAXES = 0.17‬‬ ‫קריאה‪ ,‬ברורה מה משמעות המספר גם‬
‫למי שלא יודע מהו ערכו של המע"מ‬
‫;)" ‪printf("Please enter the product’s price:‬‬
‫;)‪scanf("%f", &price‬‬
‫כדי להדפיס רק ‪ 2‬ספרות‬
‫;)‪totalPrice = price + (price*TAXES‬‬
‫אחרי הנקודה העשרונית‬
‫‪printf("Total price including %.2f%% taxes is %.2f\n",‬‬
‫;)‪TAXES*100, totalPrice‬‬
‫}‬ ‫‪ %‬כדי להדפיס‬
‫‪,‬שינוי בערך המע"מ יגרור שינוי במקום אחד בלבד בתוכנית‬
‫מה שחוסך עבודה ובעיות בעתיד (אם שכחנו לתקן במקום כלשהו‪)..‬‬ ‫‪46‬‬
‫© ‪Keren Kalif‬‬
‫קבועים‬
‫קבוע הוא משתנה שלא ניתן לשנות את ערכו‪ .‬הערך נכתב ע"י‬
‫המתכנת בשורה בה מוגדר הקבוע‪ ,‬ונרשם בזמן קומפילציה‪.‬‬
‫לא ניתן לשנות את הערך במהלך ריצת התוכנית‪ .‬רק‬
‫המתכנת יכול לשנות את הערך (שינוי בזמן כתיבת התוכנית)‬
‫ולקמפל מחדש עם הערך החדש‪.‬‬
‫יתרונות‪:‬‬
‫• תוכנית קריאה יותר‬
‫• תחזוקה‬
‫בשפת ‪ C‬קיימות שתי שיטות להגדרת קבוע ‪:‬‬
‫• באמצעות הפקודה ‪define#‬‬
‫• באמצעות הפקודה ‪const‬‬

‫‪47‬‬
‫© ‪Keren Kalif‬‬
‫‪DEFINE#‬‬
‫אפשר להגדיר קבוע באופן הבא‪:‬‬
‫‪#define TAXES 0.17‬‬ ‫שורה זו אינה מסתיימת ב‪; -‬‬
‫את הפקודה ‪ define#‬רצוי לכתוב בתחילת התוכנית‪ ,‬לפני הפונקציה‬
‫‪ main‬ובכך לקבוע לו תחום הכרה ציבורי‬
‫אפשר לכתוב את הפקודה בכל מקום בתוכנית‪ .‬הקבוע יהיה מוכר מאותו‬
‫מקום ועד לסוף התוכנית‪.‬‬
‫בכל פעם שהקומפיילר יפגוש את השם ‪ )TAXES‬בדוגמא) הוא יחליפו‬
‫בערך (‪)0.17‬‬

‫‪48‬‬
‫© ‪Keren Kalif‬‬
 DEFINE ‫הגדרת קבועים ע"י‬
#include <stdio.h> float: price
1000

float:
#define TAXES 0.17 totalPrice 1004

1008
void main()
{
float price;
float totalPrice;

printf("Please enter the product’s price: ");

scanf("%f", &price);
totalPrice = price + (price*TAXES);
printf("Total price including %.2f%% taxes is %.2f\n",
TAXES*100, totalPrice);
}

49
Keren Kalif ©
‫‪CONST‬‬
‫ניתן להגדיר משתנה קבוע באמצעות הפקודה ‪ const‬באופן הבא ‪:‬‬
‫;‪const float TAXES = 0.17‬‬
‫תבנית הפקודה ‪:‬‬
‫;‪const [variable type] variable name = value‬‬

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

‫‪: ;const grade = 100‬‬ ‫• דוגמא‬

‫ההבדל המעשי בין הגדרה באמצעות הפקודה ‪ define#‬לבין הגדרה‬

‫באמצעות הפקודה ‪ const‬הוא שפקודת ‪ define‬מתבצעת בזמן‬
‫‪ precompile‬ופקודת ‪ const‬מתבצעת בזמן קומפילציה‬

‫‪50‬‬
‫© ‪Keren Kalif‬‬
 CONST ‫הגדרת קבועים ע"י‬
#include <stdio.h> ‫ הוא משתנה ולכן יש לו תא‬TAXES
‫ אבל זהו משתנה שלא ניתן‬.‫בזיכרון‬
const float TAXES = 0.17; ‫לשנות את ערכו בזמן ריצה‬
float: 0.17
void main() TAXES 1000
{ float:
price 1004
float price;
float:
float totalPrice; totalPrice 1008

printf("Please enter the product’s price: ");

scanf("%f", &price);
totalPrice = price + (price*TAXES);
printf("Total price including %.2f%% taxes is %.2f\n",
TAXES*100, totalPrice);
}

51
Keren Kalif ©
‫שמות משתנים‬
‫שמות המשתנים יכולים להכיל אותיות גדולות וקטנות‪ ,‬מספרים וקו תחתון בלבד‬
‫לא ניתן להתחיל שם משתנה במספר‬
‫יש לתת שמות משמעותיים!!!‬
‫שם משתנה לא יכיל רווחים‬
‫יש הבדל בין אותיות גדולות לקטנות‬
‫אין להשתמש המילים שמורות של השפה‬
‫דוגמאות‪:‬‬
‫;‪• int x, _y, _average, avg, x1,x2‬‬
‫!‪• int 5, 1x, #x, !!2; // error‬‬

‫‪52‬‬
‫© ‪Keren Kalif‬‬
‫טבלת ‪ASCII‬‬
‫‪http://www.asciitable.com/‬‬

‫עד כה ראינו ייצוג של מספרים‪ ,‬אבל איך מייצגים אותיות ע"י קומבינציה של ‪ 0‬ו‪-‬‬
‫‪?1‬‬
‫• לכל תו יש קוד מספרי הנקרא "קוד ‪"ASCII‬‬
‫• ניתן לראות את הקוד של כל תו ב"טבלת ‪:"ASCII‬‬

‫‪53‬‬
‫© ‪Keren Kalif‬‬
‫ייצוג תווים‬
‫טבלאת ‪:ASCII‬‬
‫‪American Standard for Code Information Interchange‬‬

‫כאשר מאחסנים את ערכו של משתנה מטיפוס ‪ char‬למעשה שומרים את‬

‫ערך ה‪ ASCII -‬שלו‬

‫מאחר וגודלו של ‪ char‬הוא ‪ ,1byte‬כלומר ‪ ,8bit‬ניתן לאחסן במשתנה זה‬

‫‪ )28( 256‬ערכים שונים‬

‫בטבלת ה‪ ASCII -‬הבסיסית יש רק ‪ 127‬ערכים‬

‫‪54‬‬
‫© ‪Keren Kalif‬‬
‫טבלת ‪ -ASCII‬דגשים‬
‫‪http://www.asciitable.com/‬‬

‫ערכי ה‪ASCII -‬של‬

‫האותיות הגדולות‬
‫נמצאים ברצף‬

‫ערכי ה‪ASCII -‬של‬

‫הספרות נמצאים ברצף‪.‬‬
‫שימו לב כי ערכה ה‪-‬‬
‫‪ ASCII‬של ספרה אינו‬
‫זהה לערכה המספרי!‬

‫ערכי ה‪ASCII -‬של‬

‫האותיות הקטנות‬
‫‪55‬‬
‫נמצאים ברצף‬ ‫© ‪Keren Kalif‬‬
‫הגדרת משתנים מטיפוס ‪CHAR‬‬
‫משתנה מטיפוס ‪ char‬נועד כדי לאכסן תו‪ ,‬ולכן ניתן לשים בו תו‪ ,‬או מספר‬
‫• כאשר שמים מספר הכוונה לתו שמספר זה מייצג בטבלת ה‪ASCII -‬‬
‫בדוגמא זו‪ ,‬הערך בשני תאי הזיכרון זהה (משום שהערך ‪ ASCII‬של ‘‪ ’a‬הוא‬
‫‪)97‬‬

‫‪void main‬‬ ‫‪char: ch1‬‬ ‫‪01100001‬‬

‫{‬ ‫‪1000‬‬

‫‪char: ch2‬‬ ‫‪01100001‬‬

‫;’‪char ch1 = ‘a‬‬ ‫‪1001‬‬
‫;‪char ch2 = 97‬‬
‫}‬ ‫‪1002‬‬

‫‪56‬‬
‫© ‪Keren Kalif‬‬
‫הגדרת משתנים מטיפוס ‪CHAR‬‬
‫)‪(2‬‬
‫ערכו של ‪ ch1‬הוא '‪ - '8‬התו ולא המספר (בגלל שהוא בתוך ' ')‬
‫• לכן הערך שנשמר בזכרון הוא ערך ה‪ ASCII -‬של התו '‪)56( '8‬‬
‫לעומתו‪ ,‬ערכו של ‪ ch2‬הוא המספר ‪8‬‬

‫‪void main‬‬ ‫‪char: ch1‬‬ ‫‪01010110‬‬

‫‪1000‬‬

‫{‬ ‫‪char: ch2‬‬ ‫‪00001000‬‬

‫;’‪char ch1 = ‘8‬‬ ‫‪1001‬‬

‫;‪char ch2 = 8‬‬ ‫‪1002‬‬

‫}‬
‫‪57‬‬
‫© ‪Keren Kalif‬‬
‫ וההיפך‬INT -‫ כ‬CHAR ‫הצגת‬
:‫ ניתן להדפיסו או כתו או כמספר‬,‫מאחר ותו מיוצג כמספר‬

void main()
{
int num1 = 97;
int num2 = 'a';
char ch1 = 'a';
char ch2 = 97;

printf(“%d”, num1);
printf(“%c”, num1);

 97
printf(“%d”, num2);
printf(“%c”, num2);
 a

printf(“%c”, ch1);
 97
printf(“%d”, ch1);  a

printf(“%c”, ch2);  a
printf(“%d”, ch2);
}
 97

 a
 97 58
Keren Kalif ©
 ‫מעבר תו המייצג ספרה למספר‬
‫בהינתן תו המכיל ספרה‪ ,‬יש למצוא את ערך הספרה‬
‫דוגמא‪ :‬עבור התו ‘‪ ,’8‬שערך האסקיי שלו הוא ‪ ,56‬יש לשמור‬
‫את הערך ‪ 8‬ב‪int -‬‬
‫• כל הספרות נמצאות בטבלת האסקיי ברצף החל ממספר ‪( 48‬ערך האסקיי של‬
‫התו '‪)'0‬‬
‫• החסרת הערך ‪ 48‬מתו המכיל ספרה יביא לנו את ערך המספר‬

‫)(‪void main‬‬
‫{‬
‫;'‪char ch = '8‬‬
‫;'‪int num = ch - '0‬‬
‫;)‪printf("ch as char: %c, as int: %d\n", ch, ch‬‬
‫;)‪printf("num is %d\n", num‬‬
‫}‬ ‫‪59‬‬
‫© ‪Keren Kalif‬‬
 ‫הדפסת וקליטת משתנים‬
‫מטיפוסים שונים‬
‫עד כה ראינו‪:‬‬
‫• הגדרת משתנים מטיפוסים שונים‬
‫• הדפסה וקליטה של משתנה מטיפוס ‪int‬‬

‫>‪#include <stdio.h‬‬

‫)(‪void main‬‬ ‫עבור כל טיפוס יש פורמט‬

‫{‬ ‫לקליטה ולהדפסה‬
‫;‪int x‬‬ ‫• עבור ‪ int‬זה ‪d%‬‬
‫;)“ ‪printf(“Please enter a number:‬‬
‫;)‪scanf(“%d”, &x‬‬
‫;)‪printf(“number is %d”, x‬‬
‫}‬ ‫‪60‬‬
‫© ‪Keren Kalif‬‬
‫פורמט קליטה והדפסה‬
‫לטיפוסים השונים‬
Data Type Format Explaination
int d% Decimal
short d% Decimal
long ld% Long Decimal
char c% Character
float f% Float
double lf% Long Float
unsigned u% Unsigned
61
Keren Kalif ©
‫הדפסת וקליטת משתנים‬
‫מטיפוסים שונים‬
#include <stdio.h>

void main()
{
int n1;
double n2;
char ch;

printf(“Please enter an int, double and char: “);

scanf(“%d %lf %c”, &n1, &n2, &ch);
printf(“values are: %d %lf %c \n”, n1, n2, ch);
}

62
Keren Kalif ©
 ‫הדפסת תווים מיוחדים‬
#include <stdio.h> n\ ‫ירידת שורה‬

void main()
\" "
{ \t tab
printf("Hello World!");
\\ \
printf("Hello World!\n");
printf("\"Hello World!\"\n"); a\ ‫צלצול‬
printf("Hello\tWorld!\n");
printf("\\Hello World!\\\n")
printf("\a\a\a");
}

63
Keren Kalif ©
– ‫השמות בין טיפוסים שונים‬
‫דוגמא‬
#include <stdio.h>

void main()
{
int n = 3; ‫כל פעם כשיש השמה מטיפוס המכיל יותר בתים‬
double d = 97.2; :warning -‫לטיפוס המכיל פחות בתים נקבל את ה‬
long l = 20; possible lost of data
char ch = ‘d’;

n = ch; //  n= 100
n = l; //  n=20, warning: possible lost of data!
ch = d; //  ch = ‘a’ , warning: possible lost of data!
n = d; //  n=97 , warning: possible lost of data!
ch = 353; //  ch=‘a’ , from int to char reduces 256, until value is less than 256
}

64
Keren Kalif ©
TYPEDEF
:‫ זוהי דרך להגדיר שמות חדשים לטיפוסים‬typedef

typedef unsigned int uint;

‫שם מקורי‬ ‫שם חדש‬

typedef unsigned int uint;

void main()
}
uint n1 = 9, n2 = -3;
printf("n1=%u n2=%u\n", n1, n2);
{
65
Keren Kalif ©
BUFFER ‫קליטת נתונים לתוך‬
#include <stdio.h>

void main()
{
int n1, n2;

printf("Enter a number --> "); ‫ניתן להקליד נתונים עד אשר מקלידים‬

scanf("%d", &n1); -‫ נתונים אלו נמצאים ב‬.ENTER
printf("Enter another number --> "); .‫ ומחכים לפעולת הקליטה הבאה‬buffer
scanf("%d", &n2);
-‫ פקודת ה‬buffer -‫כל עוד יש נתונים ב‬
printf("n1=%d n2=%d\n", n1, n2); .‫ תיקח ממנו נתונים‬scanf
‫ תמתין‬scanf ‫ ריק‬buffer -‫רק כאשר ה‬
}
.‫לקלט מהמשתמש‬

66
Keren Kalif ©
‫בעיה‪ :‬התוכנית "מדלגת" על פקודת הקלט‬

‫)(‪void main‬‬
‫}‬
‫;‪int n1‬‬
‫;‪char c1‬‬

‫;)" ‪printf("Please enter a number:‬‬ ‫הקלדתי ‪ 7‬ואז ‪.ENTER‬‬

‫;)‪scanf("%d", &n1‬‬ ‫לתוך ‪ n1‬נכנס ‪ ,7‬ולתוך ‪ ch1‬נכנס האנטר‪.‬‬
‫;)" ‪printf("Please enter a char:‬‬
‫;)‪scanf("%c", &c1‬‬
‫;)‪printf("n1= |%d| c1=|%c|\n", n1, c1‬‬ ‫‪ ENTER‬הוא גם תו‪ ,‬ומאחר והוא‬
‫{‬ ‫היה ב‪ buffer -‬הוא נקלט לתוך ‪ch1‬‬

‫כאשר אנחנו קולטים נתונים בפקודות נפרדות‪,‬‬

‫נרצה לנקות את ה‪ buffer -‬בין הפעולות השונות‪.‬‬ ‫‪67‬‬
‫© ‪Keren Kalif‬‬
 FLUSHALL ‫ הפקודה‬:‫הפתרון‬
void main()
char ‫כאשר קוראים לתוך משתנה מטיפוס‬
} ‫ נשים את‬,‫לאחר שכבר בוצעה קליטה כלשהי‬
int n1; .‫ בין הקריאות השונות‬flushall ‫הפקודה‬
char c1;

printf("Please enter a number: ");

scanf("%d", &n1);
printf("Please enter a char: "); .f -‫ ו‬ENTER ,7 ‫הקלדתי‬
flushall(); ‫ ואז ניקיתי את‬,7 ‫ נכנס‬n1 ‫לתוך‬
scanf("%c", &c1); buffer -‫ ה‬ENTER -‫ה‬
printf("n1= |%d| c1=|%c|\n", n1, c1); .flushall ‫באמצעות הפקודה‬
{ .ch1 ‫ נכנס לתוך‬f ‫התו‬

68
Keren Kalif ©
 ‫דוגמא לשימוש מיוחד עם‬
SCANF
:‫ בין רכיבי התאריך השונים‬/ ‫נרצה שהמשתמש יקליד תאריך כך שיהיה‬
#include <stdio.h>

void main()
{
int day, month, year;

printf(“Enter your birth-date (dd/MM/yyyy): ");

scanf("%d/%d/%d", &day, &month, &year);
printf("Your birth-date is %d/%d/%d\n", day, month, year);
{

69
Keren Kalif ©
 SCANF -‫דגשים ל‬
‫ כל תו שאינו חלק‬:scanf -‫נשים לב לתוכן בתוך הגרשיים בפקודת ה‬
‫ חייב להיות מוקלד ע"י המשתמש‬,‫מנתון‬
void main()
{ :buffer -‫ה‬
‫הקומפיילר קרא את הרווח בתור תו‬ 5<<‫רווח‬f
89 enter
int num;
char ch;
int: num
5
7 1000
printf("Please enter a number and char: "); char: ch
‘m’
‘’
scanf("%d%c", &num, &ch); 1004

printf("num=|%d| ch=|%c|\n", num, ch);

flushall(); buffer -‫ שנשאר ב‬f -‫מנקה את ה‬

printf("Please enter a number: ");
scanf("%d ", &num);
printf("num=|%d|\n", num);
}
‫ ולכן הוא תקוע‬,‫נשים לב שיש פה רווח ולכן הקומפיילר מחכה שנקיש רווח‬ 70
Keren Kalif ©
 SYSTEM ‫הפקודה‬
‫פקודה המאפשרת לנו להריץ פקודות דוס‬
void main()
{
printf("Hello World!\n");
system("pause");
system("cls");
system("dir");
{

71
Keren Kalif ©
‫ביחידה זו למדנו‪:‬‬
‫בסיסי מספרים‪:‬‬
‫• בינארי (‪ ,)2‬אוקטאלי (‪ ,)8‬הקסה‪-‬דצימאלי (‪)16‬‬
‫הדפסה למסך‬
‫קבלת נתונים מהמשתמש‬
‫מבנה זיכרון התוכנית‬
‫הגדרת משתנים‬
‫טיפוסי משתנים‬
‫השמת ערך למשתנים‬
‫קבועים‬
‫הפקודה ‪flushall‬‬
‫הפקודה ‪system‬‬

‫‪72‬‬
‫© ‪Keren Kalif‬‬
‫תרגיל ‪ :1‬קלט מסוגים שונים‬
‫כתוב תוכנית המקבלת מהמשתמש את שנת הלידה שלו‪ ,‬ת‪.‬ז‪ ,.‬גובה ותו‬
‫המייצג האם המשתמש זכר או נקבה (‪)F/M‬‬
‫התוכנית תדפיס את פרטי המשתמש‪ ,‬אך במקום שנת הלידה תדפיס את‬
‫גילו‬
‫יש לראות בדיבגר את ערכי המשתנים‬

‫‪73‬‬
‫© ‪Keren Kalif‬‬
‫תרגיל ‪ :2‬עבודה עם תווים שהם‬
‫ספרות‬
‫כתוב תוכנית הקוראת מהמשתמש ‪ 3‬תווים (מטיפוס ‪ )char‬שהם ספרות‬
‫התוכנית תייצר משתנה מטיפוס ‪ int‬שיכיל את הספרות שהתקבלו כמספר‬
‫לבסוף התוכנית תדפיס את המספר‬

‫דוגמה‪ :‬אם הוכנסו התווים '‪ '7' '3' '1‬יווצר ויודפס המספר ‪.731‬‬

‫‪74‬‬
‫© ‪Keren Kalif‬‬
‫תרגיל ‪ :3‬טבלאת האסקיי‬
‫כתוב תוכנית (קצרצרה!) המדפיסה את מספר האותיות ‪ AB‬באנגלית‬
‫(בהנחה שאינך יודע כמה יש ‪)‬‬

‫‪75‬‬
‫© ‪Keren Kalif‬‬
‫תרגיל ‪ :4‬מחיר נסיעה במונית‬
‫מחיר נסיעה במונית משוקלל מהרכיבים הבאים‪:‬‬
‫• מחיר התחלתי‪ 10.20 :‬ש"ח‬
‫• מחיר עבור כל ק"מ‪ 1.30 :‬ש"ח‬
‫• מחיר עבור כל מזוודה‪ 2.00 :‬ש"ח‬

‫יש לבקש מהמשתמש את הנתונים הדרושים ולהציג את הסכום לתשלום‬

‫‪76‬‬
‫© ‪Keren Kalif‬‬
‫תרגיל ‪ :5‬זמן נסיעה במעלית‬
‫נרצה לחשב את הזמן מהרגע שזימנו את המעלית עד אשר נגיע לקומת‬
‫היעד‬
‫בכל קומה בה המעלית עוצרת היא מתעכבת ‪ 5‬שניות‬
‫זמן הנסיעה בין קומה לקומה הינו ‪ 3‬שניות‬

‫ניתן להניח שהמעלית נוסעת ללא עצירות‪ ,‬פרט לעצירה בקומה ממנה‬
‫נאסף הנוסע‬
‫לצורך הפשטות‪ ,‬ניתן להניח כי קומת המקור נמוכה מקומת היעד‬
‫• בפתרון אראה כיצד ניתן לוותר על הנחה זו‬

‫‪77‬‬
‫© ‪Keren Kalif‬‬