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

 מבנה הנתונים תור ( queue ) הוא מבנה הדומה למחסנית ( stack ) שנלמדה בקורס. לתור ניתן להוסיף איברים ( ע " י פעולה הנקראת enqueue ) וניתן להסיר את האיבר שבראש התור ( dequeue ), כלומר האיבר הוותיק ביותר בתור ( בניגוד למחסנית בה באיבר שמוסר הוא האחרון שנוסף ).  כלומר מבנה הנתונים תור צריך לתמוך בפעולות הבאות : 1. יצירה של תור חדש. 2. הריסה של תור קיים. 3. העתקה של תור קיים. 4. השמה מתור א ' לתור ב '. כך שלאחר הפעולה שני התורים יהיו זהים. 5. הוספת איבר לסוף התור. 6. הסרת האיבר הראשון בתור. אם התור ריק תיזרק חריגה מסוג QueueEmpty. 7. החזרת האיבר הראשון ( הוותיק ביותר ) בתור. יש להחזיר את האיבר עצמו ללא העתקה. גם במקרה זה אם התור ריק תיזרק חריגה מסוג QueueEmpty.  ממשו תור גנרי בשפת ++ C. הקפידו לכתוב רק את הקוד הדרוש. – ניתן להשתמש ב -std ∷ list של שפת ++ C כמו שנלמד בתרגול על ה -STL. מבוא לתכנות מערכות

template class Queue { std::list 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(); } }; מבוא לתכנות מערכות

 נתונות שתי המחלקות הבאות :  כתוב תכנית קצרה ככל הניתן המדפיסה פלט שונה לכל אחת מהמחלקות שהוצגו. כלומר, עליכם לכתוב קוד המכיל פונקצית main ומשתמש במחלקה A כך שהפלט המודפס בהרצת הקוד שונה כאשר מקמפלים אותו עם כל אחת מהמחלקות הנתונות. מבוא לתכנות מערכות class A { public: void f() { cout << "1" << endl; } }; class A { public: virtual void f() { cout << "1" << endl; } };

class B : public A { public: void f() { cout << "2" << endl; } }; int main(int argc, char **argv) { A* a = new B(); a->f(); return 0; } מבוא לתכנות מערכות

 הנכם נדרשים להרחיב את המחלקה 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. מבוא לתכנות מערכות

 תזכורת, מנשק המחלקה 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... };

 נוסיף בתוך המחלקה 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); } }; מבוא לתכנות מערכות

 בתרגול 12 ראינו את אוסף המחלקות עבור צורות, להלן תזכורת של הקוד עבור המחלקות האלו :  ברצוננו לאפשר הדפסת של צורות ע " י אופרטור ההדפסה >> כך שעבור עיגול יודפס שרדיוסו 3 יודפס Circle: radius=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; } };

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; }

עליכם לממש מחלקות גנריות עבור " מערכים בטוחים ". מערך בטוח הוא מערך המכיל מידע על אורכו, המאפשר הגנה מפני גלישה בשימוש. הגנריות מתבטאת בעובדה שהמימוש מאפשר ליצור מערכים שונים עבור סוגי עצמים שונים. למשל, הפקודה 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 SizedArray: public Array { public: SizedArray() : Array (N) {}; }; מבוא לתכנות מערכות

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