תרגול 10: הכרות עם ++C ++C כ- C משופר

Slides:



Advertisements
Similar presentations
ממיבחניםC שאלות ++.
Advertisements

תוכנה 1 סמסטר א ' תשע " ב תרגול מס ' 7 * מנשקים, דיאגרמות וביטים * לא בהכרח בסדר הזה.
מבוא למדעי המחשב לתעשייה וניהול
בתרגול הקודם הורשה: –ניתן להרחיב רק מחלקה אחת –כל מה שלא private – עובר בהורשה –המילה השמורה super –יצירת היררכיה –Object היא שורש ההיררכיה –דריסה אופרטור.
האוניברסיטה העברית בירושלים
טבלאות סמלים נכתב ע"י אלכס קוגן סמסטר חורף, תשס"ח.
Pointers הרצאה קריטית. השאלות הפתוחות מה זה ה- & שמופיע ב scanf מדוע כשמעבירים מחרוזת ל scanf אין צורך ב & האם ניתן להכריז על מערך שגדלו אינו ידוע בתחילת.
תרגול 8 היכרות עם ++C. C++ מעל שפת Cשפת תכנות שנבנתה מעל שפת C CC++ –כמעט כל תכנית ב -C היא גם תכנית ב C++ עד כדי מספר הבדלים קטן C99C שאימץ כמה מהתכונות.
תכנות מונחה עצמים Object Oriented Programming (OOP) אתגר מחזור ב'
1 מבחן מועד ג' סמסטר אביב אשכול מחשבים (Cluster) הוא קבוצה של מחשבים המחוברים ביניהם ופועלים יחד בצורה מתואמת, כך שבמובנים רבים הם יכולים להיחשב.
רקורסיות נושאי השיעור פתרון משוואות רקורסיביות שיטת ההצבה
1 מבוא למדעי המחשב משתנים. 2  סוגי משתנים בשפת C  ההבדלים בין סוגי המשתנים השונים.
1 נושאי התרגול : Copy constructor Assignment operator המרת טיפוסים אוטומטיות. תכנות גנרי - Templates.
תרגול 5 רקורסיות. רקורסיה קריאה של פונקציה לעצמה –באופן ישיר או באופן עקיף היתרון : תכנות של דברים מסובכים נעשה ברור ונוח יותר, מכיוון שזו למעשה צורת.
מבוא לשפת C חידות ונקודות חשובות נכתב על-ידי יורי פקלני. © כל הזכויות שמורות לטכניון – מכון טכנולוגי לישראל.
חורף - תשס " ג DBMS, צורות נורמליות 1 צורה נורמלית שלישית - 3NF הגדרה : תהי R סכמה רלציונית ותהי F קבוצת תלויות פונקציונליות מעל R. R היא ב -3NF.
11 Introduction to Programming in C - Fall 2010 – Erez Sharvit, Amir Menczel 1 Introduction to Programming in C תרגול
מבוא למדעי המחשב © אריק פרידמן 1 מצביעים כמערכים דוגמה.
תרגול חזרה. מבנה האובייקט תאר את מבנה האובייקט כולל מבנה טבלאות הפונקציות הוירטואליות עבור התכנית הבאה struct A { int x; virtual void a() {}; }; struct.
1 ++C: יוצרים, הורסים ואופרטורים. 2 המחלקה Stack תזכורת class Stack { private: int* array; int size, top_index; public: Result init (int size) ; void.
Formal Specifications for Complex Systems (236368) Tutorial #6 appendix Statecharts vs. Raphsody 7 (theory vs. practice)
חלון הפקודות מיועד לבצע פעולה אחת בכל פעם. כיצד אפשר לבצע רשימת פקודות או אפליקציות מורכבות ?
1 מבוא למדעי המחשב מבנה של תכנית. 2 מבנה של תכנית – חלוקה לקבצים  תכנית בשפת C הינה אוסף של הגדרות של:  משתנים (חיצוניים)  פונקציות  ניתן לפרוש תכנית.
תכנות תרגול 6 שבוע : תרגיל שורש של מספר מחושב לפי הסדרה הבאה : root 0 = 1 root n = root n-1 + a / root n-1 2 כאשר האיבר ה n של הסדרה הוא קירוב.
11 Introduction to Programming in C - Fall 2010 – Erez Sharvit, Amir Menczel 1 Introduction to Programming in C תרגול
תכנות תרגול 6 שבוע : הגדרת פונקציות return-value-type function-name(parameter1, parameter2, …) הגדרת סוג הערכים שהפונקציה מחזירה שם הפונקציהרשימת.
תכנות תרגול 10 שבוע : הקשר בין מערכים למצביעים נרצה לעמוד על הקשר בין מערך למצביע מאחר ומערכים הם הכללה של משתנים הרי שברור שלמערך ולכל אחד מאיבריו.
1 מבוא למדעי המחשב ארגומנטים לתוכנית בזמן ריצה קבצים הקדם מעבד Preprocessor טיפוסים סדורים Enumerated Types Typedef.
תרגול 8 היכרות עם ++C. C++ מעל שפת Cשפת תכנות שנבנתה מעל שפת C –כמעט כל תכנית ב -C היא גם תכנית ב C++ עד כדי מספר הבדלים קטן C99 שאימץ כמה מהתכונות C++
1 נושאי התרגול : תכנות גנרי - Templates ירושה ופולימורפיזם.
תכנות תרגול 5 שבוע : הגדרת פונקציות return-value-type function-name(parameter1, parameter2, …) הגדרת סוג הערכים שהפונקציה מחזירה שם הפונקציהרשימת.
מערכים עד היום כדי לייצג 20 סטודנטים נאלצנו להגדיר עד היום כדי לייצג 20 סטודנטים נאלצנו להגדיר int grade1, grade2, …, grade20; int grade1, grade2, …, grade20;
תכנות מונחה עצמים Object Oriented Programming (OOP) אתגר מחזור ב' Templates תבניות.
מבוא למדעי המחשב תרגול 3 שעת קבלה : יום שני 11:00-12:00 דוא " ל :
1 נושאי התרגול : Copy constructorCopy constructor Assignment operatorAssignment operator המרת טיפוסים אוטומטיות המרת טיפוסים אוטומטיות תכנות גנרי – Templates.
תוכנה 1 - תרגול שיעור 10 Pointers (2) שולי לב יהודי
תרגול 10: הכרות עם ++C היכרות עם ++C
מתמטיקה בדידה תרגול 2.
1 מבוא למדעי המחשב סיבוכיות. 2 סיבוכיות - מוטיבציה סידרת פיבונאצ'י: long fibonacci (int n) { if (n == 1 || n == 2) return 1; else return (fibonacci(n-1)
11 Introduction to Programming in C - Fall 2010 – Erez Sharvit, Amir Menczel 1 Introduction to Programming in C תרגול
תכנות תרגול 8 שבוע : מערכים עד היום התוכניות שלנו לא ידעו לשמור כמות גדולה של מידע ללא הגדרת כמות גדולה של משתנים. עד היום התוכניות שלנו לא.
אתחול עצמים. אתחולים ובנאים יצירת מופע חדש של עצם כוללת: הקצאת זכרון, אתחול, הפעלת בנאים והשמה לשדות במסגרת ריצת הבנאי נקראים גם הבנאי/ם של מחלקת הבסיס.
Structure. מה לומדים היום ? דרך לבנות מבנה נתונים בסיסי – Structure מייצר " טיפוס " חדש מתאים כאשר רוצים לאגד כמה משתנים יחד דוגמאות : עובד : שם, טלפון,
המשך תכנות מונחה עצמים 1. היום בתרגול  הורשה  שיטות מיוחדות  פולימורפיזם 2.
הגדרת משתנים יום שישי 18 ספטמבר 2015 יום שישי 18 ספטמבר 2015 יום שישי 18 ספטמבר 2015 יום שישי 18 ספטמבר 2015 יום שישי 18 ספטמבר 2015 יום שישי 18 ספטמבר.
פיתוח מערכות מידע Class diagrams Aggregation, Composition and Generalization.
Methods public class Demonstrate { public static void main (String argv[]) { public static void main (String argv[]) { int script = 6, acting = 9, directing.
מבוא למדעי המחשב לתעשייה וניהול הרצאה 7. סברוטינות subroutines.
תכנות מכוון עצמים ושפת ++C וויסאם חלילי. TODAY TOPICS: 1. Function Overloading & Default Parameters 2. Arguments By Reference 3. Multiple #include’s 4.
מבנים קרן כליף. ביחידה זו נלמד :  מהו מבנה (struct)  איתחול מבנה  השמת מבנים  השוואת מבנים  העברת מבנה לפונקציה  מבנה בתוך מבנה  מערך של מבנים.
1 תרגול 11: Design Patterns ומחלקות פנימיות אסף זריצקי ומתי שמרת 1 תוכנה 1.
עקרונות תכנות מונחה עצמים תרגול 11: OOP in C++. Outline  Where do the objects live ?  Inheritance  Slicing  Overriding vs Shadowing.
מחרוזות – הטיפוס String
מספרים אקראיים ניתן לייצר מספרים אקראיים ע"י הפונקציה int rand(void);
Object Oriented Programming
Object Oriented Programming
Computer Architecture and Assembly Language
Operators Overloading
Object Oriented Programming
Object Oriented Programming
מחלקות classes.
מבוא לתכנות מונחה עצמים Object Oriented Programming
מצביעים קרן כליף.
ניתוח מערכות מידע תכנות ב C#
סוגי משתנים קרן כליף.
מבוא לתכנות מונחה עצמים Object Oriented Programming
תוכנה 1 תרגול 13 – סיכום.
תכנות מכוון עצמים ו- C++ יחידה 02 העמסת פונקציות, ערכי ברירת מחדל, enum, קימפול מותנה קרן כליף.
Computer Programming תרגול 3 Summer 2016
Engineering Programming A
Presentation transcript:

תרגול 10: הכרות עם ++C ++C כ- C משופר מבוא לתכנות מערכות תרגול 10: הכרות עם ++C הכרות עם ++C ++C כ- C משופר

תוכנית ראשונה ב ++ C } // First C++ program הערות של שורה אחת // First C++ program #include <iostream.h> int main() { /* This is not a good program: we are not using C++ I/O */ printf(“Hello World\n”); // but notice the new style for // one line remarks: return 0; // comment till end of line }

הקצאת אובייקטים בודדים: מבוא לתכנות מערכות זיכרון דינמי ב ++ C תרגול 10: הכרות עם ++C הקצאת מערכים: [new type[# of elements להקצאת מערך. delete[] pointer to array לשחרור מערך int *pi = new int[5] ; if (pi == NULL) …. pi[3] = 6; delete[] pi ; הקצאת אובייקטים בודדים: new type במקום: malloc(sizeof(type)) delete pointer במקום: free (pointer) int *pi = new int ; if (pi == NULL) …. *pi = 6; delete pi ; אין צורך ב casting

ב ++C משתמשים ב-const כתחליף ל define# מבוא לתכנות מערכות ב ++C משתמשים ב-const כתחליף ל define# const int max = 100; const char digits[] = {‘0’,’a’,’2’,’c’,‘4’,’b’}; what happens when we try: “max = 5;”? מה יקרה במקרים הבאים ? digits[3] = ‘u’ ; //מותר? int* max2= &max ; // ? מותר const int* max2 = &max ; // פתרון int k; max2 = &k; // ? מותר שימוש נוסף הינו פרמטרים וערכי החזרה מפונקציות: int cparr (int* to, int size, const int* from); const char* getName (struct Person* p) ; תרגול 10: הכרות עם ++C const in C ++ מי שיקבל את המחרוזת שהפונקציה החזירה, לא לא יוכל לשנות אותה ישנם שמושים נוספים ל const, כאשר נרצה להעביר מצביעים לפונקציה ולהיות בטוחים שלא נשנה אותם, ב reference. . יתרון בקבלת ערך מפונקציה const - נרצה להבטיח שלר נוכל לשנות משהו מחוץ לפונקציה אך להעתיקו זה יקר. פתרון נחזיר כ const מצביע, הקומפיילר ידאג שלא נוכל לשנות. יתרון בפרמטר const - הקומפיילר יבטיח שלא נשנה ויותר חשוב לצרכי תעוד - נבטיח למשתמשים שלא נשנה. ! טוב לתיעוד ולקומפיילר

Reference reference הוא שם אחר למשתנה קיים. הביטוי &X משמעותו reference לטיפוס X (לא לבלבל עם &X שמשמעותו "הכתובת של משתנה X). reference חייב להיות מאותחל כאשר הוא נוצר כדי לדעת מי המשתנה הקיים שהוא "יתחפש" אליו. אתחול זה אינו השמה. לאחר האתחול לא ניתן להגיד ל-reference להתחפש למשתנה אחר - הוא "תקוע" עם מי שאתחל אותו. כל פעולה המופעלת על ה reference פועלת על המשתנה שהוא מהווה שם נוסף אליו. int i = 8 ; int &j = i; int x = i; i = 5 ; // j = 5 , x = 8 j++; // i = j = 6

Reference II ב-reference משתמשים בעיקר להעברת פרמטרים אל ומפונקציות. ב- C יכולנו להעביר רק את ערכם של הפרמטרים (call by value). ב- ++C נוכל להעביר את הפרמטרים עצמם. (call by reference). העברת פרמטרים גדולים by reference זולה יותר מהעברתם by value כי אין צורך להעתקם. swap in C void swap(int* p, int* q) { int t = *p ; *p = *q; *q = t ; } swap in C++ void swap(int& p, int& q) { int t = p ; p = q; q = t ; swap(x,y); // OK swap(x,5) ; // Error

דוגמא נוספת לשימוש ב reference מבוא לתכנות מערכות דוגמא נוספת לשימוש ב reference תרגול 10: הכרות עם ++C Int& arrayBounds (int* array, int size, int& max, int& min) { int i,sum = 0 ; max = min = array[0]; for (i=0 ; i<size; i++) { if (max < array[i]) max = array[i]; if (min > array[i]) min = array[i] ; sum += array[i] ; } return array[size/2] ; // what if returns sum ? דיון: מה יקבל max ומה יקבל min. מה יקרה אם נעשה int arr[] = {5,4,3,2,1} int x,n ; arrayBounds(arr,5,x,n); // x max, n min arrayBounds(arr,5,3,n); // error , expects a lvalue. // can be fixed if we used const & -just as a // performance enhancher. arrayBounds(arr,5,x,n) ++ ; // arr = {4,4,4,2,1} &arrayBounds(arr,5,x,n) - arr = ? // 2 had we returned sum ? A result of a computation ? - bad does not exist. When we return . Same as never return a poiter to a local variable. שמוש ב const מומלץ מאוד ורצוי מאוד להעזר אם רק אפשר. זהו idiom. ככה כותבים ב”רוח” השפה.

Function Overloading נניח נרצה לכתוב פונקציה המעלה בחזקה. מבוא לתכנות מערכות תרגול 10: הכרות עם ++C נניח נרצה לכתוב פונקציה המעלה בחזקה. double pow(double x, double y); בעיה - יעילות. נרצה מימוש שונה כאשר המעריך מטיפוס שלם. פתרון סטייל C: double pow_dd(double x, double y); double pow_di(double x, int y); int pow_ii(int x, int y); מה רע? פתרון סטייל ++C: double pow (double x, double y); double pow (double x, int y); int pow (int x, int y);

Function Overloading הפתרון שהוצג מסתמך על כך, שב ++C פונקציה מזוהה על פי שמה והפרמטרים שהיא מקבלת. כאשר ישנן מספר פונקציות בעלות שם זהה, הקומפיילר ינסה להחליט מהי הפונקציה ה”קרובה” ביותר מבחינת סוג הפרמטרים המועבר, ולה יקרא. אם הקומפיילר אינו מסוגל להחליט אזי הוא מוציא הודעת על שגיאת ambiguity - חוסר בהירות. בתהליך ההחלטה לא מתחשבים בטיפוס ערך ההחזרה של הפונקציה. מקובל להשתמש ב Function Overloading כאשר יש פונקציות המבצעות פעולה דומה על טיפוסים שונים (לדוגמא pow או print).

Function overloading resolution rules מבוא לתכנות מערכות תרגול 10: הכרות עם ++C 1 2 void print(int) ; void print(const char *) ; void print(double) ; void print(long ) ; char c; int i ; short s; float f; print( c ); print(i); print(s) ; print(f) ; print(‘a’); print(45); print(0.0) ; print (“a”); (what if we had void print (char*); instead ?) rules: 1. exact match (+trivial int ->int&, to const) . 2. match with promotions (char,short int -> int, float->double) . 3. match with conversions (int->float, float -> int) . 4. match with user defined type conversions. 5. match with ellipsis (…) 4 3

Default Parameters לעיתים פונקציה צריכה ברוב המקרים פרמטר בעל ערך קבוע, ורק במקרים נדירים ערך אחר. נרצה שבמקרה השכיח לא נצטרך להעביר את הפרמטר הנ”ל, אלא שזה יבחר באופן דיפולטי על ידי הקומפיילר. לדוגמא: הדפסת מספרים בבסיסים שונים. לרב הבסיס יהיה 10. void print_num(int num, int base = 10) ; void f() { print_num(24,7); print_num(12,10); // no need to send 10. print_num(12); }

Default Parameters מימוש של פונקציה עם פרמטרים דיפולטים הנו רגיל. ההבדל היחיד הנו באופן הקריאה. אם לא יסופק פרמטר אזי הפונקציה תקבל את הערך הדיפולטי. ניתן לתת ערכי ברירת מחדל רק לפרמטרים האחרונים: int f1(int a = 0, int b = 0, int c = 0); // Ok int f2(int a , int b = 0, int c = 0); // Ok int f3(int a = 0, int b = 0, int c); // Error int f4(int a = 0, int b, int c = 0); // Error את ערכי ברירת המחדל יש לכתוב פעם אחת בלבד (רצוי בהצהרה הראשונה על הפונקציה).

מימוש מבני נתונים מופשטים ב- ++C מבוא לתכנות מערכות תרגול 10: הכרות עם ++C מימוש מבני נתונים מופשטים ב- ++C

מבנה הנתונים מחסנית תזכורת מבוא לתכנות מערכות מבנה הנתונים מחסנית תזכורת תרגול 10: הכרות עם ++C מחסנית הינה מבנה נתונים התומך בפעולות הבאות: push - הוסף איבר למחסנית. pop - הוצא את האיבר ה”צעיר” ביותר במחסנית. top - החזר את האיבר ה”צעיר” ביותר במחסנית. ובנוסף: create - צור מבנה נתונים מסוג מחסנית (ריק). destroy - הרוס את מבנה הנתונים מחסנית. print - הדפס את תוכן מבנה הנתונים. דוגמא למימוש אפשרי: מערך + מצביע למקום הפנוי הבא 1 2 8 top

מימוש ב ++ C לעומת C ב-C כאשר הגדרנו ADT נעזרנו: בקובץ header אשר הכיל את הממשק: הוגדר בו הטיפוס של ה ADT והוגדרו בו פונקציות המטפלות ב ADT. בקובץ ה source הופיע המימוש של הפונקציות. ב ++C הוטמעה צורת עבודה זו בשפה, וניתן להגדיר טיפוסים (מחלקות) אשר כוללים בתוכם הן את השדות של כל משתנה מאותו טיפוס (אובייקט של אותה מחלקה) והן את הפונקציות (מתודות) המופעלות עליו.

מימוש ב-++ Header File :C enum Result {Success, Fail} ; struct Stack { int* array; int size, top_index ; } ; שדות data members Result init (int size) ; void destroy() ; Result push (int e); Result pop (); Result top(int& e); Result print() ; פונקציות של המחלקה method or member functions

גישה ישירה לשדות של ה- struct כאילו הם משתנים לוקליים מסמן שזוהי method של class Stack שם ה method מימוש ב ++C Source File Result Stack::init (int s) { if ((array = new int[s] )==NULL) return Fail; size = s; top_index = 0 ; return Success ; } void Stack::destroy () { delete[] array ; ערך מוחזר גישה ישירה לשדות של ה- struct כאילו הם משתנים לוקליים

מימוש ב ++C Source File Result Stack::push(int e) { if (top_index == size) return Fail ; array[top_index] = e; top_index ++ ; return Success; } Result Stack::pop () { if (top_index == 0) return Fail; top_index--; return Success; מימוש ב ++C Source File

מימוש ב ++C Source File Result Stack::top (int& e) { if (top_index == 0) return Fail; e = array[top_index-1]; return Success; }

קריאה לפונקציה מתבצעת בדיוק כמו גישה לשדה שימוש ב- Stack ב- ++C שימוש ב-Stack ב- C #include “Stack.h” int main() { Stack s ; int i; s.init (100) ; s.push (1); s.push(213); s.pop (); s.top(i); s .destroy (); } #include “Stack.h” int main() { Stack s ; int i; init (&s,100) ; push (s,1); push(s,213); pop (s); top(s,&i); destroy (s); } קריאה לפונקציה מתבצעת בדיוק כמו גישה לשדה

המתודה, לאחר שהקומפיילר הוסיף את המצביע this שימו לב לאופן השונה בו נקראו הפונקציות ב- C וב- ++C. ב- C נדרשנו להעביר מצביע לאובייקט (מבנה) עליו על הפונקציה לעבוד, בעוד שב- ++C לא העברנו פרמטר כזה, מצד שני קראנו לפונקציה של המחלקה (מתודה) באופן שונה: s.push(3); // calls push on object s with parameter 3 נשאלת השאלה - כיצד הפונקציה יודעת לאיזה אובייקט התכוונו כאשר קראו לה ? הפתרון: כאשר נקראת מתודה כלשהי נשלח לה פרמטר סמוי בשם this שטיפוסו הנו מצביע למחלקה בה מוגדרת המתודה, ומכיל מצביע לאובייקט עמו נקראה המתודה. בכל גישה לשדה של האובייקט או למתודה שלו מתוך מתודה אחרת הקומפיילר מוסיף הצבעה דרך this. void Stack::top(int& j) { j = array[top_index-1]; } void Stack::top(int& j) { j = this->array[this->top_index-1]; } המתודה, לאחר שהקומפיילר הוסיף את המצביע this

בעייה: גישה למשתנים ב ++C העבודה עם מחלקות מהווה את דרך העבודה העיקרית. הבעיה עם האופן בו הוגדרה קודם לכן המחלקה Stack הייתה כי כל פונקציה יכלה לגשת ישירות לשדות של אובייקטים מטיפוס Stack. בכדי למנוע זאת הוספו לשפה ה access modifier הקובעים למי מותר לגשת לאיזה חלק במחלקה. private - רק למתודות של המחלקה מותר לגשת לשדות פרטיים או לקרוא למתודות פרטיות. public - כל אחד יכול לגשת לחלק הציבורי. struct Stack { private: int* array; int size, top_index ; public: Result init (int size) ; Result destroy() ; Result push (int e); …. } ;

שמוש ב- class במקום ב- struct class Stack { int* array; int size, top_index; public: Result init (int size) ; Result destroy() ; Result push (int e); Result pop (); Result top(int& e); Result print() ; } ; מקובל להגדיר מחלקות ע”י המילה השמורה class ולא struct בה משתמשים לרוב לייצוג מבנים (מחלקות ללא מתודות). ההבדל בין struct ל class הנו כי ב- class, אלא אם כן צוין אחרת, מוד הגישה הנו private בעוד שב- struct המוד הדיפולטי הנו public.

Friend functions אם נרצה בכל זאת לאפשר לפונקציות אשר אינן מתודות של המחלקה גישה לחלק ה private של המחלקה, נוכל להגדירן כ- friend של המחלקה. נרצה לבצע זאת לרוב למען מימוש יעיל יותר של הפונקציה. class Stack { private: int* array; int size, top_index; friend int second (Stack); public: … int Second(Stack s) { if (s.top_index < 2) exit(1); return s.array[s.top_index-2]; }

Friend classes and Methods class A { …. int f() ; … }; class B { … class C { friend int A::f(); friend class B; בדומה ל friend function ניתן להגדיר גם method של מחלקה אחת כ- Friend של מחלקה אחרת. ניתן להגדיר מחלקה שלמה כחברה של מחלקה אחרת ואז כל ה- methods של אותה מחלקה יוכלו לגשת לחלק ה- private של המחלקה האחרת. השימוש ב Friends פוגע בקריאות התוכנה, ולכן מומלץ לא להשתמש בכך פרט למקרים יוצאי דופן. method f() of class A is a friend of class C all methods of class B are friends of class C

const member functions I מבוא לתכנות מערכות תרגול 10: הכרות עם ++C const member functions I כאשר מתודה אינה משנה את מצב האובייקט עליו היא נקראת (לדוגמא ()size במחלקה Stack) ניתן לציין זאת ע”י הוספת const בסוף ההצהרה על המתודה. הסיבה שרצוי לבצע זאת הנה כי עבור const objects מותר לקרוא רק ל const methods. class C { int read() const; void write(int j); … }; int func (const C& con, C& mut) { con.read () ; // ok con.write(5); // error mut.read(); // ok mut.write(5); // ok }

const member functions II class C { … inf f(); // will be called for non const objects int f() const; //will be called for const objects }; )ניתן לשנות שדות גם במתודה שהיא const אם השדות סומנו בתור mutable. לא רצוי לעשות זאת ללא סיבה טובה(.

member function overloading class calculator { … double pow(double, double); double pow(double, int); int pow(int, int); … יכולת זו שימושית במיוחד עבור constructors (בהם אולי כבר נתקלתם בהרצאות ושעליהם נעבור בתרגול הבא) ניתן להגדיר מספר constructors אשר כל אחד מקבל פרמטרים שונים וכך לאפשר מספר צורות אתחול.

inline functions I קריאה לפונקציות הנה פעולה בעלת תקורה יקרה. עבור פונקציות פשוטות חבל לשלם מחיר זה. ב-C היינו נעזרים ב MACRO. ב-++C נעזר ב inline function. inline function מוגדרת כפונקציה לכל דבר, אולם קומפיילר חכם יבחר לממש אותה בצורה שתמנע את התקורה של פונקציה רגילה. למשל, על ידי השתלת גוף הפונקציה בנקודת הקריאה בדומה למקרו. הדבר עלול לגרום לניפוח קוד ולא תמיד אפשרי (רקורסיה … ) אך לעתים קרובות מייעל את הקריאה לפונקציה.

inline functions II ניתן להגדיר inline function בשתי דרכים כחלק מהגדרת המחלקה: class Stack { int _size, top_index; int* array; public: int size() { return _size ;} להוסיף inline לפני המימוש. בכל מקרה על פונקציה זו להיות ממומשת ב-header file. int size() }; inline int Stack::size() { return _size ;}

מבוא לתכנות מערכות קלט / פלט ב ++C תרגול 10: הכרות עם ++C ב ++ C קלט ופלט מתבצע ע”י “הזרמת” נתונים באמצעות האופרטורים >> ו-<<. Input / Output in C++: #include <iostream.h> int j , k = 123; double d; cout << “A string” << k; cin >> j >> d; Input / Output in C: #include <stdio.h> int j,k = 123; double d; fprintf (stdout,“%s %d”, “A string” , k); fscanf (stdin, “%d %lf”, &j, &d); יתרונות ++C: הקומפיילר מזהה את טיפוסי המשתנים לבד (חוסך טעויות). בקלט, משתמשים במשתנים - לא בכתובותיהם (חוסך טעויות וגם יותר “נקי”).

ערוצים סטנדרטים ב-++ C הקלט והפלט ב-++C נעשה ע"י ערוצים (streams). ערוצים הם מחלקות מיוחדות המוגדרות כחלק מהספרייה הסטנדרטית של ++C. הקלט והפלט של עצם מתבצעים ע"י שימוש בפונקציות ואופרטורים המוגדרים עבור מחלקה זו. מחלקות אלו מוגדרות בקובץ iostream, ולכן על מנת להשתמש בהם צריכה להופיע בתחילת הקובץ השורה: #include <iostream> אופרטורי הקלט והפלט חכמים יותר מפקודות הקלט/פלט של שפת C בכך שאין צורך לציין את סוג המשתנים. ערוצי הפלט מוגדרים במחלקה ostream. קיימים שני ערוצי פלט סטנדרטיים: ערוץ הפלט הסטנדרטי - cout ערוץ הודעות השגיאה הסטנדרטי - cerr ערוצי הקלט מוגדרים ע"י המחלקה istream. קיים ערוץ קלט סטנדרטי אחד - cin .

קלט פלט ב ++C פלט מתבצע ע"י הזרמת נתונים לתוך ערוץ הפלט הרצוי. האופרטור המשמש להזרמת נתונים לתוך ערוץ פלט הוא ">>". ה"הזרמה" נעשית ע"י פקודה מהצורה: <ostream> << <data> ניתן גם להשתמש בפונקציה put על מנת לפלוט נתונים, בצורה הבאה: <ostream>.put(<data>); לדוגמא, נניח כי x הוא משתנה שלם וערכו 3, ו- y הוא משתנה ממשי שערכו 2.45 cout << "hello " << x << " " << (x+y); הדוגמה לעיל תדפיס: hello 3 5.45 קלט מתבצע ע"י שאיבת נתונים מתוך ערוץ הקלט. האופרטור המשמש לשאיבת נתונים מתוך ערוץ קלט הוא "<<". ה"שאיבה" נעשית ע"י פקודה מהצורה: <istream> >> <variable name> ניתן גם להשתמש בפונקציה get על מנת "לשאוב" נתונים, בצורה הבאה: <istream>.get(<variable name>); דוגמא: cin >> x >> y; קורא לתוך x את הנתון הראשון המופיע בקלט ולתוך y את הנתון השני המופיע בקלט.

דוגמא לקלט ופלט ערוצי הקלט וערוצי הפלט הם אובייקטים. ישנן מתודות נוספות אשר ניתן להפעיל על אובייקטים אילו. למשל: הפונקציה eof(), הבודקת אם בערוץ מופיע סימן סוף קובץ. דוגמא נוספת היא הפונקציה width() הקובעת את מספר התווים המינימלי אשר יודפסו בהדפסה הבאה של מחרוזת ומספר, והפונקציה fill() אשר קובעת את התו שיודפס במידה והמחרוזת/מספר קצרים מהנדרש. לדוגמא: cout.width(4); cout.fill(‘#’); cout<<“(“<<12<<“), (“ << 12 << “)\n”; הפלט המתקבל: ###(12),(12) דוגמא: תוכנית זאת קוראת את מה שמופיע בקלט תו אחר תו ומדפיסה את התוים עד שמופיע הסימן לסוף קובץ. #include <stream.h> main() { char x; while (!(cin.eof())) { cin >> x; cout << x; }

ערוצי קבצים שימוש בערוצי קבצים דומה למדי לשימוש בערוצי ק/פ. ערוצי הקבצים הם מחלקות הנורשות מערוצי הק/פ הרגילים ולכן כל הפעולות המוגדרות על ערוצים רגילים מוגדרים גם על ערוצי קבצים. מחלקות אלו מוגדרות בקובץ fstream.h, ולכן על מנת להשתמש בהם צריכה להופיע בתחילת הקובץ השורה: #include <fstream.h> ערוצי הקלט מקבצים מוגדרים ע"י המחלקה ifstream. למחלקה זו יש constructor המקבל כקלט מחרוזת ופותח את הקובץ ששמו ערך המחרוזת. ערוצי הפלט לקבצים מוגדרים ע"י המחלקה ofstream. למחלקה זו יש constructor המקבל כקלט מחרוזת ופותח את הקובץ ששמו ערך המחרוזת.

דוגמא לעבודה עם קבצים #include <fstream.h> void copy_file(char *a, char* b) { ifstream from(a); // Open the file a if(!from.is_open()) { // if(!from){ cerr << "cannot open file " << a; exit(1); } ofstream to(b); // Open the file b if(!to.is_open()) { // if(!to){ cerr << "cannot open file " << b; char c; while (!(from.eof())) { if (from.get(c)) to.put(c); דוגמא לעבודה עם קבצים

namespace בעייה ב-C: פרוייקט חולק בין מספר מתכנתים וכעת רוצים לחבר אותו לתוכנית אחת מתכנתים שונים השתמשו באותו שם לפונקציות שונות /* my.h */ …. void print_results(int, int); /* your.h */ …. void print_results(int, int);

namespace פתרון ב-++C: נעטוף כל חלק בתוכנית ברמת היררכיה נוספת /* my.h */ namespace my{ …. void print_results(int, int); } /* your.h */ namespace yours{ …. void print_results(int, int); } int main(){ my::print_results(4,5); …..

namespace ב C++ נהוג לכלול מחלקות סטנדרטיות בשמן בלבד, ללא h. בסוף. אם כוללים כך ספרייה סטנדרטית באופן זה, נכללת ספרייה מ-namespace הניקרא std. על מנת להשתמש ב-namespace זה עלינו להביא אותו במפורש ל-namespace הנוכחי לצורך תאימות לאחור ניתן לכלול מחלקות בסטנדרטיות עם h. ולעבוד ללא namespaces #include <iostream> using std::ostream;

mutable Definition: A C++ keyword that specifies that a member may be updated or modified even if it is a member of a const object. class Animal { private:      string name;      string food;      mutable int age; public:      void setAge(int age); }; main(){      const Animal Tiger("Fluffy,"Antelope",1);      Tiger.setAge(2);       /* The age of Tiger is updated to 2          even thought it is a const object          The name and food members cannot be updated          in the object Tiger because it is const. */ }