Friend Function, Friend Class, Friend Member Class

אז חשבתם ש-class member מסוג private או protected ניתנים לגישה אך ורק מתוך האובייקט? מסתבר שאפשר לגשת ל-private ו-protected גם מבחוץ. איך עושים זאת? פשוט. בעזרת הסימון: friend.

נראה שלושה סוגים של friends:

1. Friend Function - זו פונקציה שאינה שייכת ל-class ובכל זאת יכולה לגשת לאלמנטים החסויים שלו.

2. Friend Class - זה class שיורשה לגשת לאלמנטים החסויים של class אחר.

3. Friend Member Class - זוהי מתודה בתוך class שתורשה לגשת לחלקים החסויים של class אחר. 

האם ה-friendship עולה בקנה אחד אם עקרונות ה-information hiding של c++? הדעות בעניין חלוקות. יש כאלה שיעדיפו להמנע משימוש ב-friends, ובמקום זה לאחד classes או להכליל פונקציות בתוך classes. אחרים יטענו friendship מחזקת את יכולות ה-c++. בכל אופן, בואו ונכיר את הנושא מקרוב.

נראה את שלושת הסוגים בדוגמאות.

Friend Function.

נראה דוגמא עם פונקציה בשם set_code שאינה שייכת ל-class, ובכל זאת היא ניגשת ישירות ל- private data member שלו.
שם ה-class אליו היא ניגשת הוא Safe  וה-private data הוא משתנה בשם secret_code/ ראו שורה 22.
שורה 23: הגישה הישירה ל-secret_code מתוך set_code.
ההכרזה שאפשרה זאת, נמצאת בשורה 19:

    friend void set_code (Safe &safe, int new_code);

כאן מוכרזת הפונקציה, בתוך ה-class עם תוספת friend בראש. שימו לב: set_code אינה member ב-Safe.

ההוכחה לכך ש set_code אינה member נמצאת בשורה 22:  אם היא היתה member, שם ה-class היה מופיעה כקידומת לשם הפונקציה.

לסיכום: שורה 23 לא היתה אפשרית לולא הכרזת ה-friend בשורה 19.

נסתכל על main, הפונקציה המפעילה:

שורה 30: קריאה ל-set_code, היא אכן מכניסה ערך חדש ל-secret_code/
והערה נוספת לגבי שורות 19 ו-22: הסימון & Safe מציין שהאובייקט יועבר לפונקציה כ- reference value.
שתי סיבות להעברת האובייקט לא by value:
1. המתודה set_code משנה את הערך של האובייקט. העברה by_value לא היתה משנה את האובייקט אלא רק עותק שלו.
2. בנוסף לסיבה הראשונה, שפוסלת את האפשרות להעברה by value בכל מקרה, העברה by reference יעילה יותר, כי היא חוסכת את העתקה של האובייקט. במקום העתקה של האוביקט מועבר reference אליו. הנה קישור לפוסט בנושא Reference Variables.

1. 
   
2. 
   
3. /*
4.  * friend_func.cpp
5.  *
6.  *  Created on: Mar 20, 2012
7.  *      Author: ronen halevy
8.  */
9. #include <iostream>
10. using namespace std;
11. 
    
12. class Safe{
13. private:
14. int tot_deposit;
15. int secrete_code;
16. public:
17. void show(){cout << "secrete_code "<<secrete_code<< endl;}
18. Safe():secrete_code(6666){}
19.     friend void set_code (Safe &safe, int new_code);
20. };
21. 
    
22. void set_code (Safe &safe, int new_code){
23. safe.secrete_code = new_code;
24. }
25. 
    
26. 
    
27. int main(){
28. Safe safe;
29. set_code(safe, 67777);
30. safe.show();
31. }

הנה הפלט, המוכיח כי הכתיבה הצליחה:

secrete_code 67777

זה היה Friend Function.

ועתה נראה דוגמא ל-Friend Class:

נציג שהי classes:
האחד - Safe - שמייצג כספת של בנק, ובתוכה מופקד כסף.
השני -  Bank - שניגש ישירות למספר אובייקטים מסוג Safe, קורא את הסכום שבכספת ומסכם אצלו.
ה-Bank מורשה לגשת ל-private של Safe היות שהוא מוגדר כחבר של Safe.
הנה התוכנית:

1. 
   
2. /*
3.  * friend_class.cpp
4.  *
5.  *  Created on: Mar 20, 2012
6.  *      Author: ronen halevy
7.  */
8. 
   
9. #include <iostream>
10. using namespace std;
11. 
    
12. //class Safe;
13. 
    
14. class Safe{
15. private:
16. int secrete_code;
17. int tot_deposit;
18. 
    
19. public:
20. void show(){cout << "tot_deposit "<<tot_deposit<< endl;}
21. Safe(int a):secrete_code(6666),tot_deposit(a) {}
22.     friend class Bank;
23. };
24. 
    
25. class Bank{
26. private:
27. int sum_all_safes;
28. public:
29. Bank():sum_all_safes(0){}
30. void acc_safe(Safe &safe);
31. void show(){cout << "sum_all_safes "<<sum_all_safes<< endl;}
32. };
33. void Bank::acc_safe(Safe &safe){
34. Bank::sum_all_safes +=safe.tot_deposit;
35. }
36. 
    
37. int main(){
38. Safe safe1(999);
39. Safe safe2(1230);
40. Bank bank;
41. bank.acc_safe(safe1);
42. bank.acc_safe(safe2);
43. bank.show();
44. }
45. 
    

Safe ו-Bank צבועים בירוק וצהוב בהתאמה.

נסתכל על החלקים המעניינים ב-Safe:

שורה 22:

  friend class Bank;

זו השורה שמגדירה את Bank כ-friend של Safe.

והחלק המעניין ב- Bank:

שורה 34: כאן Bank ניגש ל-tot_deposit, שהוא private.

שימו לב לשורה 30 ו-33 ולסימון & Safe. האוביקט לא מועבר -by value אלא by reference. זה חוסך למערכת את ההעתקה של האובייקט ל-stack. הנה קישור לפוסט בנושא Reference Variables.

נסתכל על main, הפונקציה המפעילה:

בשורה 38 ו-39 נוצרים שני אובייקטים מסוג Safe. בכספות "מופקדים" סכומים של 999 ו-1230.

בשורה 41 ו-42 האובייקט מסוג Bank מסכם את הסכומים המופקדים בשתי הכספות.

שורה 43: מדפיס את הסכום שהצטבר. 

הנה הפלט:

sum_all_safes 2229

Friend Member Class
ראינו שני סוגים של friends: פונקציה ו-class. בדוגמא של ה-class, רק המתודה acc_safe  של ה-Bank ניגשה ל-private של Safe. לפיכך, אפשר היה להסתפק בכך ש-acc_safe בלבד תהיה friend של safe.

התוכנית דומה לזו שהוצגה בסעיף הקודם. נוספו מספר שינויים "קוסמטיים":

1. 
   
2. /*
3.  * friend_member_class.cpp
4.  *
5.  *  Created on: Mar 20, 2012
6.  *      Author: ronen halevy
7.  */
8. 
   
9. #include <iostream>
10. using namespace std;
11. 
    
12. class Safe;
13. 
    
14. class Bank{
15. private:
16. int sum_all_safes;
17. public:
18. Bank():sum_all_safes(0){}
19. void acc_safe(Safe &safe);
20. void show(){cout << "sum_all_safes "<<sum_all_safes<< endl;}
21. };
22. 
    
23. 
    
24. class Safe{
25. private:
26. int secrete_code;
27. int tot_deposit;
28. 
    
29. public:
30. void show(){cout << "tot_deposit "<<tot_deposit<< endl;}
31. Safe(int a):secrete_code(6666),tot_deposit(a) {}
32.     friend void Bank::acc_safe(Safe & safe);
33. };
34. 
    
35. void Bank::acc_safe(Safe &safe){
36. Bank::sum_all_safes +=safe.tot_deposit;
37. }
38. 
    
39. int main(){
40. Safe safe1(999);
41. Safe safe2(1230);
42. Bank bank;
43. bank.acc_safe(safe1);
44. bank.acc_safe(safe2);
45. bank.show();
46. }

נתייחס לשינויים לעומת הסעיף הקודם:
שורה 32: זו השורה שמגדירה את המתודה acc_safe של Bank כ-friend של Safe. הנה היא:

   friend void Bank::acc_safe(Safe & safe);

כזכור, בדוגמא הקודמת ההגדרה היתה:

  friend class Bank;

שימו לב: שינינו את סדר הגדרת ה-classes: כעת ההגדרה של Bank מקדימה את Safe. אם הסדר היה הפוך - כמו בדוגמא הקודמת - היינו מקבלים שגיאת קומפילציה:
בשורה:

   friend void Bank::acc_safe(Safe & safe);

הודעת השגיאה היתה:

"Bank has not been declared"

השורה הנ"ל שנמצאת ב-Safe, אמורה להכיר את המתודה acc_safe של Bank, אבל Bank מוגדרת רק בהמשך.

זו הסיבה שהחלפנו את הסדר.

כעת, עם החלפת הסדר נוצרה בעיה אצל Bank : שורה 32 מתייחסת ל-Safe. אם היינו מקמפלים את זה, היתה  ומתקבלת שם הודעת שגיאה:

"Safe has not been declared"

גם את זה נפתור, ע"י הוספת שורה 12:

Class Safe.

זה נקראה Forward Declaration - הקפצנו את ההכרזה של Safe קדימה. כל הבעיות נפתרו!