ADT

1. ADT שאלות ממבחנים לי-טל משיח litalma@cs.technion.ac.il

2. מבחן מועד ב' סמסטר אביב 2006 מבני נתונים מופשטים - ADT (40 נקודות) לצורך בקרת כניסה למתקן סודי של המוסד הוחלט להקים מערכת המצלמת את פניהם של הבאים למתקן ומאפשרת את כניסתם רק במידה והפנים זוהו כפנים של אחד העובדים. לכל עובד יש שם ומספר ת"ז (ייחודי). בעת התקנת המערכת יצולם כל אחד מהעובדים ממספר זוויות צילום שונות (יתכן מספר שונה של תמונות לכל עובד) והתמונות ישמרו במערכת. מנשק ומימוש המערכת נעזר ב-ADT בשם Image המייצג תמונה דיגיטאלית ותומך בין היתר בפעולות הבאות: imageCopy – הפונקציה מקבלת תמונה ומחזירה העתק שלה imageDestroy – משחררת את כל משאבי התמונה imagesSimilarity – מקבלת שתי תמונות ומחזירה מספר ממשי בין 0 ל- 1 המשקף את מידת הדמיון בין התמונות. ניתן להתייחס אל Image כאל "קופסא שחורה", אין צורך לתאר את מבנה הנתונים או המימוש שלו .

3. מבחן מועד ב' סמסטר אביב 2006 סעיף א' (20 נקודות) ממשו את קובץ המנשק של המודול SurveillanceSystem או בקיצור SurSys על המנשק לתמוך בפונקציות הבאות בלבד: CreateSurSys 1 יצירת SurSys AddWorker2 הוספת עובד חדש למערכת (הפונקציה מקבלת את שמו ות"ז שלו) AddWorkerImage 3 הוספת תמונה של עובד הקיים במערכת (מחזירה מספר סידורי לתמונה זו. מספר זה הנו ייחודי לעובד זה בלבד, אולם יתכן כי לעובדים אחרים ישנן תמונות עם מספר סידורי זהה) RemoveWorker 4 מחיקת עובד מהמערכת (כולל כל התמונות שלו) RemoveWorkerImage 5 מחיקת תמונה של עובד (על-פי ת"ז של העובד והמספר הסידורי של התמונה) GetWorkerImages 6 החזרת אוסף כל התמונות של עובד מסוים CheckSimilarity 7 זיהוי עובד על סמך תמונה חדשה (הסבר בהמשך...) DestroySurSys 8 הריסת ה- SurSys פונקציה מס' 7 מקבלת כפרמטר תמונה (Image) ומספר – threshold בין 0 ל- 1. על פונקציה זו להשוות את התמונה (ע"י שימוש בפונקציה imagesSimilarity) לכל תמונות העובדים שנשמרו במערכת. במידה ונמצאה תמונה שמידת הדמיון שלה גבוהה מה- threshold הפונקציה תחזיר ערך המשקף זיהוי מוצלח. אחרת, הפונקציה תחזיר ערך המשקף חוסר זיהוי. בנוסף, תחזיר הפונקציה בכל מקרה את ת"ז ושמו של העובד עבורו נמצא הדמיון הגדול ביותר.

4. פתרון סעיף א' CreateSurSys 1 AddWorker2 AddWorkerImage 3 RemoveWorker 4 RemoveWorkerImage 5 GetWorkerImages 6 CheckSimilarity 7 DestroySurSys 8 #ifndef SURSYS_H #define SURSYS_H #include "image.h" typedef enum {FALSE, TRUE} Boolean; typedef enum {SUCCESS =1, FAILURE =-1} Result; typedef struct SurSys_t *SurSys; SurSys CreateSurSys(); // or Result CreateSurSys(SurSys *); Result AddWorker(SurSys,int, const char *); Result AddWorkerImage(SurSys,int, Image, int*); Result RemoveWorker(SurSys,int); Result RemoveWorkerImage(SurSys,int,int); Result GetWorkerImages(SurSys,int,Image**,int *); // id, Array of Image, size Result CheckSimilarity(SurSys,Image,double,Boolean *,int *, char**); Result DestroySurSys(SurSys); #endif

5. מבחן מועד ב' סמסטר אביב 2006 • סעיף ב' (20 נקודות) • (8 נקודות) הציגו את מבנה הנתונים של SurSys כפי שיופיע בקובץ SurSys.c, עם כל • ההגדרות הנלוות הנדרשות. אין צורך לממש אף פונקציה בסעיף זה. • 2.(9 נקודות) ממשו את פונקציה 7 מסעיף א' על פי מבנה הנתונים שבחרתם בסעיף ב' 1. על המימוש • להיות נכון ויעיל. המימוש צריך לתאר את האלגוריתם העיקרי במלואו (בפונקציה אחת או יותר), אי • צורך לממש פונקציות מנשק של ADTs בסיסיים וגם לא פונקציות מנשק אחרות של SurSys. • 3.(3 נקודות) ציינו 3 קודי שגיאה אפשריים שונים (ספציפיים ל- SurSys) המוחזרים ע"י פונקציות • המנשק (אין לציין "בעיה בהקצאת זיכרון", וגם לא קודי שגיאה של ADT(s) בסיסיים).

6. פתרון סעיף ב' 1 #include “SurSys.h” #include "set.h" struct SurSys_t { Set workSet; }; struct Worker_t { int id; char* name; Set workerImagesSet; }; struct Image_t { int id; Image im; }; SurSys

7. מבחן מועד ב' סמסטר אביב 2006 • סעיף ב' (20 נקודות) • (8 נקודות) הציגו את מבנה הנתונים של SurSys כפי שיופיע בקובץ SurSys.c, עם כל • ההגדרות הנלוות הנדרשות. אין צורך לממש אף פונקציה בסעיף זה. • 2.(9 נקודות) ממשו את פונקציה 7 מסעיף א' על פי מבנה הנתונים שבחרתם בסעיף ב' 1. • על המימושלהיות נכון ויעיל. המימוש צריך לתאר את האלגוריתם העיקרי במלואו (בפונקציה • אחת או יותר), אין צורך לממש פונקציות מנשק של ADTs בסיסיים וגם לא פונקציות מנשק • אחרות של SurSys. • 3.(3 נקודות) ציינו 3 קודי שגיאה אפשריים שונים (ספציפיים ל- SurSys) המוחזרים ע"י פונקציות • המנשק (אין לציין "בעיה בהקצאת זיכרון", וגם לא קודי שגיאה של ADT(s) בסיסיים).

8. !! #define SET_FOREACH(e,s) \ for (e=setFirst(s); e!=NULL; e=setNext(s)) פתרון סעיף ב' 2 Result CheckSimilarity(SurSys s,Image im,double trashold, Boolean *ret_val,int *id, char** name){ double sim,max_sim = 0.0; Worker *curr_w; Image *curr_im; char* tmp_name= NULL; if (s==NULL || ret_val==NULL || id == NULL || name ==NULL) return WRONG_PARAM; if (trashold < 0 || trashold >1) return INVALID_THRESHOLD; SET_FOREACH(curr_w,s->workerSet){ SET_FOREACH(curr_im, curr_w->workerImagesSet){ sim = imagesSimilarity(curr_im,im); if (sim > max_sim){ max_sim = sim; *id =curr_w->id; tmp_name = curr_w->name; } } } if (tmp_name!=NULL){ *name = (char*)malloc(strlen(tmp_name)+1); if (*name == NULL) return ALLOC_FAIL; strcpy(*name, tmp_name); } if (max_sim > trashold) *ret_val = TRUE; else *ret_val = FALSE; return SUCCESS; }

9. מבחן מועד ב' סמסטר אביב 2006 • סעיף ב' (20 נקודות) • (8 נקודות) הציגו את מבנה הנתונים של SurSys כפי שיופיע בקובץ SurSys.c, עם כל • ההגדרות הנלוות הנדרשות. אין צורך לממש אף פונקציה בסעיף זה. • 2.(9 נקודות) ממשו את פונקציה 7 מסעיף א' על פי מבנה הנתונים שבחרתם בסעיף ב' 1. על המימוש • להיות נכון ויעיל. המימוש צריך לתאר את האלגוריתם העיקרי במלואו (בפונקציה אחת או יותר), אי • צורך לממש פונקציות מנשק של ADTs בסיסיים וגם לא פונקציות מנשק אחרות של SurSys. • 3.(3 נקודות) ציינו 3 קודי שגיאה אפשריים שונים (ספציפיים ל- SurSys) המוחזרים ע"י פונקציות • המנשק (אין לציין "בעיה בהקצאת זיכרון", וגם לא קודי שגיאה של ADT(s) בסיסיים).

10. פתרון סעיף ב' 3 INVALID_THRESHOLD IMAGE_DOENT_EXIST WORKER_ALREADY_EXIST

11. מבחן מועד ג' סמסטר אביב -2006 אשכול מחשבים (Cluster) הוא קבוצה של מחשבים המחוברים ביניהם ופועלים יחד בצורה מתואמת,כך שבמובנים רבים הם יכולים להיחשב כמחשב אחד. עיקרון הפעולה הוא חלוקת המשימותהחישוביות (Jobs) למספר רב של נקודות קצה (Nodes) המחוברות לאשכול. לצורך פתרון השאלה ניתן להניח כי Node מאופיין על ידי שם יחודי (מחרוזת) והוא בעל התכונותהבאות: מהירות CPU (שבר עשרוני), גודל הזיכרון (מספר שלם) וגודל דיסק (מספר שלם). משימה חישובית מתוארת באמצעות שורת הפעלה (מחרוזת), מספר המחשבים שהמשימה תרוץעליהם (לא יותר ולא פחות, מס' מדוייק) ודרישות מדוייקות לגבי מאפייני המחשבים האלו (מהירות,גודל זיכרון וגודל דיסק). לצורך פתרון השאלה יש להניח כי לא ניתן להריץ בו-זמנית 2 משימות עלאותו מחשב.

12. מבחן מועד ג' סמסטר אביב -2006 סעיף א' (20 נקודות) ממש/י את קובץ המנשק של המודול Cluster. בנוסף ל-type-ים וכד', על המנשק לתמוך בפונקציות הבאות בלבד: CreateCluster– יצירת אשכול מחשבים DestroyCluster– הריסת אשכול מחשבים AddNode– הוספת מחשב מסוים לאשכול מחשבים RemoveNode– הורדת מחשב מסוים מאשכול מחשבים MergeClusters- בהינתן 2 אשכולות יצירת אשכול חדש – איחוד של השניים RemoveSubcluster– בהינתן 2 אשכולות יצירת אשכול חדש – הפרש בין הראשון והשני IsNodeInCluster– בהינתן אשכול ומחשב מסוים, בדיקה האם המחשב שייך לאשכול IsJobRunnable– בהינתן אשכול ומשימה מסוימים, הפונקציה מחזירה אינדיקציה האם ניתן להריץ את המשימה על האשכול ואם כן אז גם מחזירה תת-אשכול (מתוך האשכול שניתן כפרמטר) שניתן להריץ עליו משימה זו. CreateMatchings– בהינתן אשכול ורשימת משימות חישוביות הפונקציה תחזיר את אוסף "ההתאמות" של משימות אל תתי אשכולות מתוך האשכול שניתן כפרמטר. הסברים נוספים בהמשך...

13. פתרון סעיף א' CreateCluster DestroyCluster AddNode RemoveNode MergeClusters RemoveSubcluster IsNodeInCluster IsJobRunnable CreateMatchings #ifndef CLUSTER_H #define CLUSTER_H #include "image.h" typedef enum {FALSE, TRUE} Boolean; typedef enum {SUCCESS =1, FAILURE =-1} Result; typedef struct Cluster_t *Cluster; Cluster CreateCluster(); // or Result CreateCluster(Cluster *); Result DestroyCluster(Cluster c); Result AddNode(Cluster c,char* name,double cpu, int memsize, int disksize); Result RemoveNode(Cluster c,char* name); Result MergeCluster(Cluster c1,Cluster c2, Cluster * c3); Result RemoveSubCluster(Cluster c,Cluster c2, Cluster * c3); Result IsNodeInCluster(Cluster c, char* name, Boolean * res); Result IsJobRunnable(Cluster c,Jobjob, Cluster * res); // res will be null // incase the job is not runnable Result CreateMatching(Cluster c,Job*jobs, int num_jobs, Cluster** mutch);

14. פתרון סעיף א' המשך struct Job_t { char* command; int nodes_num; double cpu_size; int mem_size; int diskspace_size; } ; typedef struct Job_t * Job; #endif

15. מבחן מועד ג' סמסטר אביב -2006 סעיף ב' (20 נקודות) 1. (8 נקודות) הציגו את מבנה הנתונים של Cluster כפי שיופיע ב- Cluster.c. תאר/י איזה ADT(s) תבחרו לביסוס המימוש. ניתן להיעזר בכלADT שנלמד בכיתה עם שינויים סבירים. תאר/י את השינויים. אם השתמשתם במבנים נוספים לצורך פתרון סעיף א', יש לתאר גם אותם. 2. (12 נקודות) יש לממש את פונקציה 9 מתוך הממשק מסעיף א'. לצורך הפתרון יש להניח את ההנחות הבאות: רשימת משימות הניתנת כפרמטר נתונה בתור אוסף סדור של משימות ויותר חשוב להתאים מחשבים למשימות "ראשונות" מאשר למשימות "אחרונות", כלומר אם ניתן להתאים את משימות 1 ו-2 או משימות 1 ו-3 אז האפשרות הראשונה היא עדיפה. אוסף ההתאמות צריך להיות מקסימלי, כלומר אם הצלחתם "להתאים" משימות 1, 2, ו-5, אבל ניתן בנוסף "להתאים" את משימה 6, אז אוסף ההתאמות שלכם הוא אינו מקסימלי. ניתן להשתמש בפונקציות אחרות מסעיף א'

16. פתרון סעיף ב' 1 #include “Set.h” #include “Custer.h” struct Cluster_t { Set nodes; } ; typedef struct Node_t { char* name; double cpu; int mem_size; int disk_size; } Node;

17. מבחן מועד ג' סמסטר אביב -2006 סעיף ב' (20 נקודות) 1. (8 נקודות) הציגו את מבנה הנתונים של Cluster כפי שיופיע ב- Cluster.c. תאר/י איזה ADT(s) תבחרו לביסוס המימוש. ניתן להיעזר בכלADT שנלמד בכיתה עם שינויים סבירים. תאר/י את השינויים. אם השתמשתם במבנים נוספים לצורך פתרון סעיף א', יש לתאר גם אותם. 2. (12 נקודות) יש לממש את פונקציה 9 מתוך הממשק מסעיף א'. לצורך הפתרון יש להניח את ההנחות הבאות: רשימת משימות הניתנת כפרמטר נתונה בתור אוסף סדור של משימות ויותר חשוב להתאים מחשבים למשימות "ראשונות" מאשר למשימות "אחרונות", כלומר אם ניתן להתאים את משימות 1 ו-2 או משימות 1 ו-3 אז האפשרות הראשונה היא עדיפה. אוסף ההתאמות צריך להיות מקסימלי, כלומר אם הצלחתם "להתאים" משימות 1, 2, ו-5, אבל ניתן בנוסף "להתאים" את משימה 6, אז אוסף ההתאמות שלכם הוא אינו מקסימלי. ניתן להשתמש בפונקציות אחרות מסעיף א'

18. פתרון סעיף ב' 2 Result CreateMatching(Cluster c,Job*jobs, int num_jobs, Cluster** mutches){ Cluster sub_cluster = NULL, mutch = NULL; if(c==NULL || jobs == NULL || Cluster == NULL || num_jobs < 0) return BAD_PARAM; *mutches = (Cluster*) malloc(sizeof(Cluster)*num_jobs); if (*mutches == NULL) return ALLOC_FAIL; for (int i=0; i<num_jobs; i++){ IsJobRunnable(c, jobs[i], &mutch); (*mutches)[i] = mutch; if (mutch !=NULL) RemoveSubCluster(c,mutch, &sub_cluster); c = sub_cluster; } return SUCCESS; }

19. מבחן 12.3.99 1. מבני נתונים מופשטים - ADT (35 נקודות) השאלה עוסקת ב ADT בשם SmartFile המשמש לכתיבה וקריאה מקבצים. ה SmartFile כותב וקורא מהקובץ בעזרת "ראש" המהווה מעין מצביע לתו מסוים בקובץ (אין קשר למצביע של C ). ניתן להעביר את ה"ראש" כך שיצביע על כל אחד מתווי הקובץ ,וכל פעולות הקריאה, כתיבה ומחיקה מתבצעות ע"י ה"ראש" הנ"ל. על ה ADT לתמוך בפעולות הבאות: • יצירת SmartFile חדש: ה SmartFileיאותחל לעבוד עם קובץ ששמו ינתן כפרמטר. • הריסת ה SmartFile: שחרור המשאבים שהוקצו עבור ה SmartFile (כולל סגירת הקובץ). • העברת הראש: הראש "יקפוץ" לתו הנמצא במרחק נתון מראש הקובץ או מסופו. • קריאת תו מהקובץ: התו שיקרא יהיה התו עליו מצביע הראש. הראש יעבור לתו הבא. • מחיקת תו מהקובץ: התו שימחק יהיה התו שנמצא לפני (מכיוון תחילת הקובץ) התו עליו מצביע הראש. • קביעת סוג כתיבה:OVERRIDE (התו הנכתב יכתב במקום התו עליו מצביע הראש) או INSERT (התו הנכתב יכתב לפני התו עליו מצביע הראש). • כתיבת תו בודד לקובץ: כתיבת תו בהתאם לסוג הכתיבה.

20. מבחן 12.3.99 הערות: • שימו לב כי הראש אינו נע בכתיבה או מחיקה (מרחקו מסוף הקובץ אינו משתנה). • הוספת תווים לקובץ מבוצעת ע"י קפיצה למרחק 0 מסוף הקובץ וכתיבה במצב INSERT. במיקום זה נמצא "אחרי התו האחרון", ומשמש רק לצורך הוספת תווים לסוף הקובץ. • ביצירתSmartFile אם הקובץ ששמו ניתן קיים, אזי הקובץ יפתח וה"ראש" יצביע לתו הראשון בקובץ. אחרת, יווצר קובץ ריק בשם זה, והראש יעבור למרחק 0 מסוף הקובץ (מוכן להוספת תווים.) מצב הכתיבה בשני המקרים יהיה INSERT.

21. מבחן 12.3.99 להלן דוגמא לקטע קוד העושה שימוש ב SmartFile . בהנחה כי לפני ריצת התוכנית לא קיים קובץ בשם "hello" אזי בסיומה יהיה קובץ בשם זה המכיל את הטקסט "Hey\nyou!" #include "SmartFile.h" קטע הקוד: int main() { SmartFile myfile; SmartFileResult status; char c; status = SmartFileCreate(&myfile, “hello”); if (status != SUCCESS) error (“can't create SmartFile\n”); /* We will not check for errors any more */ status = SmartFilePut (myfile, ‘H’); SmartFilePut (myfile, ‘e’); SmartFilePut(myfile, ‘k’); SmartFilePut (myfile, ‘\n’); status = SmartFileDestroy (myfile); /* the file "hello" contains "Hek\n" */ SmartFileCreate (&myfile, "hello"); status = SmartFileJump (myfile, END, 0); SmartFilePut (myfile, ‘y’); SmartFilePut (myfile, ‘o’); SmartFilePut (myfile, ‘u’); SmartFilePut (myfile, ‘?’); SmartFileDelete (myfile); SmartFilePut (myfile, ‘!’); status = SmartFileJump (myfile, START, 3); status = SmartFileGet (myfile, &c); /* c is set to 'k' */ status = SmartFileSetMode (myfile, OVERRIDE); SmartFilePut (myfile, 'y'); /* 'k' is replaced by 'y' */ SmartFileDestroy (myfile); return 0; } • בכל הסעיפים הנכם יכולים לרשום SF במקום SmartFile לשם קיצור.

22. מבחן 12.3.99 סעיף א ( 12 נקודות). בהסתמך על ההסבר וקטע הקוד הנתון, כתבו את הקובץ SmartFile.h המכיל את המנשק interface)) של ה ADTSmartFile.

23. סעיף א. # ifndef SMART_H #define SMART_H typedef struct SmartFile_t* SmartFile ; typedefenum {INSERT, OVERRIDE} Mode_t; typedef enum {START, END} Base_t; typedef enum { SUCCESS, FAILURE, } SmartFileResult ; SmartFileResult SmartFileCreate (SmartFile* file, const char* filename); SmartFileResult SmartFilePut (SmartFile file, char c); SmartFileResult SmartFileDestroy (SmartFile file); SmartFileResult SmartFileJump (SmartFile file, Base_t base, int pos); SmartFileResult SmartFileDelete (SmartFile file); SmartFileResult SmartFileGet (SmartFile file, char* c); SmartFileResult SmartFileSetMode (SmartFile file, Mode_t mode); #endif

24. מבחן 12.3.99 סעיף ב' (20 נקודות) הוחלט להוסיף ל ADT פונקציה בשם SmartFileUndo קריאה לפונקציה זו מבטלת את השנוי האחרון שבוצע בקובץ (כתיבת תווים לקובץ או מחיקתם ממנו, אין צורך לזכור את השינויים עקב פעולות Undo) מרגע ביצוע הקפיצה האחרונה או מפתיחת הקובץ אם לא בוצעה עדיין קפיצה. דוגמה לשימוש בפונקציה . בסוף התוכנית יתוסף “\nWhy?” לסוף קובץ hello: #include "SmartFile.h" int main() { SmartFileResult status ; SmartFileCreate (&myfile, “hello"); SmartFileJump (myfile, END,0); SmartFilePut (myfile, ‘\n’); SmartFilePut (myfile, ‘W’); SmartFilePut (myfile, ‘o’); SmartFilePut (myfile, ‘h’); status = SmartFileUndo (myfile); /* The ‘h’ is deleted */ SmartFileUndo (myfile); /* the ‘o’ is deleted */ SmartFilePut (myfile,'h'); SmartFilePut (myfile, ‘y’); SmartFilePut (myfile, ‘$’); SmartFileJump(myfile,END,1); SmartFileSetMode(myfile,OVERRIDE); SmartFilePut(myfile,'p'); /* 'p' is replacing '$' */ SmartFileUndo(myfile); /* the 'p' is replaced by '$' */ SmartFileUndo(myfile); /* nothing is done, only one change since jump*/ SmartFilePut(myfile,'?'); /* '?' is replacing '$' */ SmartFileDestroy (myfile); return 0; }

25. מבחן 12.3.99 חלק 1 (2 נקודות) הוסיפו למנשק שכתבתם בסעיף א' את חתימת הפונקציה SmartFileUndo . (אין צורך לכתוב את כל המנשק מחדש, אלא רק את חתימת הפונקציה). חלק 2 (10 נקודות) תארו באיזה מבנה נתונים תשתמשו בכדי לאפשר את פעולת ה Undo. (ניתן להיעזר בכל מבנה נתונים שנלמד בכיתה או בתירגול). אין צורך לכתוב את מבנה הנתונים, רק לתאר כיצד הוא פועל ואיזה נתונים ישמרו בו. הקפידו לתאר אילו שינויים ידרשו להתבצע בפונקציות SmartFilePut, SmartFileJump, SmartFileSetMode ו SmartFileDelete ובהגדרת המבנה SmartFile בכדי לאפשר את פעולת ה SmartFileUndo. זכרו כי אין צורך לשמור את השינויים הקורים עקב פעולת Undo. חלק 3 (8 נקודות) ממשו את הפונקציה: SmartFileUndo בעזרת מבנה הנתונים שבחרתם בחלק הקודם. הנכם רשאים להיעזר בכל פונקציות הנמצאות במנשק של SmartFile אשר כתבתם בסעיף א'. זכרו כי אין צורך לשמור את השינויים הקורים עקב פעולת Undo. סעיף ג (3 נקודות) . תנו דוגמא לשלושה ( 3 ) קודי שגיאה אשר הפונקציות של המנשק SmartFile עלולות להחזיר (ערכים אפשריים של SmartFileResult) , והסבירו את משמעותם.

26. סעיף ב. חלק 1 SmartFileResult SmartFileUndo (SmartFile file); חלק 2 נעזר במבנה הנתונים מחסנית אשר הוצג בכיתה ואשר יתווסף ל SmartFile. במחסנית ישמר מבנה מטיפוס Oper שיוגדר כ: typedef enum {R,P,D} op; typedef struct Oper_t { op code; char old_char ; } Oper; • op הנו קוד הפעולה שבוצעה: • D - תו נמחק. ואזי old_char מכיל את התו שנמחק. • P - תו נכתב. old_char אינו מוגדר. • R - תו הוחלף, ואזי old_char מכיל את התו שהוחלף. • פעולת ה SetMode לא תשתנה. • בפעולת ה Delete נכניס למחסנית מבנה חדש שיכיל כ op את D ואת התו הנמחק. • בפעולת ה Put נכניס למחסנית מבנה שיכיל רק P כ op אם אנו במצב insert , או את R כ op אם אנו במצב override . במצב זה גם נקבע את התו שעליו הצביע הראש כ old_char. • בפעולת Jump, ו read (במהלך המבחן נאמר שיש להתייחס ל read כ jump) נרוקן את המחסנית. • כמו כן, נשמור דגל אשר יאמר אם אנו מבצעים פעולת Undo (ואז כל הפעולות מתנהגות כמו בסעיף א' ואין צורך לשמור את השינויים במחסנית) או שאנו בפעולה רגילה.

27. מבחן 12.3.99 חלק 1 (2 נקודות) הוסיפו למנשק שכתבתם בסעיף א' את חתימת הפונקציה SmartFileUndo . (אין צורך לכתוב את כל המנשק מחדש, אלא רק את חתימת הפונקציה). חלק 2 (10 נקודות) תארו באיזה מבנה נתונים תשתמשו בכדי לאפשר את פעולת ה Undo. (ניתן להיעזר בכל מבנה נתונים שנלמד בכיתה או בתירגול). אין צורך לכתוב את מבנה הנתונים, רק לתאר כיצד הוא פועל ואיזה נתונים ישמרו בו. הקפידו לתאר אילו שינויים ידרשו להתבצע בפונקציות SmartFilePut, SmartFileJump, SmartFileSetMode ו SmartFileDelete ובהגדרת המבנה SmartFile בכדי לאפשר את פעולת ה SmartFileUndo. זכרו כי אין צורך לשמור את השינויים הקורים עקב פעולת Undo. חלק 3 (8 נקודות) ממשו את הפונקציה: SmartFileUndo בעזרת מבנה הנתונים שבחרתם בחלק הקודם. הנכם רשאים להיעזר בכל פונקציות הנמצאות במנשק של SmartFile אשר כתבתם בסעיף א'. זכרו כי אין צורך לשמור את השינויים הקורים עקב פעולת Undo. סעיף ג (3 נקודות) . תנו דוגמא לשלושה ( 3 ) קודי שגיאה אשר הפונקציות של המנשק SmartFile עלולות להחזיר (ערכים אפשריים של SmartFileResult) , והסבירו את משמעותם.

28. סעיף ב. ניתן לבצע הנחה סבירה כי ניתן לגשת לשדה זה והוא קיים, או שנדרוש כי במסגרת השינויים יתווספו פונקציות גישה לשדה זה. חלק 3 SmartFileResult SmartFileUndo (SmartFile file) { SmartFileResult res; Oper rec; Mode_t mode = file->mode ; res = pop (file->s,&rec); if (res == FAIL) return (NoMoreOperation); file->flag = UNDO ; switch (rec.oper) { case P: SmartFileDelete(file); break; case R: SmartFileSetMode(file, OVERRIDE); SmartFilePut(file,rec.old_char); SmartFileSetMode(file, mode); break; case D: SmartFileSetMode(file, INSERT); SmartFilePut(file,rec.old_char); SmartFileSetMode(file, mode); break; } file->flag=NOT_UNDO; return(Success); }

29. מבחן 12.3.99 חלק 1 (2 נקודות) הוסיפו למנשק שכתבתם בסעיף א' את חתימת הפונקציה SmartFileUndo . (אין צורך לכתוב את כל המנשק מחדש, אלא רק את חתימת הפונקציה). חלק 2 (10 נקודות) תארו באיזה מבנה נתונים תשתמשו בכדי לאפשר את פעולת ה Undo. (ניתן להיעזר בכל מבנה נתונים שנלמד בכיתה או בתירגול). אין צורך לכתוב את מבנה הנתונים, רק לתאר כיצד הוא פועל ואיזה נתונים ישמרו בו. הקפידו לתאר אילו שינויים ידרשו להתבצע בפונקציות SmartFilePut, SmartFileJump, SmartFileSetMode ו SmartFileDelete ובהגדרת המבנה SmartFile בכדי לאפשר את פעולת ה SmartFileUndo. זכרו כי אין צורך לשמור את השינויים הקורים עקב פעולת Undo. חלק 3 (8 נקודות) ממשו את הפונקציה: SmartFileUndo בעזרת מבנה הנתונים שבחרתם בחלק הקודם. הנכם רשאים להיעזר בכל פונקציות הנמצאות במנשק של SmartFile אשר כתבתם בסעיף א'. זכרו כי אין צורך לשמור את השינויים הקורים עקב פעולת Undo. סעיף ג (3 נקודות) . תנו דוגמא לשלושה ( 3 ) קודי שגיאה אשר הפונקציות של המנשק SmartFile עלולות להחזיר (ערכים אפשריים של SmartFileResult) , והסבירו את משמעותם.

30. סעיף ג. BadJump– קפיצה מעבר לתחילת / סוף הקובץ. NoMoreOperation- אין יותר פעולות לבטל. CannotOpenFile– אין אפשרות לפתוח את הקובץ שניתן כפרמטר. הערה: בתשובה זו אין התייחסות לשנויי mode, ונשמר ה mode שהיה כאשר נקראה פעולת ה undo. ניתן גם להתייחס לשנוי mode כאל שנוי, ואזי אין צורך בגישה לשדה ה mode.