1. שאלות ממבחנים לי-טל משיח 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 AddWorker 2 הוספת עובד חדש למערכת (הפונקציה מקבלת את שמו ות"ז שלו) AddWorkerImage 3 הוספת תמונה של עובד הקיים במערכת (מחזירה מספר סידורי לתמונה זו. מספר זה הנו ייחודי לעובד זה בלבד, אולם יתכן כי לעובדים אחרים ישנן תמונות עם מספר סידורי זהה) RemoveWorker 4 מחיקת עובד מהמערכת (כולל כל התמונות שלו) RemoveWorkerImage 5 מחיקת תמונה של עובד (על-פי ת"ז של העובד והמספר הסידורי של התמונה) GetWorkerImages 6 החזרת אוסף כל התמונות של עובד מסוים CheckSimilarity 7 זיהוי עובד על סמך תמונה חדשה (הסבר בהמשך...) DestroySurSys 8 הריסת ה- SurSys פונקציה מס' 7 מקבלת כפרמטר תמונה (Image) ומספר – threshold בין 0 ל- 1. על פונקציה זו להשוות את התמונה (ע"י שימוש בפונקציה imagesSimilarity) לכל תמונות העובדים שנשמרו במערכת. במידה ונמצאה תמונה שמידת הדמיון שלה גבוהה מה- threshold הפונקציה תחזיר ערך המשקף זיהוי מוצלח. אחרת, הפונקציה תחזיר ערך המשקף חוסר זיהוי. בנוסף, תחזיר הפונקציה בכל מקרה את ת"ז ושמו של העובד עבורו נמצא הדמיון הגדול ביותר.

4. פתרון סעיף א' #ifndef SURSYS_H #define SURSYS_H #include "image.h" typedef enum {FALSE, TRUE} Boolean; typedef enum {SUCCESS, FAIL, OUT_OF_MEMORY, BAD_PARAM, …. } SurSysResult; typedef struct SurSys_t *SurSys; SurSys CreateSurSys(); // or SurSysResult CreateSurSys(SurSys *system); SurSysResult AddWorker(SurSys system,int id, const char * name); SurSysResult AddWorkerImage(SurSys system,int id, Image image, int*imageId); SurSysResult RemoveWorker(SurSys system, int id); SurSysResult RemoveWorkerImage(SurSys system,int id,int imageId); SurSysResult GetWorkerImages(SurSys system,int id,Image** images, int * imagesSize); SurSysResult CheckSimilarity(SurSys system, Image image, double threshold, Boolean * match, int * bestID, char** bestName); void DestroySurSys(SurSys system); #endif

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

6. פתרון סעיף ב' 1 #include “SurSys.h” #include "set.h" /* the struct of the ADT */ struct SurSys_t { Set workSet; }; /* internal struct (not ADT) */ typedef struct Worker_t { int id; char* name; Set workerImagesSet; } Worker; /* internal struct (not ADT) */ typedef struct WorkerImage_t { int id; Image image; } WorkerImage; SurSys

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

8. פתרון סעיף ב' 2 SurSysResult CheckSimilarity(SurSys system, Image image, double threshold, Boolean * match, int * id, char** name){ double similarity, maxSimilarity = 0.0; Worker *currentWorker; WorkerImage *currrentImage; char* tmpName= NULL; if (system==NULL || match==NULL || id == NULL || name ==NULL) return BAD_PARAM; if (threshold 1) return INVALID_THRESHOLD; SET_FOREACH(currentWorker,system->workerSet){ SET_FOREACH(currentImage, currentWorker->workerImagesSet){ similarity = imagesSimilarity(currentImage->image,image); if (similarity > maxSimilarity){ maxSimilarity = similarity; *id =currentWorker->id; tmp_name = currentWorker->name; } if (tmpName!=NULL){ *name = (char*)malloc(strlen(tmpName)+1); if (*name == NULL) return OUT_OF_MEMORY; strcpy(*name, tmpName); } if (maxSimilarity > threshold) *match = TRUE; else *match = FALSE; return SUCCESS; } #define SET_FOREACH(e,s) \ for (e=setFirst(s); e!=NULL; e=setNext(s)) !!

9. מבחן מועד ב' סמסטר אביב 2006 סעיף ב' (20 נקודות) 1.(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. פתרון סעיף א' #ifndef CLUSTER_H #define CLUSTER_H typedef enum {FALSE, TRUE} Boolean; typedef enum {SUCCESS, FAIL, OUT_OF_MEMORY, BAD_PARAM, …. } ClusterResult; typedef struct Cluster_t *Cluster; /* this struct is not ADT. It is used only for passing parameters to the functions of Cluster ADT */ struct Job_t { char* command; int nodes_num; double cpu_size; int mem_size; int diskspace_size; } ; typedef struct Job_t * Job;

14. פתרון סעיף א' המשך Cluster CreateCluster(); // or ClusterResult CreateCluster(Cluster *); void DestroyCluster(Cluster c); ClusterResult AddNode(Cluster c,char* name,double cpu, int memsize, int disksize); ClusterResult RemoveNode(Cluster c,char* name); ClusterResult MergeCluster(Cluster c1, Cluster c2, Cluster * c3); ClusterResult RemoveSubCluster(Cluster c1, Cluster c2, Cluster * c3); ClusterResult IsNodeInCluster(Cluster c, char* name, Boolean * res); ClusterResult IsJobRunnable(Cluster c, Job job, Cluster * res); // res will be null incase the job is not runnable ClusterResult CreateMatching(Cluster c, Job* jobs, int num_jobs, Cluster** matches); #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 “Cluster.h” /* the struct of the ADT */ struct Cluster_t { Set nodes; } ; /* internal struct (not ADT) */ typedef struct Node_t { char* name; double cpu; int mem_size; int disk_size; } Node; קובץ Cluster.c:

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

18. פתרון סעיף ב' 2 ClusterResult CreateMatching(Cluster c, Job* jobs, int num_jobs, Cluster** matches){ Boolean free_flag = FALSE; Cluster sub_cluster = NULL, match = NULL; ClusterResult result; if(c == NULL || jobs == NULL || num_jobs < 0 || matches == NULL) return BAD_PARAM; *matches = (Cluster*) malloc(sizeof(Cluster)*num_jobs); if (*matches == NULL) return OUT_OF_MEMORY; for (int i=0; i<num_jobs; i++){ result = IsJobRunnable(c, jobs[i], &match); assert(result == SUCCESS); (*matches)[i] = match; if (match !=NULL){ result = RemoveSubCluster(c, match, &sub_cluster); assert(result == SUCCESS); if (free_flag) DestroyCluster(c); c = sub_cluster; free_flag = TRUE; } } return SUCCESS; }

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

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

21. דוגמא: בהנחה כי לפני ריצת התוכנית לא קיים קובץ בשם "hello" אזי בסיומה יהיה קובץ בשם זה המכיל את הטקסט "Hey\nyou!" #include "SmartFile.h“ int main() { SF myfile; SFResult status; char c; status = SFCreate(&myfile, “hello”); if (status != SUCCESS) error (“can't create SmartFile\n”); status = SFPut (myfile, ‘H’); SFPut (myfile, ‘e’); SFPut(myfile, ‘k’); SFPut (myfile, ‘\n’); SFDestroy (myfile); SFCreate (&myfile, "hello"); status = SFJump (myfile, END, 0); SFPut (myfile, ‘y’); SFPut (myfile, ‘o’); SFPut (myfile, ‘u’);SFPut (myfile, ‘?’); SFDelete (myfile); SFPut (myfile, ‘!’); status = SFJump (myfile, START, 3); status = SFGet (myfile, &c); /* c is set to 'k' */ status = SFSetMode (myfile, OVERRIDE); SFPut (myfile, 'y'); SFDestroy (myfile); return 0; } Hek\n Hek\nyou? Hek\nyou! Hey\nyou!

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

23. סעיף א. # ifndef SMART_H #define SMART_H typedef struct SmartFile_t* SF ; typedef enum {INSERT, OVERRIDE} Mode; typedef enum {START, END} Base; typedef enum {SUCCESS, FAILURE, BAD_PARAM, … } SFResult ; SFResult SFCreate (SF* file, const char* filename); SFResult SFPut (SF file, char c); void SFDestroy (SF file); SFResult SFJump (SF file, Base base, int pos); SFResult SFDelete (SF file); SFResult SFGet (SF file, char* c); SFResult SFSetMode (SF file, Mode mode); #endif

24. סעיף ב' (20 נקודות) הוחלט להוסיף ל ADT פונקציה בשם SFUndo קריאה לפונקציה זו מבטלת את השנוי האחרון שבוצע בקובץ (כתיבת תווים לקובץ או מחיקתם ממנו, אין צורך לזכור את השינויים עקב פעולות Undo) מרגע ביצוע הקפיצה האחרונה או מפתיחת הקובץ אם לא בוצעה עדיין קפיצה. לדוגמא: #include "SmartFile.h" int main() { SFResult status ; SFCreate (&myfile, “hello"); SFJump (myfile, END,0); SFPut (myfile, ‘\n’);// Hey\nYou!\n SFPut (myfile, ‘W’); // Hey\nYou!\nW SFPut (myfile, ‘o’); // Hey\nYou!\nWo SFPut (myfile, ‘h’);// Hey\nYou!\nWoh status = SFUndo (myfile); // Hey\nYou!\nWo SFUndo (myfile); // Hey\nYou!\nW SFPut (myfile,'h'); // Hey\nYou!\nWh SFPut (myfile, ‘y’); // Hey\nYou!\nWhy SFPut (myfile, ‘$’); // Hey\nYou!\nWhy$ SFJump(myfile,END,1); SFSetMode(myfile,OVERRIDE); SFPut(myfile,'p'); // Hey\nYou!\nWhyp SFUndo(myfile); // Hey\nYou!\nWhy$ SFUndo(myfile); // nothing is done, only one change since jump SFPut(myfile,'?'); // Hey\nYou!\nWhy? SFDestroy (myfile); return 0; }

25. חלק 1 (2 נקודות) הוסיפו למנשק שכתבתם בסעיף א' את חתימת הפונקציה SFUndo. (אין צורך לכתוב את כל המנשק מחדש, אלא רק את חתימת הפונקציה). חלק 2 (10 נקודות) תארו באיזה מבנה נתונים תשתמשו בכדי לאפשר את פעולת ה Undo. (ניתן להיעזר בכל מבנה נתונים שנלמד בכיתה או בתירגול). אין צורך לכתוב את מבנה הנתונים, רק לתאר כיצד הוא פועל ואיזה נתונים ישמרו בו. הקפידו לתאר אילו שינויים ידרשו להתבצע בפונקציות SFPut, SFJump, SFSetMode ו SFDelete ובהגדרת המבנה SF בכדי לאפשר את פעולת ה SFUndo. זכרו כי אין צורך לשמור את השינויים הקורים עקב פעולת Undo. חלק 3 (8 נקודות) ממשו את הפונקציה: SFUndo בעזרת מבנה הנתונים שבחרתם בחלק הקודם. הנכם רשאים להיעזר בכל פונקציות הנמצאות במנשק של SF אשר כתבתם בסעיף א'. זכרו כי אין צורך לשמור את השינויים הקורים עקב פעולת Undo. סעיף ג (3 נקודות). תנו דוגמא לשלושה ( 3 ) קודי שגיאה אשר הפונקציות של המנשק SF עלולות להחזיר (ערכים אפשריים של SFResult), והסבירו את משמעותם. SmartFile

26. סעיף ב. חלק 1 SFResult SFUndo (SF file); חלק 2 נעזר במבנה הנתונים מחסנית אשר הוצג בכיתה ואשר יתווסף ל SF. במחסנית ישמר מבנה מטיפוס Oper שיוגדר כ: typedef enum {R,P,D} op; /* internal struct (not ADT) */ 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. חלק 1 (2 נקודות) הוסיפו למנשק שכתבתם בסעיף א' את חתימת הפונקציה SFUndo. (אין צורך לכתוב את כל המנשק מחדש, אלא רק את חתימת הפונקציה). חלק 2 (10 נקודות) תארו באיזה מבנה נתונים תשתמשו בכדי לאפשר את פעולת ה Undo. (ניתן להיעזר בכל מבנה נתונים שנלמד בכיתה או בתירגול). אין צורך לכתוב את מבנה הנתונים, רק לתאר כיצד הוא פועל ואיזה נתונים ישמרו בו. הקפידו לתאר אילו שינויים ידרשו להתבצע בפונקציות SFPut, SFJump, SFSetMode ו SFDelete ובהגדרת המבנה SF בכדי לאפשר את פעולת ה SFUndo. זכרו כי אין צורך לשמור את השינויים הקורים עקב פעולת Undo. חלק 3 (8 נקודות) ממשו את הפונקציה: SFUndo בעזרת מבנה הנתונים שבחרתם בחלק הקודם. הנכם רשאים להיעזר בכל פונקציות הנמצאות במנשק של SF אשר כתבתם בסעיף א'. זכרו כי אין צורך לשמור את השינויים הקורים עקב פעולת Undo. סעיף ג (3 נקודות). תנו דוגמא לשלושה ( 3 ) קודי שגיאה אשר הפונקציות של המנשק SF עלולות להחזיר (ערכים אפשריים של SFResult), והסבירו את משמעותם. SmartFile

28. חלק 3 SFResult SFUndo (SF file) { SFResult result; Oper rec; assert(file != NULL); Mode_t mode = file->mode ; result = pop (file->s,&rec); if (result == FAIL) return NoMoreOperation; file->flag = UNDO ; switch (rec.oper) { case P: // Put result = SFDelete(file); assert(result == SUCCESS); break; case R: // Replace result = SFSetMode(file, OVERRIDE); assert(result == SUCCESS); result = SFPut(file,rec.old_char); assert(result == SUCCESS); result = SFSetMode(file, mode); assert(result == SUCCESS); break; סעיף ב. ניתן לבצע הנחה סבירה כי ניתן לגשת לשדה זה והוא קיים, או שנדרוש כי במסגרת השינויים יתווספו פונקציות גישה לשדה זה.

29. case D: // Delete result = SFSetMode(file, INSERT); assert(result == SUCCESS); result = SFPut(file,rec.old_char); assert(result == SUCCESS); result = SFSetMode(file, mode); assert(result == SUCCESS); break; } file->flag=NOT_UNDO; return SUCCESS; } סעיף ב.

30. חלק 1 (2 נקודות) הוסיפו למנשק שכתבתם בסעיף א' את חתימת הפונקציה SFUndo. (אין צורך לכתוב את כל המנשק מחדש, אלא רק את חתימת הפונקציה). חלק 2 (10 נקודות) תארו באיזה מבנה נתונים תשתמשו בכדי לאפשר את פעולת ה Undo. (ניתן להיעזר בכל מבנה נתונים שנלמד בכיתה או בתירגול). אין צורך לכתוב את מבנה הנתונים, רק לתאר כיצד הוא פועל ואיזה נתונים ישמרו בו. הקפידו לתאר אילו שינויים ידרשו להתבצע בפונקציות SFPut, SFJump, SFSetMode ו SFDelete ובהגדרת המבנה SF בכדי לאפשר את פעולת ה SFUndo. זכרו כי אין צורך לשמור את השינויים הקורים עקב פעולת Undo. חלק 3 (8 נקודות) ממשו את הפונקציה: SFUndo בעזרת מבנה הנתונים שבחרתם בחלק הקודם. הנכם רשאים להיעזר בכל פונקציות הנמצאות במנשק של SF אשר כתבתם בסעיף א'. זכרו כי אין צורך לשמור את השינויים הקורים עקב פעולת Undo. סעיף ג (3 נקודות). תנו דוגמא לשלושה ( 3 ) קודי שגיאה אשר הפונקציות של המנשק SF עלולות להחזיר (ערכים אפשריים של SFResult), והסבירו את משמעותם. SmartFile

31. סעיף ג. BadJump – קפיצה מעבר לתחילת / סוף הקובץ. NoMoreOperation - אין יותר פעולות לבטל. CannotOpenFile – אין אפשרות לפתוח את הקובץ שניתן כפרמטר.