מבוא לתכנות מחשבים - c 02- c building blocks - 842033

1.

‫אבני היסוד של תוכנית ב‪C -‬‬
‫קרן כליף‬

2.

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

3.

‫בסיס עשרוני (דצימלי)‬
‫‪ ‬בסיס הינו שיטת ספירה‬
‫‪ ‬בבסיס בייצוג עשרוני (השיטה הטבעית לנו) קיימות ‪10‬‬
‫ספרות‪ 0 :‬עד ‪9‬‬
‫‪ ‬לכן אנו אומרים שהן מיוצגות בבסיס ‪10‬‬
‫‪ ‬נקרא גם בסיס דצימלי‬
‫‪ ‬כל מספר שלם ניתן לייצג כסכום של ערכים בחזקות של ‪10‬‬
‫‪ ‬דוגמא‪:‬‬
‫‪2857= 2*103 + 8* 102 + 5*101 + 7* 100‬‬
‫‪3‬‬
‫‪© Keren Kalif‬‬

4.

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

5.

‫ייצוג מספרים בבסיס בינארי – חישוב ערך‬
‫עשרוני של מספר בינארי (מבסיס ‪ 2‬ל‪)10 -‬‬
‫‪ ‬ערכו של מספר המיוצג בבסיס עשרוני הוא סכום חזקות‬
‫‪10 10 10‬‬
‫של ‪:10‬‬
‫‪1 7 3 = 1*102 + 7*101 + 3*100 = 173‬‬
‫‪ ‬הספרה ‪ d‬במיקום ה‪ k-‬מוסיפה לסכום‪( d*10k :‬כלומר‬
‫אם ‪ d==0‬הספרה לא תורמת לסכום)‬
‫‪ ‬ובדומה‪ ,‬ערכו של מספר המיוצג בבסיס בינארי הינו סכום‬
‫של חזקות של ‪( 2‬הספרה ‪ d‬במיקום ה‪ k-‬מוסיפה לסכום‬
‫‪)d*2k‬‬
‫הביט הכי שמאלי נקרא ‪ MSB‬משום שהוא הכי משמעותי לסכום‬
‫‪2 2 2 2 2‬‬
‫‪ ‬דוגמא‪:‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪2‬‬
‫‪2‬‬
‫‪3‬‬
‫‪4‬‬
‫‪11001 = 1*24 + 1*23 + 0*22 + 0*21 + 1*20 =25‬‬
‫‪5‬‬
‫‪© Keren Kalif‬‬
‫הביט הכי ימני נקרא ‪ LSB‬משום שהוא הכי פחות משמעותי לסכום‬

6.

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

7.

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

8.

‫טווח המספרים שניתן לייצג ע"י ספרות‬
‫בינאריות – מספרים חיוביים‬
‫‪ ‬ע"י מספר עשרוני בעל ‪ 3‬ספרות ניתן לייצג ‪ )103=( 1000‬מספרים‬
‫שונים (‪)999...0‬‬
‫‪ ‬ובאופן כללי‪ ,‬מספר עשרוני בעל ‪ k‬ספרות יכול לייצג ‪ 10k‬מספרים‬
‫שונים (‪)10k-1...0‬‬
‫‪ ‬ובדומה‪ ,‬ע"י מספר בינארי בעל ‪ k‬ספרות ניתן לייצג ‪ 2k‬מספרים‬
‫שונים )‪ ,(2k-1…0‬למשל עבור ‪:k=3‬‬
‫‪000 = 0*22 + 0*21 + 0*20 = 0‬‬
‫‪ 001 = 0*22 + 0*21 + 1*20 = 1‬‬
‫‪ 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‬‬
‫‪ ‬‬
‫‪8‬‬
‫‪© Keren Kalif‬‬

9.

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

10.

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

11.

‫יצוג מספר שלילי בבינארי‬
‫‪ ‬נשתמש בשיטת המשלים ל‪:2 -‬‬
‫‪ ‬נמצא את יצוגו הבינארי של המספר החיובי‬
‫‪ ‬נוסיף ‪ 0‬מוביל משמאלו‬
‫‪ ‬נהפוך כל סיבית (‪ 0‬ל‪ ,1 -‬ו‪ 1-‬ל‪)0 -‬‬
‫‪ ‬נוסיף ‪ 1‬לתוצאה‬
‫‪ ‬לבסוף נוסיף את הסיבית ‪ 1‬משמאל למספר‬
‫‪ ‬דוגמא‪ :‬המספר ‪-7‬‬
‫‪0111‬‬
‫‪ 7 ‬בבינארי ‪ 0 +‬מוביל ‪:‬‬
‫‪1000‬‬
‫‪ ‬לאחר הפיכת הסיביות‪:‬‬
‫‪+‬‬
‫‪1‬‬
‫‪ ‬הוספת ‪ 1‬לתוצאה‪:‬‬
‫‪11001‬‬
‫‪ ‬הוספת הסיבית ‪ 1‬משמאל למספר‪:‬‬
‫‪11‬‬
‫‪© Keren Kalif‬‬

12.

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

13.

‫ייצוג מספרים בבסיס ‪ – 8‬חישוב ערך עשרוני‬
‫של מספר אוקטאלי (מ‪ 8 -‬ל‪)10 -‬‬
‫‪ ‬ראינו כי ערכו של מספר המיוצג בבסיס עשרוני הוא סכום‬
‫‪10 10 10‬‬
‫חזקות של ‪:10‬‬
‫‪1 7 3 = 1*102 + 7*101 + 3*100 = 173‬‬
‫‪ ‬הספרה ‪ d‬במיקום ה‪ k-‬מוסיפה לסכום‪( d*10k :‬כלומר‬
‫אם ‪ d=0‬הספרה לא תורמת לסכום)‬
‫‪ ‬ובדומה‪ ,‬ערכו של מספר המיוצג בבסיס ‪ 8‬הינו סכום של‬
‫חזקות של ‪( 8‬הספרה ‪ d‬במיקום ה‪ k-‬מוסיפה לסכום‬
‫‪)d*8k‬‬
‫‪8 8 8 8‬‬
‫‪ ‬דוגמא‪:‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪2‬‬
‫‪2‬‬
‫‪3‬‬
‫‪4 2 5 6 = 4*83 + 2*82 + 5*81 + 6*80 =2222‬‬
‫‪13‬‬
‫‪© Keren Kalif‬‬

14.

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

15.

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

16.

‫ייצוג מספרים בבסיס ‪ – 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‬‬
‫‪16 16 16 16‬‬
‫‪ ‬דוגמא‪:‬‬
‫‪0‬‬
‫‪1‬‬
‫‪2‬‬
‫‪3‬‬
‫‪4 D 5 E = 4*163 + 13*162 + 5*161 + 14*160 =19806‬‬
‫‪16‬‬
‫‪© Keren Kalif‬‬

17.

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

18.

‫ובאופן כללי‪ :‬מעבר מבסיס ‪ n‬לבסיס ‪10‬‬
‫‪ ‬מעבר מבסיס ‪( 2‬בינארי) לבסיס ‪( 10‬עשרוני)‪:‬‬
‫‪11012 = 1*23 + 1*22 + 0*21 + 1*20 = 1310‬‬
‫‪ ‬מעבר מבסיס ‪( 8‬אוקטאלי) לבסיס ‪( 10‬עשרוני)‪:‬‬
‫‪2538=2*82 + 5*81 + 3*80 = 17110‬‬
‫‪ ‬מעבר מבסיס ‪( 16‬הקסה‪-‬דצימלי) לבסיס ‪(10‬עשרוני)‪:‬‬
‫‪1FA16 = 1*162 + 15*161 + 10*160 = 50610‬‬
‫‪18‬‬
‫‪© Keren Kalif‬‬

19.

‫ובאופו כללי‪ :‬מעבר מבסיס ‪ 10‬לבסיס ‪n‬‬
‫יהיה ‪ X‬מספר עשרוני‪.‬‬
‫יהיה ‪ n‬הבסיס עליו רוצים להעביר את ‪.X‬‬
‫‪.1‬‬
‫‪19‬‬
‫‪© Keren Kalif‬‬
‫כל עוד ‪ X‬אינו ‪:0‬‬
‫‪(a‬‬
‫חלק את ‪ X‬ב ‪ n‬ורשום את השארית‬
‫‪(b‬‬
‫חלק את המנה שהתקבלה שוב ב‪ n -‬ורשום את השארית‬
‫החדשה משמאל לשארית הקודמת‬

20.

‫המרה מבסיס ‪ 2‬ל‪16 -‬‬
‫‪ ‬כל ‪ 4‬סיביות (מה‪ LSB -‬ל‪ )MSB -‬ייצגו ספרה בבסיס ‪:16‬‬
‫‪ ‬למשל‪ ,‬עבור‪0 1 1 0 1 0 1 1 0 1 0 :‬‬
‫‪A‬‬
‫‪5‬‬
‫‪3‬‬
‫‪ ‬בקרה‪011010110102 = 85810 :‬‬
‫‪35A16 = 85810‬‬
‫המעבר מבסיס ‪ 2‬ל‪ 8 -‬זהה‪ ,‬רק כל ‪ 3‬סיביות ייצגו ספרה‬
‫‪20‬‬
‫‪© Keren Kalif‬‬

21.

‫המרה מבסיס ‪ 16‬ל‪2 -‬‬
‫‪ ‬כל ספרה תיוצג ע"י ‪ 4‬סיביות‪:‬‬
‫‪3‬‬
‫‪5‬‬
‫‪A‬‬
‫‪ ‬למשל‪ ,‬עבור‪:‬‬
‫‪0011 0101 1010‬‬
‫‪ ‬בקרה‪011010110102 = 85810 :‬‬
‫‪35A16 = 85810‬‬
‫המעבר מבסיס ‪ 8‬ל‪ 2 -‬זהה‪ ,‬רק כל ספרה תיוצג ע"י ‪ 3‬סיביות‬
‫‪21‬‬
‫‪© Keren Kalif‬‬

22.

‫כתיבת תוכנית ראשונה ב‪C -‬‬
‫‪ ‬כל תוכנית ב‪ C -‬תראה כך‪:‬‬
‫ספריה המכילה פקודות‬
‫בסיסיות אשר המחשב מכיר‬
‫>‪#include <stdio.h‬‬
‫במקום ‪ 3‬נקודות נשים‬
‫את אוסף הפקודות שנרצה‬
‫שהתוכנית תבצע‬
‫)(‪void main‬‬
‫{‬
‫…‬
‫}‬
‫‪ main ‬היא פונקציה המורצת עם הרצת התוכנית‬
‫‪ ‬בכל תוכנית תהייה פונקצית ‪ main‬אחת בדיוק‬
‫‪22‬‬
‫‪© Keren Kalif‬‬

23.

‫‪23‬‬
‫‪© Keren Kalif‬‬
‫הדפסה למסך‬
‫‪ ‬אחת הפקודות שהמחשב מכיר היא הדפסה למסך‬
‫>‪#include <stdio.h‬‬
‫הרצה של התוכנית הזו תדפיס‬
‫למסך את המחרוזת‬
‫!‪Hello World‬‬
‫)(‪void main‬‬
‫{‬
‫;)”!‪printf(“Hello World‬‬
‫}‬

24.

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

25.

‫קבלת קלט מהמשתמש‬
‫‪ ‬היינו רוצים שהתוכנית שלנו תהייה גמישה‪ ,‬ותדע להדפיס‬
‫את המחרוזת שראינו עבור כל מספר שתקבל ממי שיריץ‬
‫את התוכנית (המשתמש)‬
‫‪ ‬לשם כך עלינו ללמוד את הדברים הבאים‪:‬‬
‫‪ ‬כיצד מקבלים מידע מהמשתמש‬
‫‪ ‬היכן מאחסנים מידע זה‬
‫‪ ‬כיצד מדפיסים מידע זה‬
‫‪25‬‬
‫‪© Keren Kalif‬‬

26.

‫קבלת קלט מהמשתמש (‪)2‬‬
‫‪ ‬פקודה נוספת שהמחשב מכיר היא קריאת נתון מהשתמש‬
‫>‪#include <stdio.h‬‬
‫פירוש הפקודה ‪:scanf‬‬
‫אחסן את הערך שיתקבל‬
‫מהמשתמש במשתנה הנקרא ‪x‬‬
‫‪ ‬מה זה ‪?x‬‬
‫)(‪void main‬‬
‫{‬
‫;‪int x‬‬
‫;)‪scanf(“%d”, &x‬‬
‫}‬
‫‪ x ‬הוא השם של המקום שבו נאכסן את הערך המתקבל מהמשתמש‬
‫‪ & ‬מציין לנו איפה נמצא מקום זה‬
‫‪ ‬מה זה ‪?%d‬‬
‫‪ ‬ציון שהנתון אותו אנו קוראים הוא מספר דצימלי‬
‫‪ ‬כדי להקצות עבורנו מקום זה עלינו להגדיר משתנה‬
‫‪ ‬מה זה ‪ ?int‬נראה בהמשך‬
‫‪26‬‬
‫‪© Keren Kalif‬‬

27.

‫אחסון ערכים‬
‫‪ ‬כאשר מריצים תוכנית נרצה לשמור ערכים מסוימים כדי‬
‫שישמשו אותנו בפקודות בהמשך‬
‫‪ ‬כאשר התוכנית רצה‪ ,‬היא מקבלת שטח בזיכרון בו היא‬
‫יכולה לאחסן ערכים אלו‪ .‬שטח זה נקרא מחסנית (‪)stack‬‬
‫‪ ‬המחסנית מורכבת מתאים‪ ,‬ולכל תא יש כתובת‬
‫‪ ‬כל תא נקרא ‪( byte‬בייט)‬
‫‪ ‬יש משתנים שערכם מאוחסן בבייט אחד‪ ,‬ויש‬
‫משתנים שערכם מאוחסן ביותר (נראה בהמשך)‬
‫‪1000‬‬
‫‪1001‬‬
‫‪1002‬‬
‫‪1003‬‬
‫‪1004‬‬
‫‪27‬‬
‫‪© Keren Kalif‬‬
‫‪1005‬‬

28.

‫אחסון ערכים (‪)2‬‬
‫‪1000‬‬
‫‪1004‬‬
‫‪1008‬‬
‫‪1012‬‬
‫‪1016‬‬
‫‪1020‬‬
‫‪4‬‬
‫‪int:x‬‬
‫>‪#include <stdio.h‬‬
‫)(‪void main‬‬
‫{‬
‫;‪int x‬‬
‫;)‪scanf(“%d”, &x‬‬
‫}‬
‫‪ ‬בתוכנית זו הגדרנו את המשתנה ‪ ,x‬ולכן התוכנית מקצה‬
‫תא במחסנית למשתנה זה‬
‫‪ ‬כאשר המשתמש יקליד מספר‪ ,‬המספר יכנס לתוך התא‬
‫המוקצה עבור ‪x‬‬
‫‪28‬‬
‫‪© Keren Kalif‬‬

29.

‫הדפסת ערכו של משתנה‬
‫‪1000‬‬
‫‪1004‬‬
‫‪1008‬‬
‫‪1012‬‬
‫‪1016‬‬
‫‪1020‬‬
‫‪4‬‬
‫‪int:x‬‬
‫>‪#include <stdio.h‬‬
‫)(‪void main‬‬
‫{‬
‫;‪int x‬‬
‫;)“ ‪printf(“Please enter a number:‬‬
‫;)‪scanf(“%d”, &x‬‬
‫לאחר הקלדת ‪4‬‬
‫;)‪printf(“%d is a number”, x‬‬
‫}‬
‫‪ ‬פקודת ההדפסה מדפיסה את התוכן של התא המוקצה‬
‫עבור המשתנה ‪ x‬ולכן יודפס למסך ‪4 is a number‬‬
‫‪ ‬כדי שהתוכנית שלנו תהייה ידידותית נציג הודעה מתאימה‬
‫‪29‬‬
‫‪© Keren Kalif‬‬

30.

‫טיפוסי משתנים‬
‫‪ ‬בתוכנית הקודמת ראינו כיצד קולטים מהמשתמש מספר שלם‬
‫‪ ‬ניתן לקלוט גם מספר עשרוני‪ ,‬מספר שלילי או תו‬
‫‪ ‬אבל צריך לידע את המחשב עם איזה סוג של נתונים אנחנו רוצים‬
‫לעבוד‬
‫‪ ‬בתוכנית הגדרנו‪:‬‬
‫>‪#include <stdio.h‬‬
‫)(‪void main‬‬
‫{‬
‫;‪int x‬‬
‫;)‪scanf(“%d”, &x‬‬
‫}‬
‫‪ ‬כאשר כתבנו את השורה ;‪ int x‬הגדרנו משתנה שמכיל מספרים‬
‫שלמים‬
‫‪30‬‬
‫‪© Keren Kalif‬‬

31.

‫טיפוסי משתנים ‪Data Types‬‬
‫‪ ‬ישנם סוגים שונים של משתנים הנבדלים ב‪:‬‬
‫‪ ‬בתוכן אותו הם יכולים להכיל (שלם‪ ,‬עשרוני‪ ,‬תו‪ ,‬שליליים)‬
‫‪ ‬בכמות ה‪ byte -‬שהמשתנה תופס בזיכרון‪ ,‬ומכאן טווח הערכים‬
‫שמשתנה מהטיפוס יכול להכיל‬
‫‪ ‬שימו לב‪:‬‬
‫‪ ‬טווח הערכים של טיפוסים מסוימים יכול להיות שונה ממערכת‬
‫הפעלה אחת לאחרת‬
‫‪31‬‬
‫‪© Keren Kalif‬‬

32.

C -‫טיפוסי נתונים ב‬
Definition
Size
Range
char
1 byte
-27…27-1
4 bytes
-231…231-1
)‘a’, ‘A’, ‘6’,’!’( ‫תו‬
int
(-128..127)
)-3,7,8234( ‫מספר שלם‬
float
4 bytes
)5.2 ,-89 ,3.6( ‫מספר ממשי‬
double
8 bytes
)5.2 ,-89 ,3.6( ‫מספר ממשי‬
32
© Keren Kalif

33.

)2( C -‫טיפוסי נתונים ב‬
Definition
Size
Range
short
2 bytes
-215… 215-1
(-32,768…32,767)
8 bytes
-263…263-1
4 bytes
0…232-1
2 bytes
0…216-1
(0….65535)
8 bytes
0…264-1
1 byte
0…28-1
‫מספר שלם‬
long
‫מספר שלם‬
unsigned int
‫מספר שלם חיובי‬
unsigned short
‫מספר שלם חיובי‬
unsigned long
‫מספר שלם חיובי‬
unsigned char
‫תו חיובי בלבד‬
(0…255(
33
© Keren Kalif

34.

‫הגדרת משתנים בתוכנית‬
int: n1
void main()
{
int n1 = 4;
double n2 = 5.2;
char ch = ‘f’;
short n3 = 7, n4 = 77;
unsigned int n5 = 234234;
int n6 = -11;
}
double: n2
char: ch
short: n3
short: n4
uint: n5
int: n6
4
5.2
‘f’
7
77
234234
-11
1000
1004
byte 4 -‫ מורכב מ‬int
1012
1013
1015
byte1 -‫ מורכב מ‬char
1017
1021
?‫ למה ההפרש בין הכתובות שונה‬
‫כי כל סוג משתנה תופס כמות שונה של בייטים‬
:‫ הגדרת משתנים‬
<type> <var name>[=init value][,<var name2>…];
34
© Keren Kalif

35.

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

36.

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

37.

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

38.

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

39.

‫ייצוג תווים‬
‫‪ ‬עד כה ראינו ייצוג של מספרים‪ ,‬אבל איך מייצגים אותיות‬
‫ע"י קומבינציה של ‪ 0‬ו‪?1 -‬‬
‫‪ ‬לכל תו יש קוד מספרי הנקרא "קוד ‪ ,"ASCII‬ניתן לראות את‬
‫הקוד של כל תו ב"טבלת ‪"ASCII‬‬
‫‪ ‬כאשר מאחסנים את ערכו של משתנה מטיפוס ‪ char‬למעשה‬
‫שומרים את ערך ה‪ ASCII -‬שלו‬
‫‪ ‬מאחר וגודלו של ‪ char‬הוא ‪ ,1byte‬כלומר ‪ ,8bit‬ניתן‬
‫לאחסן במשתנה זה ‪ (28) 256‬ערכים שונים‬
‫‪ ‬בטבלת ה‪ ASCII -‬הבסיסית יש רק ‪ 127‬ערכים‬
‫‪American Standard for Code Information Interchange‬‬
‫‪39‬‬
‫‪© Keren Kalif‬‬

40.

‫טבלת ‪ - ASCII‬דגשים‬
‫‪http://www.asciitable.com/‬‬
‫ערכי ה‪ ASCII -‬של‬
‫האותיות הגדולות‬
‫נמצאים ברצף‬
‫ערכי ה‪ ASCII -‬של‬
‫הספרות נמצאים ברצף‪.‬‬
‫שימו לב כי ערכה ה‪-‬‬
‫‪ ASCII‬של ספרה אינו‬
‫זהה לערכה המספרי!‬
‫‪40‬‬
‫‪© Keren Kalif‬‬
‫‪40‬‬
‫ערכי ה‪ ASCII -‬של‬
‫האותיות הקטנות‬
‫נמצאים ברצף‬

41.

‫הגדרת משתנים מטיפוס ‪char‬‬
‫‪ ‬משתנה מטיפוס ‪ char‬נועד כדי לאכסן תו‪ ,‬ולכן ניתן‬
‫לשים בו תו‪ ,‬או מספר‬
‫‪ ‬כאשר שמים מספר הכוונה לתו שמספר זה מייצג בטבלת ה‪-‬‬
‫‪ASCII‬‬
‫‪ ‬בדוגמא זו‪ ,‬הערך בשני תאי הזיכרון זהה (משום שהערך‬
‫‪ ASCII‬של ’‪ ‘a‬הוא ‪)97‬‬
‫‪01100001‬‬
‫‪char: ch1‬‬
‫‪1000‬‬
‫‪01100001‬‬
‫‪1001‬‬
‫‪1002‬‬
‫‪41‬‬
‫‪© Keren Kalif‬‬
‫‪char: ch2‬‬
‫‪void main‬‬
‫{‬
‫;’‪char ch1 = ‘a‬‬
‫;‪char ch2 = 97‬‬
‫}‬

42.

‫הגדרת משתנים מטיפוס ‪)2( char‬‬
‫‪ ‬ערכו של ‪ ch1‬הוא '‪ - '8‬התו ולא המספר (בגלל שהוא‬
‫בתוך ' ')‬
‫‪ ‬לכן הערך שנשמר בזכרון הוא ערך ה‪ ASCII -‬של התו '‪)56( '8‬‬
‫‪ ‬לעומתו‪ ,‬ערכו של ‪ ch2‬הוא המספר ‪8‬‬
‫‪01010110‬‬
‫‪char: ch1‬‬
‫‪1000‬‬
‫‪00001000‬‬
‫‪1001‬‬
‫‪1002‬‬
‫‪42‬‬
‫‪© Keren Kalif‬‬
‫‪char: ch2‬‬
‫‪void main‬‬
‫{‬
‫;’‪char ch1 = ‘8‬‬
‫;‪char ch2 = 8‬‬
‫}‬

43.

‫ההבדל בין מספר לתו‬
‫ ניתן להדפיסו או כתו או‬,‫ מאחר ותו מיוצג כמספר‬
:‫כמספר‬
#include <stdio.h>
void main()
{
printf(“int=%d, char=%c”, ‘Z’, ‘Z’);
printf(“int=%d, char=%c”, 97, 97);
}
43
© Keren Kalif

44.

‫מעבר תו המייצג ספרה למספר‬
‫‪ ‬בהינתן תו המכיל ספרה‪ ,‬יש למצוא את ערך הספרה‬
‫‪ ‬דוגמא‪ :‬עבור התו ’‪ ,‘8‬שערך האסקיי שלו הוא ‪ ,56‬יש לשמור‬
‫את הערך ‪ 8‬ב‪int -‬‬
‫‪ ‬כל הספרות נמצאות בטבלת האסקיי ברצף החל ממספר ‪48‬‬
‫(ערך האסקיי של התו '‪)'0‬‬
‫‪ ‬החסרת הערך ‪ 48‬מתו המכיל ספרה יביא לנו את ערך המספר‬
‫‪44‬‬
‫‪© Keren Kalif‬‬
‫)(‪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‬‬
‫}‬

45.

‫הדפסת וקליטת משתנים מטיפוסים שונים‬
‫‪ ‬עד כה ראינו‪:‬‬
‫‪ ‬הגדרת משתנים מטיפוסים שונים‬
‫‪ ‬הדפסה וקליטה של משתנה מטיפוס ‪int‬‬
‫>‪#include <stdio.h‬‬
‫‪ ‬עבור כל טיפוס יש פורמט‬
‫לקליטה ולהדפסה‬
‫‪ ‬עבור ‪ int‬זה ‪%d‬‬
‫‪45‬‬
‫‪© Keren Kalif‬‬
‫)(‪void main‬‬
‫{‬
‫;‪int x‬‬
‫;)“ ‪printf(“Please enter a number:‬‬
‫;)‪scanf(“%d”, &x‬‬
‫;)‪printf(“number is %d”, x‬‬
‫}‬

46.

‫פורמט קליטה והדפסה לטיפוסים השונים‬
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
46
© Keren Kalif

47.

‫הדפסת וקליטת משתנים מטיפוסים שונים‬
#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);
}
47
© Keren Kalif

48.

‫הדפסת תווים מיוחדים‬
#include <stdio.h>
void main()
{
printf("Hello World!");
printf("Hello World!\n");
printf("\"Hello World!\"\n");
printf("Hello\tWorld!\n");
printf("\\Hello World!\\\n")
printf("\a\a\a");
}
\n
‫ירידת שורה‬
\"
"
\t
tab
\\
\
\a
‫צלצול‬
48
© Keren Kalif

49.

‫אתחול והשמת משתנים‬
‫‪ ‬כאשר מגדירים משתנה ערכו הוא זבל‪,‬‬
‫אלא אם הוא אותחל עם הגדרתו‬
‫‪ ‬פעולת השמה היא נתינת ערך למשתנה‪:‬‬
‫>‪<variable> = <expression‬‬
‫נקרא גם‪:‬‬
‫‪L-Value = R-Value‬‬
‫‪ ‬ראשית מתבצע חישוב הביטוי שמימין ואז ערכו‬
‫מושם לתוך המשתנה שמשמאל‬
‫‪1000‬‬
‫‪1004‬‬
‫‪49‬‬
‫‪© Keren Kalif‬‬
‫???‬
‫‪17‬‬
‫‪5‬‬
‫???‬
‫‪15‬‬
‫‪17‬‬
‫‪9‬‬
‫‪1008‬‬
‫)(‪void main‬‬
‫{‬
‫;‪int x, y‬‬
‫;‪int z = 9‬‬
‫;‪x = 5‬‬
‫; ‪y = x*3‬‬
‫;‪x = y = 17‬‬
‫}‬
‫‪int: x‬‬
‫‪int: y‬‬
‫‪int: z‬‬

50.

‫השמות בין טיפוסים שונים – דוגמא‬
#include <stdio.h>
void main()
{
int
n = 3;
double d = 97.2;
long
l = 20;
char ch = ‘d’;
}
‫כל פעם כשיש השמה מטיפוס המכיל יותר בתים‬
:warning -‫לטיפוס המכיל פחות בתים נקבל את ה‬
possible lost of data
// n= 100
n = ch;
// n=20, warning: possible lost of data!
n = l;
// ch = ‘a’ , warning: possible lost of data!
ch = d;
// n=97 , warning: possible lost of data!
n = d;
ch = 353; // n=‘a’ , from int to char reduces 256, until
value is less than 256
50
© Keren Kalif

51.

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);
{
51
© Keren Kalif

52.

‫הגדרת קבועים‬
#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);
}
52
© Keren Kalif

53.

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

54.

‫קבועים‬
‫‪ ‬קבוע הוא משתנה שלא ניתן לשנות את ערכו‪ .‬הערך נכתב‬
‫ע"י המתכנת בשורה בה מוגדר הקבוע‪ ,‬ונרשם בזמן‬
‫קומפילציה‪.‬‬
‫‪ ‬לא ניתן לשנות את הערך במהלך ריצת התוכנית‪ .‬רק‬
‫המתכנת יכול לשנות את הערך (שינוי בזמן כתיבת‬
‫התוכנית) ולקמפל מחדש עם הערך החדש‪.‬‬
‫‪ ‬יתרונות‪:‬‬
‫‪ ‬תוכנית קריאה יותר‬
‫‪ ‬תחזוקה‬
‫‪ ‬בשפת ‪ C‬קיימות שתי שיטות להגדרת קבוע‪:‬‬
‫‪ ‬באמצעות הפקודה ‪#define‬‬
‫‪ ‬באמצעות הפקודה ‪const‬‬
‫‪54‬‬
‫‪© Keren Kalif‬‬

55.

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

56.

define ‫הגדרת קבועים ע"י‬
#include <stdio.h>
float: price
#define TAXES 0.17
void main()
{
float price;
float totalPrice;
}
1000
float:
totalPrice
1004
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);
56
© Keren Kalif

57.

‫‪const‬‬
‫‪ ‬ניתן להגדיר משתנה קבוע באמצעות הפקודה ‪const‬‬
‫באופן הבא‪:‬‬
‫;‪const float TAXES = 0.17‬‬
‫‪ ‬תבנית הפקודה‪:‬‬
‫;‪const [variable type] variable name = value‬‬
‫‪ ‬לא חייבים לכתוב את סוג הקבוע‪ ,‬בהשמה נקבע הסוג‪.‬‬
‫‪ ‬דוגמא‪:‬‬
‫;‪const grade = 100‬‬
‫‪ ‬ההבדל המעשי בין הגדרה באמצעות הפקודה‬
‫‪#define‬לבין הגדרה באמצעות הפקודה ‪ const‬הוא‬
‫שפקודת ‪ define‬מתבצעת בזמן ‪ precompile‬ופקודת‬
‫‪ const‬מתבצעת בזמן קומפילציה‬
‫‪57‬‬
‫‪© Keren Kalif‬‬

58.

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

59.

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);
printf("n1=%d n2=%d\n", n1, n2);
}
-‫ פקודת ה‬buffer -‫כל עוד יש נתונים ב‬
.‫ תיקח ממנו נתונים‬scanf
‫ תמתין‬scanf ‫ ריק‬buffer -‫רק כאשר ה‬
.‫לקלט מהמשתמש‬
59
© Keren Kalif

60.

‫בעיה‪ :‬התוכנית "מדלגת" על פקודת הקלט‬
‫)(‪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‬‬
‫‪ ENTER‬הוא גם תו‪ ,‬ומאחר והוא‬
‫;)‪printf("n1= |%d| c1=|%c|\n", n1, c1‬‬
‫היה ב‪ buffer -‬הוא נקלט לתוך ‪ch1‬‬
‫‪60‬‬
‫‪© Keren Kalif‬‬
‫כאשר אנחנו קולטים נתונים בפקודות נפרדות‪,‬‬
‫נרצה לנקות את ה‪ buffer -‬בין הפעולות השונות‪.‬‬
‫{‬

61.

flushall ‫ הפקודה‬:‫הפתרון‬
void main()
}
int
n1;
char c1;
char ‫כאשר קוראים לתוך משתנה מטיפוס‬
‫ נשים את‬,‫לאחר שכבר בוצעה קליטה כלשהי‬
.‫ בין הקריאות השונות‬flushall ‫הפקודה‬
printf("Please enter a number: ");
scanf("%d", &n1);
printf("Please enter a char: ");
_flushall();
scanf("%c", &c1);
printf("n1= |%d| c1=|%c|\n", n1, c1);
{
.f -‫ ו‬ENTER ,7 ‫הקלדתי‬
‫ ואז ניקיתי את‬,7 ‫ נכנס‬n1 ‫לתוך‬
buffer -‫ ה‬ENTER -‫ה‬
.flushall ‫באמצעות הפקודה‬
.ch1 ‫ נכנס לתוך‬f ‫התו‬
61
© Keren Kalif

62.

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);
{
62
© Keren Kalif

63.

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

64.

system ‫הפקודה‬
‫ פקודה המאפשרת לנו להריץ פקודות דוס‬
void main()
{
printf("Hello World!\n");
system("pause");
system("cls");
system("dir");
{
64
© Keren Kalif

65.

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