עומס יתר על פונקציות ב- C ++: כל מה שאתה צריך לדעת



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

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

C ++ עומס יתר

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





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

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

types-of-overloading-in-c++

מהי עומס יתר על פונקציות ב- C ++?

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



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

על ידי שינוי מספר הארגומנטים

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

// הגדרת הפונקציה הראשונה int להוסיף (int a, int b) {cout<< a+b } // second overloaded function definition int add(int a, int b, int c) { cout << a+b+c }

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



int main () {add (10, 20) // add () with 2 parameter נקרא add (10, 20, 30) // sum () עם 3 פרמטר ייקרא}
# כלול באמצעות namespace std int add (int a, int b) {cout<< a+b <

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

בכך שיש טענות מסוגים שונים

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

# כלול באמצעות namespace std int add (int x, int y) // הגדרה ראשונה {cout<< x+y << endl return 0 } float add(float a, float b) { cout << a+b << endl return 0 } double add(double x, double y) { cout << x+y << endl return 0 } int main() { add(20, 40) add(23.45f, 34.5f) add(40.24, 20.433) }

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

יתרונות פונקציית עומס יתר ב- C ++

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

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

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

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

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

  • זה עוזר ליישום לטעון את שיטת הכיתה בהתבסס על סוג הפרמטר.

  • תחזוקת קוד קלה.

חסרונות של עומס יתר בפונקציה ב- C ++

  • לא ניתן להעמיס הצהרות על פונקציות הנבדלות רק לפי סוג ההחזר שלהן בתהליך העמסת פונקציות.
  • לא ניתן להעמיס הצהרות על פונקציות חבר באותם פרמטרים או אותם סוגי שמות אם מישהו מהם מוכרז כפונקציה של חבר סטטי.
  • class XYZ {funic ריק ריק () פונקציה ריק () // שגיאה}

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

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

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

סוג המרה:

# כלול שימוש בפונקציית חלל שמות std void (float) פונקציית void (int) פונקציית void (float x) {std :: cout<< 'Value of x is : ' <

הדוגמה לעיל מטילה שגיאה - 'קריאה של 'פונקציה (כפולה)' עמוסה אינה דו משמעית'. הפונקציה (3.4) תקרא לפונקציה הראשונה. הפונקציה (34) מכנה את הפונקציה השנייה על פי התחזית שלנו. אבל זה לא מה שקורה מכיוון שב- C ++ מתייחסים לכל קבועי הנקודה הצפה ככפול ולא כאל צף. אם נחליף את המשתנה לצוף למשתנה כפול, התוכנית תפעל בסדר. לכן אנו קוראים לזה שגיאת המרה מסוג מ- float ל- double.

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

# כלול שימוש בפונקציית החלל std פונקציה בטל (int) חלל (int, int) פונקציית חלל (int x) {std :: cout<< 'Value of x is : ' <

הדוגמה שלעיל נותנת שגיאה האומרת 'קריאה של 'כיף (אינט)' עמוסה אינה חד משמעית', מכיוון שניתן לקרוא לפונקציה (int y, int z = 12) בשתי דרכים:

מה מבוי סתום בג'אווה
  1. על ידי קריאה לפונקציה עם ארגומנט אחד (והיא תיקח אוטומטית את הערך של z = 12)
  2. על ידי קריאה לפונקציה בשני טיעונים.

כאשר אנו קוראים לפונקציה: פונקציה (12) אנו ממלאים באופן מלא את מצב הפונקציה (int) ופונקציה (int, int) וכך המהדר נקלע לעמימות מראה שגיאה.

פונקציה עם מעבר לפי הפניה

# כלול באמצעות פונקציית חלל שמות std פונקציה בטל (int) פונקציה (int &) בטל (int a) {std :: cout<< 'Value of a is : ' < 

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

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

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