כיצד ליישם עומס יתר של מפעילים ב- c ++?



במאמר זה נבחן מושג אחר מונחה עצמים ההופך את הטיפול במפעילים לקל. נלמד עומס יתר של מפעילים ב- C ++.

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

אז בואו נתחיל במאמר זה בנושא עומס יתר על המפעיל ב- C ++.





עומס יתר ב- C ++

אם אנו יוצרים שניים או יותר מאותו מחלקה בעלי שם זהה אך שונים במספר או סוג הפרמטר, זה מכונה C ++ עומס יתר.



מה זה אידיאה של ג'אווה

ב- C ++ נוכל להעמיס יתר על המידה:

  • שיטות
  • בונים
  • נכסים צמודים

זה בגלל שלחברים האלה יש פרמטרים בלבד.

ממשיך הלאה עם מאמר זה על עומס יתר על המפעיל ב- C ++.



סוגי עומס יתר ב- C ++

  • העמסת יתר על הפונקציה
  • העמסת יתר על המפעיל

עומס יתר - העמסת יתר על המפעיל ב- C ++ - אדוריקה

ממשיך הלאה עם מאמר זה על עומס יתר על המפעיל ב- C ++.

מדוע משתמשים בעומס יתר של המפעיל?

ניתן לכתוב תוכניות C ++ ללא ידיעת עומס יתר על ידי המפעיל. אז גם הפעלת מפעילים משמשת עמוקות על ידי מתכנתים כדי להפוך את התוכנית לאינטואיטיבית. לדוגמה,

אנו יכולים להחליף את הקוד כמו:

חישוב = הוסף (חלק (a, b), הכפל (a, b))

למשוואה

חישוב = (a / b) + (a * b)

העמסת יתר על המפעיל מספקת דרך פשוטה וקלה לפיתוח הגדרות חדשות עבור מרבית המפעילים ב- C ++. עם ידע מספיק, אנחנו יכולים כמעט ליצור שפה חדשה משלנו על ידי שימוש יצירתי בפונקציות וטכניקות העמסת יתר של המפעיל. אנו יכולים להעמיס על כל המפעילים ב- C ++ למעט הדברים הבאים:
● מפעיל היקף (: :)
● אופרטור גודל (Sizeof)
● בורר חברים (.)
● בורר מצביע חברים (*)
● מפעיל טריני (? :)

תחביר של העמסת יתר על המפעיל

return_type class_name:: operator op (argument_list) {// body function}

כאשר סוג ההחזרה הוא סוג הערך שהפונקציה מחזירה. class_name הוא שם הכיתה.

ממשיך הלאה עם מאמר זה על עומס יתר על המפעיל ב- C ++.

יישום העמסת יתר של מפעילים ב- C ++

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

מה ההבדל בין פונקציות אופרטור לפונקציות רגילות?

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

ממשיך הלאה עם מאמר זה על עומס יתר על המפעיל ב- C ++.

סוגי גישות עומס יתר

ניתן לבצע העמסת יתר של המפעיל באמצעות שלוש גישות, כך הן

  • עומס יתר על המפעיל האונרי.
  • העמסת יתר על המפעיל הבינארי.
  • העמסת יתר על המפעיל הבינארי באמצעות פונקציית חבר.

ממשיך הלאה עם מאמר זה על עומס יתר על המפעיל ב- C ++.

העמסת יתר על המפעיל האונרי

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

דוגמא:

# כלול שימוש במרחב השמות std class גובה {ציבורי: // אובייקטים חבר int רגליים, אינץ // בונה לאתחול ערך האובייקט גובה (int f, int i) {feet = f inch = i} // עומס יתר (-) אופרטור ל לבצע ירידה // פעולת אובייקט גובה ריק ריק- () {רגליים - אינץ '- cout<< 'Feet & Inches after decrement: ' << feet << ' ' ' << inch <

תְפוּקָה:

הֶסבֵּר:
בדוגמה שלעיל, אנו מעמיסים יתר על המידה של '-' כדי לבצע ירידה בשני המשתנים של מעמד הגובה. אנו מעבירים שני פרמטרים לבנאי ושומרים את ערכיהם במשתנים רגליים ואינץ '. ואז אנו מגדירים את פונקציית עומס המפעיל (חלל אופרטור- ()
) שבהם שני המשתנים מצטמצמים במיקום אחד.
כשאנחנו כותבים -h1 זה מכנה את פונקציית העמסת יתר של המפעיל ומוריד את הערכים שהועברו לבנאי.

ממשיך הלאה עם מאמר זה על עומס יתר על המפעיל ב- C ++.

העמסת יתר על המפעיל הבינארי

זהו עומס יתר של מפעיל הפועל בשני אופרנדים. בואו ניקח את אותה דוגמה למחלקה גובה, אך הפעם, נוסיף שני אובייקטים בגובה h1 ו- h2.

דוגמא:

# כלול שימוש בכיתת מרחב שמות std גובה {ציבורי: int רגליים, אינץ 'גובה () {רגל = 0 אינץ = 0} גובה (int f, int i) {רגל = f אינץ = i} // אופרטור עומס יתר (+) לביצוע תוספת של // אובייקט שני מרחק באמצעות אופרטור בינארי אופרטור גובה + (גובה & d2) // התקשר באמצעות הפניה {// צור אובייקט להחזרת גובה h3 // בצע תוספת של רגליים וסנטימטרים h3.feet = feet + d2.feet h3. אינץ '= אינץ' + d2.inch // להחזיר את האובייקט שהתקבל להחזיר h3}} int ראשי () {גובה h1 (3, 7) גובה h2 (6, 1) גובה h3 // השתמש במפעיל עומס יתר h3 = h1 + h2 cout<< 'Sum of Feet & Inches: ' << h3.feet << ''' << h3.inch << endl return 0 } 

תְפוּקָה:

הֶסבֵּר:
אופרטור גובה + (גובה & h2), כאן return_type של פונקציה הוא class Height ובכך הוא מחזיר אובייקט h3 של class Height. בשורה h3 = h1 + h2, h1 מכנה את פונקציית האופרטור של אובייקטים המחלקה שלה ולוקח h2 כפרמטר, ואז אנו מיישמים h3.feet = feet + d2.feet ו- h3.inch = inch + d2.inch המאחסן את סכום הערכים של המשתנים רגליים וסנטימטר במשתנים המשויכים לאובייקט h3.
כאשר המשפט 'h3 = h1 + h2' קורא לפונקציה העמוסה של המפעיל האובייקט h1 לקח את האחריות להפעיל את הפונקציה ו- h2 ממלא את תפקיד הטיעון שמועבר לפונקציה. משפט ההפעלה שלמעלה שווה ערך ל- h3 = h1.operator + (h2) ולכן ניתן לגשת ישירות לחבר הנתונים של h2 ולחבר הנתונים של h2 (שמועבר כארגומנט) באמצעות אופרטור הנקודה.

כללים לעומס מפעיל

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

לפיכך הגענו לסוף מאמר זה בנושא 'העמסת יתר על המפעיל ב- C ++'. אם ברצונך ללמוד עוד, עיין ב- Java Training של Edureka, חברת למידה מקוונת אמינה. אדוריקה הקורס נועד להכשיר אותך למושגי ליבה וגם למושגי ג'אווה מתקדמים יחד עם מסגרות ג'אווה שונות כמו Hibernate & Spring.

יש לך שאלה עבורנו? אנא הזכיר זאת במדור התגובות בבלוג זה ונחזור אליך בהקדם האפשרי.