פרק 3

פונקציות:

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

לכל פונקציה יש ארבעה חלקים:

1. שם הפונקציה. שם הפונקציה יכול להיות מורכב מתווים גדולים או קטנים ומקו תחתון "_" להפרדה בין מילים. שם הפונקציה צריך להיות בעל משמעות אשר תרמוז על מהותה.
2. הטיפוס של הערך שהפונקציה מחזירה, כאשר היא מסיימת את פעולתה.
3. הנתונים שהפונקציה מקבלת בכדי לבצע את פעולתה- רשימת ארגומנטים המציינת את טיפוס הנתונם של כל ארגומנט.
4. בלוק קוד (גוף הפונקציה) המכיל את ההוראות שעל הפונקציה לבצע.

(float add (int a, float b  

פרמטרי הפונקציה בדוגמה שלנו : (int a, float b)

שם הפונקציה בדוגמה שלנו : add

סוג ערך מוחזר בדוגמה שלנו : float  

שלושת עקרונות הפונקציה:

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

תכונות הפונקציה:

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

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

לדוגמה:  

#include<iostream.h>  
#include<conio.h> 

   int mult(int x,int y);  
   int main() 
   { 
        int x,y; 
        cout<<"please input two numbers to be multiplied:"; 
        cin>>x>>y; 
        cout<<"the product of your two numbers is:"<<mult(x,y); 
        getch();  
        return 0; 
        } 
        int mult(int x,int y)  
        { 
          return x*y; 
   } 

התוצאה של הכפלת שני המספרים שהמשתמש מכניס.  

הסבר התוכנית: השורה ;(int mult(int x,int y היא בעצם ההצהרה שלנו על הפונקציה. הצהרה זו אומרת שבתוכנית זו תוגדר פונקציה בשם mult . הפונקציה mult מוגדרת כך שהיא מקבלת שני משתנים x ו y מסוג int וכמו כן היא מחזירה ערך,גם הוא מסוג int . תפקידה של הפונקציה הוא לכפול את שני המשתנים x ו y ואת תוצאת הכפל להחזיר. בפונקצית main אנו מבקשים מהמשתמש להכניס שני מספרים. ולאחר הכנסת שני המשתנים מתבצעת הקריאה לפונקציה (mult(x,y . בקריאה אנו בעצם עוברים לפונקציה ומתחילים לבצעה. במקרה שלנו הכפלת שני המספרים שהמשתמש הכניס. נשים לב שבעת הקריאה לפונקציה אין אנו רושמים את הערך המוחזר אלא רק את שם הפונקציה ואת הערכים שהיא מקבלת.  

הצהרה על פונקציה:

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

הגדרה של פונקציה:

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

מקום הגדרת הפונקציה:

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

קריאה לפונקציה:

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

פרמטרי הפונקציות:

פרמטרי הפונקציות מוגדרים בתוך הסוגריים שלאחר שם הפונקציה עם פסיקים ביניהם. קיימת אפשרות להגדרת פרמטרים מסוגים שונים. כמו: float add(int a, (float b, char c . בזמן הקריאה לפונקציה מועתקים הערכים למשתנים אלו. מספר הפרמטרים האקטואליים צריך להיות זהה למספר הפרמטרים הפורמליים. בהגדרת הפרמטרים ירשם סוג המשתנה עבור כל משתנה לחוד, כלומר בניגוד להגדרה רגילה של משתנים בה ניתן לרשום את סוג המשתנה עבור מספר משתנים מאותו סוג.  

הגדרת משתנים רגילה ;int a,b,c

הגדרת המשתנים בפונקציה (add(int a, int b, int c

רישום לא נכון!!! (add(int a, b, c

סוג הערך המוחזר:

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

פונקציה המחזירה void :

פונקציה המחזירה void היא בעצם פונקציה שלא מחזירה ערך כלל.

משתנים בתוך הפונקציה:

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

#include <iostream.h> 
#include <conio.h> 
	 
      double power_loss(double R, double I); 
      void main() 
      { 
         double p; 
         float x = 1, y = 2; 
         double z = 3, w = 40.5; 
         p = power_loss(3 , 4); 
           cout<<p<<endl;  
         p = power_loss(x , y); 
           cout<<p<<endl;  
         p = power_loss(z , w); 
           cout<<p<<endl; 
         getch(); 
      } 
      double power_loss(double R, double I) 
      { 
         double watts; 
         watts = R * I * I; 
         return watts; 
      }

פלט התוכנית:

48

4

4920.75  

בתוכנית זו הגדרנו פונקציה power_loss .זוהי פונקציה המקבלת שני משתנים מסוג double ומחזירה משתנה מסוג double. כשאנו כותבים שורה ;(p = power_loss(3,4 זאת אומרת שאנו קוראים לפונקציה power_loss ,אנו מעבירים לפונקציה שני ערכים 3 ו 4 . כעת התוכנית עוברת לביצוע הפונקציה ,וכמו שניתן לראות בשורה האחרונה של הפונקציה יש לנו פקודת return שבעצם מחזירה לנו את הערך שחושב בפונקציה ,ומכניסה אותו למשתנה p .