1. מבוא למדעי המחשב הרצאה 7: מבנים מבוסס על השקפים שנערכו שי ארצי, גיתית רוקנשטיין, איתן אביאור, וסאהר אסמיר, מיכאל אלעד, רון קימל וניר אילון עדכון אחרון סמסטר חורף 2013

2. מבוא למדעי המחשב. כל הזכויות שמורות ©2 תוכנייה מבנים –הגדרה ודוגמאות פשוטות –דוגמאות יותר מעניינות

3. תוכנה לניהול עסק מבוא למדעי המחשב. כל הזכויות שמורות ©3 #define NUM 1000 #define MAX _ STR 100 int main() { char employee_names[NUM][MAX_STR]; char employee_ids[NUM][MAX_STR]; double empoyee_salaries[NUM]; int employee_birth_years[NUM]; int employee_birth_months[NUM]; int employee_birth_days[NUM]; char employee_address_cities[NUM][MAX_STR]; char employee_address_streets[NUM][MAX_STR]; int employee_address_house_numbers[NUM];... }

4. מבוא למדעי המחשב. כל הזכויות שמורות ©4 מבנים (Structure) מבנה הוא אוסף של משתנים מטיפוסים זהים או שונים המקובצים יחד תחת שם אחד. מבנים תורמים לארגון נוח יותר של המידע כיוון שהם מאפשרים להתייחס למספר משתנים הקשורים זה בזה כאל יחידה אחת. המבנה מהווה טיפוס חדש.

5. מבוא למדעי המחשב. כל הזכויות שמורות ©5 הכרזה על מבנים struct { ;... ; }; #define NAME_SIZE 20 #define ID_SIZE 10 struct address { char city[NAME_SIZE]; char street[NAME_SIZE]; int house_number; }; struct employee { char name[NAME_SIZE]; char id[ID_SIZE]; double salary; struct date birth_date; struct address addr; }; struct date { int day, month, year; };

6. מבוא למדעי המחשב. כל הזכויות שמורות ©6 גישה לשדות במבנה המשתנים day, month, year של struct date נקראים שדות (members). ניתן להתייחס אל שדה במבנה ע"י אופרטור ". " –לדוגמה: אם d הוא משתנה מטיפוס struct date, כלומר הגדרנו, אזי d.day הינו שדה day במבנה d. –האופרטור ". " הינו בעל הקדימות הגבוהה ביותר, כמו זו של ( ), והאסוציאטיביות שלו הינה משמאל לימין:. ההשמה struct_name.member_name = x מעתיקה את תוכן המשתנה x לתוך השדה member_name במבנה struct_name. struct date { int day, month, year; }; struct date d; emp.addr.city

7. מבוא למדעי המחשב. כל הזכויות שמורות ©7 דוגמה לשימוש במשתנים מטיפוס מבנה int main() { struct date d1 = {2, 5, 1975}; struct address home = {"Los-Angeles", “Kipling", 711}; struct employee beckham; strcpy(beckham.name, "David Beckham"); strcpy(beckham.id, "123456789"); beckham.salary = 10000000.0; beckham.birth_date = d1; beckham.addr = home;... return 0; } נשענים על ההגדרות הקודמות struct employee { char name[NAME_SIZE]; char id[ID_SIZE]; double salary; struct date birth_date; struct address addr; };

8. מבוא למדעי המחשב. כל הזכויות שמורות ©8 העברת מבנים לפונקציות by-value כאשר קוראים לפונקציה earlier_date(), מועתקים שני משתני מבנה מטיפוס date_t. עם החזרת הערך מהפונקציה earlier_date() מתבצעת העתקת מבנה. typedef struct date date_t; date_t earlier_date(date_t d1, date_t d2) { if ( d1.year < d2.year ) return d1; if ( d1.year > d2.year ) return d2; if ( d1.month < d2.month ) return d1; if ( d1.month > d2.month ) return d2; return (d1.day < d2.day) ? d1 : d2; }

9. מבוא למדעי המחשב. כל הזכויות שמורות ©9 העברת מבנים לפונקציות by-address כדי לחסוך בהעתקות ניתן להעביר מבנים באמצעות מצביעים. האופרטור " -> " מאפשר לגשת, בצורה נוחה, לשדות של המבנה שכתובתו נתונה במצביע ( p->m שקול ל - (*p).m ). קדימות האופרטור " -> " הינה כשל האופרטור ". ". boolean before(date_t* pd1, date_t* pd2) { if((pd1->year year) || ((pd1->year == pd2->year) && (pd1->month month)) ||...))) return TRUE; return FALSE; }

10. מבוא למדעי המחשב. כל הזכויות שמורות ©10 מערך של משתנים מטיפוס מבנה – דוגמה struct employee beckham, employees[NUM_OF_EMPL]; double sum = 0; int counter = 0;... for(i = 0; i < NUM_OF_EMPL; i++) { if(before(&employees[i].date, &beckham.date)) { sum += (employees + i)->salary; counter ++; } return sum / counter; מה מחשב קטע הקוד ?

11. מבוא למדעי המחשב. כל הזכויות שמורות ©11 גודל של מבנים #define NAME_SIZE 20 #define ID_SIZE 10 struct date { int day, month, year; }; struct address { char city[NAME_SIZE]; char street[NAME_SIZE]; int house_number; }; struct employee { char name[NAME_SIZE]; char id[ID_SIZE]; double salary; struct date birth_date; struct address addr; }; sizeof (struct date) = ? sizeof (struct address) = ? sizeof (struct employee) = ? 3 * sizeof (int) = 12 2 * 20 * sizeof (char) + sizeof (int) = 44 20 * sizeof (char) + 10 *sizeof (char) + sizeof (double) + sizeof (struct date) + sizeof (struct address) = 20+10+8+12+44=94 השוויונות המסומנים הם תלויי מערכת

12. סיכום: מה (לא) ניתן לעשות עם מבנים ארגומנט לפונקצייה ערך חזרה מפונקציה אופרטור השמה פוינטר ל.. מערך של.. גישה לשדה אריתמטיקה לוגיקה השוואה מבוא למדעי המחשב. כל הזכויות שמורות ©12 void print_address(struct address A) { printf("%s\n%s\n%d\n", A.city, A.street, A.house_number); } struct address get_office_address() { struct address A = {"New York", "Wall Street", 20}; return A; } int main() { struct address A1; struct address A2; struct address* pA; struct address addresses[100]; A1 = get_office_address(); A2 = A1; pA = &A1; }

13. השוואה בין מבנים אופרטור השוואה (==) לא מוגדר על מבנים ניתן להשתמש ב memcmp (מוגדר ב stdlib.h) 14 הרצאהמבוא למדעי המחשב. כל הזכויות שמורות ©13 struct A { char *s; }; struct B { int n; }; int main() { struct A A1,A2; struct B B1,B2; char S1[]="hello"; char S2[]="hello"; A1.s=S1; A2.s=S2; printf("%d\n", memcmp(&A1, &A2, sizeof(struct A)))); B1.n = 10; B2.n = 10; printf("%d\n", memcmp(&B1, &B2, sizeof(struct B)));... } int memcmp (void* m1, void* m2, int n); מחזיר 0 אם ורק אם שני שטחי הזיכרון הנתונים זהים מה יודפס?

14. מבוא למדעי המחשב. כל הזכויות שמורות ©14 תוכנייה מבנים –הגדרה ודוגמאות פשוטות –דוגמאות יותר מעניינות: זיכרון גדל דינמית מחסנית

15. זיכרון גדל דינמית במקרים רבים אנו מקצים זיכרון באופן דינמי ומגלים בהמשך שהזיכרון לא מספיק אפשרות מעשית היא, בכל פעם שרוצים עוד זיכרון, להקצות זיכרון בגודל כפול מבוא למדעי המחשב. כל הזכויות שמורות ©15

16. זיכרון גדל דינמית מבוא למדעי המחשב. כל הזכויות שמורות ©16 #define INITIAL_SIZE 6... int *mem; int *tmp; int i; int size = INITIAL_SIZE; mem = malloc(size * sizeof(int));... tmp = malloc(2 * size * sizeof(int)); for (i = 0; i < size; i++) tmp[i] = mem[i]; free(mem); mem = tmp;... 1 2 3 4 5 6

17. זיכרון גדל דינמית: מימוש באמצעות struct נרצה לחזור ולהשתמש בזיכרון גדל דינמית שוב ושוב נכתוב ספריית פונקציות ומבנה נתונים ש"מסתירה" את המימוש הספריה תתמוך בפעולות הבאות: –אתחול זיכרון גדל דינמית –הכפלת הזיכרון –שחרור זיכרון גדל דינמית מבוא למדעי המחשב. כל הזכויות שמורות ©17

18. זיכרון גדל דינמית: מימוש באמצעות struct מבוא למדעי המחשב. כל הזכויות שמורות ©18 struct doubling_memory { int *mem; int capacity; }; typedef struct doubling_memory DM; int DM_init(DM* dm, int capacity) { dm->capacity = capacity; dm->mem = malloc(sizeof(int) * capacity); if (!dm->mem) return 0; return 1; } void DM_free(DM* dm) { free(dm->mem); } int DM_double(DM* dm) { int i; int *tmp = malloc(sizeof(int) * 2 * dm->capacity); if (!tmp) return 0; for (i = 0; i capacity; i++) tmp[i] = dm->mem[i]; free(dm->mem); dm->capacity *= 2; dm->mem = tmp; return 1; }

19. מחסנית (stack) מחסנית הינה תור שעובד לפי כלל LIFO: Last In First Out למחסנית יש שתי פעולות: –push(X): הכנס את הערך X –pop(): החזר את הערך האחרון שהוכנס והוצא אותו מהמחסנית דוגמא: push(5) push(10) pop() push(20) pop() מבוא למדעי המחשב. כל הזכויות שמורות ©19 5 1020 ERROR returned value: 10 returned value: 20 returned value: 5

20. מבוא למדעי המחשב. כל הזכויות שמורות ©20 תוכנייה מבנים –הגדרה ודוגמאות פשוטות –דוגמאות יותר מעניינות: זיכרון גדל דינמית מחסנית

21. מחסנית (stack) אין לדעת מראש לכמה שטח תזדקק המחסנית כדאי להשתמש בזיכרון גדל דינמית מבוא למדעי המחשב. כל הזכויות שמורות ©21 struct stack { DM dm; int size; }; typedef struct stack STACK; הגודל הנוכחי של המחסנית DM dm int *mem int capacity int size STACK

22. מחסנית (stack) מבוא למדעי המחשב. כל הזכויות שמורות ©22 #define INITIAL STACK_SIZE 100... int STACK_init(STACK* s) { s->size = 0; return DM_init(&(s->dm), INITIAL_STACK_SIZE); } int STACK_push(STACK* s, int value) { if(s->size == s->dm.capacity) { if (!DM_double(&(s->dm))) return 0; } s->dm.mem[s->size] = value; s->size++; return 1; } int STACK_pop(STACK* s, int *value) { if(s->size == 0) return 0; s->size--; *value = s->dm.mem[s->size]; return 1; } void STACK_free(STACK* s) { DM_free(&(s->dm)); }

23. מחסנית (stack) - שימוש מבוא למדעי המחשב. כל הזכויות שמורות ©23 int main() { STACK s; int value; char command[10]; if(!STACK_init(&s)) { printf ("Error: No memory for init.\n"); return -1; } HERE: handle push, pop commands STACK_free(&s); return 0; } while(1) { scanf("%10s", command); if (strcmp(command, "push") == 0) { scanf("%d", &value); if (!STACK_push(&s, value)) { printf ("Error: No mem.\n"); return -1; } } else if(strcmp(command, "pop") == 0) { if (!STACK_pop(&s, &value)) { printf ("Error: Stack empty.\n"); return -1; } printf ("%d\n", value); } else break; } RUN