עקרונות תכנות מונחה עצמים תרגול 9:C++ - תרגילים

בשפת ++C ניתן להגדיר מתודות מסויימות במחלקה כוירטואליות, על ידי המילה השמורה virtual. בJava לא קיימת מילה שמורה כזו, ולא ניתן לציין שמתודה מסויימת היא וירטואלית. מדוע?   בJAVA אין מנגנון של דריסה (Overriding) , רק של העמסה (Overloading) ולכן אין צורך במתודות וירטואליות. בJAVA כל המתודות הן וירטואליות (ניתנות לדריסה) כברירת מחדל, ולכן אין צורך לציין זאת. מתודות וירטואליות הן פתרון לבעיית היהלום הנוצרת עקב הורשה מרובה, מנגנון שלא קיים בJava , לכן אין צורך בהן. בJava כל האובייקטים מוקצים על הHeap , ולכן אין צורך במתודות וירטואליות.

בשפת ++C ניתן להגדיר מתודות מסויימות במחלקה כוירטואליות, על ידי המילה השמורה virtual. בJava לא קיימת מילה שמורה כזו, ולא ניתן לציין שמתודה מסויימת היא וירטואלית. מדוע?   בJAVA אין מנגנון של דריסה (Overriding) , רק של העמסה (Overloading) ולכן אין צורך במתודות וירטואליות. בJAVA כל המתודות הן וירטואליות (ניתנות לדריסה) כברירת מחדל, ולכן אין צורך לציין זאת. מתודות וירטואליות הן פתרון לבעיית היהלום הנוצרת עקב הורשה מרובה, מנגנון שלא קיים בJava , לכן אין צורך בהן. בJava כל האובייקטים מוקצים על הHeap , ולכן אין צורך במתודות וירטואליות.

התבוננו בקטע הקוד הבא ,הכתוב ב++C , וסמנו את כל המשפטים הנכונים class A { /* class A definition… */ }; class B : public A { /* class B definition… */ }; void printA ( A a ) { /* Get a variable of type A and print it. */ } void main () { A* b = new B() ; A a; printA (a); printA(*b); } הקוד לא עובר קומפילציה b מצביע לאובייקט על הheap וa הוא אובייקט שנמצא בstack שתי השיטות להקצאת משתנים המופיעות בקוד(שורות 5 ו 6), קיימות גם בJava. הקוד עובר קומפילציה אבל תתרחש שגיאה בזמן ריצה. בקריאה לפונקציה בשורה 7 יתבצע Slicing בקריאה לפונקציה בשורה 8 יתבצע Slicing הקוד יעבור קומפילציה רק אם כל המתודות בA מוגדרות כוירטואליות. הקוד יעבור קומפילציה רק אם הפרמטר לפונקציה printA יהיה מצביע לA.

התבוננו בקטע הקוד הבא ,הכתוב ב++C , וסמנו את כל המשפטים הנכונים class A { /* class A definition… */ }; class B : public A { /* class B definition… */ }; void printA ( A a ) { /* Get a variable of type A and print it. */ } void main () { A* b = new B() ; A a; printA (a); printA(*b); } הקוד לא עובר קומפילציה b מצביע לאובייקט על הheap וa הוא אובייקט שנמצא בstack שתי השיטות להקצאת משתנים המופיעות בקוד(שורות 5 ו 6), קיימות גם בJava. הקוד עובר קומפילציה אבל תתרחש שגיאה בזמן ריצה. בקריאה לפונקציה בשורה 7 יתבצע Slicing בקריאה לפונקציה בשורה 8 יתבצע Slicing הקוד יעבור קומפילציה רק אם כל המתודות בA מוגדרות כוירטואליות. הקוד יעבור קומפילציה רק אם הפרמטר לפונקציה printA יהיה מצביע לA.

קראו את הקוד הבא, הכתוב ב++C : class B { public: void foo() { cout << " B:: foo ";} virtual void goo() { cout << " B::goo " ;} virtual void hoo() { cout << " B::hoo " ;} }; class D : public B{ void foo() { cout << " D:: foo ";} virtual void goo() { cout << " D::goo " ;} void moo(){ cout << "D::moo" ;}  

עבור כל אחת מהשורות הבאות כתבו מה יהיה הפלט עבור כל אחת מהשורות הבאות כתבו מה יהיה הפלט. במידה והשורה גורמת לשגיאה, ציינו איזו שגיאה. השורות נמצאות בפונקציה main, הסעיפים אינם תלויים זה בזה. int main(int argc, char** argv) { B* b = new D(); D* d = new D(); b->foo(); d->foo(); b->goo(); d->goo(); b->hoo(); d->hoo(); b->moo(); d->moo(); }  B::foo  D::foo  D::goo  B::hoo  Compilation Error  D::moo #include <iostream> class B { public: void foo() { std::cout << " B:: foo "; } virtual void goo() { std::cout << " B::goo "; } virtual void hoo() { std::cout << " B::hoo "; } }; class D : public B { void foo() { std::cout << " D:: foo "; } virtual void goo() { std::cout << " D::goo "; } void moo() { std::cout << "D::moo"; }

התבוננו בקוד הבא וסרטטו תרשים המייצג את תמונת הזיכרון בצורה המדוייקת ביותר: class Card { protected: const char sign; // ‘H’, ‘D’, ‘C’ or ‘S’ const int num; public: Card(char _sign, int _num) : sign(_sign), num(_num) {} }; class MagicCard : public Card { Card* replacement; MagicCard(char sign, int num, Card* _replacement) : Card(sign, num) , replacement(replacement) {}

התבוננו בקוד הבא וסרטטו תרשים המייצג את תמונת הזיכרון בצורה המדוייקת ביותר: class Card { protected: const char sign; const int num; …} class MagicCard : public Card { protected: Card* replacement; …} int main(int c, char** v) { Card *c1 = new Card(1, 'H'); char ch1 = 'D'; Card* mc2 = new MagicCard(2, ch1, c1); char* ch2 = new char('C'); int x = 4; MagicCard mc3(x, *ch2, mc2); Card c4 = mc3; } ‘C’ 4 ‘D’ c4: mc3: x: ch2: mc2: ch1: c1: C’ 2 ‘D’ 1 ‘H’ Stack Heap

התבוננו בקוד הבא וסרטטו תרשים המייצג את תמונת הזיכרון בצורה המדוייקת ביותר: class Card { protected: const char sign; const int num; …} class MagicCard : public Card { protected: Card* replacement; …} int main(int c, char** v) { Card *c1 = new Card(1, 'H'); char ch1 = 'D'; Card* mc2 = new MagicCard(2, ch1, c1); char* ch2 = new char('C'); int x = 4; MagicCard mc3(x, *ch2, mc2); Card c4 = mc3; delete c1; delete ch2; } c4: mc3: x: ch2: mc2: ch1: c1: ‘C’ 4 ‘D’ C’ 2 ‘D’ 1 ‘H’ Stack Heap

מה יהיה הפלט? class B1 { public: int x; B1() :x(1) {} int foo() { return x; } }; class B2 { B2() :x(2) {} class Derived : public B1, public B2 {}; int main(int argc, char** argv) { Derived *drv = new Derived(); std::cout << drv->foo(); } פלט: שגיאת קומפילציה

מה יהיה הפלט? class B1 { public: int x; B1() :x(1) {} int foo() { return x; } }; class B2 { B2() :x(2) {} class Derived : public B1, public B2 {}; int main(int argc, char** argv) { Derived *drv = new Derived(); std::cout << drv->B1::foo(); } פלט: 1

מה יהיה הפלט? class Base { protected: int arr[10]; public: int getA(int i) {return arr[i];} }; class B1: public Base { B1() { arr[0]=1; } class B2 : public Base { B2() { arr[0]=2; } class Derived : public B1, public B2 {}; int main(int argc, char** argv) { Derived *drv = new Derived(); std::cout << drv->getA(0); } פלט: שגיאת קומפילציה

מה יהיה הפלט? class Base { protected: int arr[10]; public: int getA(int i) {return arr[i];} }; class B1: virtual public Base { B1() { arr[0]=1; } class B2 : virtual public Base { B2() { arr[0]=2; } class Derived : public B1, public B2 {}; int main(int argc, char** argv) { Derived *drv = new Derived(); std::cout << drv->getA(0); } פלט: 2 When a base class is specified as a virtual base, a single copy of its data members is shared by all the classes that inherite it using virtual base.

מה יהיה הפלט? class Base { protected: int arr[10]; public: int getA(int i) {return arr[i];} }; class B1: virtual public Base { B1() { arr[0]=1; } class B2 : virtual public Base { B2() { arr[0]=2; } class Derived : public B2, public B1 {}; int main(int argc, char** argv) { Derived *drv = new Derived(); std::cout << drv->getA(0); } פלט: 1 Last one counts

מה יהיה הפלט? class Base { protected: int arr[10]; public: int getA(int i) {return arr[i];} }; class B1: virtual public Base { B1() { arr[0]=1; } class B2 : virtual public Base { B2() { arr[0]=2; } class Derived : public B2, public B1 {}; int main(int argc, char** argv) { Derived *drv = new Derived(); std::cout << drv->B1::getA(0); std::cout << drv->B2::getA(0); } פלט: 11 Remember Only a single copy of the base class Last one counts