פונקציה הורסת במחלקה

פונקציה הורסת Destructor

כשם שפונקציה בונה מופעלת אוטומטית כשנוצר אובייקט, כך פונקציה הורסת מופעלת אוטומטית כשאובייקט מת.
מתי אובייקט מת? כמו כל משתנה:
                                 • כשיוצאים מהבלוק שלו (לדוגמה יוצאים מהפונקציה שיצרה אותו).
                                 • כמשחררים אותו מהזיכרון הדינאמי.

- שם הפונקציה ההורסת זהה לשם המחלקה. אבל בתוספת התו ~ לפניו.
- התחביר זהה לזה של פונקציה בונה, לכן לא נמצא שום "סוג ערך מוחזר" לפני שם הפונקציה. גם לא void.
- לא מקבלת ולא מחזירה נתונים. לכן לעולם לא תהיה יותר מפונקציה הורסת אחת במחלקה.
- תפקידה להשמיד את האובייקט (דבר שלפעמים נחוץ).
- בשפת ++C אין חובה לכתוב פונקציה הורסת. בין אם יש ובין אם אין פונקציה בונה.





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

#include <iostream>
#include <string.h>
using namespace std;
class worker {
 char *name;
 int age;
public:
 worker(char *n , int a) {
  name = new char[strlen(n) + 1]; // לא החשיב strlen המסיים ש NULL ה 1+ זה עבור ה
  strcpy(name, n);
  age = a;
 }
};
void main() {
 worker w1("Shalom" , 38);
 delete[] w1.name; // לא חוקי
}

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



לכן:

#include <iostream>
#include <string.h>
using namespace std;
class worker {
 char *name;
 int age;
public:
 worker(char *n , int a) {
  name = new char[strlen(n) + 1];
  strcpy(name, n);
  age = a;
 }
 ~worker() {
  delete [] name;
 }
};
void main() {
 worker w1("Shalom" , 38);
}

זה שימוש מעולה בפונקציה הורסת.







פרט נוסף (ולא מאוד חשוב)
כאשר נגמרת פונקציה וכל האובייקטים מושמדים, הם מושמדים בסדר הפוך מסדר יצירתם. כלומר הראשון שנוצר הוא האחרון שמושמד.
לדוגמה:

#include <iostream>
#include <string.h>
using namespace std;
class worker {
 char *name;
 int age;
public:
 worker(char *n , int a) {
  name = new char[strlen(n) + 1];
  strcpy(name, n);
  age = a;
 }
 void show() {
  cout<<"Name: "<<name << " Age: " << age<<"\n";
 }
 ~worker() {
  cout<<"\nDistructing  "<<name <<"\n"; // עבור בדיקת סדר ההשמדה
   delete [] name;
 }
};
void main() {
 worker w1("Shalom" , 38), w2("Shlomo" , 66), *p;
 w1.show();
 w2.show();
 p = new worker("Bibi" , 88); // כאשר פונקציה בונה מקבלת ערכים, זה התחביר בהקצאה הדינמית
 p->show();
 delete p; // p כאן מופעלת הפונקציה ההורסת של 
}

הפלט יהיה:

שאלות:

שאלה 1:

  הגדר מחלקה אשר מכילה מצביע לתחילת מערך arr , וגודל המערך size.

  הגדר בנוסף הפונקציות הבאות:

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

- פונקציה בונה אשר מקבלת מצביע לתחילת מערך המסתיים בערך –1 ,  מקצה מקום ומאתחלת את הנתונים של האובייקט.

- הפונקציה show.

- פונקציה אשר מקבלת עוד איבר ומוסיפה אותו לסוף המערך.

- פונקציה הורסת אשר משחררת את הזיכרון.

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

שאלה 2:

  הגדר מחלקה בשם point המייצגת נקודה.

  היא מכילה פונקציה בונה והפונקציה show .

  הגדר מחלקה נוספת אשר מייצגת מצולע.

  היא מכילה מצביע ל- point ומשתנה שלם אשר מייצג את כמות הנקודות.

 יש להגדיר את הפונקציות הבאות:

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

-  הפונקציה show.

- פונקציה למציאת היקף המצולע.

- פונקציה למציאת שטח המצולע. (לא חובה. *)

-  פונקציה הורסת  לשחרור הזיכרון.

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

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

לצורך מציאת שטח משולש השתמשו ב"נוסחת הרון".

שאלה 3:

  הגדר מחלקה אשר מייצגת בן אדם (person).

  נתוני המחלקה יהיו:

  מצביע לשם ולשם משפחה. ומשתנה לגיל.

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

  הגדר מחלקה אשר מייצגת קבוצת חברים.

  נתוני המחלקה יהיו:

  כמות החברים ומצביע מסוג person (עבור המערך הדינמי).

  יש להגדיר את הפונקציות הבאות:

  פונקציה בונה, פונקציה הורסת, הפונקציה show ופונקציה שמחזירה את ממוצע הגילאים.

תשובות:

תשובה 1

#include <iostream>
using namespace std;
 
class ARR {
 int *Arr;
 int Size;
public:
 ARR() {  //פונקציה בונה שמאתחלת 
  int x=0;
  cout << "Enter length of the array: ";
  cin >> Size;
  Arr = new int [Size];
  for (int i=0; i<Size; i++) {
   cout<<i+1 <<".  Enter number: ";
   cin >> Arr[i];
  }
 }
 ARR(int *Parr) { //פונקציה בונה שמקבלת מצביע למערך אשר נגמר ב -1. ה -1 הוא לא חלק מהמארך שצריך לשמור
  int i;
  for(i=0; Parr[i]!=-1; i++);
  Size = i;
  Arr = new int [Size];
  for(i=0; i<Size; i++){
   Arr[i] = Parr[i];
  }
 }
 
 void show() {
  for(int i=0; i<Size; i++){
   cout << Arr[i] << ",";
  }
  cout<<"\n";
 }
 
 void Add(int x) {
  int *arrtmp, i;
  arrtmp = new int [Size+1];
  for(i=0; i<Size; i++){
   arrtmp[i] = Arr[i];
  }
  arrtmp[Size] = x;
  Size++;
  delete[] Arr;
  Arr = arrtmp;
 }
 
 ~ARR() {
  delete []Arr;
 }
};
 
void main() {
 int Arr1[] = {1,3,7,88,-1};
 
 ARR W1;
 W1.show();
 W1.Add(7);
 W1.show();
 
 ARR W2(Arr1);
 W2.show();
 W2.Add(5);
 W2.show();
}

תשובה 2

#include <iostream>
#include <math.h>
using namespace std;
 
class point {
public:
 int x , y;
 point() {
  cout<<"Enter x , y: ";
  cin >> x >> y;
 }
 void show() {
  cout<<"("<<x<<","<<y<<")\n";
 }
};
double dist(point p1, point p2) {
 return sqrt( pow(p1.x - p2.x,2.0) + pow(p1.y - p2.y,2.0) );
}
 
double Triangle(point p1, point p2, point p3) { 
 double a, b, c, q;
 a = dist(p1, p2);
 b = dist(p2, p3);
 c = dist(p3, p1);
 q = (a + b + c) / 2;
 return sqrt(q * (q-a) * (q-b) * (q-c) );  // זה שימוש בנוסחת הרון לשטח משולש
}
class Polygon {
 int n;
 point *p;
 
public:
 Polygon() {
  cout<<"Enter n:   ";
  cin >> n;
  p = new point[n];
 }
 void show() {
  for(int i=0; i<n; i++)
   p[i].show();
 }
 
 double Hekef() {
  double h = 0;
  int i;
  for(i=0; i<n-1; i++)
   h += dist(p[i] , p[i+1]);
  h += dist(p[i] , p[0]);
  return h;
 }
 
 double Shetah() {
  /*
  זה מתאים רק למצולעים שהצורה שלהם היא עיגולית
  הגדרה של עיגולית: אפשר למתוח קו ישר מכל קודקוד אל כל קודקוד מבלי שהקו יחתוך את צלעות המצולע
  */
  double s = 0;
  for(int i=1; i<n-1; i++)
   s += Triangle(p[0] , p[i] , p[i+1]);
  return s;  
 }
 ~Polygon() {
  delete []p;
 }
};
void main() {
 Polygon t;
 t.show();
 cout << "Shetah: "<<t.Shetah() << "   Hekef: "<<t.Hekef()<<"\n";
}

תשובה 3

#include <iostream>
#include <string.h>
using namespace std;
 
class person {
 char *Fname , *Lname; 
 int age;
public:
 person () {
  char F[50] , L[50];
  cout <<"Enter First name: ";
  cin >> F;
  Fname = new char [strlen(F)+1];
  strcpy(Fname , F);
  cout << "Enter last name: ";
  cin >> L;
  Lname = new char [strlen(L)+1];
  strcpy (Lname , L);
  do{
   cout << "Enter age: ";
   cin >> age;
  }while(age<=0);
 }
 
 void show() {
  cout <<Fname<<" "<<Lname<<"   Age: "<<age<<"\n";
 }
 
 int getAge(){
  return age;
 }
 ~person (){
  delete []Fname;
  delete []Lname;
 }
};
 
class group {
 person *G;
 int number;
public:
 group (){
  cout << "Enter number of members in the group: ";
  cin >> number;
  G = new person[number];
 }
void show(){
  for(int i=0; i<number; i++){
   cout<<i+1<<".  ";
   G[i].show();
   cout<<"\n";
  }
 }
 double avg(){
  double A=0;
  for (int i=0 ; i<number ; i++) {
   A += G[i].getAge();
  }
return A/number;
 }
 ~group() {
  delete []G;
 }
};
 
void main() {
 group g;
 g.show();
 cout << "Avg: " << g.avg() <<"\n";
}

בהצלחה!