Operator Overloading

המשמעות של Operator Overloading: אפשרות לתת לאופרטור של C++ משמעות נוספת. העיקרון דומה לזה של function overloading שם פונקציה עם אותו שם יכולה להתקיים במספר צורות ולבצע פעולות שונות. ניתן לעשות overloading רק על אופרטורים חוקיים של C++. כך ש-$ למשל לא כלול אבל +,->,= וגם ! [] ()  % & ועוד ניתנים ל-overloading.

למה צריך את זה? דוגמא: Operator Overloading על האופרטור +.
האופרטור + יכול לחבר שני סקלארים, למשל c=a+b. אבל נניח ש-a ו-b הם אובייקטים מסוג Example. מה יקרה אם נרצה לחבר אותם?
הנה דוגמא:

1. 
   
2. /*
3.  * oveloading.cpp
4.  *
5.  *  Created on: Mar 21, 2012
6.  *      Author: ronen halevy
7.  */
8. 
   
9. #include <iostream>
10. using namespace std;
11. 
    
12. class Example{
13. private:
14. int a;
15. int b;
16. int c;
17. public:
18. Example(int a, int b):a(a),b(b){c = a + b;}
19. void sum(){c = a+b;}
20. }
21. int main(){
22. Example ex1(1,2);
23. Example ex2(2,3);
24. Example ex3 = ex1+ex2
25. }

בשורה 24 מופעל האופרטור + על שני האובייקטים ex1 ו-ex2.

תוצאת הקומפילציה - שגיאה:

error: no match for ‘operator+’ in ‘ex1 + ex2’

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

ה- operator overloading  מאפשר להגדיר פעולת + חדשה שתתאים לאובייקטים מסוג Example.

את פעולת ה + החדשה נוכל להגדיר כרצוננו. במקרה הנ"ל בחרתי לבצע חיבור של כל ה-data members של ה-class כך שהתוצאה תהיה:

ex3.a = 8

ex3.b = 5

ex3.c = 8

אני מניח שהחישוב ברור אבל אפרט בכ"ז: 

ex3.a = ex1.a + ex2.a = 1 + 2 = 3

ex3.b = ex1.b + ex2.b = 2 + 3 = 5

ex3.c = ex1.c + ex2.c = (1+2) + (2+3) =8

 זו התוצאה שנקבל אחרי שה-operator overloading יוגדר לפי הדרישות הנ"ל.

אז איך מגדירים operator overloading?

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

type operator op(parameter list);

ובדוגמא שלנו למשל:

Example operator+(Example b);

למה המתודה מקבלת פרמטר יחיד - Example b ולא מקבלת את שני המחוברים? כלומר, למה לא לכתוב זאת כך:

Example operator+(Example a, Example b);

תשובה: 

רק המחובר השני מועבר כפרמטר. המחובר הראשון הוא האוביקט הלוקאלי (this).

הכל יהיה ממש ברור כשנסתכל על הדוגמא כולה. הנה היא:

1. /*
2.  * oveloading.cpp
3.  *
4.  *  Created on: Mar 21, 2012
5.  *      Author: ronen halevy
6.  */
7. 
   
8. #include <iostream>
9. using namespace std;
10. 
    
11. class Example{
12. private:
13. int a;
14. int b;
15. int c;
16. public:
17. Example(int a, int b):a(a),b(b){c = a + b;}
18. Example(){}
19. 
    
20. void sum(){c = a+b;}
21. int get_a(){ return a;}
22. int get_b(){ return b;}
23. int get_c(){ return c;}
24. void set_a(int _a){ a = _a;}
25. void set_b(int _b){ b = _b;}
26. void set_c(int _c){ c = _c;}
27. Example operator+(Example b);
28. };
29. Example Example::operator +(Example ex){
30. Example sum;
31. sum.set_a(a + ex.get_a());
32. sum.set_b(b + ex.get_b());
33. sum.set_c(c + ex.get_c());
34. return(sum);
35. }
36. 
    
37. int main(){
38.     Example ex1(1,2);
39.     Example ex2(2,3);
40.     Example ex3;
41.     ex3 = ex1.operator+(ex2); 
42.     ex3 = ex1+ex2;
43.     cout << " " << ex3.get_a() << " " << ex3.get_b() <<" " << ex3.get_c();
44. }

שורות 13-15 - בכתום: ה-data members של ה-class. הם יהיו האלמנטים שיחוברו באופרטור + שנגדיר.

שימו לב: ה-data members הנ"ל הם מסוג private. כדי שנוכל לגשת אליהם מבחוץ מוגדרים Setters ו- Getters עבור a, b ו-c.

שורות 21-26 - בצהוב: ה-Getters וה-Setters.

שורה 27 - בירוק ליים:

Example operator+(Example b);

זו ההגדרה של ה-operator overloading function. תבנית הפונקציה היא זו:

type operator op(parameter list);

כשבמקרה הנל:

ה-type הוא Example

ה- op הוא +

והפרמטר הוא המחובר השני Example b.

שורות 29-35: ממוש ה- operator overloading function. כפי שצוין למעלה, הגישה ל-data members של האובייקטים sum ו-ex אינה אפשרית כי הם private. מסיבה זו, השתמשנו ב-Setters ו- Getters שהם public.

 ונעבור לפונקציה המפעילה - main.

שורות 41 ו-42 מדגימות הצגה שונה של פונקצית האופרטור, אך הן שתיהן אקוויולנטיות.

שורה 41 מציגה פורמט ארוך יותר, שתואם את הפורמט הקונבנציונלי. המתודה +operator של האובייקט ex1 מופעלת עם פרמטר ex2.

   ex3 = ex1.operator+(ex2); 

והנה ההצגה המקוצרת, אליה שאפנו להגיע. פשוט משמיטים את operator.

    ex3 = ex1 + ex2;

הפלט למסך - בדיוק כפי שצפינו:

 3 5 8