הטכניון - מכון טכנולוגי לישראל

הפקולטה למדעי המחשב הטכניון - מכון טכנולוגי לישראל מבוא לתכנות מערכות 221422 חומר עזר למבחן תוכן שפת 2... C פונקציות להקצאת זיכרון דינאמי...2 עבודה עם קבצים...2 עבודה עם מחרוזות... 2 פקודות לשלב העיבור המקדים 3...(Preprocessor) מצביעים לפונקציות...3 מבני הנתונים שנלמדו בקורס...4 מנשק עבור ADT של...4 Set מנשק עבור ADT של...5 List מנשק עבור ADT של...6 Stack קבצי 6... Makefile שימוש ב- Bash...7 רשימת פקודות...7 עבודה עם סקריפטים:...01 חישובים אריתמטיים...01 מבני בקרה...01 סוגי תנאים... 00 פונקציות... 02 קריאת קלט... 02 02... PATH שפת ++C...03 קבועים...03 מרחבי שמות - namespace 03... העמסת פונקציות...04 קלט/פלט )ועבודה עם קבצים(... 04 מחלקות...05 העמסת אופרטורים...06 המרות...06 תבניות 07...(templates) חריגות 07...(exceptions) המרות ומידע על טיפוסים בזמן ריצה...01 אלגוריתמים גנריים... 01 01...Function Objects 01... shared_ptr מחלקה עבור מספר רציונלי - Rational...21 מחלקה עבור קבוצה גנרית - Set...20 דוגמה למחלקה אבסטרקטית (Shape) ולירושה...25 מבני נתונים שימושיים של...25 STL המחלקה 25... std::vector המחלקה 26... std::list 1

שפת C פונקציות להקצאת זיכרון דינאמי.NULL בתים, במקרה של כשלון מוחזר bytes משמשת להקצאת גוש זיכרון חדש בגודל malloc הפונקציה void* malloc(size_t bytes); // NULL is returned in case of failure. הפונקציה free משמשת לשחרור גוש זיכרון שהוקצה ע"י malloc או פונקצית הקצאת זיכרון אחרת. ניתן לשלוח NULL ל- free. שליחה של כתובת זיכרון שאינה NULL ואינה תחילת הקצאה הינה שגיאה. void free(void* ptr); דוגמה לשימוש: int* my_array = malloc(sizeof(*my_array) * n); //... using my_array... free(my_array); עבודה עם קבצים.NULL משמשת לפתיחת קובץ. במקרה של כשלון מוחזר fopen הפונקציה מצב הפתיחה של קובץ יכול להיות "w" עבור כתיבה, "r" עבור קריאה או "a" עבור שרשור לסוף קובץ קיים. FILE* fopen (const char* filename, const char* mode); הפונקציה fclose משמשת לסגירת קובץ קיים. אסור לשלוח לה.NULL int fclose (FILE* stream); הפונקציות fprintf ו- fscanf עובדות בדומה ל- printf ו- scanf אך מקבלות בנוסף ערוץ קלט/פלט כארגומנט: תגי בקרה שימושיים: char string (char*) pointer int fprintf (FILE* stream, const char* format,...); int fscanf (FILE* stream, const char* format,...); %d %f %lf int float double %c %s %p הפונקציות fgets ו- fputs משמשות לכתיבת או קריאת מחרוזת. במקרה של הצלחה fgets מחזירה את,buffer ו- NULL אחרת. fgets מחזירה את מספר התווים שניתן לה או עד סוף השורה,מה שבא קודם. char* fgets (char* buffer, int size, FILE* stream); int fputs (const char* str, FILE* stream); הפונקציה feof מחזירה ערך שונה מ- 1 אם התו EOF )סוף קובץ( נקרא מהערוץ שהתקבל. אם עוד לא נקרא סוף הקובץ, מוחזר 1. int feof (FILE* stream); עבודה עם מחרוזות הפונקציה strcpy מעתיקה מחרוזת. על destination להכיל מספיק מקום בזיכרון עבור הכתיבה. הפונקציה מחזירה את.destination char* strcpy (char* destination, const char* source); הפונקציה strcat משמשת לשרשור מחרוזות, על destination להכיל מספיק זיכרון פנוי בסופה כדי להכיל את שרשור המחרוזות. הפונקציה מחזירה את.destination char* strcat (char* destination, const char* source); הפונקציה strcmp משווה בין שתי מחרוזות ומחזירה 1 אם הן שוות, מספר גדול מ- 1 אם str1 גדולה יותר לפי סדר לקסיקוגרפי, ומספר קטן מ- 1 עם str2 גדולה יותר. לדוגמה: הקריאה strcmp("aba","cdc") תחזיר מספר קטן מ- 1. הפונקציה strlen מחזירה את מספר התווים המחרוזת, לא כולל התו '0\'. int strcmp (const char * str1, const char* str2); size_t strlen (const char* str); 2

פקודות לשלב העיבור המקדים (Preprocessor) הפקודה define מגדירה מאקרו חדש. לאחר הגדרתו ה- preprocessor יחליף כל הופעה של.<value> אם המאקרו מוגדרם עם משתנים, המשתנים יוחלפו בערכם בכל פעם. <macro> ב- #define <macro> <value> דוגמה להגדרת מאקרו עבור חישוב המקסימום: #define MAX(a,b) ((a) > (b)? (a) : (b)) הפקודה include גורמת ל- preprocessor להכניס את תוכן הקובץ המבוקש ליחידת הקומפילציה. אם שם הקובץ מופיע בתוך < > אז הוא נלקח מספריה הידועה לקומפיילר. אם שם הקובץ מופיע בתוך " " אז הוא נלקח מהספריה הנוכחית. #include <filename> ניתן להגדיר תנאים עבור ה- preprocessor. אם התנאי אינו מתקיים, הקוד שהוא תוחם לא יוכנס ליחידת הקומפילציה: #endif מתקיים רק אם מוגדר מאקרו בעל שם מתאים. הוא נמשך עד לפקודת ifdef התנאי o #ifdef <macro> //... #endif o התנאי ifndef מתקיים רק אם לא מוגדר מאקרו בעל שם מתאים: #ifndef <macro> //... #endif o בכל אחד מהתנאים, ניתן גם להשתמש בפקודת else כדי לציין קוד שיש לצרף במקרה שהתנאי נכשל. #include <stdio.h> #include "set.h" דוגמאות לשימוש ב- preprocessor : #ifdef NDEBUG #define CHUNK_SIZE 1024 #else #define CHUNK_SIZE 256 #endif מצביעים לפונקציות.bool ומחזירה ערך מטיפוס int להלן דוגמה להגדרת מצביע לפונקציה המקבלת שני ארגומנטים מטיפוס בדוגמה זו שם המצביע הינו ptr וערכו מאותחל ל- NULL : bool (*ptr)(int, int) = NULL; מצביע לפונקציה יכול להצביע רק לפונקציות בעלות אותה חתימה כמו שהוגדרה עבור המצביע. ניתן להציב למצביע כתובת של פונקציה על ידי שימוש בשמה ללא אופרטור ההפעלה )(: bool isbigger(int a, int b); bool (*ptr)(int, int) = isbigger; ניתן להפעיל מצביע לפונקציה על ידי שימוש באופרטור ההפעלה )( עם ארגומנטים מתאימים: bool res = ptr(5,4); ניתן להשתמש ב- typedef על מנת להגדיר שם נוח יותר לטיפוס של המצביע לפונקציה, למשל: typedef bool (*BiggerFunction)(int, int); בשם החדש ניתן להשתמש כשם טיפוס רגיל לכל דבר: BiggerFunction function = isbigger; דוגמה לחתימה של פונקציה גנרית למיון מערך של עצמים לא ידועים :)void*( void sort(void** array, int size, int (*compare)(void*, void*)); 3

מבני הנתונים שנלמדו בקורס קבוצה - :Set שומרת אוסף של איברים ללא כפילויות וללא חשיבות לסדר ביניהם. רשימה - :List שומרת אוסף איברים וייתכן שאיבר יופיע יותר מפעם אחת. לכל איבר מוגדר האינדקס שלו ברשימה. מחסנית - :Stack מאפשרת פעולת push להוספת איבר, פעולת pop להוצאת האיבר האחרון שהתווסף ופעולת top לקבלת האיבר האחרון שהתווסף. גרף - :Graph מורכב משתי קבוצות. קבוצת צמתים וקבוצת קשתות. כל קשת מוגדרת להיות זוג של צמתים הנמצאים בגרף. מילון - :Map מכיל זוגות של מפתח (Key) וערך.(Value) המפתחות הינם ייחודים וללא חשיבות לסדר )כמו בקבוצה(. לכל מפתח מוצמד ערך. ייתכן וערך יופיע מספר פעמים עבור מספר מפתחות. #ifndef SET_H_ #define SET_H_ #include <stdbool.h> מנשק עבור ADT של Set typedef struct set* Set; typedef enum { SET_SUCCESS, SET_OUT_OF_MEMORY, SET_FAIL SetResult; typedef void* SetElement; typedef SetElement (*SetCopyFunction)(SetElement); typedef void (*SetFreeFunction)(SetElement); /** * Function for comparing elements in the set to determine if they are equal. * The call x=setcomparefunction(a,b) should return x>0 for a>b, x<0 for a<b, * or x==0 for a==b. */ typedef int (*SetCompareFunction)(SetElement a, SetElement b); typedef void* SetFilterKey; /** * Function for checking condition on an element. Should return true if * condition holds, false otherwise. */ typedef bool (*SetConditionFuncion)(SetElement a, SetFilterKey key); /** * Function that converts an element to a string representation and writes it to * buffer up to size characters. The function returns the full size of the * string representation (may be larger than size). */ typedef int (*SetToStringFunction)(SetElement, char buffer[], int size); Set setcreate(setcopyfunction copy, SetFreeFunction destroy, SetCompareFunction compare); Set setcopy(set set); void setdestroy(set set); SetResult setadd(set set, SetElement element); SetResult setremove(set set, SetElement element); bool setcontains(set set, SetElement element); bool setissubsetof(set set1, Set set2); int setgetsize(set set); Set setunion(set set1, Set set2); Set setintersection(set set1, Set set2); Set setfilter(set set, SetConditionFuncion condition, SetFilterKey key); bool setisempty(set set); bool setequals(set set1, Set set2); 4

int settostring(set set, SetToStringFunction tostring, char buffer[], int size); SetElement setgetfirst(set set); // returns NULL if the set is empty SetElement setgetnext(set set); // returns NULL if there are no more elements SetElement setgetcurrent(set set); /** Macro to enable simple iteration */ #define SET_FOREACH(Type, element, set) for(type element = setgetfirst(set); \ element!= NULL; \ element = setgetnext(set)) #endif #ifndef LIST_H_ #define LIST_H_ #include <stdbool.h> מנשק עבור ADT של List typedef struct list* List; typedef enum { LIST_SUCCESS, LIST_NULL_ARGUMENT, LIST_OUT_OF_MEMORY, LIST_INVALID_CURRENT, ListResult; typedef void* ListElement; typedef ListElement (*CopyListElement)(ListElement); typedef void (*FreeListElement)(ListElement); /** For an explanation see SetCompareFunction in the previous page */ typedef int (*CompareListElements)(ListElement, ListElement); typedef void* ListFilterKey; /** * Function for checking condition on an element. Should return true if * condition holds, false otherwise. */ typedef bool (*FilterListElement)(ListElement, ListFilterKey); List listcreate(copylistelement copyelement, FreeListElement freeelement); List listcopy(list list); int listgetsize(list list); ListElement listgetfirst(list list); // returns NULL if list is empty ListElement listgetnext(list list); // returns NULL if no more elements ListElement listgetcurrent(list list); ListResult listinsertfirst(list list, ListElement element); ListResult listinsertlast(list list, ListElement element); ListResult listinsertbeforecurrent(list list, ListElement element); ListResult listinsertaftercurrent(list list, ListElement element); ListResult listremovecurrent(list list); ListResult listsort(list list, CompareListElements compareelement); List listfilter(list list, FilterListElement filterelement, ListFilterKey key); ListResult listclear(list list); void listdestroy(list list); /** Macro to enable simple iteration */ #define LIST_FOREACH(Type, elem, list) for(type elem = listgetfirst(list); \ elem!= NULL; \ elem = listgetnext(list)) #endif /* LIST_H_ */ 5

#ifndef STACK_H_ #define STACK_H_ typedef struct stack* Stack; typedef enum { STACK_SUCCESS, STACK_IS_EMPTY StackResult; typedef void* StackElement; typedef StackElement (*CopyStackElement)(StackElement); typedef void (*FreeStackElement)(StackElement); מנשק עבור ADT של Stack Stack stackcreate(copystackelement copyelement, FreeStackElement freeelement); Stack stackcopy(stack stack); int stackgetsize(stack stack); StackResult stackpush(stack stack, StackElement element); StackResult stackpop(stack stack); StackResult stacktop(stack stack, StackElement* element); void stackdestroy(stack stack); #endif /* STACK_H_ */ קבצי Makefile קבצי Makefile משמשים להגדרת תהליך הבנייה של תוכנה ומאפשרים )על ידי שימוש בפקודה )make לבנות רק את החלקים שהשתנו לאחר ביצוע שינוי בקוד. דוגמה ל- Makefile : CC = gcc OBJS = a.o b.o c.o EXEC = prog DEBUG_FLAG = # now empty, assign -g for debug COMP_FLAG = -std=c99 -Wall -Werror $(EXEC) : $(OBJS) $(CC) $(DEBUG_FLAG) $(OBJS) -o $@ a.o : a.c a.h b.h $(CC) -c $(DEBUG_FLAG) $(COMP_FLAG) $*.c b.o : b.c b.h $(CC) -c $(DEBUG_FLAG) $(COMP_FLAG) $*.c c.o : c.c c.h b.h $(CC) -c $(DEBUG_FLAG) $(COMP_FLAG) $*.c clean: rm -f $(OBJS) $(EXEC) קובץ ה- Makefile מכיל כללים. כלל מתחיל בשורה מהצורה <dependencies>.<file>: כלל מתאר כיצד יש לבנות גרסה חדשה של.<file> ומגדיר את התלויות של <file> על מנת שנדע מתי יש לבנות גרסה חדשה. השורות הבאות אחרי השורה הראשונה מתחילות בטאב, ומגדירות את רשימת הפקודות לביצוע )בדומה ל- script פשוט( קובץ o תלוי בקובץ ה- c ממנו הוא מהודר ובקבצי ה- h אותם קובץ ה- c כולל בעזרת.include בנוסף, ניתן להגדיר מאקרוים ע"י שורה מהצורה <value>.<macro> = כדי לבצע החלפה של מאקרו בערכו יש לקרוא למאקרו בעזרת.$(<macro>) ניתן להשיג את שורות התלויות עבור תכנית C בעזרת הפקודה <files>.gcc -MM למשל, אם הקובץ a.c מבצע include ל- a.h ו- b.h, אז הפקודה gcc -MM a.c תגרום להדפסת: a.o: a.c a.h b.h 6

שימוש ב- Bash רשימת פקודות תחביר - Syntax פקודה משמעות ודגלים הדפסת שמות )ופרטי( הקבצים בתיקייה הנוכחית או בתיקייה שהתקבלה בארגומנט - l- ידפיס פרטים נוספים על הקובץ - a- ידפיס את הקבצים בתיקייה המצוינת כולל קבצים המתחילים ב "." הדפסת תוכן קבצים למסך. ls [-l] [-a] [dir] cat <files> more <files> ls cat more הדפסת תוכן קבצים למסך בצורה מאורגנת )המדפיסה מסך שלם ומחכה לקלט ממשתמש לפני הדפסה של מסך נוסף(. הדפסה ועיבוד תוכן קובץ בממשק טקסטואלי. less <file> mv filename1 filename2 mv <files> dirname less mv הזזה או שינוי שם קובץ. ניתן להזיז כמה קבצים לתוך תיקייה. העתקת קובץ. cp filename1 filename2 rm [-r] <files> cp rm מחיקת קבצים או תיקיות. - עם הדגל r ימחקו כל הקבצים והתיקיות רקורסיבית. הדפסת הבדלים בין קבצים diff filename1 filename2 chmod <options> <files> diff chmod שינוי הרשאות קבצים/תיקיות others יתן הרשאות קריאה לקבוצה o+r - others יבטל הרשאות קריאה לקבוצה o-r - יצירת תיקייה חדשה בתיקייה הנוכחית mkdir <dirname> cd <dirname> mkdir cd שינוי התיקייה הנוכחית הדפסת התיקייה הנוכחית pwd make [target] pwd make הרצת התוכנה make המחפשת קובץ makefile ומנסה לבנות בו את ה target הראשון. - ניתן לציין target alias <name>="<command>" unalias <alias> head [-n#] [files] tail [-/+#] [files] head -3 a_file tail -2 sort [options] [files] >sort data Father World for who echo [-n] [words] data: World who for Fathe הגדרת קיצורים ב- Shell ביטול alias להדפסת שורות ראשונות מהקלט. - אם לא מוגדר מספר יודפסו 01 שורות - אם המספר שהוגדר שלילי יודפסו כל השורות מלבד # השורות האחרונות - עבור מספר חיובי ניתן לרשום גם #- להדפסת השורות האחרונות מהקלט - עבור #- מדפיסה את # השורות האחרונות בקלט - עבור #+ מדפיסה החל מהשורה ה-# - ברירת המחדל היא הדפסת 01 השורות האחרונות דוגמא לשימוש ב- pipeline עבור הדפסת את שורות 2-3 מקובץ מסוים מדפיסה את הקלט ממוין )לפי שורות( n-: ממיינת מספרים לפי ערכם - r-: מדפיס בסדר יורד )ברירת המחדל היא סדר עולה( - #k-: מתייחס לכל שורה החל מהמילה ה-# - המילים ממסופרות החל מ- 0 - uppercase/lowercase מתעלם מהבדלי :-f - b-: מתעלם מרווחים בתחילת השורה - s-: מיון יציב - שומר על הסדר המקורי בין שורות שערכן שווה - n-: מדפיס ללא ירידת שורה alias unalias head tail sort echo 7

uniq [options] [input [output]] >uniq file one two three one file: grep [options] <expression> [files] >grep -i cow farm1 cow Betsy slim cow Dazy Fat Cow Burger two cows Dartsy & Teo cut <options> [files] > cut -d":" f1 file2 a11 b21 c31 c32 c33 file2: > cut -c1-3,5,8-10 file1 a11a a1 b21b b2 file1: c31c c3 a11 a12 a13 a14 a15 b21 b22 b23 b24 b25 c31 c32 c33 c34 c35 wc [options] [files] >wc mtm_ex1.h example.c 120 641 4161 mtm_ex2.h 136 692 4543 example.c 256 1333 8704 total tee [options] [files] one two two three three three one one a11:a12:a13 b21:a15 c31 c32 c33 printf <format> [arguments] >printf "%s %s!\n" Hello world Hello world! מדפיסה עותק יחיד של שורות זהות סמוכות c-: מדפיס כל שורה פעם אחת ואת מספר העותקים שלה - d-: מדפיס רק שורות המופיעות יותר מפעם אחת - u-: מדפיס רק שורות המופיעות פעם אחת בלבד - ניתן להשתמש רק באחת האפשרויות מבין -c/-d/-u בבת אחת - #-: התעלם מ-# המילים הראשונות בקבלת ההחלטה האם שורות - זהות( ניתן לחפש מילים מסוימות או ביטויים מורכבים מדפיסה את כל השורות בקובץ המכילות את הביטוי שהוגדר v-: מדפיסה את השורות בהן לא מופיע הביטוי - uppercase/lowercase מתעלם מהבדלי :-i - w-: מדפיסה את כל השורות בהן <expression> מופיע בדיוק )לא - כתת מחרוזת( n-: הדפס את השורות ואת מספרן בקבצים - l-: הדפס רק את שמות הקבצים בהן נמצאו שורות מתאימות - c-: הדפס רק את כמות השורות שנמצאו בכל קובץ ללא הדפסת - השורות עצמן הביטוי לחיפוש יכול להיות מורכב יותר ממילה פשוטה: - כדי לחפש מחרוזת עם רווחים יש להוסיף גרשיים - התו ^ מייצג תחילת שורה והתו $ את סוף השורה - משמשת להפרדת עמודות מתוך הקלט :-c<list> הדפסת התווים בשורה המתאימים לאינדקסים - הדפסת השדות בשורה המתאימים לאינדקסים :-f<list> - השדות בשורה מופרדים כברירת מחדל ע"י Tab - אם התו המפריד אינו קיים בשורה תודפס כל השורה - f-( השתמש בתו שהוגדר כתו המפריד )עבור שימוש בדגל "?"d-: - רשימת האינדקסים מורכבת ממספר אינדקסים מופרדים בפסיק, - כאשר בנוסף ניתן לבקש טווח אינדקסים ע"י שימוש בתו - )מקף( -c1,2,5-6,10- ידפיס את התווים,,6,5,2,0 ו- 01 ומעלה - אם האינדקסים המבוקשים מחוץ לתחום תודפס שורה ריקה - משמשת לספירת תווים, מילים או שורת בקלט c-: מדפיסה את מספר התווים בלבד l-: מדפיסה את מספר השורות בלבד w-: מדפיסה את מספר המילים בלבד אם לא צוין דגל מסוים wc מדפיסה את כל שלושת המספרים אם הפקודה מופעלת על מספר קבצים מודפסת גם שורת סיכום משמשת לשכפול הפלט. משכפלת את הקלט הסטנדרטי ומדפיסה אותו לפלט הסטנדרטי ולכל אחד מהקבצים ברשימה [files] a-: משרשרת לקבצים במקום לכתוב אותם מחדש מבנה הפקודה אינו סטנדרטי, היא מקבלת קלט רק מהקלט הסטנדרטי מאפשרת הדפסה מעוצבת של טקסט s%: מציין במחרוזת הפורמט שיש להכניס כאן את ערך הארגומנט הבא :%[-]m[.n]s מדפיסה את המחרוזת המתאימה מרשימת המחרוזות כך שהתוצאה תהיה באורך m תווים ותכיל לכל היותר n תווים מהמחרוזת. המחרוזת תהיה מיושרת לימין אלא אם מופיע - )מקף(. אם יש יותר ארגומנטים מהדרוש ברשימה, הפונקציה תדפיס את השורה מחדש ותשתמש בארגומנטים הבאים בכל פעם עד שייגמרו. uniq grep cut wc tee printf 8

תבניות: * מתאים למחרוזת כלשהי )כולל ריקה(.? מתאים לתו כלשהו יחיד. [ ] התייחסות למספר תווים אפשריים. התווים יכולים להינתן: כטווח של תווים, למשל a-z או אחד אחרי השני במפורש. { התייחסות למספר מחרוזות שונות. אפשרות זו אינה מתחשבת בקבצים קיימים: משתנים: ל$ קריאת ערך ממשתנה. { לסימון שם המשתנה לאופרטור $ unset <varname> לביטול משתנה. = 9 ${<varname> מערך - שימוש בסוגריים - קריאת האיבר הראשון )אינדקס 1( מהרשימה(. arr=(1 2 3) קריאת שם המשתנה של המערך. )שקולה לקריאת > echo $arr 1 קריאת כל המערך echo ${arr[*]{ 1 2 3 ${<varname>[*] - גישה לאיבר והוספת איבר חדש - אופרטור [ ] arr[3] = 4 מספר האיברים במערך >${#arr[*] 4 ${#<varname>[*] - גישה לתחומים של איברים במערך - ${${<varname>[*]:<num1>:<num2> -num1 אינדקס ההתחלה של התחום -Num2 מספר האיברים בתחום )אם הוא אינו מופיע יודפסו כל האיברים החל מהאינדקס המבוקש( > echo A:${arr[*]:0:2 מספר התווים במשתנה שימוש ב-# A:1 2 > echo ${#str סוגי גרשיים: גרשיים כפולים " " תפקיד: משמשים לשמירה על רווחים. משתמשים ב-" " כאשר יש צורך לשמור מחרוזות שלמות במדויק. בתוך גרשיים אלו לא מתבצעות החלפות של תבניות בשמות הקבצים המתאימים. דוגמא: > echo "*.c" : *.c *.c : main.c app.c hello.c גרשיים בודדים ' ' תפקיד: מונעים ההחלפות בתחומם. דוגמא: > echo lets make some '$$' lets make some $$ גרשיים הפוכים תפקיד: מבצעים command substitution ניתן "לשרשר" פקודות. דוגמא: < echo a3b.{c,txt a3b.c a3b.txt > a=hell > echo ${ao Hello > echo The length of $str is `echo -n $str wc -c` The length of Hello is 5

עבודה עם סקריפטים: 1. הגישה לפרמטרים המועברים בשורת הפקודה לתסריט משמעות סימן קריאת הפרמטר ה- n לתסריט n$ רשימת כל הארגומנטים לתסריט *$ שמירה על מספר הארגומנטים הנכון, במידה וייתכנו רווחים בתוך הארגומנטים. @$ שם התסריט $0 מספר הארגומנטים #$ #!/bin/bash 2. הרצת תסריט: בתחילת התסריט יש להוסיף את השורה : 3. סוגי העברת פרמטרים לתסריטי עזר סוג העברה שורת הפקודה Pipeline קובץ זמני דוגמא helper_script $arg1 $arg2 echo $arg1 $arg2 helper_script echo $arg1 $arg2 > temp helper_script < temp 4. סוגי החזרת ערכים סוג החזרה backticks Pipeline קובץ זמני דוגמא result = `helper_script` helper_script another_script helper_script > temp חישובים אריתמטיים $((<expression>)) ניתן להחליף ביטוי אריתמטי בערכו על ידי הערך המספרי של המחרוזות ישמש בחישוב הביטוי o משתנים יוחלפו בערכם )גם ללא $( o אם אחד הארגומנטים אינו מספר, ערכו יהיה 0 בחישוב o משתנה שאינו מוגדר, או ערכו אינו מספר יחושב כ- 0 o פעולות חשבוניות פשוטות:,+,- * ו-/, השמות:,= הגדלות והקטנות:,+=,-= o let ++n לדוגמא:,let ניתן גם להשתמש בפקודה o -- ו-++ while <expression>; do <command1> <command2>... done מבני בקרה לולאת while לולאת for מעבר על איברי מערך <varname> o הוא שם המשתנה שיכיל בכל פעם איבר מהרשימה <array> o היא רשימה של מחרוזות 11

for <varname> in <array> ; do <commands> done for ((i = 1; i <= 3; i++)); do <commands> done או לחלופין: if <expression>; then <command1> <command2>... fi if <expression>; then <commands> else <commands> fi תנאי if תנאי if עם else בכל התנאים ניתן להשתמש באופרטורים &&, שמשמעותם דומה ל- C. סוגי תנאים [[ ]] תנאי מהצורה.4 בתוך ]] [[ האופרטורים ==, > ו-> משווים מחרוזות )לפי סדר לקסיקוגרפי( -le,-gt ניתן לבצע השוואת על ערכי מספרים בעזרת דגלים כגון,-eq בודק האם קיים קובץ בשם <filename> התנאי <filename> f- התנאי <dirname> d- בודק האם קיימת תיקייה בשם <dirname> האופרטור = מאפשר התאמת מחרוזת לתבנית הארגומנט השמאלי הוא מחרוזת רגילה הארגומנט הימני הוא תבנית אשר יכולה לכלול את הסימנים *,? ו-] ] האופרטור =! הוא השלילה של אופרטור ההתאמה = המשמעות של = ו-== שונה > end_with_z="some string with z" > if [[ "$end_with_z" = *[zz] ]]; then echo match; fi match > if [[ "this string start with t" = t* ]]; then echo true; fi true > if [[ "this string doesn't start with t" = [^t]* ]]; then echo true; fi > file=test4.in > if [[ $file = test*.in ]]; then echo test file; fi test file > if [[ "string doesn't start with t"!= t* ]]; then echo true; fi true (( )) תנאי מהצורה.2 בתוך (( )) האופרטורים,==,!= > ו- < מתייחסים לערכים מספריים אין צורך לרשום $ לפני שם משתנה ניתן לבצע פעולות חשבוניות תנאים המוגדרים בעזרת )) (( מתנהגים כמו ביצוע פעולות חשבוניות בעזרת )) (($ דוגמא: )דוגמה בעמוד הבא( 11

> if (( 11 < 7 )); then echo true; fi > i=5 > if (( i >= 0 && i <= 10 )); then echo true; fi true > if [[ 11 -eq 11 ]]; then echo true; fi true > if (( 0 == Hello )); then echo true; fi true > if (( ++i == 6 )); then echo true; fi true > if (( ++i == 6 )); then echo true; fi function <name> { <commands> > read line Hello world > echo $line Hello world > read -a line Hello world > echo $line Hello > echo ${line[*] Hello world while read line; do echo $line done < "$1" דוגמא: פונקציות השימוש בפונקציה יכול להתבצע רק אחרי הגדרתה. אפשר להעביר לפונקציה ארגומנטים משתמשת בהם בדומה לשימוש בארגומנטים המועברים לתסריט לא יכולה לגשת לארגומנטים של התסריט שקרא לה. משתנה מקומי בפונקציה בעזרת המילה :local "החזרת" ערכים מפונקציה בעזרת )backticks( command substitution קריאת קלט קריאת שורה מהקלט הסטנדרטי: name> read <flags> <variable השורה תיקלט לתוך שם המשתנה שהוגדר. הדגל a- יחלק את השורה לפי מילים לתוך מערך. o הביטוי read יוחלף על ידי bash בשורת קלט שתיקלט מהקלט הסטנדרטי דוגמא: read line < filename קריאת קובץ ע"י הפניית קלט קריאה מקובץ שורה אחר שורה: ושימוש ב- read : בהרצת פקודה, הshell יחפש את הקובץ המתאים לפקודה בתיקיות במשתנה ה.PATH על מנת לאפשר ל- Shell להריץ תכניות מהתיקייה הנוכחית ללא שימוש ב-. יש להוסיף את התיקייה הנוכחית ל- PATH. ע"י הפקודה: PATH=$PATH:. - התיקיות מופרדות ע"י סימן ":". הפקודה which איזו תכנית תופעל עבור שם פקודה מסוים PATH 12

שפת ++C קבועים המילה const מגדירה משתנים כקבועים ומאפשרת לקומפיילר לוודא שערכם אינו משתנה. משנה קבוע חייב להיות מאותחל לערך )לא ניתן לבצע לו השמה בהמשך(. const int n = 5; n = 7; // error: assignment of read-only variable `n' const int m; // error: uninitialized const `m' כאשר מוסיפים const להגדרת מצביע ייתכנו מספר אפשרויות: הערך של *ptr נותר קבוע const int* ptr; int* const ptr = NULL; הכתובת ש- ptr מצביע עליה קבועה // Must be initialized שילוב שתי האפשרויות const int* const ptr = NULL; ניתן להכריז על פרמטרים וערכי חזרה של פונקציה כ- const : o הפונקציה מתחייבת שלא לשנות את הערך שהארגומנט מצביע עליו: char* strcpy(char* destination, const char* source); o ניתן להחזיר מצביע למשתנה פרטי ללא חשש לגרימת נזק מצד המשתמש: const char* studentgetname(student s); עבור מתודה )שאינה סטטית(, const בסוף החתימה של הפונקציה מתייחס לעצם עליו מופעלת המתודה להפעיל רק מתודות שהוגדרו כ- const. ניתן ומתחייב שלא לשנותו. על עצם המוגדר כ- const (this) מרחבי שמות - namespace :namespace ניתן לאגד מספר פונקציות וטיפוסים בצורה לוגית תחת namespace math { double power(double base, double exp); double sqrt(double number); double log(double number); לכל שם )טיפוס, משתנה, פונקציה( המוגדר ב- namespace יש שם מלא מהצורה <namespace>::<item> ניתן להשתמש בהוראת using על מנת לאפשר גישה לשם מסויים ב- namespace באמצעות שמו ה"פרטי" בלבד. הוראת ה- using תקפה לכל הבלוק הנוכחי או לכל המשך הקובץ אם היא מופיעה מחוץ לכל בלוק בדומה לשם משתנה לו היה מוגדר באותו המקום. using math::power; ניתן לבצע using לכל תוכן ה- namespace בבת אחת: using namespace math; 13

.0 העמסת פונקציות ב-++ C פונקציה מזוהה על פי שמה ועל פי מספר וסוג הפרמטרים שלה. הקומפיילר יבחר את הפונקציה המתאימה על פי טיפוס הארגומנטים בקריאה לה מבין כל הפונקציות המתאימות הקומפיילר מחפש את הפונקציה שהפרמטרים שלה הם המתאימים ביותר, לפי הדירוג הבא: התאמה מדויקת או המרות טריוויאליות )T,const T מערך למצביע(.2.3 התאמה בעזרת פונקצית template התאמה באמצעות קידום טיפוסים char(,double וכו'( float,char bool,int.4 התאמה באמצעות המרות מובנות )*T )...,int double,void*.5 התאמה באמצעות המרות שהוגדרו על ידי המשתמש - למשל printf התאמה לפונקציה עם מספר ארגומנטים משתנה ellipsis(...( 6. עבור פונקציה עם יותר מפרמטר אחד, הקומפיילר מחפש פונקציה שיש לה את ההתאמה הטובה ביותר עבור פרמטר אחד כלשהו, והתאמה שווה או טובה לכל שאר הפרמטרים אם קיימות שתי התאמות בעדיפות הגבוהה ביותר של התאמה אזי הקריאה דו-משמעית והיא לא תתקמפל בחירת הפונקציה אינה תלויה בערך ההחזרה. לא ניתן לכתוב שתי פונקציות השונות רק בערך ההחזרה שלהן ניתן להגדיר ערך ברירת מחדל לפרמטרים עבור פונקציה: void print(int n, int base = 10); ההגדרה הקודמת שקולה לכתיבת שתי פונקציות מועמסות: void print(int n, int base); void print(int n) { print(n, 10); ניתן לתת ערך ברירת מחדל רק לפרמטרים האחרונים של הפונקציה את ערך ברירת המחדל יש לכתוב פעם אחת בלבד בהכרזת הפונקציה קלט/פלט )ועבודה עם קבצים( cout עבור פלט הבאים: ערוצי הקלט ופלט הסטנדרטיים מיוצגים ב-++ C על ידי המשתנים הגלובליים סטנדרטי, cin עבור קלט סטנדרטי ו- cerr עבור פלט שגיאות סטנדרטי. ניתן להדפיס משתנה כלשהו לערוץ על ידי אופרטור <<. ניתן להעמיס על אופרטור זה עבור טיפוסים חדשים. ניתן לקלוט משתנה על ידי אופרטור >>. גם במקרה זה ניתן להעמיס על האופרטור עבור טיפוסים חדשים..endl על ידי הדפסת )flush ניתן להדפיס ירידת שורה )ולבצע ניתן לשרשר מספר הדפסות/קריאות בבת אחת..istream היורשת את ifstream פתיחת קובץ לקריאה נעשית בעזרת המחלקה.ostream היורשת את ofstream פתיחת קובץ לכתיבה נעשית באמצעות המחלקה ifstream file_in("a.txt"); ofstream file_out("b.txt"); int input; while (file_in >> input) { file_out << input << endl; ניתן להדפיס לתוך מחרוזת בעזרת שימוש במחלקה ostringstream היורשת את.ostream ostringstream str_out; int num1 = 7; double num2 = 2.81; str_out << num1 << num2; string str = str_out.str(); const char* c_str = str.c_str(); 14

מחלקות ניתן להגביל את הגישה לחלקים מהמחלקה על ידי קביעת הגישה האפשרית לכל חלק. את המילה המציינת את רמת הגישה האפשרית רושמים ולאחריה נקדתיים, והיא משפיעה על כל ההכרזות במחלקה עד למילה המציינת הגישה הבאה. public שמות שנגישים תמיד private שמות שנגישים רק מקוד אשר נכתב כחלק מהמחלקה או מקוד אשר סומן כ- friend שמות שמתנהגים בדומה ל- private, אך מאפשרים בנוסף גישה מקוד אשר נכתב כחלק ממחלקה protected יורשת )ישירות או בעקיפין(.private הינה ברירת המחדל לרמת הגישה ב- class o.public הינה ברירת המחדל לרמת הגישה ב- struct o ניתן להגדיר שדה כסטטי על ידי שימוש במילה.static שדה סטטי הוא שדה אשר יש לו עותק יחיד משותף לכל העצמים במחלקה. השדה קיים ונגיש גם אם לא קיים אף עצם המהמחלקה. התהנהגותו דומה לשל משתנה גלובלי. ניתן להגדיר מתודה כסטטית על ישי שימוש במילה.static מתודה סטטית היא מתודה אשר אינה מופעלת על עצם, אלא מורצת כמו פונקציה רגילה. אין לה גישה ל- this. משתנים ומתודות סטטיים מצייתים לחוקי בקרת הגישה. למשל, לא ניתן לגשת למשתנה סטטי שהוגדר כ- private מחוץ למחלקה. ניתן להכריז על פונקציה כלשהי )שאינה חלק מה- class ( כחברה של ה- class בעזרת המילה.friend פונקציה אשר הוגדרה כ- friend של מחלקה X יכולה לגשת לשדות ומתודות פרטיים של X. דוגמאות: class A { friend int f(const A&); friend void B::f(A&); template <class T> friend int f(); ; template <class T> class B { friend int g(); friend int g(b<t>&); ; // function int f(const A&) is friend // function void B::f(A&) is friend // all functions int f<t>() are friends // int g() is friend of all classes B<T> // int g(b<t>&) is friend of B<T> ניתן להכריז על מחלקה Y כלשהי כחברה של מחלקה X בעזרת המילה.friend במקרה זה כל הפונקציות של Y יוכלו לגשת לחלקים פרטיים )ומוגנים( של X. דוגמאות: class C { friend class A; // class A is friend template <class T> friend class B; // all classes B<T> are friends ; template <class T> class D { friend class A; friend class B<T>; ; // class A is friend of all classes D<T> // class B<T> is friend of D<T> הקומפיילר מייצר בעצמו את הפונקציות הבאות, תחת התנאים הבאים: פעולת הפונקציה תנאי ליצירה פונקציה קורא לבנאים חסרי הפרמטרים של כל השדות במידה ולא נכתב אף בנאי במפורש default c tor ושל מחלקת האב )בנאי חסר פרמטרים( מאתחל את כל השדות ואת מחלקת האב בעזרת copy c tor בנאי ההעתקה שלהם במידה ולא נכתב copy c tor מפורש )בנאי העתקה( ההורס לא מבצע כלום )קריאה להורסים של כל השדות ומחלקת האב מתבצעת תמיד, לכל הורס( d'tor )הורס( במידה ולא נכתב d tor מפורש מבצע השמה של כל שדה ושדה באמצעות operator= אופרטור ההשמה שלו במידה ולא נכתב operator= מפורש )אופרטור השמה( מחזיר את כתובת העצם operator& במידה ולא נכתב operator& מפורש )אופרטור כתובת( 15

העמסת אופרטורים ניתן להתייחס לאופרטורים ב-++ C כמו פונקציה רגילה. שקולה ל-( operator+(a,b a+b מהצורה + מבחינת הקומפיילר קריאה לאופרטור בינארי o.a.operator+(b).a.operator-() או שקולה ל-( operator-(a a- בצורה דומה, קריאה לאופרטור אונארי כגון o ניתן להעמיס על אופרטורים ב-++ C בדומה לפונקציות תחת המגבלות הבאות:.enum אחר הפרמטרים חייב להיות מטיפוס מחלקה או o ההעמסה מתבצעת על אופרטור קיים ושומרת על מספר הפרמטרים שלו והקדימות שלו. o או אופרטורים מיוחדים: את האופרטורים הבאים חייבים לממש בתוך המחלקה: operator() operator-> operator[] operator= המרות )כמו )operator double,operator() המשמש להגדרת function object יכול להיות מוגדר עם כל מספר של פרמטרים. operator->() חייב להחזיר ערך עבורו מוגדר האופרטור חץ גם כן. הקריאה a->x למעשה מבצעת קריאה כפולה לאופרטור חץ, ראשית על a ואז על הערך המוחזר מהאופרטור: ). a.operator->() ) <- x לאופרטורים ++ ו--- שתי גרסאות: operator++(), operator--() operator++(int), operator--(int) prefix: ++x, --x postfix: x++, x-- המרות ניתן להגדיר המרות בשפת ++C אשר ישמשו את הקומפיילר בזמן בחירת פונקציה מתאימה בתהליך ההעמסה. את ההמרות ניתן להגדיר בעזרת בנאי או בעזרת אופרטור המרה: class Complex { double re, im; Complex(double re) : re(re), im(0.0) { //... ; class Rational { int num, denom; Rational(int num, int denom); //... operator double() const; ; בנאי המקבל ארגומנט יחיד, או שניתן לקרוא לו עם ארגומנט יחיד בשל קיום ערכי ברירת מחדל, ושאינו מסומן כ- explicit הגדרת מתודה ()T operator )אופרטור המרה( מגדיר המרה מטיפוס הפרמטר לטיפוס המחלקה מגדיר המרה מטיפוס המחלקה לטיפוס T המילה השמורה explicit מציינת שאסור לקומפיילר להשתמש בבנאי או אופרטור המרה ללא קריאה מפורשת בקוד. מטרתה למנוע המרות אוטומטיות. o בנאי אשר מוגדר כ- explicit אינו יכול לשמש לאתחול משתנה באמצעות סינטקס של השמה. למשל, לא ניתן לכתוב 5; = v,vector<int> אלא רק v(5);.vector<int> הקומפיילר לא ממיר בצורה אוטומטית עצמים משמאל לאופרטור הנקודה..מקרה זה נכון גם עבור מקרה בו הנקודה אינה מפורשת - למשל קריאה a + b אשר קוראת ל-( a.operator+(b, ואינה מבצעת המרות על a. אם יש צורך לאפשר לקומפיילר להמיר אוטומטית את הפרמטר הראשון של אופרטור, יש לממש את האופרטור כפונקציה חיצונית. 16

תבניות (templates) ניתן ליצור תבנית עבור מחלקה או פונקציה אשר תשמש את הקומפיילר ליצירת מחלקות או פונקציות לפי התבנית שהוגדרה. הכרזה על תבנית מתבצעת באמצעות המילה השמורה,template ולאחריה בתוך >,> את רשימת הפרמטרים לתבנית. לבסוף מופיעה מחלקה או פונקציה אשר יכולה להיות תלויה בפרמטרים של התבנית. )typename או ערכים class או פרמטרים יכולים להיות שמות טיפוסים )על ידי שימוש במילה o מטיפוסים אחרים, ביניהם int, bool ומצביעים לפונקציות. הקומפיילר ישתשמש בתבניות כדי ליצור פונקציות ומחלקות בהתאם לנדרש מהקוד. תבניות מופיעות בקבצי h כך שיהיו נגישות לקומפיילר. o רק כאשר הקומפיילר משתמש בתבנית הוא יקמפל את הקוד עם הארגומנטים המתאימים. אם o הארגומנטים אינם עומדים בדרישות התבנית תתקבל שגיאת קומפילציה. )למשל, עבור פרמטר שהינו שם טיפוס T, בתבנית נעשה שימוש באתחול חסר פרמטרים של T אך לארגומנט המועבר כ- T אין בנאי מתאים( עבור תבנית של מחלקה, הקומפיילר מייצר אך ורק את המתודות שנעשה בהן שימוש בפועל. למשל, o אם לטיפוס T אין בנאי חסר פרמטרים, עדיין ניתן להשתמש במתודות שאינן דורשות בנאי זה. עבור תבנית של פונקציה, הקומפיילר יכול להסיק את הפרמטרים של התבנית אוטומטית אם הם מופיעים כחלק מהפרמטרים לפונקציה. אחרת יש לציינם במפורש. הקומפיילר יכול גם להסיק רק חלק מהפרמטרים, אך הפרמטרים שהוא מסיק חייבים להיות o האחרונים. חריגות (exceptions) מומלץ להגדיר מחלקה עבור כל סוג שגיאה ולהשתמש בה כחריגה לזרוק. מומלץ שמחלקות עבור חריגות יירשו את std exception או מחלקה סטנדרטית אחרת. o ניתן לתפוס חריגה על ידי מחלקת האב שלה. חשוב לתפוס חריגות by-reference בעזרת & כדי להימנע מהתנהגות לא רצויה. o.throw; על ידי הפקודה catch ניתן לזרוק חריגה מחדש מתוך בלוק זו הדרך היחידה לזרוק מתוך בלוק של.catch(...) מומלץ להשתמש בשיטה זו תמיד עבור כל זריקה o מחדש. ניתן לזרוק חריגות מבנאים או אופרטורים. מסוכן לזכור חריגה מהורס: אסור שיהיו שתי חריגות בו-זמנית )במקרה זה התכנית מתרסקת( ובזמן זריקת חריגה מתבצע קוד של הורסים. :std::exception הגדרת המחלקה class exception { exception(); exception(const exception&); exception& operator=(const exception&); virtual ~exception(); virtual const char* what() const; ; חריגות חשובות מהספרייה הסטנדרטית: std::bad_alloc נזרק כאשר הקצאת זיכרון באמצעות new נכשלת נזרק כאשר המרה בין רפרנסים באמצעות dynamic_cast נכשלת. לדוגמה: void f(employee& emp) { Engineer& eng = dynamic_cast<engineer&>(emp); יזרוק std::bad_cast אם emp אינו ניתן להמרה ל-& Engineer. std::bad_cast 17

המרות ומידע על טיפוסים בזמן ריצה המרה שנבדקת בזמן קומפילציה. מאפשרת המרות בין מצביעים שיש ביניהם קשר הורשה, או בין טיפוסים שמוגדרת ביניהם המרה. המרה בלתי הגיונית תגרום לשגיאת קומפילציה. נכונות ההמרה אינה נבדקת בזמן הריצה. המרה הנבדקת גם בזמן ריצה. מאפשרת המרה בטוחה בין מצביע או רפרנס של מחלקת אב למחלקה יורשת. במקרה שההמרה אינה נכונה מוחזר NULL במקרה של מצביעים או נזרק std::bad_cast במקרה של רפרנסים. ההמרה דורשת מחלקה פולימורפית )בעלת פונקציה וירטואלית אחת או יותר(. מאפשרת להוריד const משם הטיפוס. מאפשרת המרה בין כל שני טיפוסים על ידי פירוש מחדש של הזכרון. המרה מסוכנת שמשמשת למקרים מיוחדים בלבד. static_cast<t>(x) dynamic_cast<t>(x) const_cast<t>(x) reinterpret_cast<t>(x) האופרטור typeid מחזיר עצם מטיפוס type_info המייצג את הטיפוס בזמן ריצה של עצם. ניתן להפעיל את typeid על שם טיפוס או על עצם o כדי לקבל את הטיפוס בזמן ריצה יש להפעיל את typeid על העצם ולא על מצביע o המתודה type_info::name() מחזירה מחרוזת המתאת את שם הטיפוס o type_info מממש אופרטור השוואה )==( o A* ptra = new A; A* ptrb = new B; // B extends A, so B is an A if (typeid(*ptra) == typeid(*ptrb) { cout << "same type" << endl; if (typeid(*ptrb) == typeid(b)) { cout << "ptrb has a B" << endl; // this is not true // this is true cout << typeid(*ptrb).name() << endl; // prints a string description of type B אלגוריתמים גנריים דוגמה לאלגוריתם למציאת האיבר המקסימלי בתחום של איברים: דוגמאות נוספות לחתימות של פונקציות המממשות אלגוריתמים גנריים: template<typename Iterator> Iterator max(iterator start, Iterator end) { if (start == end) { return end; Iterator maximum = start; for(iterator i = ++start; i!= end; ++i) { if (*i > *maximum) { maximum = i; return maximum; template<typename Iterator, typename T> Iterator find(iterator start, Iterator end, const T& val); template<typename Iterator> void sort(iterator start, Iterator end); template<typename Iterator> void random_shuffle(iterator start, Iterator end); 18

class LessThanZero { bool operator()(int m) const { return m < 0; ; Function Objects במקום לשלוח מצביעים לפונקציות ב- STL משתמשים ב- objects function Function object הוא כל עצם המעמיס את אופרטור )( )אופרטור ההפעלה( דוגמא: void f() { LessThanZero isnegative; cout << isnegative(-4) << endl; // true cout << isnegative(6) << endl; // false class SumOf { bool operator()(int a, int b, int s) { return a + b == s; ; void g() { SumOf issum; cout << issum(2,3,5) << endl; // true cout << issum(1,2,5) << endl; // false אופרטור ההפעלה ניתן להגדרה עם מספר כלשהו של פרמטרים בניגוד למצביעים לפונקציות, ניתן לזכור מצב ב- Object Function ולכן ניתן להשתמש באותה מחלקה למס' פונקציות השונות רק בפרמטר כלשהו. class LessThan { int n; LessThan(int n) : n(n) { bool operator()(int m) const { return m < n; ; void h() { LessThan isless(5); LessThan isless2(8); cout << isless(4) << endl; // true cout << isless(6) << endl; // false cout << isless2(6) << endl; // true שימוש בפונקציה שהגדרנו בקריאה לאלגוריתם: template<typename Iterator, typename Predicate> Iterator find_if(iterator first, Iterator last, Predicate pred) { for (; first!= last; first++) if (pred(*first)) break; return first; shared_ptr לכל עצם מוצבע נשמור מונה הצבעות, וכל המצביעים ישתמשו במונה זה על מנת לדעת מתי יש לשחרר את העצם המוצבע. כאשר המצביע האחרון לעצם כלשהו ישתחרר הוא ישחרר את העצם. 19

:std::shared_ptr מנשק חלקי של המחלקה template<typename T> class shared_ptr { explicit shared_ptr(t* ptr = NULL); shared_ptr(const shared_ptr<t>& other); template<typename S> shared_ptr(const shared_ptr<s>& other); template<typename S> shared_ptr<t>& operator=(shared_ptr<s>& other); ~shared_ptr(); T& operator*() const; T* operator->() const; void reset(); // releases this pointer and sets it to NULL operator bool() const; ; vector<shared_ptr<shape> > function(const vector<point>& points) { shared_ptr<shape> shape(new Polygon(points)); shared_ptr<circle> circle(new Circle(5.0)); shared_ptr<square> square(new Square(2.0)); vector<shared_ptr<shape> > vec; vec.push_back(shape); vec.push_back(circle); vec.push_back(square); vector<shared_ptr<shape> > copy = vec; copy.pop_back(); Shape* shape = copy.front().get(); דוגמא לשימוש ב shared_ptr circle = square return copy; class Rational { int numerator, denominator; מחלקה עבור מספר רציונלי - Rational void simplify(); Rational(int numerator = 0, int denominator = 1); /** An implicit converion is a bad idea, this operator is here mainly * as an exmaple for overloading a conversion operator */ explicit operator double() const; Rational operator-() const; Rational& operator+=(const Rational& r); Rational& operator-=(const Rational& r); Rational& operator*=(const Rational& r); Rational& operator/=(const Rational& r); friend std::ostream& operator<<(std::ostream& os, const Rational& r); friend bool operator==(const Rational& r1, const Rational& r2); friend bool operator<(const Rational& r1, const Rational& r2); ; 21

class DivisionByZero : public std::runtime_error { DivisionByZero(); ; Rational operator+(const Rational& r1, const Rational& r2); Rational operator-(const Rational& r1, const Rational& r2); Rational operator*(const Rational& r1, const Rational& r2); Rational operator/(const Rational& r1, const Rational& r2); std::ostream& operator<<(std::ostream& os, const Rational& r); bool operator==(const Rational& r1, const Rational& r2); bool operator<(const Rational& r1, const Rational& r2); bool operator!=(const Rational& r1, const Rational& r2); bool operator>=(const Rational& r1, const Rational& r2); bool operator>(const Rational& r1, const Rational& r2); bool operator<=(const Rational& r1, const Rational& r2); #ifndef SET_H_ #define SET_H_ #include <iostream> #include <cassert> מחלקה עבור קבוצה גנרית - Set class Set { Set(); Set(const Set& set); ~Set(); Set& operator=(const Set& set); bool add(const T& t); bool remove(const T& t); bool contains(const T& t); int getsize() const; Set unionwith(set set) const; Set intersectwith(set set) const; class Iterator; Iterator begin() const; Iterator end() const; template <typename Function> Set filter(function f) const; private: T* data; int size; int maxsize; int find(const T& t) const; void expand(); static const int EXPAND_RATE = 2; static const int INITIAL_SIZE = 10; static const int NUMBER_NOT_FOUND = -1; ; 21

class Set<T>::Iterator { const Set<T>* set; int index; Iterator(const Set<T>* set, int index); friend class Set<T>; const T& operator*() const; Iterator& operator++(); Iterator operator++(int); bool operator==(const Iterator& iterator) const; bool operator!=(const Iterator& iterator) const; ; std::ostream& operator<<(std::ostream& os, const Set<T>& set); Set<T>::Set() : data(new T[INITIAL_SIZE]), size(0), maxsize(initial_size) { Set<T>::Set(const Set<T>& set) : data(new T[set.getSize()]), size(set.getsize()), maxsize(set.getsize()) { for (int i = 0; i < size; i++) { data[i] = set.data[i]; Set<T>::~Set<T>() { delete[] data; bool Set<T>::add(const T& t) { if (contains(t)) { return false; if (size >= maxsize) { expand(); data[size++] = t; return true; bool Set<T>::remove(const T& t) { int index = find(t); if (index == NUMBER_NOT_FOUND) { return false; data[index] = data[--size]; return true; int Set<T>::find(const T& t) const { for (int i = 0; i < size; i++) { if (data[i] == t) { return i; return NUMBER_NOT_FOUND; 22

bool Set<T>::contains(const T& t) { return find(t)!= NUMBER_NOT_FOUND; int Set<T>::getSize() const { return size; Set<T> Set<T>::unionWith(Set<T> set) const { Set<T> result = set; for (const T& t : *this) { result.add(t); return result; Set<T> Set<T>::intersectWith(Set<T> set) const { Set<T> result; for (const T& t : *this) { if (set.contains(t)) { result.add(t); return result; std::ostream& operator<<(std::ostream& os, const Set<T>& set) { os << "{"; bool first = true; for (const T& t :set) { if (!first) { os << ","; first = false; os << " " << t; os << " "; return os; // NOTE: This is not an optimal implementation for operator=() as it does // not handle well the case in which an exception is thrown Set<T>& Set<T>::operator=(const Set<T>& set) { if (this == &set) { return *this; delete[] data; data = new T[set.size]; size = set.size; maxsize = set.size; for (int i = 0; i < size; ++i) { data[i] = set.data[i]; return *this; 23

template <typename Function> Set<T> Set<T>::filter(Function f) const { Set<T> result; for (const T& t : *this) { if (f(t)) { result.add(t); return result; typename Set<T>::Iterator Set<T>::begin() const { return Iterator(this, 0); typename Set<T>::Iterator Set<T>::end() const { return Iterator(this, size); void Set<T>::expand() { int newsize = maxsize * EXPAND_RATE; T* newdata = new T[newSize]; for (int i = 0; i < size; ++i) { newdata[i] = data[i]; delete[] data; data = newdata; maxsize = newsize; template<typename T> Set<T>::Iterator::Iterator(const Set<T>* set, int index) : set(set), index(index) { template<typename T> const T& Set<T>::Iterator::operator*() const { assert(index >= 0 && index < set->getsize()); return set->data[index]; template<typename T> typename Set<T>::Iterator& Set<T>::Iterator::operator++() { ++index; return *this; template<typename T> typename Set<T>::Iterator Set<T>::Iterator::operator++(int) { Iterator result = *this; ++*this; return result; template<typename T> bool Set<T>::Iterator::operator==(const Iterator& i) const { assert(set == i.set); return index == i.index; template<typename T> bool Set<T>::Iterator::operator!=(const Iterator& i) const { return!(*this == i); #endif /* SET_H_ */ 24

class Shape { int center_x, center_y; דוגמה למחלקה אבסטרקטית (Shape) ולירושה Shape(int x, int y) : center_x(x), center_y(y) { virtual ~Shape() { virtual double area() const = 0; ; class Circle : public Shape { int radius; Circle(int x, int y, int radius) : Shape(x, y), radius(radius) { virtual double area() const override { return radius * radius * PI; ; class Square : public Shape { int edge; Square(int x, int y, int edge) : Shape(x, y), edge(edge) { virtual double area() const override { return edge * edge; ; מבני נתונים שימושיים של STL המחלקה std::vector מנשק חלקי של המחלקה: template<typename T> class vector { vector(); vector(const vector& c); vector(size_t num, const T& val = T()); vector(std::initializer_list<t> values); // vector<int> v = { 1, 2, 3 ; vector& operator=(const vector& v); ~vector(); T& operator[](size_t index); const T& operator[](size_t index) const; T& at(size_t loc); const T& at(size_t loc) const; void pop_back(); void push_back(const T& val); typedef T* iterator; // a pointer is used as an iterator typedef const T* const_iterator; iterator begin(); iterator end(); const_iterator begin() const; const_iterator end() const; size_t size() const; 25

; int main() { vector<int> v1; // empty vector vector<int> v2(20, 8); // 20 integers, all of value 8 vector<int> v3 = { 1, 2, 3, 4, 5 ; דוגמה לשימוש בוקטור: // use vector's `begin' and `end' methods for iteration for (int n : v3) { cout << n; for (size_t i = 0; i < v2.size(); ++i) { cout << v2[i]; // Unsafe access by index for (int i = 0; i < 10; ++i) { v1.push_back(i); // Inserts items at the end of the vector while(v1.size() > 0) { v1.pop_back(); const vector<int> copy(v1); //Safely copies a vector return 0; המחלקה std::list מנשק חלקי של המחלקה: template<typename T> class list { list(); list(const list& c); list(size_t num, const T& val = T()); list(std::initializer_list<t> values); // list<int> v = { 1, 2, 3 ; list& operator=(const list& v); ~list(); void pop_back(); void push_back(const T& val); void pop_front(); void push_front(const T& val); iterator begin(); iterator end(); const_iterator begin() const; const_iterator end() const; size_t size() const; ; 26