מבוא לפונקציות C

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

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

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

מהן פונקציות ב-C?

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

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

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

שלושת ההיבטים הללו הם בסיסיים לשימוש בפונקציות.

הצהרת פונקציה

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

return_type function_name(parameters);

איפה:

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

לדוגמה, הנה הצהרת פונקציה פשוטה:

intadd(int a, int b);

הגדרת פונקציה

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

return_type function_name(parameters){
// Function body - code that defines what the function does
// Return a value if applicable
return value;
}

בואו נפרק חלקים מהתחביר:

גוף פונקציה: זהו גוש הקוד המוקף בסוגריים מסולסלים {}. הוא מכיל את ההוראות שמגדירות מה הפונקציה עושה כאשר היא נקראת.

הצהרת החזרה: אם לפונקציה יש סוג החזרה אחר מאשר בָּטֵל, ה לַחֲזוֹר הצהרה שולחת ערך חזרה למתקשר. ערך זה צריך להתאים לסוג ההחזרה שצוין.

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

intadd(int a, int b){
int sum = a + b;
return sum;
}

שיחת פונקציה

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

return_type result = function_name(arguments);

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

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

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

#include
// Function prototype
intadd(int a, int b);
intmain(){
int x = 5, y = 3;
// Call the function and store the result in 'sum'
int sum = add(x, y);
printf("The sum of %d and %d is %d\n", x, y, sum);
return0;
}
// Function definition
intadd(int a, int b){
return a + b;
}

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

פרמטרים של פונקציות וערכי החזרה

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

ישנן שתי שיטות להעברת פרמטרים.

עוברים לפי ערך

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

לדוגמה:

#include
intsquare(int num){
 num = num * num;
return num;
}
intmain(){
int x = 5;
int y = square(x);
// Output: x and y after function call: 5 25
printf("x and y after function call: %d %d\n", x, y);
return0;
}

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

עוברים ליד הפניה

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

מצביעים, כולל השימוש בהם כפרמטרים, הם אחד ההיבטים של C שעושים את זה שונה משפה כמו Python.

#include
voidsquare(int *num){
 *num = *num * *num;
}
intmain(){
int x = 5;
 square(&x);
// Output: x after function call: 25
printf("x after function call: %d\n", x);
return0;
}

• ה כיכר הפונקציה לוקחת מצביע של מספר שלם (int *) פרמטר, מספר. זה לא מחזיר ערך.
• הפונקציה הריבועית מחשבת את הריבוע של הערך ש מספר מכיל ומעדכן את הערך הזה באמצעות אופרטור ה-pointer dereference, *.
• ה רָאשִׁי הפונקציה מכריזה על משתנה מספר שלם, איקס, ומקצה לו את הערך 5.
• לאחר מכן הוא קורא ל- כיכר פונקציה עם מצביע ל איקס באמצעות ה- address of operator: &איקס.
• לאחר קריאת הפונקציה, main מדפיס את הערך של איקס, שהוא עכשיו 25 מאז השינויים ל *מספר בתוך ה כיכר הפונקציה משפיעה על המקור איקס.

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

לשפות אחרות יש לרוב מקבילה למצביעים של C, אבל הם בדרך כלל עובדים ברמה גבוהה יותר. דוגמה אחת היא תמיכה של C# במשתני Out.

פונקציות בטלות

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

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

#include
// Void function with no parameters
voidgreet(){
printf("Hello, MUO!");
}
intmain(){
// Call the void function, output: "Hello, MUO!"
 greet();
return0;
}

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

חקור פונקציות בתכנות C

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

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