תרגול מס' 13

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

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

1שאלה ( מבנה הנתונים תורqueue( הוא מבנה הדומה למחסנית )stack.שנלמדה בקורס )

( וניתן להסיר את האיבר שבראש התור enqueueלתור ניתן להוסיף איברים )ע"י פעולה הנקראת (dequeue.)(, כלומר האיבר הוותיק ביותר בתור )בניגוד למחסנית בה באיבר שמוסר הוא האחרון שנוסף

:כלומר מבנה הנתונים תור צריך לתמוך בפעולות הבאותיצירה של תור חדש.1.

הריסה של תור קיים.2.

העתקה של תור קיים.3.

השמה מתור א' לתור ב'. כך שלאחר הפעולה שני התורים יהיו זהים.4.

הוספת איבר לסוף התור.5.

הסרת האיבר הראשון בתור.6.

.QueueEmptyאם התור ריק תיזרק חריגה מסוג •

החזרת האיבר הראשון )הוותיק ביותר( בתור. יש להחזיר את האיבר עצמו ללא העתקה.7.

.QueueEmptyגם במקרה זה אם התור ריק תיזרק חריגה מסוג •

++ ממשו תור גנרי בשפתC.הקפידו לכתוב רק את הקוד הדרוש .

stdניתן להשתמש ב-– list∷ ++ של שפתC-כמו שנלמד בתרגול על ה STL.


- פתרון1שאלה template<typename T>

class Queue {

std::list<T> items;

public:

class QueueEmpty: public std::exception {};

void enqueue(const T& t) {

items.push_back(t);

}

void dequeue() {

if (items.empty())

throw QueueEmpty();

items.pop_front();

}

T& front() { return items.front(); }

const T& front() const { return items.front(); }

};


2שאלה

:נתונות שתי המחלקות הבאות

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

כך שהפלט המודפס בהרצת הקוד שונה כאשר Aומשתמש במחלקה מקמפלים אותו עם כל אחת מהמחלקות הנתונות.

class A {public:

void f() {cout << "1" <<

endl;}

};

class A {public:

virtual void f() {cout << "1"

<< endl;}

};


- פתרון2שאלה

class B : public A {

public:

void f() {

cout << "2" << endl;

}

};

int main(int argc, char **argv) {

A* a = new B();

a->f();

return 0;

}


3שאלה

הנכם נדרשים להרחיב את המחלקהString עליכם 10 כפי שנלמדה בתרגול .( כך שהקוד reverse iteratorלהוסיף תמיכה באיטרטור אשר נע לכיוון הנגדי )

.cbaהבא יתקמפל והפלט המתקבל בהרצתו יהיה #include "string.h"

int main() {String s("abc");

for (String::reverse_iterator i = s.rbegin(); i != s.rend(); ++i) {

std::cout << *i;}return 0;

}

הוסיפו וממשו את ההגדרות המתאימות עבור הטיפוסString reverse_iterator∷..const_reverse_iteratorאין צורך להוסיף תמיכה גם ב-–


3שאלה

תזכורת, מנשק המחלקהString)חלקי( :class String {

char* data;int length;

public:String();String(const char*);String(const String&);~String();String& operator=(const String&);int size() const;const char& operator[](int) const;char& operator[](int);

typedef char* iterator;typedef const char* const_iterator;

iterator begin() { return data; }const_iterator begin() const { return data; }iterator end() { return data + length; }const_iterator end() const { return data +

length; }// ... more code ...

};


- פתרון3שאלה נוסיף בתוך המחלקהString:את הקוד הבא

class String {// ... more code ...

public:

class reverse_iterator {

char* index;

public:

explicit reverse_iterator(char* i) : index(i) {}

reverse_iterator& operator++() {

--index;

return *this;}

char& operator*() const { return *index; }

bool operator!=(const reverse_iterator& i) const { return index != i.index; }

};

reverse_iterator rbegin() { return reverse_iterator(data + length - 1); }

reverse_iterator rend() { return reverse_iterator(data - 1); }

};


4שאלה ראינו את אוסף המחלקות עבור צורות, להלן תזכורת של הקוד עבור המחלקות 12בתרגול

האלו:

ברצוננו לאפשר הדפסת של צורות ע"יאופרטור ההדפסה << כך שעבור עיגול

Circle: radius=3 יודפס 3יודפס שרדיוסו 2ואילו עבור ריבוע שאורך הצלע שלו היא

.Square: side length=2יודפס הוסיפו תמיכה באופרטור ההדפסה למחלקות

הנ"ל. תארו במדויק את שינויי הקוד שלכםוהיכן הם צריכים להתבצע.

class Shape {int center_x, center_y;

public:Shape(int x, int y) :

center_x(x), center_y(y) {}

virtual ~Shape() {}virtual double area()

const = 0;};

class Circle : public Shape {int radius;

public:Circle(int x, int y, int

radius) :Shape(x,y),

radius(radius) {}virtual double area()

const {return

radius*radius*PI;}

};

class Square : public Shape {int edge;

public:Square(int x, int y, int

edge) :Shape(x,y),

edge(edge) {}virtual double area()

const {return

edge*edge;}

};


- פתרון4שאלה class Shape {

//...

protected:

friend ostream& operator<<(ostream& os,

const Shape& s);

virtual void print(ostream& os) const = 0;

};

class Circle: public Shape {

//...

protected:

virtual void print(ostream& os) const {

os << "Circle: radius=" << radius;

}

};

class Square: public Shape {

//...

protected:

virtual void print(ostream& os) const {

os << "Square: side length=" << edge;

}

};

ostream& operator<<(ostream& os, const Shape& s) {

s.print(os);

return os;

}


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

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

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 ... :פלט

}}


- פתרון5שאלה 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;}


- פתרון5שאלה 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;

}};


- פתרון5שאלה 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);

}


- פתרון5שאלה ~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;

}};


- פתרון5שאלה 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 N>class SizedArray: public Array<T>{public:

SizedArray() : Array<T>(N) {};};


6שאלה #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;

}


- פתרון6שאלה

:יודפס

--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&)


7שאלה

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

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


- קטע הקוד7שאלה #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;

}


- פתרון7שאלה #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://...

};


- פתרון7שאלה // 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_

תרגול מס' 13

Documents