העמסת אופרטור-Operator Overloading
>, + ו-++ לעבוד על מחלקה שאנחנו בונים, בדיוק כמו שהם עובדים על מספרים.> עובדים על מספרים, אבל על אובייקט של מחלקה שכתבנו הקומפיילר לא מאפשר אותם.Gold מתארת משקל של זהב. בלי העמסה, השורה g1 > g2 לא עוברת קומפילציה.public static bool operator >(Gold g1, Gold g2) שמחזירה g1.weight > g2.weight. האובייקט משמאל נכנס לפרמטר הראשון, והאובייקט מימין לשני.> בלי <. הקומפיילר מציג שגיאה, ולכן מעמידים גם את <, >= ו-<=.== ו-!=: ברירת המחדל של == משווה כתובות ולא תוכן, ולכן גם הם צריכים העמסה כדי להשוות לפי המשקל.operator + מחזיר אובייקט חדש שמשקלו הוא סכום המשקלים. operator - פועל באותה דרך.operator ++ מוסיף גרם אחד. כשהאופרטור מופיע מצד ימין של השמה, מתקבל הערך לפני הקידום, ואילו מצד שמאל מתקבל הערך אחרי הקידום.operator -- פועל באותה דרך ומוריד גרם אחד.public static explicit operator Gold(double weight) מאפשר לכתוב Gold g = (Gold)6.2;.explicit operator double(Gold g) מאפשר להמיר זהב למשקל מספרי.implicit במקום explicit מאפשרת המרה בלי סוגריים. בדרך כלל עדיף explicit, כי הכתיבה המפורשת מונעת המרה לא מכוונת.+ צריך לחבר ולא להכפיל, ומי שמשתמש במחלקה מצפה להתנהגות המוכרת.פרקי ההרצאה: העמסת אופרטור-Operator Overloading
תמלול ההרצאה: העמסת אופרטור-Operator Overloading
הטקסט המלא של הדקות הראשונות בהרצאה «העמסת אופרטור-Operator Overloading» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
אנחנו מגיעים לנושא מאוד מעניין באובג'קט אוריינטד שנקרא העמסת אופרטורים אופרטור אוברלואודינג אנחנו ראינו בעולם האלגוריתמיקה שניתן לבנות איזושהי פונקציה ולהעמיס אותה כלומר ניתן לבנות עוד פונקציה עם אותו השם רק אם המספר של הפרמטרים או הטיפוסים שלהם שונים
וכך כאשר אנחנו קוראים לפונקציה אז בעצם המערכת יודעת לאיזה לפונקציה לקפוץ לפי מספר הטיפוסים שיש או הסוגים של הטיפוסים. אבל השאלה היא האם המערכת יכולה לבצע את אותו הדבר עבור אופרטורים? זאת אומרת נניח שיש לנו פה איזשהו int x שווה 3 ו-int y שווה 4.
האם אנחנו יכולים לבדוק האם x יותר גדול מ-y? אז כמובן שאנחנו יכולים לעשות את זה מפני שאופרטור גדול מהם מסוגל לבצע פעולה על שני אינטג'רים.
אבל רגע, מה קורה אם y זה דאבל, האם עכשיו הדבר הזה הוא חוקי? בואו נראה. אם אנחנו נציג פה x is larger, if x isn't larger, כי הוא יכול להיות קטן או שווה, נריץ, ונראה שאין לנו שום בעיה לבצע השוואה של אופרטור
גדול מ- על אינטג'ר ועל דאבל. רגע, ואם אנחנו נבצע 4 וחצי ולא 4, כי 4 זה אינטג'ר? בואו נבדוק. אנחנו רואים שעדיין אין למערכת בעיה לבצע את זה.
זאת אומרת שאופרטור גדול מי יכול לפעול גם על שני אינטג'רים וגם לדוגמה על אינט ודאבל. אוקיי, אבל מה קורה אם יש לנו פה איזושהי מחלקה קלאס פרסון שמתארת בן אדם? ואנחנו, בוא נגיד לבן אדם יש public string full name ויש לנו פה איזשהו אובייקט פרסון.
פרסון p, בוא ניקח p1 שווה new person, p1 full name שווה מוישה פורן ואנחנו רוצים לבצע השוואה של x האם x יותר גדול מ-p1 ולאם כל האם זה בכלל הגיוני שנעשה דבר כזה אז אני לא חושב שזה כל כך הגיוני להשוות אדם מול מספר מה זאת אומרת אדם מול מספר ובאמת המערכת כבר כאן אומרת לנו אנחנו לא יכולים לעשות את זה מה פתאום אי אפשר
לבצע השוואה של אינטג'ר מול בן אדם וגם למה לנו לעשות דבר כזה? אבל מה היה קורה אם היו לנו שני אובייקטי פרסון, P1 ו-P2?
ו-P2 היה לו איזשהו פול ניים אחר, כמו דנה לוי, והאם אנחנו יכולים לבצע השוואה של האם P1 יותר גדול מ-P2? קודם כל אנחנו רואים שגם כאן המערכת לא נותנת לנו לעשות את זה, ויכול להיות שזה היה הגיוני ויכול להיות שזה לא היה הגיוני.
יכול להיות שהייתם אומרים, רגע, אני כן רוצה להשוות בין שני אנשים עם אופרטור גדול מאתם. ואז אולי הייתי רוצה להשוות את השמות שלהם, אולי הייתי רוצה להשוות את הגיל שלהם.
כלומר, יכול להיות שזה היה כן הגיוני, ויכול להיות שזה גם היה לא הגיוני. מה זאת אומרת להשוות האם בן אדם אחד יותר גדול מבן אדם שני? מה זה אומר, בגיל יותר גדול?
או שהשם שלו יותר גדול? אולי זה לא היה הגיוני. אז by default אנחנו רואים שכל האופרטורים בעצם לא ניתנים לשימוש על ידי מחלקות שאנחנו בונים.
עכשיו יכול להיות מצב שזה כן הגיוני שאנחנו נרצה שזה יהיה ניתן לשימוש. אולי עבור פרסון זה לא כל כך הגיוני. אבל בואו נבנה מחלקה אחרת שזה כן יהיה הגיוני לבצע כל מיני השוואות עם אופרטורים עליה ונראה איך אנחנו יכולים לבצע משהו שנקרא העמסת אופרטור ולומר לאופרטור גדול משהוא כן יוכל לעבוד
על טיפוסים של המחלקה שלנו בדיוק כמו שהוא יכול לעבוד לדוגמה על אינטג'ר. אז בואו נראה איך אפשר לעשות את זה. דבר ראשון ניפטר מכל מה שעשינו כאן, אנחנו לא נצטרך את הקוד הזה.
ניפטר מהמחלקה פרסון, שזה לא כל כך היה הגיוני לבצע אופרטור גדול מעליה. ובואו נניח שאנחנו עכשיו הולכים לבנות תוכנה עבור איזושהי חנות או מעבדה של צורפים.
כלומר, אנשים שמתעסקים בכסף וזהב. והתוכנה הזאת מיועדת לנהל זהב. ואנחנו רוצים בתוכנה לבנות מחלקה שנקראת גולד. והמחלקה הזאת מתארת בעצם זהב, אונקיית זהב, טיסת זהב או משהו שקשור לזהב.
ומה יש לזהב? בואו נניח שלזהב יש משקל. אז נייצר פה איזשהו פרייבט, ניקח דאבל ווייט, פאבליק דאבל ווייט שהולך להיות פרופרטי.
לסט אנחנו הולכים להכניס איזושהי בדיקה אם הvalue שמנסים להכניס קטן שווה לאפס מבחינתי זה לא חוקי נבצע throw new exception weight must be positive כך אף אחד לא יכול לבוא ולהכניס לנו ערך שגוי אם הכל בסדר weight שווה לvalue נבנה סיטור ריק נבנה סיטור מלא נכניס את ה-weight לקונסטרקטור
ונבנה פרינט אוקיי אז כרגע יש לנו איזושהי מחלקה שמתארת זהב והצורפים כרגע יכולים לעבוד עם הזהב, אבל הצורפים עושים כל מיני דברים עם זהב.
הם יכולים להתיך זהב, הם יכולים לקחת שני מתכות זהב ולחבר אותם ביחד, יש לנו פה כבר צורך בפלוס, או לחלק, להפריד, יש לנו צורך במינוס. זאת אומרת שיכול להיות מצב שאנחנו בעצם רוצים שיהיה לנו אפשרות בתוכנית לבצע כל מיני פעולות עם אופרטורים על אובייקטים מטיפוס גולד.
בואו נראה אם זה אפשרי ניקח גולד G1 שווה ניו גולד ונניח שאנחנו נותנים לו משקל של 2.5 נניח שזה גרמים בואו ניקח עוד גולד G2 וניתן לו 3.4 גרמים ואנחנו עכשיו רוצים לדעת איזה מהם יותר גדול האם G1 הוא יותר גדול מ-G2 יכול להיות שהמשתמש גם הכניס את הערכים האלה ואנחנו רוצים לבדוק מי יותר
גדול ממי בואו נרשום כזה דבר G1 נקודה או שנדפיס G1 נקודה weight is larger אם G1 יותר גדול אלס יש לנו פה את G2 נקודה weight is larger אבל בכלל אנחנו לא יכולים לעשות את זה כרגע מפני שבי דיפולט לא ניתן להפעיל על אופרטור גדול מ כל טיפוס של מחלקה שאנחנו בונים והנושא כרגע בווידאו זה איך אנחנו יכולים לאפשר את זה איך אנחנו יכולים להעמיס את האופרטור גדול מ כך שהוא
יוכל לעבוד ספציפית על אובייקטים מסוג גולד והביצוע של זה הוא מאוד מאוד פשוט. זה מתבצע בתוך המחלקה גולד, זאת אומרת אם אנחנו רוצים לאפשר את זה על בונה המחלקה לאפשר את זה וזה מתבצע בצורה הבאה אנחנו צריכים לבנות פונקציה בתוך המחלקה גולד
שנקראת פאבליק סטטיק הפונקציות האלה סטטיק ואנחנו צריכים לחשוב מה בדיוק האופרטור מחזיר אנחנו הולכים לבנות כרגע את האופרטור גדולמה כך שהוא ידע לקבל שני טיפוסים מסוג גולד אז מה בדיוק האופרטור מחזיר?
אז אנחנו יודעים שאופרטור גדולמה מחזיר ערך בוליאני אז אנחנו צריכים להחזיר מהפונקציה שלנו בוליאן שם הפונקציה חייבת להיות אופרטור גדולמה זה בדיוק האופרטור שאנחנו כותבים ומה שאנחנו הולכים לקבל עכשיו זה שני טיפוסים גולד גולד, נקרא לזה גולד 1 וגולד, גולד 2. עכשיו
אנחנו יודעים איך בדיוק אנחנו רוצים לבצע השוואה בין שני אובייקטי גולד ואנחנו רוצים לבצע את ההשוואה על ידי ה-weight, המשקל.
אז אנחנו רוצים להחזיר האם גולד 1.weight יותר גדול מגולד 2.weight וברגע שעשינו את זה אנחנו כבר רואים שאין לנו פה שגיאה שהייתה מקודם על ההשוואה בין G1 ל-G2.
בואו נבין מה דוטנט עושה. מה שדוטנט עושה היא אומרת דבר כזה שנייה לפני שאני הולכת לתת לכם פה שגיאת קומפילציה בואו נבדוק האם בניתם במחלקה גולד איזשהו אופרטור שמקבל שני טיפוסי גולד.
אם כן אני הולכת לשלוח את הטיפוס או יותר נכון את האובייקט שנמצא משמאל לאופרטור לפרמטר הראשון תמיד זה עובד ככה שמאל נכנס לראשון והפרמטר הימני מימין לאופרטור אנחנו הולכים לשלוח לפרמטר השני בפונקציה הפונקציה הולכת לבצע את ההשוואה מחזירה ערך ואז הערך הבוליאני הזה חוזר לפה ולכן אנחנו יודעים לפי מה לבצע השוואה
בין שני טיפוסי גולד אבל בואו נריץ קומפילציה ונראה אם זה עובר קומפילציה control shift b מריץ לנו קומפילציה ובעצם אנחנו רואים פה איזושהי שגיאת קומפילציה על האופרטור גדול מי כאשר אין לי שום שגיאה באופרטור גדול מי אבל בואו נקרא מה השגיאה
אומרת והשגיאה אומרת כזה דבר the operator גדול מי שמקבל שני גולדים requires a matching operator קטן מי to also be defined זאת אומרת שישנם זוגות של אופרטורים שחייבים לבוא ביחד אופרטורים מסוימים שנמצאים בזוגות ואחד מהם זה גדול מי.
אם אתם בונים אופרטור גדול מי המערכת אומרת לכם אתם חייבים לספק לנו אופרטור קטן מי אז בואו נבנה גם אופרטור קטן מי שמקבל שני גולדים ומחזיר true אם הגולד הראשון יותר קטן מהגולד השני נריץ קומפילציה ועכשיו אין שום בעיה בואו נריץ את זה ונראה שהוא אומר לנו 3.4 is larger שבייסיקלי זה מאוד נכון בואו ננסה
את קטן מ נריץ ונראה שהוא אומר לנו 2.5 is larger כי בייסיקלי לא שיניתי את ההודעה ובואו נגדיר אם אנחנו משווים קטן מהם אז g1.weight is smaller ו-G2.weight is smaller or isn't smaller יותר נכון או ליתר דיוק G2.weight is smaller or equal to בואו נריץ ונראה שעכשיו 2.5 is smaller סבבה
בואו ננסה עכשיו את אופרטור קטן שווה ונחטוף שגיאת קומפילציה מפני שקטן שווה וגדול שווה ושווה שווה ושונה מכל אלה הם אופרטורים אחרים שאנחנו נאלצים ללכת ולהעמיס אותם אם אנחנו רוצים וכנראה שאם יש לנו גדול מי וקטן מי אנחנו נרצה את כל אופרטורי ההשוואה האחרים בסדר אז בואו נעמיס גם אותם הם מאוד מאוד פשוטים יש לנו פה גדול שווה
גם הוא לפי המשקל כולם בעצם הולכים להיות לפי המשקל קטן שווה ניקח את שווה ושונה שגם אותם אנחנו חייבים לבצע השוואה כעת יש לנו את כל אופרטורי ההשוואה מוכנים בואו נסתכל רגע האם G1 שווה שווה ל-G2?
אם כן נציג G1 is equal to G2. אחרת G1 isn't equal to G2. בואו נריץ ונראה שהם שונים. נגדיר ששניהם אותו הדבר 2.5 ונראה ששניהם שווים.
אם אנחנו הולכים ומוחקים את האופרטור שווה אז אנחנו בעצם הולכים לראות שהמערכת מבצעת משהו דומה. בעצם אנחנו רואים שאין לנו פה שגיאת קומפילציה אבל השאלה האם האופרטור שווה שווה הוא נכון.
בואו נריץ ונראה שהוא אומר לנו G1 איזנט איכול to G2. איך זה יכול להיות? הם שווים. מפני שביידיפולט אופרטור שווה שווה משווה כתובות הוא לא משווה את הערכים שאנחנו יודעים שצריך להשוות אותם.
זה הסיבה שזה לא עזר לנו כל כך גם אופרטור שונה מהם. בואו נסתכל ונראה שעכשיו הוא אומר לנו ש-G1 is איקואל ו-G2 כאשר היינו צריכים להחליף אותם אם הם שונים בוא תדפיס לנו שהם שונים מה הוא אומר לנו G1 איזנט איקואל בואו נסתכל לא הם שווים זאת אומרת שהאופרטורים האלה לא ממש עזרו לנו אז אם אנחנו הולכים ומעמיסים את האופרטורים האלה ואומרים למערכת איך באמת
הם צריכים לעבוד הם לא צריכים לעבוד על האובייקטים עצמם אלא על ה-weight שנמצא בתוך האובייקט עכשיו הכל בסדר אנחנו רואים שהם שווים בסדר כל אלה היו אופרטורי השוואה קומפריסון אופרטור דרך אגב אם אנחנו נריץ את זה עם דיבאגר אנחנו נוכל לראות בדיוק לאן הוא נכנס יש לנו פה את השונמה נבצע קפיצה ונראה שהוא נכנס לשונמה בדיוק לאופרטור
גולד אחד מקבל את האופרטור הראשון שתיים וחצי גולד שתיים מקבל את האופרטור השני שגם הוא היה שתיים וחצי בסדר, בואו שנייה נעצור ונשנה אותם בכדי לראות באמת את הערכים.
זה 3.4, נריץ את זה F5, ניכנס עם F11 ונגיע למצב שבו האופרטור הראשון, האובייקט הראשון קיבל 2.5 כי זה G1 ו-G1 יש לו 2.5.
גולד 2 קיבל את G2 וזה יהיה 3.4. הם כמובן שונים ולכן אנחנו הולכים להחזיר false ולהיכנס, סליחה, להחזיר true כי הם אכן שונים, ולהיכנס לאיף טוב מה בקשר לאופרטורים אחרים לגמרי לדוגמה אופרטורים מתמטיים האם אנחנו יכולים לבצע העמסה של אופרטור פלוס או אופרטור מינוס יכול להיות שזה הגיוני
לנו לעשות את זה לדוגמה אולי אותו צורף רוצה לבצע בתוכנה חיבור של שני אובייקטי זהב שתי מתכות זהב למתכת זהב נוספת שלישית בואו נראה אם זה ניתן לביצוע כך public static אבל בואו נחשוב רגע אם אנחנו מעמיסים אופרטור פלוס מה הוא בדיוק מחזיר לנו?
אופרטור פלוס אמור להיות מופעל בצורה הבאה שימו לב בואו ניפטר רגע מהעקיף הזה ונבצע דבר כזה גולד g3 שווה ל-g1 ועוד g2 ככה אני אמור לעבוד עם אופרטור פלוס לחבר שתי פיסות זהב ולהגיע לפיסת זהב שלישית ולאחר מכן בואו נגיד g3 נקודה פרינט בכדי לראות את התוצאה כבר אנחנו רואים שיש לנו פה שגיאת
קומפילציה מפני שלא העמסנו אופרטור פלוס אז בואו נחשוב מה הוא אמור