 שאלות ממבחנים - C++

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

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; }; מבוא לתכנות מערכות

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); } }; מבוא לתכנות מערכות

 סעיף ב ' (10 נקודות )  סעיף ב ' (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. מבוא לתכנות מערכות

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

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 {}; מבוא לתכנות מערכות

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

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 {}; מבוא לתכנות מערכות נוסיף למחלקה שתי פונקציות עזר ואת הגדרת החריגות המדויקות שנזדקק להן במימוש

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(); } מבוא לתכנות מערכות בזכות השימוש בחריגות בפונקציות העזר פונקציות הקוראות להן לא יצטרכו לבדוק את ערך החזרה עבור מקרי קצה נחסך הצורך בשימוש בערכי מספרים מיוחדים עבור מצביע השגיאה

Branch::Branch(string name, int number) : name(name), number(number) { for (int i=0; i<MAX_CARS; i++) { cars[i] = NULL; } void Branch::addCar(const Car& car) { if (contains(car)){ throw CarAlreadyInBranch(); } int index = findEmptySlot(); cars[index] = car.Clone(); return; } מבוא לתכנות מערכות ) ניתן לבנות סניף חדש בעזרת שם הסניף ומספרו 2) לקבל כלי רכב חדש - הפונקציה המתאימה תיצור עותק של כלי הרכב

void Branch::transferTo(Branch& branch, const Car& car) { removeCar(car); branch.addCar(car); } void Branch::transferFrom(Branch& branch, const Car& car) { branch.transferTo(*this, car); } void Branch::rentCar(Customer& customer, Car& car) { int index = findCarIndex(car); if (!isCarVacant(car)) { throw CarAlreadyRented(); } cars[index]->Rent(); customer.RentCar(car); } מבוא לתכנות מערכות ) להעביר כלי רכב לסניף אחר 5) לקבל כלי רכב מסניף אחר 6) להשכיר כלי רכב ללקוח

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

typedef T1; typedef T2; typedef T3; typedef T4; //... more code?... int main () { try { // משמעות + תוצאה T1 a1(12), a11(10); // הגדרת 2 מערכים של // בגודל 12 ו -10 double 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; // בגודל 5 double הגדרת מערך של T4 a4; // בגודל 8 double הגדרת מערך של 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 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; } מבוא לתכנות מערכות

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; } }; מבוא לתכנות מערכות

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]; } 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; } 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; } }; מבוא לתכנות מערכות

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; } template class ArraySize: public Array { public: ArraySize() : Array (SZ) {}; }; מבוא לתכנות מערכות

#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; }; מבוא לתכנות מערכות  מה מדפיסה התכנית הבאה ? int 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; return 0; }

 יודפס : A::A(A&) B::B(A) A::A(A&) C::C(A aa) C::~C() מבוא לתכנות מערכות A::A() A::A() A::A(A&) B::B(A) A::A(A&) B::B(B&)

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

#include "Array.h" #include "iostream.h" class A { int a; public: A(int aa = 0) : a(aa) {} }; 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; }

#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: //... }; מבוא לתכנות מערכות

// 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_ מבוא לתכנות מערכות