1. ממבחניםC שאלות ++

2. תכנות מונחה עצמים ו C++ (40 נקודות) בשאלה זאת עליכם לסייע בכתיבת תוכנית לניהול צי רכב של חברת השכרה. סעיף א' (10 נקודות): עליכם לכתוב 3 מחלקות (ממשקים ומימושים) עבור 3 סוגי מכוניות שהחברה משכירה: Sedan (מכונית פרטית), Truck (מסחרית), ו- AllTerrain (רכב שטח), כולן יורשות ממחלקת בסיס אבסטרקטית משותפת Car (שגם אותה יש לכתוב). דרישות: א. לכל מכונית יש מספר רישוי ייחודי ב. לכל מכונית ניתן לדעת אם היא פנויה או בהשכרה אצל לקוח, וניתן לשנות מצב זה מבחוץ. ג. ניתן להשוות מכוניות לפי מספר הרישוי ד. כל אובייקט מכונית יוכל להכין מעצמו עותק, באמצעות פונקצית מחלקה Clone, גם אם טיפוס האובייקט ידוע רק בזמן ריצה (כלומר – פולימורפיזם). הפונקציה תחזיר את כתובת המכונית החדשה.

3. class Car { int serNum; bool vacant; public: Car(int sn) : serNum(sn), vacant(true) {} virtual ~Car() {} bool operator==(const Car &car) const { return serNum == car.serNum; } void Rent() { vacant = false; } void Return() { vacant = true; } bool IsVacant() const {return vacant; } virtual Car* Clone() const = 0; }; פתרון סעיף א':

4. class Sedan: public Car{ public: Sedan(int num) : Car(num) {} virtual Car* Clone() const { return new Sedan(*this); } }; class Truck: public Car{ public: Truck(int num) : Car(num){} virtual Car* Clone() const { return new Truck(*this); } }; class AllTerrain: public Car{ public: AllTerrain(int num) : Car(num){} virtual Car* Clone() const { return new AllTerrain(*this); } };

5. סעיף ב' (10 נקודות): נתונה המחלקה Customer (לקוח) שהממשק שלה: class Customer{ string name; int id; const Car *pRentedCar; public: Customer(const string& n, int i); void RentCar(const Car& car); void ReturnCar(); }; עליכם לכתוב ממשק למחלקה Branch (סניף של החברה). אין צורך לממש את המחלקה Customer.

6. דרישות: 1.כל סניף יחזיק מערך של כלי הרכב שברשותו. המערך יכלול כלי רכב מכל 3 הסוגים. מספר כלי הרכב המקסימלי בסניף נתון ע"י קבוע. 2.לכל סניף יש שם ומספר סידורי. 3.כל סניף יוכל: 1)לבדוק אם כלי רכב נתון פנוי. אם כלי הרכב לא ברשימה, זה ייחשב כאילו הוא אינו פנוי. 2)לקבל כלי רכב חדש - הפונקציה המתאימה תיצור עותק של כלי הרכב 3)להוציא כלי רכב מהמלאי 4)להעביר כלי רכב לסניף אחר 5)לקבל כלי רכב מסניף אחר 6)להשכיר כלי רכב ללקוח 7)להחזיר כלי רכב מלקוח 8)ניתן לבנות סניף חדש בעזרת שם הסניף ומספרו 4.הנחיות נוספות: 1)עבור הדרישות הנ"ל, פרט לדרישה 1, אם כלי הרכב הנדון לא נמצא בסניף, יש להתריע על כישלון הפעולה. 2)אם לא ניתן להוסיף מכונית מפאת חוסר מקום, הפונקציה המתאימה צריכה להתריע על כישלון הפעולה. 3)עבור כל אחת מהדרישות, הפונקציה המתאימה צריכה להיות יחידה, כלומר, אמורה לטפל בכל שלושת טיפוסי כלי הרכב 4)כל הדרישות הנ"ל ימומשו ע"י פונקציות מחלקה.

7. class Branch { static const int MAX_CARS = 100; Car* cars[MAX_CARS]; string name; int number; public: // functionality Branch(string name,int number); // 8 ~Branch(); bool isCarVacant(const Car& car) const; // 1 void addCar(const Car& car); // 2 void removeCar(const Car& car); // 3 void transferTo(Branch& branch, const Car& car); // 4 void transferFrom(Branch& branch, const Car& car); // 5 void rentCar(Customer& customer, Car& car); // 6 void returnCar(Customer& customer, Car& car); // 7 }; class BranchException : public exception {}; פתרון סעיף ב':

8. סעיף ג' (20 נקודות): יש לממש את הפונקציות האחראיות לפעולות 2), 4), 5), 6), ו 8) הנחיות: 1)יתכן צורך להגדיר משתני עזר ו/או פונקציות עזר נוספות במחלקות השונות. אם מגדירים פונקצית עזר, אין צורך לממש אותה, אלא רק לכתוב אב-טיפוס ולהסביר מה היא עושה. 2)אין להגדיר פונקציות או משתני מחלקה שלא מתחייבים מהדרישות, או מהנחייה 1) 3)אין להשתמש במבנים מ STL (פרט, אולי, ל string)

9. class Branch { static const int MAX_CARS = 100; Car* cars[MAX_CARS]; string name; int number; int findCarIndex(const Car& car); bool contains(const Car& car); int findEmptySlot();... }; class CarAlreadyInBranch: public BranchException {}; class CarNotFound : public BranchException {}; class BranchFull : public BranchException {}; class CarNotRented : public BranchException {}; class CarAlreadyRented : public BranchException {}; פתרון סעיף ג': נוסיף למחלקה שתי פונקציות עזר, ואת הגדרת החריגות המדויקות שנזדקק להן במימוש.

10. int Branch::findCarIndex(const Car& car) { for(int i=0; i<MAX_CARS; i++) { if (cars[i] && *cars[i] == car){ return i; } throw CarNotFound(); } bool Branch::contains(const Car& car) { try { findCarIndex(car); return true; } catch (CarNotFound&) { return false; } int Branch::findEmptySlot() { for(int i=0; i<MAX_CARS; i++) { if (!cars[i]) { return i; } throw BranchFull(); } מימוש פונקציות העזר (לא נדרש בפתרון) לשימוש בחריגות יתרונות: פונקציות התלויות בפונקציות העזר לא יצטרכו לבדוק בצורה מפורשת את ערך ההחזרה אין צורך להשתמש בערכי מספרים מיוחדים למצבי השגיאה

11. Branch::Branch(string name, int number) : name(name), number(number) { for (int i=0; i<MAX_CARS; i++) { cars[i] = NULL; } 8) ניתן לבנות סניף חדש בעזרת שם הסניף ומספרו

12. void Branch::addCar(const Car& car) { if (contains(car)){ throw CarAlreadyInBranch(); } int index = findEmptySlot(); cars[index] = car.Clone(); return; } 2) לקבל כלי רכב חדש - הפונקציה המתאימה תיצור עותק של כלי הרכב

13. void Branch::transferTo(Branch& branch, const Car& car) { removeCar(car); branch.addCar(car); } 4) להעביר כלי רכב לסניף אחר 5) לקבל כלי רכב מסניף אחר void Branch::transferFrom(Branch& branch,const Car& car){ branch.transferTo(*this, car); }

14. void Branch::rentCar(Customer& customer, Car& car) { int index = findCarIndex(car); if (!isCarVacant(car)) { throw CarAlreadyRented(); } cars[index]->Rent(); customer.RentCar(car); } 6) להשכיר כלי רכב ללקוח

15. תכנות מונחה עצמים ו C++ (35 נקודות) מערכים בטוחים עליכם לממש מחלקות גנריות עבור "מערכים בטוחים". מערך בטוח הוא מערך המכיל מידע על אורכו, המאפשר הגנה מפני גלישה בשימוש. הגנריות מתבטאת בעובדה שהמימוש מאפשר ליצור מערכים שונים עבור סוגי עצמים שונים. למשל, הפקודה array vec(12) class arrayBase תיצור מערך של double בגודל 12. כדי למנוע שכפול קוד ע"י הקומפיילר (לכל instance של ה-template), יש לאסוף את החלקים המשותפים במחלקת בסיס class arrayBase ואח"כ לבצע הורשה: template class array: public arrayBase {...} יש לממש מחלקות כדי שהתוכנית למטה תתבצע כפי שנדרש. שימו לב: בראש הקוד הושמטו שמות המחלקות; עליכם להשלים את הקוד. מומלץ לקרוא את כל הקוד לפני פתרון השאלה. סעיף א (15 נקודות): הגדרת המחלקות הגדירו את המחלקות 1T, 2T, 3T, ו-T4 עם מתודות סבירות לשימוש קל ונוח במערכים (כולל קלט/פלט). שימו לב כי יש להגדיר את כל שדות הנתונים ולהצהיר על כל הפונקציות הנדרשות. אין צורך לממש שום פונקציה. הגדירו גם את המחלקה לטיפול בחריגות. סעיף ב (20 נקודות): מימוש (חלק מהפונקציות של) המחלקות ממשו את הפונקציות הבאות בכל מחלקה בה הן מופיעות: בנאים (constructors) - אין צורך לאפס ערכים לא מאותחלים, הורסים (destructors), אופרטור פלט (operator<<), ופעולת אינדקס (operator[]). טפלו נכון בשגיאות.

16. int main () { try { // משמעות + תוצאה T1 a1(12), a11(10); //בגודל 12 ו-10 double הגדרת 2 מערכים של T2 a2(10); // 10 בגודל int הגדרת מערך של a2 = a11; // Syntax error a1 = a11; // O.K. a1[5] = a2[4]; // O.K. cout << a1; // הדפסת מערך שלם const T1 ca1(a11); // הגדרת מערך קבוע עם אתחול ca1 = a11; // Syntax error ca1[2] = a11[3]; // Syntax error a11[3] = ca1[2]; // O.K. double c_array[] = {0.5, -7, 3.14, 0.3}; // "C הגדרת "מערך T1 a12(c_array, 4); // "C הגדרת מערך ואתחולו ע"י "מערך T3 a3; // בגודל 5double הגדרת מערך של T4 a4; // בגודל 8double הגדרת מערך של a3[1] = a4[2]; // O.K. a3 = a4; // Syntax error a4 = a3; // Syntax error a1 = a4; // O.K. return 0; } catch (Bad_Index exc) { cerr << exc; // Bad-Index value is... : פלט } typedef.................. T1; typedef.................. T2; typedef.................. T3; typedef.................. T4;......... more code?.........

17. typedef Array T1; typedef Array T2; typedef SizedArray T3; typedef SizedArray T4; class BadIndex { int index; public: BadIndex(int i):index(i){} friend ostream& operator<<(ostream& os, const BadIndex& b); }; ostream& operator<<(ostream& os, const BadIndex& b) { return os << “Array index “ << b.index << “ is out of bounds” << endl; } פתרון סעיפים א' ו-ב'

18. class ArrayBase { protected: int size; bool isLegal(int index) const { return index>=0 && index<size; } public: arrayBase(int sz): size(sz) { } int getSize() const { return size; } }; הגדרת המחלקה ArrayBase

19. template class Array: public ArrayBase { T* elements; void fillArray(T* data,int sz){ elements = new T[sz]; size = sz; for (int i=0;i<sz;i++) elements[i] = data[i]; } הגדרת המחלקה Array // to be continued (next slide)

20. public: Array(int sz):ArrayBase(sz), elements(new T[sz]) { } Array(const Array & array2) : ArrayBase(array2.size){ fillArray(array2.elements,size); } Array(T* array2, int sz):ArrayBase(sz) { fillArray(array2,size); } ~Array() { delete[] elements; } הגדרת המחלקה Array (המשך)

21. T& operator[](int i) { if (!isLegal(i)) throw BadIndex(i); return elements[i]; } const T& operator[](int i) const { if (!isLegal(i)) throw BadIndex(i); return elements[i]; } array& operator=(const array& other) { if (this == &other) return *this; delete[] elements; fillArray(other.elements,other.size()); return *this; } }; הגדרת המחלקה Array (סוף)

22. template ostream& operator & array) { for (int i=0;i< array.getSize();i++) out << array[i] << ' '; return out << endl; } template istream& operator>> (istream& in, Array & array) { for (int i=0;i<array.getSize();i++) in >> array[i]; return in; } פונקציות גלובליות רלוונטיות ל-Array

23. template class ArraySize: public Array { public: ArraySize():Array (SZ){}; }; הגדרת המחלקה array

24. חלק א' (15 נק') #include using namespace std; template class A { public: A() { cout << "A::A()" << endl;} A(const A& a) :i(a.i) { cout << "A::A(A&)" << endl;} private: T i; }; template class B { public: B(A aa): a(aa) { cout << "B::B(A)" << endl;} B(const B& b): a(b.a) { cout << "B::B(B&)" << endl;} A a; }; class C : public B { public: C(A aa): B (aa), a(aa) { cout << "C::C(A aa)" << endl;} ~C(){ cout << "C::~C()" << endl;} A a; }; רשמו את הפלט של התוכנית הבאה: void main() { cout << "--1--" << endl; A a; cout << "--2--" << endl; A a1; cout << "--3--" << endl; B b(a); cout << "--4--" << endl; B b1(b); cout << "--5--" << endl; C c(a); cout << "--6--" << endl; B & b2 = c; cout << "--7--" << endl; }

25. פתרון סעיף א': --1-- A::A() --5-- A::A(A&) B::B(A) A::A(A&) C::C(A aa) --2-- A::A() --3-- A::A(A&) B::B(A) --4-- A::A(A&) B::B(B&) --7-- C::~C() --6--

26. חלק ב' (15 נק') הגדר מחלקה/מחלקות הנדרשות בקובץ Array.h על מנת שקטע הקוד הבא יעבור הידור (קומפילציה). שים לב: רק הצהרת המחלקה/ות נדרשת - ללא מימוש הפונקציות. יש להניח שבמימוש המחלקה ישנם מצביעים.

27. חלק ב' (15 נק') #include "Array.h" #include "iostream.h" class A { public: A(int aa = 0) : a(aa) {} private: int a; }; int main () { Array *a1 = new Array (3); // An array with 3 elements of type int Array arr[20]; // An array of 20 Arrays, each one of them // is of 100 elements of type double Array sum(100); // An Array of 100 elements of type double Array min(100); // An Array of 100 elements of type double sum[0] = 10; sum[1] = 20; sum[2] = 30; for (int i = 0; i < 20; i ++) { cin >> arr[i]; sum += arr[i]; } cout << “Sum is:” << sum << endl; min = arr[0]; for (i = 1; i < 20; i ++) if (arr[i] < min) min = arr[i]; cout << “Min is: ” << min << endl; if (min == arr[0]) cout <<“The first Array is the minimum” <<endl; const Array c_arr = sum; for (int i = 0; i < c_arr.size() ; i ++){ cout <<“Element #” << i << “: “ << c_arr[i] <<endl; } delete a1; Array arr_A(7); Array arr_A2 = arr_A; return 0; }

28. פתרון חלק ב' #ifndef __ARRAY_H_ #define __ARRAY_H_ template class Array { public: Array(int size=100); const T& operator[](int i) const; T& operator[](int i); Array& operator+=(const Array& arr); int size() const; Array(const Array& src); Array& operator=(const Array& src); ~Array(); private: //... };

29. פתרון חלק ב' (המשך) // the next operators are global functions template ostream& operator & arr); template istream& operator>>(istream& inp, Array & arr); // the next operators may be implemented as member functions template bool operator & left, const Array & right); template bool operator==(const Array & left, const Array & right); #endif //__ARRAY_H_