תרגול מס' 10
description
Transcript of תרגול מס' 10
10תרגול מס' עבודה עם קבציםתבניותחריגות
2מבוא לתכנות מערכות - 234122
עבודה עם קבצים
המחלקותofstream-ו ifstream
3מבוא לתכנות מערכות - 234122
++Cקלט/פלט עם קבצים ב-
-כמו בC-גם ב C הטיפול בקבצים דומה לטיפול בערוצי הקלט/פלט ++הסטנדרטיים
-בC עבודה עם קבצים מתבצעת בעזרת מחלקות המוגדרות בקובץ ++fstream
המחלקהofstream משמשת לכתיבה לקובץ המחלקהifstream משמשת לקריאה מקובץ שם הקובץ לפתיחהלשתי המחלקות יש בנאי המקבל את כאשר העצם נהרסהמוודא שהקובץ נסגר לשתי המחלקות יש הורסכמו עבור ערוצים >> ו-<< מתבצעות על ידי שימוש ב-קריאה והדפסה
רגילים כמתודות של שאר הפעולות הדרושות על ערוצי הפלט מבוצעות
המחלקות מחזירה חיווי האם הגענו לסוף הקובץeofלמשל המתודה –
4מבוא לתכנות מערכות - 234122
קלט/פלט עם קבצים - דוגמה#include <fstream>using std::ifstream;using std::ofstream;using std::cerr;using std::endl;
void copyFile(const char* fromName, const char* toName) {ifstream from(fromName);if (!from) {
cerr << "cannot open file " << fromName << endl;return;
}ofstream to(toName);if (!to) {
cerr << "cannot open file " << toName << endl;return;
}while (!from.eof()) {
char c;from >> c;to << c;
}}
למה לא צריך לסגור את הקובץ?
boolהמרה ל-
5מבוא לתכנות מערכות - 234122
תבניות
תבניות של פונקציותתבניות של מחלקות
6מבוא לתכנות מערכות - 234122
תכנות גנרי
נניח שברצוננו לכתוב פונקציה למציאת המקסימום במערך של עצמים - לכל טיפוסנצטרך לרשום מחדש פונקציה כמעט זהה
של פונקציות המוצאות מקסימום במערךהתבנית הכללית קל לנו לראות את(string ו-intמשתנה )בדוגמאות שלנו שם הטיפוס רק –
שיתאים לכל טיפוסקוד גנרי ברצוננו לכתוב? מה היו החסרונות בשיטה זו?Cכיצד עשינו זאת ב-–
int max(const int* array, int size) {
int result = array[0];for (int i = 1; i < size;
++i) {if (result <
array[i]) {result =
array[i];}
}return result;
}
string max(const string* array, int size) {
string result = array[0];for (int i = 1; i < size; ++i) {
if (result < array[i]) {result =
array[i];}
}return result;
}
7מבוא לתכנות מערכות - 234122
תבניות קוד התלוי בפרמטרים של זמן הקומפילציהתבניות של קוד ניתן לכתוב - כדי להגדיר תבנית לפונקציה משתמשים במילה השמורהtemplate לפני הגדרת
על הפרמטרים של התבנית:> < הפונקציה ומכריזים בתוך
הקומפיילר ישתמש בתבנית כדי ליצור קוד במקרה הצורךתהליך יצירת מופע של הקוד המוגדר על ידי התבנית מתבצע בזמן הקומפילציה –
instantiationוקרוי
בקבצי תבניות יש להגדיר תמידhכך שיהיו זמינות לקומפיילר
template<class T>T max(const T* array, int size) {
T result = array[0];for (int i = 1; i < size;
++i) {if (result <
array[i]) {result =
array[i];}
}return result;
}
ניתן להשתמש במילה במקום typenameהשמורה
classב- מייצג שם Tבתוך קוד התבנית
של טיפוס וניתן להשתמש בו כמו בשם של טיפוס רגיל: Tלהכריז על משתנים מסוג
ולבצע עליהם פעולות
8מבוא לתכנות מערכות - 234122
תבניות - שימוש
כדי להשתמש בפונקציה המוגדרת על ידי תבנית ניתן לקרוא לה לפישמה ובתוספת הפרמטרים הדרושים לתבנית:
ניתן לקרוא לפונקציה ללא ציון הפרמטרים לתבנית - במקרה זההקומפיילר יסיק אותם בעצמו
במקרה זה הפונקציה משתתפת בשלב פתרון ההעמסה יחד עם פונקציות –נוספות
int array[] = {4, -1 ,2};
string array2[] = {"Hello", "cruel", "world"};
cout << max<int>(array, 3) << endl;
cout << max<string>(array2, 3) << endl;
int array[] = {4, -1 ,2};
string array2[] = {"Hello", "cruel", "world"};
cout << max(array, 3) << endl;
cout << max(array2, 3) << endl;
array הוא int ולכן תיקרא *max<int>
array2 הוא string ולכן תיקרא *max<string>
9מבוא לתכנות מערכות - 234122
תבניות והעמסת פונקציות
:בפתרון העמסה אשר מעורבות בו תבניותמאשר שימוש מתאימה בדיוק לפרמטרים הקומפיילר יעדיף פונקציה אשר –
בתבנית )על ידי הסקת טיפוסים(
הקומפיילר יעדיף שימוש בתבנית על שימוש בהמרות–
כדי להתאים לתבניתלא יבצע המרות אוטומטיות הקומפיילר –
ניתן להכריח שימוש בפונקצית תבנית על ידי ציון הפרמטרים לתבנית במפורש–
10מבוא לתכנות מערכות - 234122
תבניות - העמסת פונקציות
:דוגמאות
template<class T>
T max (T a , T b , T c ) {
if (a > b && a > c) return a ;
if (b > c) return b ;
return c;
}
// ...
int j = max(1,3,3); //
char c= max (’w’,’w’,’w’); //
String s1 = max (s1,s2,s3); //
int j = max (1,’a’,’a’); //
int j = max<int> (1,’a’,’a’); //
int max(int a , int b , int c ) {
if (a > b && a > c) return a ;
if (b > c) return b ;
return c;
}
// ...
int j = max (1,3,3); //
char c = max ('w','w','w');//
String s1 = max (s1,s2,s3); //
int j = max (1,'a','a'); //
11מבוא לתכנות מערכות - 234122
תבניות - יצירת מופעים
כאשר הקומפיילר משתמש בתבנית הוא מנסה ליצור פונקציה אשרהפרמטרים לתבנית מוחלפים בה
האם תהליך זה יכול להיכשל?–
בכדי שהשימוש בתבנית יצליח על הארגומנטים המועברים לתבנית לעמודבדרישות הלא מפורשות על הטיפוס המופיעות בקוד
?max ב-Tאילו דרישות יש על הטיפוס –
template<class T>T max(const T* array, int size) {
T result = array[0];for (int i = 1; i < size;
++i) {if (result <
array[i]) {result =
array[i];}
}return result;
}Stack array[] = {Stack(50), Stack(60), Stack(70);cout << max(array, 3) << endl;
12מבוא לתכנות מערכות - 234122
מחלקות גנריות
ניתן להגדיר תבנית עבור מחלקה ובכך לממש מחלקות גנריות בדומהCל-והקומפיילר יוודא את לא נצטרך לשלוח מצביעים לפונקציות Cבניגוד ל-–
<template <class T בעצמונכונות הטיפוסיםclass Array {
T* data;int size;
public:Array(int size);Array(const Array& a);~Array();Array& operator=(const Array&
a);int size() const;T& operator[](int index);const T& operator[](int index)
const;};
בתוך ההכרזה על המחלקה במקום Arrayניתן לרשום
Array<T>
13מבוא לתכנות מערכות - 234122
מחלקות גנריות
בניגוד לפונקציות, עבור מחלקות חייבים לרשום במפורש אתהקומפיילר לא יכול להסיק אותם בעצמוהארגומנטים לתבנית -
טיפוס חדשכל שימוש בתבנית עם ארגומנטים אחרים יוצר
void f(Array<string>& words) {
Array<int> numbers(100);
for(int i = 0; i < numbers.size(); ++i) {
numbers[i] = i;
}
words = numbers; // error, type mismatch
}
14מבוא לתכנות מערכות - 234122
++Cמחסנית גנרית ב-template <class T>class Stack {
T* data;int size;int nextIndex;
public:Stack(int size = 100);Stack(const Stack& s);~Stack();Stack& operator=(const Stack&);void push(const T& t);void pop();T& top();const T& top() const;int getSize() const;
};
:נשפר את המחסנית שלנו כך שתהיה גנרית
15מבוא לתכנות מערכות - 234122
++Cמחסנית גנרית ב-template <class T>Stack<T>::Stack(int size) :
data(new T[size]), size(size), nextIndex(0) {} template <class T>Stack<T>::Stack(const Stack<T>& s) :
data(new T[s.size]), size(s.size), nextIndex(s.nextIndex) {for (int i = 0; i < nextIndex; ++i) {
data[i] = s.data[i];}
} template <class T>Stack<T>::~Stack() {
delete[] data;}
16מבוא לתכנות מערכות - 234122
++Cמחסנית גנרית ב-template <class T>
Stack<T>& Stack<T>::operator=(const Stack<T>& s) {
if (this == &s) {
return *this;
}
delete[] data;
data = new T[s.size];
size = s.size;
nextIndex = s.nextIndex;
for (int i = 0; i < nextIndex; ++i) {
data[i] = s.data[i];
}
return *this;
}
17מבוא לתכנות מערכות - 234122
++Cמחסנית גנרית ב-template <class T>void Stack<T>::push(const T& t) {
if (nextIndex >= size) {error("Stack full");
}data[nextIndex++] = t;
} template <class T>void Stack<T>::pop() {
if (nextIndex <= 0) {error("Stack empty");
}nextIndex--;
}
18מבוא לתכנות מערכות - 234122
++Cמחסנית גנרית ב-template <class T>T& Stack<T>::top() {
if (nextIndex <= 0) {error("Stack empty");
}return data[nextIndex - 1];
} template <class T>const T& Stack<T>::top() const {
if (nextIndex <= 0) {error("Stack empty");
}return data[nextIndex - 1];
}
template <class T>int Stack<T>::getSize() const {
return size;}
19מבוא לתכנות מערכות - 234122
שימוש במחסנית הגנריתint main() {
Stack<int> s;
Stack<string> s2;
s.push(20);
s2.push("Hello");
Stack<int> s3(s);
s = s2; // error
cout << s.top() << s2.top() << endl;
return 0;
}
למה מתקבלת שגיאה?
20מבוא לתכנות מערכות - 234122
תבניות - פרמטרים
ניתן להגדיר תבניות המקבלותיותר מפרמטר אחד
Pair<char, double> p('a', 15.0);
cout << "(" << p.first << "," << p.second << ")";
template<class T, class S>
struct Pair {
T first;
S second;
Pair(const T& t, const S& s)
: t(t), s(s) {}
};
List<Pair<string, int> > phonebook;
phonebook.add(Pair<string, int>("Dani",8343434));
phonebook.add(Pair<string, int>("Rami",8252525));
21מבוא לתכנות מערכות - 234122
תבניות - פרמטרים
ניתן להגדיר תבניות גם עבור פרמטרים מטיפוסint:למשל ,template<class T, int N>class Vector {
int data[N];public:
Vector();Vector& operator+=(const
Vector& v);//...
}; void f(Vector<int, 3>& v) {
Vector<int, 5> v5;Vector<int, 3> v3;v3 += v; // o.k.v5 += v; // error
}
,Vector<intהמספר הוא חלק מהטיפוס, לכן < הם טיפוסים שוניםVector<int, 5< ו-3
נסיון לחבר וקטורים ממימדים לא יתקמפלשונים
N נקבע בזמן הקומפילציה, לכן אנו מגדירים למעשה מערך בגודל קבוע
כשדה במחלקה
22מבוא לתכנות מערכות - 234122
תבניות - שגיאות קומפילציהכאשר הקומפיילר עובר על תבנית הוא יכול למצוא בה רק שגיאות בסיסיות של תבנית יתגלו שגיאות התלויות בארגומנט יוצר מופע כאשר הקומפיילר
הספציפיהשגיאה המתקבלת מהקומפיילר תהיה מורכבת ממספר שורות ותכלול את רשימת –
התבניות והארגומנטים שלהן
ורק אחרי שהוא מומלץ לכתוב תחילה קוד רגיל בגלל השגיאות המסובכותעובד להמיר אותו לתבנית
void f() {Stack<Pair<int, int> >
ranges(10);}..\main.cpp: In constructor `Stack<T>::Stack(int) [with T = Pair<int, int>]':
..\main.cpp:241: instantiated from here
..\main.cpp:108: error: no matching function for call to `Pair<int, int>::Pair()'
..\main.cpp:233: note: candidates are: Pair<int, int>::Pair(const Pair<int, int>&)
..\main.cpp:237: note: Pair<T, S>::Pair(T, S) [with T = int, S = int]
הרווח הזה הוא חובה
23מבוא לתכנות מערכות - 234122
תבניות - סיכום
ניתן להגדיר תבנית לפונקציה-ניתן להגדיר מחלקות גנריות בעזרת שימוש בtemplate-בניגוד לCכל בדיקות הטיפוסים נעשות בזמן קומפילציה כדי שהשימוש בתבנית יתקמפל על הארגומנטים המועברים לתבנית
להיות בעלי כל התכונות הדרושות לפי התבניתניתן להגדיר תבניות שהפרמטרים שלהן הם מספריםניתן להגדיר תבניות עם מספר פרמטרים מומלץ לכתוב תחילה קוד ללא תבניות ולהמירו אח"כ כדי למנוע
התמודדות עם פלט מסובך מהקומפיילר
24מבוא לתכנות מערכות - 234122
חריגות
-שימוש בtry, catch-ו throwהקצאה על ידי אתחול
25מבוא לתכנות מערכות - 234122
חריגות
מנגנון החריגות עובד בעזרת שלושת המילים השמורותthrow, try:-ו catch–throwמקבלת כפרמטר את העצם אותו יש לזרוק כחריגה :
–tryמציינת תחילה של בלוק אשר ייתכן ותיזרק ממנו חריגה שנרצה לתפוס :
–catchמציינת סוג חריגה לתפוס ואת הקוד המתאים לטיפול בחריגה :
כאשר נזרקת חריגה הקוד הרגילומתחילה יציאהמפסיק להתבצע
מכל פונקציה בתכנית עד אשרהחריגה מטופלת
בכלללא מטופלת אם חריגההתכנית תסתיים( main)נזרקת מ-
void f(int n) {if (n < 0) {
throw -1;}
} int main(int argc, char **argv) {
try {f(-7);
} catch (int e) {cerr << "Error: "
<< e << endl;}
}
26מבוא לתכנות מערכות - 234122
חריגות
:כאשר חריגה נזרקת מתבצעים הדברים הבאיםקוראים להורסים של המשתנים המקומיים tryלא בתוך בלוק כל עוד אנחנו –
ויוצאים מהפונקציה
לסוג החריגה הקיים מתאים catchקיים בודקים האם tryאם אנחנו בבלוק –
אם לא, קוראים להורסים וממשיכים לצאת•
ולאחריו הפונקציה ממשיכה catchמתבצע הקוד בבלוק ה-אם כן, • האחרוןcatchמהשורה שאחרי בלוק ה-
עבור טיפוסים שוניםcatchייתכנו מספר בלוקים של •
התרת המחסניתתהליך היציאה מפונקציות עד לתפיסת שגיאה נקרא(stack unwinding)בין זריקת החריגה ועד לתפיסתה הקוד היחיד שמתבצע הוא של הורסים של –
המשתנים המקומיים המשוחררים
27מבוא לתכנות מערכות - 234122
חריגות השימוש בחריגות מונע כתיבה מיותרת של קוד עבור
טיפול בשגיאות בכל פונקציה בדרךמי שיודע למצוא את השגיאה זורק חריגה–
רק מי שיודע לטפל בשגיאה מתייחס אליה–
-בשימוש בקודי שגיאה כמו בC הטיפול במקרי למרבית הקודהשגיאה נהפך
-בC אבל נהוג לזרוק כל עצם שהוא ++ ניתן לזרוקכדי לציין שגיאות מחלקות שנוצרו במיוחד רק
ספציפיות
void f(int n) {if (n < 0) {
throw -1;
}}
void g(int n) {f(-n);
}
void h(int n) {g(2*n);
}
int main() {try {
h(7);} catch (int e)
{cerr <<
"Error: " << e;}
}
main
h g f
call call call
return return return
throw
28מבוא לתכנות מערכות - 234122
חריגות
:נוסיף חריגות למחסנית הגנרית שלנוtemplate<typename T>class Stack {
T * data;int size;int nextIndex;
public:
Stack(int size = 100);Stack(const Stack&
stack);~Stack();Stack& operator=(const
Stack& s);void push(const T& t);void pop();T& top();const T& top() const;int getSize() const;
class Full {};class Empty {};
};
template<typename T>void Stack::push(const T& t) {
if (nextIndex >= size) {throw Full();
}data[nextIndex++] = t;
} template<typename T>void Stack::pop() {
if (nextIndex <= 0) {throw Empty();
}nextIndex--;
}
ניתן להגדיר מחלקות בתוך מחלקות
29מבוא לתכנות מערכות - 234122
חריגות - שימוש במחסנית
במספר משפטי ניתן להשתמשcatch עבור tryיחיד
-כדי לתפוס כל ...ניתן להשתמש ב חריגה
במקרה זה לא ניתן לגשת לחריגה –שנתפסה
אם כמה מקרים מתאימים לתפיסתהחריגה ייבחר הראשון שמופיע
אחרוןלכן ... תמיד מופיע –
-ניתן לזרוק חריגה מחדש מcatch ללא פרמטרים throwעל ידי
void f(Stack<int>& s) {try {
s.pop();for (int i = 0; i
< 10; ++i) {
s.push(i);}
} catch (Stack<int>::Empty& e) {
cerr << "No numbers";
} catch (Stack<int>::Full& e) {
cerr << "Not enough room";
} catch (...) {cerr << "Oops";throw;
}}
30מבוא לתכנות מערכות - 234122
חריגות
חריגות יכולות להיותיותר מורכבות
למשל ניתן לשלוח בהןמידע מדויק על
השגיאה
class String::BadIndex {public:
int index;BadIndex(int index) : index(index) {}
};
void String::verify_index(int index) const {if (index >= size() || index < 0) {
throw BadIndex(index);}return;
}
const char& String::operator[](int index) const {
verify_index(index);return data[index];
}
char& String::operator[](int index) {verify_index(index);return data[index];
}
בשביל להגדיר מחלקה מקוננת כך יש להכריז
Stringעליה בתוך
void f(String& s) {try {
cout << s[50];} catch
(String::BadIndex& e) {cerr << "Bad
Index: "<<
e.index;}
}
31מבוא לתכנות מערכות - 234122
חריגות
חריגות מבנאיניתן לזרוק:
לזרוק חריגות מהורסמסוכן:יכולה להיות רק חריגה אחת בו זמנית–
בזמן זריקת חריגה הורסים ממשיכים להתבצע–
אם נזרקת חריגה נוספת התכנית תתרסק–
כאשר הקצאת זיכרון על ידיnew נכשלתstd::bad_allocנזרקת חריגה מסוג
Rational::Rational(int n, int d) :
num(num), denom(denom) {
if (denom == 0) {throw
DivideByZero();}
}
int main() {try {
while (true) {
new int[1000000];
}} catch
(std::bad_alloc& e) {cerr << "Out
of memory";}return 0;|
}
32מבוא לתכנות מערכות - 234122
קוד בטוח לחריגות
לחריגות יש חיסרון חשוב - כל קריאה בקוד שלנו עלולה לגרום לזריקתחריגה )בצורה ישירה או עקיפה( ולכן הקוד צריך להיות מוכן לזריקת
חריגה בכל שלב לדוגמה, מה הבעיה באופרטור ההשמה שלString?שלנו char* String::allocate_and_copy(const char* str, int
size) {return strcpy(new char[size+1], str);
}
String& String::operator=(const String& str) {if (this == &str) {
return *this;}delete[] data;data = allocate_and_copy(str.data, str.size());length = str.length;return *this;
}
33מבוא לתכנות מערכות - 234122
קוד בטוח לחריגות
כאשר מבצעים קוד של שחרור והקצאות - קודם מבצעים את החלקהבעייתי ואח"כ את שחרור המידע הישן:
?עדיין קיימת בעיה - מה קורה אם יש שתי הקצאות בבת אחת
char* String::allocate_and_copy(const char* str, int size) {
return strcpy(new char[size+1], str);}
String& String::operator=(const String& str) {
char* temp = allocate_and_copy(str.data, str.size()); delete[] data;
data = temp;
length = str.length;
return *this;
}
למה לא צריך בדיקת השמה עצמית?
34מבוא לתכנות מערכות - 234122
הקצאת משאבים על ידי אתחולResource Acquisition is Initialization
לעטוף את כל כדי להתמודד עם הסכנות הלא צפויות של חריגות נהוגהקצאות המשאבים במחלקות
בשיטה זו ההורס של המחלקה אחראי לנקות–
, בפרט בזמן התרת המחסניתאוטומטיתהורסים נקראים –
התעסקות מייגעת בהקצאות השימוש בשיטה זו חוסך למתכנת} ()void badושחרורים
char* str1 = new char[N+1];
try {char* str2 =
new char[N+1];// ... code ...
} catch (bad_alloc& e) {
delete[] str1;}
}
void good() {string str1;string str2;// ...
code ...}
35מבוא לתכנות מערכות - 234122
חריגות -שימוש נכון
משתמש בחריגות כבערכי חזרההמנעו מכתיבת קוד אשרהמנעו משימוש בחריגות לשם שליטה בקוד
המנעו מלהכריח את המשתמשים בקוד שלכם מלעשות זאת–
void bad(Stack<int>& s) {while(true) {
try {cout <<
s.top() << endl;s.pop();
} catch (Stack<int>::Empty& e) {
break;}
}}
void good(Stack<int>& s) {while(s.getSize()
> 0) {cout <<
s.top() << endl;s.pop();
}}
36מבוא לתכנות מערכות - 234122
חריגות - סיכום
-טיפול בשגיאות מתבצע בC בעזרת ++throw, try-ו catchאפשר לזרוק כל דבר אבל נהוג לזרוק רק עצמים ממחלקות ייעודיותהשתמשו בחריגות כדי לאפשר לבנאי להיכשל שגיאות מהספריה הסטנדרטית, כמו כשלון שלnew מטופלות על ידי
חריגותכדי לשמור על קוד בטוח לחריגות עטפו הקצאות משאבים במחלקותהמנעו מכתיבת קוד אשר משתמש בחריגות כבערכי חזרה