1 ++C: יוצרים, הורסים ואופרטורים. 2 המחלקה Stack תזכורת class Stack { private: int* array; int size, top_index; public: Result init (int size) ; void.

Slides:



Advertisements
Similar presentations
Object Oriented 33 MCSD DORON AMIR
Advertisements

ממיבחניםC שאלות ++.
תוכנה 1 סמסטר א ' תשע " ב תרגול מס ' 7 * מנשקים, דיאגרמות וביטים * לא בהכרח בסדר הזה.
מבוא למדעי המחשב לתעשייה וניהול
בתרגול הקודם הורשה: –ניתן להרחיב רק מחלקה אחת –כל מה שלא private – עובר בהורשה –המילה השמורה super –יצירת היררכיה –Object היא שורש ההיררכיה –דריסה אופרטור.
האוניברסיטה העברית בירושלים
מבוא למדעי המחשב לתעשייה וניהול דוגמאות ותרגול נוסף במערך חד ממדי הרצאה 12.
Pointers הרצאה קריטית. השאלות הפתוחות מה זה ה- & שמופיע ב scanf מדוע כשמעבירים מחרוזת ל scanf אין צורך ב & האם ניתן להכריז על מערך שגדלו אינו ידוע בתחילת.
תרגול 8 היכרות עם ++C. C++ מעל שפת Cשפת תכנות שנבנתה מעל שפת C CC++ –כמעט כל תכנית ב -C היא גם תכנית ב C++ עד כדי מספר הבדלים קטן C99C שאימץ כמה מהתכונות.
תכנות מונחה עצמים Object Oriented Programming (OOP) אתגר מחזור ב'
רקורסיות נושאי השיעור פתרון משוואות רקורסיביות שיטת ההצבה
1 מבוא למדעי המחשב משתנים. 2  סוגי משתנים בשפת C  ההבדלים בין סוגי המשתנים השונים.
1 נושאי התרגול : Copy constructor Assignment operator המרת טיפוסים אוטומטיות. תכנות גנרי - Templates.
תרגול 5 רקורסיות. רקורסיה קריאה של פונקציה לעצמה –באופן ישיר או באופן עקיף היתרון : תכנות של דברים מסובכים נעשה ברור ונוח יותר, מכיוון שזו למעשה צורת.
שאלות חזרה לבחינה. שאלה דיסקים אופטיים מסוג WORM (write-once-read-many) משמשים חברות לצורך איחסון כמויות גדולות של מידע באופן קבוע ומבלי שניתן לשנותו.
מבוא לשפת 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)
חלון הפקודות מיועד לבצע פעולה אחת בכל פעם. כיצד אפשר לבצע רשימת פקודות או אפליקציות מורכבות ?
תכנות תרגול 6 שבוע : תרגיל שורש של מספר מחושב לפי הסדרה הבאה : root 0 = 1 root n = root n-1 + a / root n-1 2 כאשר האיבר ה n של הסדרה הוא קירוב.
אתחולים ובנאים יצירת מופע חדש של עצם כוללת : הקצאת זכרון, אתחול, הפעלת בנאים והשמה לשדות במסגרת ריצת הבנאי נקראים גם הבנאי / ים של מחלקת הבסיס תהליך זה.
1 Formal Specifications for Complex Systems (236368) Tutorial #1 Course site : T.A. :Emilia Katz.
תרגול 10: הכרות עם ++C ++C כ- C משופר
תרגול 8 היכרות עם ++C. C++ מעל שפת Cשפת תכנות שנבנתה מעל שפת C –כמעט כל תכנית ב -C היא גם תכנית ב C++ עד כדי מספר הבדלים קטן C99 שאימץ כמה מהתכונות C++
1 נושאי התרגול : תכנות גנרי - Templates ירושה ופולימורפיזם.
תכנות תרגול 5 שבוע : הגדרת פונקציות return-value-type function-name(parameter1, parameter2, …) הגדרת סוג הערכים שהפונקציה מחזירה שם הפונקציהרשימת.
C++: יוצרים, הורסים ואופרטורים. המחלקה Stack - תזכורת class Stack { private: int* array; int size; int topIndex; public: Result init (int size); void.
מערכים עד היום כדי לייצג 20 סטודנטים נאלצנו להגדיר עד היום כדי לייצג 20 סטודנטים נאלצנו להגדיר int grade1, grade2, …, grade20; int grade1, grade2, …, grade20;
עקרון ההכלה וההדחה.
תכנות מונחה עצמים Object Oriented Programming (OOP) אתגר מחזור ב' Templates תבניות.
תחשיב היחסים (הפרדיקטים)
1 נושאי התרגול : Copy constructorCopy constructor Assignment operatorAssignment operator המרת טיפוסים אוטומטיות המרת טיפוסים אוטומטיות תכנות גנרי – Templates.
© המרכז להוראת המדעים האוניברסיטה העברית בירושלים
תרגול 10: הכרות עם ++C היכרות עם ++C
מתמטיקה בדידה תרגול 2.
11 Introduction to Programming in C - Fall 2010 – Erez Sharvit, Amir Menczel 1 Introduction to Programming in C תרגול
Sscanf example #include int main () { char sentence []="Rudolph is 12 years old"; char str [20]; int i; sscanf (sentence,"%s %*s %d",str,&i); printf ("%s.
אתחול עצמים. אתחולים ובנאים יצירת מופע חדש של עצם כוללת: הקצאת זכרון, אתחול, הפעלת בנאים והשמה לשדות במסגרת ריצת הבנאי נקראים גם הבנאי/ם של מחלקת הבסיס.
המשך תכנות מונחה עצמים 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.
Object Oriented Programming
Object Oriented Programming
תכנות מכוון עצמים ו- C++ יחידה 11 תבניות - templates
Object Oriented Programming
Object Oriented Programming
מחלקות classes.
הורשה ופולימורפיזם צורה ריבוע משושה עיגול תרגול 13: ירושה
מבוא לתכנות מונחה עצמים Object Oriented Programming
מצביעים קרן כליף.
Static and enum קרן כליף.
תכנות מכוון עצמים ו- C++ יחידה 04 constructors, destructor
תכנות מכוון עצמים בשפת JAVA
ממשקים - interfaces איך לאפשר "הורשה מרובה".
ניתוח מערכות מידע תכנות ב C#
תכנות מכוון עצמים ושפת JAVA
סוגי משתנים קרן כליף.
מבוא לתכנות מונחה עצמים Object Oriented Programming
תוכנה 1 תרגול 13 – סיכום.
תכנות מכוון עצמים ו- C++ יחידה 02 העמסת פונקציות, ערכי ברירת מחדל, enum, קימפול מותנה קרן כליף.
Computer Programming תרגול 3 Summer 2016
Engineering Programming A
Presentation transcript:

1 ++C: יוצרים, הורסים ואופרטורים

2 המחלקה Stack תזכורת class Stack { private: int* array; int size, top_index; public: Result init (int size) ; void destroy() ; Result push (int e); Result pop (); Result top(int& e); Result print() ; } ; class Stack { private: int* array; int size, top_index; public: Result init (int size) ; void destroy() ; Result push (int e); Result pop (); Result top(int& e); Result print() ; } ; init ומה יקרה אם המשתמש ישכח לקרוא ל- destroyאו ל- ???

3 יוצרים והורסים הבעיה - בהגדרת הטיפוס אנו משאירים פתח לטעויות של המשתמש היכול לשכוח לאתחל אובייקטים לפני השימוש בהם ( לא לקרוא ל init) דבר העלול לגרום לכך שהתוכנית תתנהג באופן בלתי צפוי, או לשכוח להרוס אובייקט וכך לגרום לדליפת זיכרון. יתר על כן, פעמים רבות נוצרים אובייקטים זמנים ( למשל, בהעברת והחזרת פרמטרים מפונקציות ) שאין למשתמש יכולות לאתחלם בצורה מפורשת. הפתרון –פונקציות אתחול והריסה שנקראות אוטומטית כאשר האובייקט נוצר וכאשר הוא אמור להיהרס. מעתה, בכל פעם שנגדיר משתנה מטיפוס Stack נדרש להעביר ליוצר את הפרמטרים הדרושים לצורך אתחול האובייקט, ובכל פעם שהאובייקט לא יהיה נגיש יותר הקומפיילר יקרא להורס אשר ישחרר את האובייקט. שמות היוצרים (constructors) כשם המחלקה. שם ההורס (destructor) כשם המחלקה שלפניה ~. class Stack { private: int* array; int size, top_index ; public: Stack (int size) ; ~Stack() ; ~Stack() ; …

4 Stack::Stack (int s) { array = new int[s] ; // חסרה בדיקה top_index = 0; size = s ; } Stack::~Stack() { delete[] array; } מימוש Constructors ו Destructors שימו לב C ’ tor ו D ’ tor לא מחזירים ערכים ! הערה : כמעט לכל מחלקה נדרש להגדיר יוצרים לאתחול שדותיה. הגדרת הורסים תתבצע בד ” כ עבור מחלקות המקצות זיכרון דינמי בעצמן. במקרה זה על ההורס לשחררו. אם איננו מגדירים יוצרים והורסים, מוגדרים אוטומטית יוצרים והורסים דיפולטיים.

5 שימוש במחסנית שיש לה יוצרים והורסים #include “Stack.h” int main() { int i; Stack s(100) ; // the c’tor is called with size 100 Stack* ps = new Stack(100); // same here if (ps == NULL) exit(1); s.push (1); s.push(213); s.pop (); s.top(i); ps->push(1); ps->push(2); ps->pop() ; delete ps ; // the d’tor is called for ps } // the d’tor is called for s

6 זמני קריאה של יוצרים והורסים קיימות 4 דרכים להקצאת משתנים. זמני הקריאה של היוצרים וההורסים תלויים באופן שבו הוקצה האובייקט. משתנים לוקאליים היוצר נקרא בכל פעם שהתוכנית מגיעה להכרזת המשתנה. ההורס בכל פעם שהתוכנית יוצאת מהתחום בו הוגדר המשתנה משתנים גלובאליים היוצר נקרא עם תחילת התוכנית ( לפני ה -main). ההורס עם סיום התוכנית ( לאחר סיום main). משתנים דינמיים היוצר נקרא בכל פעם שמוקצה אובייקט ע ” י new. ההורס בכל פעם שאובייקט משוחרר ע ” י delete. משתנים סטאטיים היוצר נקרא בפעם הראשונה שהתוכנית מגיע לתחום בו מוגדר המשתנה. ההורס עם סיום התוכנית.

7 דוגמא לזמני קריאה #include “Stack.h” Stack glbals(100); // globals c’tor is called int main() { Stack locals(50) ;// locals c’tor is called Stack* ps = new Stack(600); // ps c’tor is called Stack* ps2 = new Stack(600); // ps2 c’tor is called delete ps ;// ps destructor is called return 0;// locals destructor is called } // globals destructor is called // ps2 destructor is never called !

8 Advanced C ’ tors and D ’ tors class TwoStack.. { Stack s1, s2 ; public : TwoStack(int s) ;.. }; TwoStack::TwoStack (int size) : s1(100), s2(size * 5) { … } בכדי להקצות מערכים של אובייקטים ממחלקה כלשהי, לאותה מחלקה נדרש שיהיה יוצר שלא מקבל פרמטרים (או שיש לו ערכים דיפולטיים לכל הפרמטרים שלו כך שאין צורך לציין פרמטרים במפורש). ניתן להגדיר מחלקות אשר יש בהן שדות שהם עצמם עצמים של מחלקות אחרות. במקרה זה: –כאשר נוצר אובייקט של המחלקה, ראשית מאותחלים כל שדותיו. כאשר נהרס אובייקט כזה, ראשית נקרא ההורס שלו ורק אח”כ של שדותיו. –אם יוצרי השדות זקוקים לפרמטרים ניתן לבצע זאת ע”י רשימת אתחול.

9 רשימות אתחול הדרך המקובלת לאתחול שדות פנימיים של מחלקה. מייד אחרי הצהרת היוצר ולפני גוף היוצר (החלק שבתוך ה-{}) מופיעות נקודותיים ואז רשימה של השדות הפנימיים, כשהם מופרדים על ידי פסיקים. כל מופע של שדה ברשימת האתחול הוא למעשה קריאה לאחד מהיוצרים של השדה. לכל שדה כותבים בסוגריים את הערכים שמעבירים ליוצר שלו (ויכולים להיות תלויים בפרמטרים שהועברו ליוצר הראשי). סדר הפעלת היוצרים אינו הסדר בו הם מופיעים ברשימת האתחול אלא בו השדות מופיעים בהגדרת המחלקה. רשימת אתחול כדאית על פני "אתחול" בתוך הפונקציה כיוון שחוסכים אתחול ראשוני בזבל.

10 Copy constructor & Assignment operator מה קורה כאשר מבצעים s1 = s2? מה קורה כאשר מבצעים Stack s1 = s2? מה ההבדל? מה הסכנה? מה קורה כאשר קוראים לפונקציה: f(Stack s) ; f(Stack& s) ; פתרון copy c’tor - לאתחול, assign. Op. - להשמה

11 Copy constructor & Assignment operator עבור כל מחלקה חדשה, מוגדרות באופן אוטומטי שתי פונקציות : copy constructor - זהו c’tor המשמש לאתחול של עצם אחד של המחלקה ע " י עצם אחר של אותה מחלקה. פונקציה זו גם משמשת לאתחל פרמטרים בקריאה לפונקציות, כלומר כאשר מעבירים פרמטר מסוג מחלקה מסוימת by value, ערכי השדות של הפרמטרים מאותחלים ע " י קריאה לפונקציה זאת ( כנ " ל לגבי החזרת ערכים ). ה - prototype של פונקציה זו עבור מחלקה X הוא : X(const X&) מובטח שלא נשנה את הפרמטר המועבר אי אפשר להגדיר copy constructor באמצעות copy constructor

12 Copy constructor & Assignment operator אופרטור ההשמה (=) - פונקציה זו משמשת להשמה של עצמים מהמחלקה זה לזה פרט לאתחול של עצם אחד של המחלקה ע " י עצם אחר של אותה מחלקה ( במקרה של אתחול ייקרא ה -copy c’tor, אפילו אם משתמשים בסימן = בביצוע האתחול ). בשני המקרים, בפונקצית ברירת המחדל ההעתקה היא איבר איבר. יש מקרים שבהם העתקה איבר איבר אינה טובה ( למשל, במקרה בו יש מצביעים כשדות במחלקה ). במקרים האלה, על המשתמש להגדיר פונקציות אלו מחדש ( דוגמא להגדרה מחדש של אופרטורים אלו נראה במחלקה Stack בהמשך )

13 Copy constructor & Assignment operator כלל אצבע : בכל מחלקה בה יש שדות שהם מצביעים, יש להגדיר מחדש : Copy Constructor Assignment Operator Destructor

14 The Final Stack class Stack { int* array; int top_index, size; public: Stack (int s = 100) ; Stack (const Stack&) ; Stack& operator=(const Stack&); ~Stack() ; Result push(int e); Result pop() ; Result top(int& e); void print() ; };

15 Copy constructor Stack::Stack(const Stack & st) { array = new int [st.size]; if (array == 0) error(“out of memory”); // assumes error exits size = st.size; top_index = st.top_index; for (int top = 0 ; top<st.top_index; top++) array[top] = st.array[top]; }

16 Assignment operator Stack& Stack::operator=(const Stack& st) { if (this == &st) return *this; if (st.size != size) { delete[] array; array = new int[size = st.size]; } for (int top = 0 ; top<st.top; top++) array[top] = st.array[top]; top_index = top; return *this ; } חמשת הצעדים: בדיקת הצבה עצמית שחרור משאבים הקצאת משאבים חדשים אתחול השדות החזרת this*

17 class String { int len;// length of string char* val;// value of string void enter(const char*); public: String();// String x; String(const char*);// String x = "abc” String(const String&);// String x = y; String& operator=(const String&);// x = y; String& operator=(const char*);// x = “abc”; ~String(); int len() const { return len; }// x.len() char operator[](int i) const ;// c = x[1] char& operator[](int i);// x[1] = ‘d’ String& operator+=(const String&);// x+=y friend bool operator==(const String&, const String&); // if (x == y) friend bool operator!=(const String&, const String&); // if (x != y) friend ostream& operator<<(ostream&, const String&);// cout << x; }; String.h

18 #include error(const char* st) { cerr << st << '\n'; exit (1); } void String::enter(const char* st) { if (val) delete[] val; // if string exists if (st == 0) // Null pointer val = 0 ; else if (val = new char[strlen(st)+1]) { strcpy(val, st); len = strlen(st); } else error("String: out of memory"); } String.cc (1)

19 String::String() { len = 0; val = 0;// Null pointer } String::String(const char* st) { len = 0; val = 0; enter(st); } String::String(const String& st) { len = 0; val = 0; enter(st.val); } String::~String() { if (val) delete[] val; } String.cc (2) למה קובעים את val ל 0 לפני הקריאה ל enter?

20 String& String::operator=(const char* st) { enter(st); return *this; } String& String::operator=(const String& st){ if (this!= &st) enter(st.val); return *this; } String.cc (3) בדיקת הצבה עצמית

21 char& String::operator[](int i) { if ((i len)) error("String: index out of range"); return val[i]; } char String::operator[](int i) const { if ((i len)) error("String: index out of range"); return val[i]; } String.cc (4)

22 String& String::operator+=(const String& st) { char* p; if (st.len == 0) return *this ; if ( (p = new char[len+st.len+1]) == 0) error (“String: out of memory”); strcpy(p,val); strcat(p,st.val); enter(p); delete[] p; return *this ; } String.cc (5)

23 bool operator==(const String& x, const String& y){ return !strcmp(x.val, y.val) ; } bool operator!=(const String& x, const String& y) { return !(x == y); } ostream& operator<<(ostream& os,const String& st) { if(st.val) os << st.val; return os; } String.cc (6)

24 String תוכנית הנעזרת ב int main() { String a; String b(“1234"); String c = b; // Copy constructor a = "kookoo"; // operator=(const char*) is called cout << a << "\n"; // kookoo is printed a = c; // operator=(const String&) is called cout << a << "\n";// 1234 is printed a+=b; cout << a << "\n"; // is printed c="oooo";// If the copy constructor or assignment // were not redefined, b or a would be // changed as well }

25 Class String: important points שימוש בפונקציה אחת שעושה את כל העבודה האמיתית בבניה (enter) וכל השאר רק קוראות לה. דבר זה מאפשר גמישות למשתמש במחלקה תוך הימנעות מכתיבת קוד מרובה אצל המיישם. העובדה כי const הינו חלק מחתימת ה method. מדוע האופרטורים == ו =! הינם פונקציות גלובליות בעוד =+ ו [] הינם methods. אופרטור הפלט.

26 Class String: points to improve לא השתמשנו ברשימת אתחול ב-c’tors String::string(): val(0), len(0){} יותר מדיי פונקציות חברות, מחלקה צריכה להיות כמה שיותר סוציומטית. אפשר להוסיף פונקציות פנימיות נוספות על מנת שפונקציות ההשוואה לא יצטרכו לגשת לשדות. נחליף את: char operator[] (int i) const; const char& operator[](int i) const;ב-

27 מומלץ מאוד!!!