1. מבוא למדעי המחשב
תרגול מספר 3

2. בשיעור הקודם... קלט / פלט חתימה (צורת רישום) של פונקציה
putchar, getchar
printf, scanf
תווי בקרה לשליטה על מחרוזת הבקרה (%d,%f,%c…)
קביעת רוחב שדה, יישור, מספר ספרות עשרוניות להצגה
#include <stdio.h>

3. תפריט היום מנה ראשונה מנה עיקרית ולקינוח... מזהים טיפוסים אופרטורים
קבועים
ולקינוח...
enum
(אם יישאר זמן)

4. מזהים (identifiers)
הגדרה - מזהים הם שמות הניתנים לעצמים בתוכנית. לדוגמא - למשתנים, פונקציות וכו'...
כללים למזהים חוקיים
רצף של אותיות, ספרות, underscore ('_')
אורך בלתי מוגבל (בד"כ רק 31 התווים הראשונים נחשבים)
ישנה הבחנה בין אותיות קטנות לגדולות (size ו-SizE הם שני מזהים שונים)
רצוי - שם משמעותי
דוגמאות - time, iterator2, day_of_week

5. מזהים (identifiers) כללים למזהים לא חוקיים רצף המתחיל בספרה מילה שמורה
if, while, int, double, return, char, void...
לא מומלץ לתת שמות המשמשים כבר עבור זיהוי עצמים אחרים (לדוגמא - לתת למשתנה את השם printf)
לא מומלץ לתת שם שמתחיל ב-underscore
דוגמאות לא חוקיות:
2pac, #123, day-of-week

6. מילים שמורות (keywords)
auto
break
case
char
const
continue
default do
double
else
enum
extern
float
for
goto if
int
long
register
return
short
signed
sizeof
static
struct
switch
typedef
union
unsigned
void
volatile
while

7. טיפוסים (types) ראינו: int, double, char
לכל משתנה מטיפוס מסוים מוקצה מספר בתים בזיכרון
מספר הבתים תלוי במחשב ובקומפיילר, וקובע את טווח הייצוג של המשתנה
לדוגמא, יש מחשבים שבהם למשתנה מטיפוס int מוקצים 2 בתים, ואז המשתנה יכול להכיל ערכים שבין לבין 32767

8. מספרים שלמים הטיפוס הבסיסי לייצוג מספרים שלמים הוא int
טיפוסים נוספים: short int (בקיצור short), long int (בקיצור long)
בד"כ ל-short מוקצים 2 בתים, ול-long 4 בתים
אסור להציב למשתנה ערך מחוץ לטווח הערכים שלו

9. מספרים שלמים – טווח הייצוג
2 בתים (= 16 ביטים)
215 ≈ 32,000
4 בתים (= 32 ביטים)
231 ≈ 2 billion

10. מספרים שלמים ללא סימן טיפוס נוסף: unsigned int (או בקיצור unsigned)
ל- unsigned int מוקצה אותו מספר בתים כמו ל-int
ההבדל: טווח הייצוג לא כולל מספרים שליליים, וטווח הייצוג של המספרים החיוביים גדל פי 2
טיפוסים נוספים:
unsigned long, unsigned short

11. מספרים שלמים ללא סימן – טווח הייצוג
2 בתים (= 16 ביטים)
216 ≈ 65,000
4 בתים (= 32 ביטים)
232 ≈ 4 billion

12. מספרים ממשיים ראינו טיפוס אחד – double
טיפוסים נוספים: float, long double
ההבדל: מספר הבתים המוקצה בזיכרון
בד"כ ל- double מוקצים 8 בתים, ל- float מוקצים 4 בתים, ול-long double מוקצים 8 או 16 בתים

13. מספרים ממשיים – טווח הייצוג
4 בתים
כ-6 ספרות דיוק עשרוניות
טווח סדרי הגודל הוא בקירוב: 10-38…10+38
8 בתים
כ-15 ספרות דיוק עשרוניות
טווח סדרי הגודל הוא בקירוב: …10+308

14. תווים תווים מיוצגים בזיכרון בתור מספר, לפי ערך ה-ASCII שלהם
הגרשיים שסביב התו מתרגמים את התו לערך ה-ASCII שלו (למשל, 'a' מתורגם ל-97)
ניתן לייצג תו ע"י כל טיפוס המייצג מספר שלם
טיפוס מיוחד לייצוג תווים הוא char, טווח הייצוג שלו הוא בדיוק (למשתנה מטיפוס char מוקצה תמיד בית אחד)

15. טבלת ASCII

16. דוגמא לשימוש ב-char מה עושה התוכנית הבאה? char letter;
printf("Enter a lowercase letter: ");
scanf("%c", &letter);
printf("In uppercase: %c", (letter-'a(' + 'A');

17. הגדרת טיפוס חדש
"יצירת" הטיפוס החדש היא בעצם נתינת כינוי חדש לטיפוס קיים
תחביר
typedef known_type identifier;
מנקודה זו ואילך, ההתייחסות אל המזהה תהייה כמו אל הטיפוס הידוע
דוגמא
typedef double weight;
weight my_body_weight;

18. הגדרת טיפוס חדש דוגמא #include <stdio.h>
typedef double distance;
int main(void) {
distance miles, kilometers;
scanf(“%lf”,&miles);
kilometers = miles * 1.609;
printf(“%f miles=%f kilometers\n”,miles,kilometers);
return 0; }

19. אופרטורים מהו אופרטור (operator)? אופרטורים אריתמטיים:
+,*,-,/,%
הוספה והורדה (אופרטורים שמוסיפים 1 או מורידים 1 ממשתנים): ++ --
פועלים רק על משתנים! (לא ניתן לכתוב 5++ )
מיקומם חשוב מאוד

20. אופרטורי הוספה והורדה X++ ++X באופן דומה מוגדרות הפעולות X-- ו --X
אם האופרטור מופיע אחרי המשתנה, אזי קודם משתמשים בערך המשתנה לחישוב הביטוי, ורק אז המשתנה גדל ב-1
++X
אם האופרטור מופיע לפני המשתנה, קודם המשתנה גדל ב-1 ורק אז מחושב הביטוי
באופן דומה מוגדרות הפעולות X-- ו --X

21. אופרטורי הוספה והורדה דוגמא לאופרטור הוספה (מצד ימין): int x,y; x = 8;
שקול ל :
y = x;
x = x + 1;
לאחר הביצוע, x יהיה שווה 9 ו-y יהיה שווה 8

22. אופרטורי הוספה והורדה דוגמא לאופרטור הוספה (מצד שמאל): int x,y; x = 8;
שקול ל :
x = x+1;
y = x;
לאחר הביצוע, x יהיה שווה 9 ו-y יהיה שווה 9

23. אופרטורי הוספה והורדה מה הפלט? int n, x, y; n = 5; x = n--; y = --n;
printf("x=%d y=%d n=%d", x, y, n);
x=5 y=3 n=3

24. אופרטורים במקום לכתוב x = x+y; אפשר לכתוב x += y;
אופרטורים נוספים: -=, *=, /=, %= ועוד...

25. קדימויות וסדר ביצוע קדימויות
תזכורת מבית ספר - כפל וחילוק קודמים לחיבור וחיסור
מה עם שאר האופרטורים?
טבלה בשקף הבא...

26. טבלת קדימויות וסדר ביצוע

27. אופרטורים מה יהיה הפלט? result=2,w=2 int x, y, w, result; x = 7;
result += (y++-x)*(--w*2)/8;
printf("result=%d,w=%d\n", result, w);
result=2,w=2

28. המרת טיפוסים
הבעיה - ניתן להפעיל אופרטורים מסוימים בשפת C רק על משתנים מאותו טיפוס +
= ?
Type Casting +
= 2

29. המרת טיפוסים
המרה אוטומטית (תהליך סמוי) מתבצעת כאשר אופרטור הופעל על טיפוסים שונים
הערה: בשפת C, אם אנחנו רוצים להתייחס למספר שלם (למשל ל-4) כאל מספר ממשי, יש להוסיף לו את הסיומת "0." (למשל: 4.0)
עבור אופרטורי השמה(=, =+, =-, ...), הערך בצד ימין של האופרטור יומר לטיפוס של המשתנה שלתוכו כותבים
דוגמא:
int i;
i = 3.5;
לאחר ביצוע ההשמה, ערכו של i יהיה 3

30. המרת טיפוסים
עבור שאר האופרטורים, הטיפוס בעל העדיפות הנמוכה יותר יומר לטיפוס בעל העדיפות הגבוהה יותר, לפי סדר העדיפויות הבא:
long double, double, float, long, int, char
ההמרה היא זמנית, נשמרת בזיכרון ולא במשתנה
double x = 6.5, y;
int i = 5;
y = x + i;
לצורך ביצוע הפעולה ערכו של i מומר ל-double (כלומר ערכו הופך מ-5 ל-5.0), אבל השינוי הוא זמני בלבד (לאחר ביצוע הפעולה i נשאר מטיפוס int, וערכו עדיין 5)

31. המרת טיפוסים דוגמא: בסיום d2=7.0 int i1, i2; double d1, d2; i1 = 3;
d2 = d1+i1/i2;

32. המרת טיפוסים דוגמא: בסיום i=7 int i; double x, y; x = 7.0; y = 2.0;
i = 4 + x/y

33. המרת טיפוסים מכוונת המרה מכוונת (type casting)
תחביר : (type)expression
דוגמאות
(int) 4.7
(double)(z + 5)
לאופרטור cast יש את הקדימות הגבוהה ביותר בעת חישוב ביטוי
דוגמא נוספת
(int)(4.3)/(int)(5.2)+(double)(3/7)

34. המרת טיפוסים מכוונת דוגמא: בסיום d2=7.75 int i1, i2; double d1, d2;
d2 = d1 + (double)i1/i2;

35. המרת טיפוסים מכוונת דוגמא: בסיום d2=7.0 int i1, i2; double d1, d2;
d2 = d1 + (double)(i1/i2);

36. האופרטור sizeof תחביר - sizeof(type) או sizeof(expression)
אופרטור זה מחזיר את מספר הבתים הדרושים לאכסן בזיכרון את הטיפוס או הביטוי
שימושים? נראה בהמשך הקורס (הקצאות דינאמיות)
דוגמאות:
sizeof(char), sizeof(int), sizeof(double)
sizeof(x), sizeof(y+x)
sizeof(4), sizeof(7.0)

37. קבועים אם נכתוב בתוכנית: #define PI 3.14
אז ה- preprocessor יחליף את כל המופעים של PI בתוכנית ל- 3.14
יתרונות:
קל לכתוב
קל להבין
קל לשנות

38. קבועים דוגמא לשימוש ב#define שימו לב – אין נקודה פסיק אחרי הגדרת PI
#include <stdio.h>
#define PI
int main(void) {
double radius, area, circumference;
radius = 4;
area = PI * radius * radius;
circumference = 2 * PI * radius;
return 0;

39. enum מגדיר קבוצה של קבועים מטיפוס שלם דוגמא
enum animal {cat, dog, dolphin, monkey, human};
מגדיר טיפוס חדש, ששמו enum animal, והערכים שהוא יכול לקבל הם cat, dog וכו'
הצהרה על משתנים מטיפוס enum animal:
enum animal an1, an2=cat;
בדומה ל int i, j=3;

40. enum לכל קבוע בקבוצה שהוגדרה יש ערך מספרי שלם
ברירת המחדל: ערך האיבר הראשון הוא 0, ערך האיבר השני 1, ערך האיבר השלישי 2 וכן הלאה...
בדוגמא: cat=0, dog=1 וכו'
ניתן להגדיר ערכים אחרים, למשל, אם נכתוב:
enum animal {cat=1, dog, dolphin, monkey=7, human};
אז cat=1, dog=2, dolphin=3, monkey=7, human=8

41. enum דוגמא לשימוש: an1 = dog; if (an1>an2) … if ((int)an2 == 3) …
typdef ו-enum:
typedef enum animal animal;
כעת ניתן לכתוב:
animal a1;

42. תרגיל נניח שכתוב בתחילת התוכנית:
enum day {sun, mon, tue, wed, thu, fri, sat};
typedef enum day day;
day d, next;
נניח של-d יש ערך מסוים. איך נכניס למשתנה next את היום הבא אחרי d?

43. 2 פתרונות אפשריים if (d == sun) next = mon; if (d == mon) next = tue;
if (d == tue)
next = wed;
if (d == wed)
next = thu;
if (d == thu)
next = fri;
if (d == fri)
next = sat;
if (d == sat)
next = sun;
next = (day) ( ((int)d + 1) % 7 )

44. סיכום מזהים טיפוסים אופרטורים קבועים טווח ייצוג הגדרת טיפוס חדש
סדר קדימויות
אופרטור ההמרה
קבועים