תרגול מס' 13

13תרגול מס' - שאלות ממבחניםC++

2מבוא לתכנות מערכות - 234122

1שאלה .בשאלה זאת עליכם לסייע בכתיבת תוכנית לניהול צי רכב של חברת השכרה

( '10סעיף א)מחלקות )ממשקים ומימושים( 3: עליכם לכתוב נקודות Truck )מכונית פרטית(, Sedan סוגי מכוניות שהחברה משכירה: 3עבור

)רכב שטח(, כולן יורשות ממחלקת בסיס AllTerrain)מסחרית(, ו- )שגם אותה יש לכתוב(. דרישות:Carאבסטרקטית משותפת

לכל מכונית יש מספר רישוי ייחודי1.

לכל מכונית ניתן לדעת אם היא פנויה או בהשכרה אצל לקוח, וניתן לשנות מצב 2.זה מבחוץ.

ניתן להשוות מכוניות לפי מספר הרישוי3.

, Cloneכל אובייקט מכונית יוכל להכין מעצמו עותק, באמצעות פונקצית מחלקה 4.גם אם טיפוס האובייקט ידוע רק בזמן ריצה )כלומר – פולימורפיזם(. הפונקציה

תחזיר את כתובת המכונית החדשה.


פתרון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); }

};


- המשך1שאלה ( '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כל סניף יחזיק מערך של כלי הרכב שברשותו. המערך יכלול כלי רכב מכל 1.מספר כלי הרכב המקסימלי בסניף נתון ע"י קבוע.

לכל סניף יש שם ומספר סידורי.2.

:כל סניף יוכל3.לבדוק אם כלי רכב נתון פנוי. אם כלי הרכב לא 1(

ברשימה, זה ייחשב כאילו הוא אינו פנוי.לקבל כלי רכב חדש - הפונקציה המתאימה 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; // 1void addCar(const Car& car); // 2void removeCar(const Car& car); // 3void transferTo(Branch& branch, const Car& car); // 4 void transferFrom(Branch& branch, const Car& car); // 5void rentCar(Customer& customer, Car& car); // 6void returnCar(Customer& customer, Car& car); // 7

}; class BranchException : public exception {};


- המשך1שאלה ( '20סעיף ג)יש לממש את הפונקציות האחראיות לפעולות נקודות :

(8(, ו 6(, 5(, 4( , 2

:הנחיותיתכן צורך להגדיר משתני עזר ו/או פונקציות עזר נוספות במחלקות השונות. –

אם מגדירים פונקצית עזר, אין צורך לממש אותה, אלא רק לכתוב אב-טיפוס ולהסביר מה היא עושה.

אין להגדיר פונקציות או משתני מחלקה שלא מתחייבים מהדרישות, או –(1מהנחייה

(string )פרט, אולי, ל-STLאין להשתמש במבנים מ –


הוספת פונקציות עזר וחריגות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;

}

( ניתן לבנות סניף חדש 8בעזרת שם הסניף

ומספרו

( לקבל כלי רכב חדש - הפונקציה 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);

}

( להעביר כלי רכב לסניף 4אחר

( לקבל כלי רכב מסניף 5אחר

( להשכיר כלי רכב ללקוח6


2שאלה עליכם לממש מחלקות גנריות עבור "מערכים בטוחים". מערך בטוח הוא מערך המכיל מידע על אורכו, המאפשר הגנה מפני גלישה בשימוש. הגנריות מתבטאת בעובדה שהמימוש מאפשר ליצור

מערכים שונים עבור סוגי עצמים שונים. למשל, הפקודה array<double> vec(12)

של instance. כדי למנוע שכפול קוד ע"י הקומפיילר )לכל 12 בגודל doubleתיצור מערך של ואח"כ class arrayBase(, יש לאסוף את החלקים המשותפים במחלקת בסיס templateה-

לבצע הורשה:template <class T> class array: public arrayBase}...{

יש לממש מחלקות כדי שהתוכנית למטה תתבצע כפי שנדרש. שימו לב: בראש הקוד הושמטו שמות המחלקות; עליכם להשלים את הקוד. מומלץ לקרוא את כל הקוד לפני פתרון השאלה.

: הגדרת המחלקות: נקודות(15סעיף א )• עם מתודות סבירות לשימוש קל ונוח במערכים )כולל T4, ו-1T, 2T, 3Tהגדירו את המחלקות

קלט/פלט(. שימו לב כי יש להגדיר את כל שדות הנתונים ולהצהיר על כל הפונקציות הנדרשות. אין צורך לממש שום פונקציה. הגדירו גם את המחלקה לטיפול בחריגות.

: מימוש )חלק מהפונקציות של( המחלקות: נקודות(20סעיף ב )( אין צורך לאפס constructorsממשו את הפונקציות הבאות בכל מחלקה בה הן מופיעות: בנאים )

>>(, ופעולת אינדקס operator(, אופרטור פלט )destructorsערכים לא מאותחלים, הורסים )(operator.טפלו נכון בשגיאות ,)][


קוד השימוש במחלקותtypedef ........ T1; typedef ........ T2; typedef ........ T3; typedef ........ T4;//... more code? ... int main () {

try { // משמעות + תוצאהT1 a1(12), a11(10); //

מערכים של2הגדרת

// 10 ו-12בגודל doubleT2 a2(10); // 10 בגודל

int הגדרת מערך שלa2 = a11; // Syntax

errora1 = a11; // O.K.a1[5] = a2[4]; // O.K.cout << a1; // הדפסת

מערך שלםconst T1 ca1(a11); //

הגדרת מערך קבוע //

עם אתחולca1 = a11; // Syntax

errorca1[2] = a11[3]; //

Syntax errora11[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

errora4 = a3; // Syntax

errora1 = a4; // O.K.return 0;

}catch (Bad_Index exc) {

cerr << exc; //Bad-Index value is ... :פלט

}}


פתרוןtypedef Array<double> T1;typedef Array<int> T2;typedef SizedArray<double, 5> T3;typedef SizedArray<double, 8> 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 T>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<T>& 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 <class T>ostream& operator<< (ostream& out, const Array<T>& array) {

for (int i=0 ; i<array.getSize() ; i++)out << array[i] << ' ';return out << endl;

} template <class T>istream& operator>> (istream& in, Array<T>& array) {

for (int i=0 ; i<array.getSize() ; i++)in >> array[i];return in;

} template <class T,int SZ>class ArraySize: public Array<T>{public:

ArraySize() : Array<T>(SZ) {};};


3שאלה #include <iostream>using namespace std;template<class T>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 T>class B {public:

B(A<T> aa) : a(aa) { cout << "B::B(A)" << endl; }

B(const B& b) : a(b.a) { cout << "B::B(B&)" << endl; }

A<T> a;};class C: public B<int> {public:

C(A<int> aa) : B<int> (aa), a(aa) {cout << "C::C(A aa)" << endl; }

~C() { cout << "C::~C()" << endl; }A<int> a;

};

?מה מדפיסה התכנית הבאה

int main() {cout << "--1--" << endl;A<int> a;cout << "--2--" << endl;A<double> a1;cout << "--3--" << endl;B<int> b(a);cout << "--4--" << endl;B<int> b1(b);cout << "--5--" << endl;C c(a);cout << "--6--" << endl;B<int>& b2 = c;cout << "--7--" << endl;return 0;

}


פתרון:יודפס

--5--A::A(A&)A::A(A&)A::A(A&)B::B(A)A::A(A&)C::C(A aa)--6----7--C::~C()

--1--A::A()--2--A::A()--3--A::A(A&)A::A(A&)B::B(A)--4--A::A(A&)B::B(B&)


4שאלה הגדר מחלקה/מחלקות הנדרשות בקובץArray.h על מנת שקטע הקוד

הבא יעבור הידור )קומפילציה(. שים לב: רק הצהרת המחלקה/ות נדרשת - ללא מימוש הפונקציות. יש

להניח שבמימוש המחלקה ישנם מצביעים.


קטע הקוד#include "Array.h"#include "iostream.h"class A {

int a;public:

A(int aa = 0) : a(aa) {}};

int main() {Array<int> *a1 = new

Array<int>(3);//An array with 3 elements of

type intArray<double> arr[20];//An array of 20 Arrays, each

one of them //is of 100 elements of type

doubleArray<double> sum(100);//An Array of 100 elements of

type doubleArray<double> min(100);//An Array of 100 elements of

type doublesum[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<double> c_arr = sum;for (int i = 0; i < c_arr.size(); i+

+) {cout <<"Element #"<<i<<":

"<<c_arr[i]<<endl;}delete a1;Array<A> arr_A(7);Array<A> arr_A2 = arr_A;return 0;

}


פתרון#ifndef __ARRAY_H_#define __ARRAY_H_ template<class T>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 functionstemplate<class T>ostream& operator<<(ostream& out, const Array<T>& arr); template<class T>istream& operator>>(istream& inp, Array<T>& arr); // the next operators may be implemented as member functionstemplate<class T>bool operator<(const Array<T>& left, const Array<T>& right); template<class T>bool operator==(const Array<T>& left, const Array<T>& right); #endif //__ARRAY_H_

Documents

תרגול מס' 13