מבוא כללי למדעי המחשב שיעור 4 מרצה: שי גוטנר

חזרה - משתנים מסוג char משתנים אלו מיצגים תווים. משתנים אלו מיצגים תווים. לכל תו יש קוד מספרי שמייצג אותו לכל תו יש קוד מספרי שמייצג אותו קוד זה נקרא קוד הASCII. קוד זה נקרא קוד הASCII. נתון הקוד הבא: נתון הקוד הבא: char ch; char ch; ch = ‘a’; ch = ‘a’; קוד זה זהה לדבר הבא: קוד זה זהה לדבר הבא: ch = 97; ch = 97; וזאת משום ש 97 הוא קוד הAscii של ‘a’. וזאת משום ש 97 הוא קוד הAscii של ‘a’. כלומר במשתנה ch יושב מספר למעשה העובדה שסוג המשתנה הוא char מאפשרת לנו עבודה ישירה באמצעות תווים. כלומר במשתנה ch יושב מספר למעשה העובדה שסוג המשתנה הוא char מאפשרת לנו עבודה ישירה באמצעות תווים.

חזרה-Flow of Control לולאות לולאות for(expr1;expr2;expr3) for(expr1;expr2;expr3){…} while(expr2)while(expr2){…} dodo{… } while(expr2); expr1 מתבצע פעם אחת בהתחלה expr2 הוא התנאי לכניסה ללולאה expr3 מתבצע בסיום כל סיבוב

חזרה-Flow of Control לולאות לולאות for(expr1;expr2;expr3) for(expr1;expr2;expr3){…} while(expr2)while(expr2){…} dodo{… } while(expr2); כל עוד expr2 מתקיים הלולאה מתבצעת

חזרה-Flow of Control לולאות לולאות for(expr1;expr2;expr3) for(expr1;expr2;expr3){…} while(expr2)while(expr2){…} dodo{ … } while(expr2); לולאה מתבצעת לפחות פעם אחת

חזרה - break/continue break מפסיק מידית את ריצת הלולאה ומדלג לשורה הבאה אחרי הלולאה break מפסיק מידית את ריצת הלולאה ומדלג לשורה הבאה אחרי הלולאה continue - מדלג על הסיבוב (האיטרציה) הנוכחית (while, do while עובר לבדיקת התנאי) (for עובר לביצוע expr3 ורק לאחר מכאן לבדיקת התנאי expr2 ) continue - מדלג על הסיבוב (האיטרציה) הנוכחית (while, do while עובר לבדיקת התנאי) (for עובר לביצוע expr3 ורק לאחר מכאן לבדיקת התנאי expr2 )

- תרגום ציון אמריקאיswitch חזרה - תרגום ציון אמריקאיswitch חזרה char grade; scanf(“%c”, &grade); switch (grade) { case ‘A’: printf(“90 – 100\n”); break; case ‘B’: printf(“80 – 89\n”); break; case ‘C’: printf(“70 -79\n”); break;default:printf(“Failed\n”);} הביטוי שערכו נבדק – הוא יכול להיות כל ביטוי מטיפוס בדיד (תו או מספר שלם). הבדיקה היא אם הביטוי הנ"ל שווה לאחד מהקבועים הרשומים (לפי הסדר)

- תרגום ציון אמריקאיswitch חזרה - תרגום ציון אמריקאיswitch חזרה char grade; scanf(“%c”, &grade); switch (grade) { case ‘A’: printf(“90 – 100\n”); break; case ‘B’: printf(“80 – 89\n”); break; case ‘C’: printf(“70 -79\n”); break;default:printf(“Failed\n”);} הביטוי שערכו נבדק – הוא יכול להיות כל ביטוי מטיפוס בדיד (תו או מספר שלם). הבדיקה היא אם הביטוי הנ"ל שווה לאחד מהקבועים הרשומים (לפי הסדר) אם נמצא שוויון, כל הפקודות משם והלאה מבוצעות

- תרגום ציון אמריקאיswitch חזרה - תרגום ציון אמריקאיswitch חזרה char grade; scanf(“%c”, &grade); switch (grade) { case ‘A’: printf(“90 – 100\n”); break; case ‘B’: printf(“80 – 89\n”); break; case ‘C’: printf(“70 -79\n”); break;default:printf(“Failed\n”);} הביטוי שערכו נבדק – הוא יכול להיות כל ביטוי מטיפוס בדיד (תו או מספר שלם). הבדיקה היא אם הביטוי הנ"ל שווה לאחד מהקבועים הרשומים (לפי הסדר) אם נמצא שוויון, כל הפקודות משם והלאה מבוצעות הפקודה הזו אומרת לא לבצע את הפקודות שמופיעות במקרים הבאים

- תרגום ציון אמריקאיswitch חזרה - תרגום ציון אמריקאיswitch חזרה char grade; scanf(“%c”, &grade); switch (grade) { case ‘A’: printf(“90 – 100\n”); break; case ‘B’: printf(“80 – 89\n”); break; case ‘C’: printf(“70 -79\n”); break;default:printf(“Failed\n”);} הביטוי שערכו נבדק – הוא יכול להיות כל ביטוי מטיפוס בדיד (תו או מספר שלם). הבדיקה היא אם הביטוי הנ"ל שווה לאחד מהקבועים הרשומים (לפי הסדר) אם נמצא שוויון, כל הפקודות משם והלאה מבוצעות (אפשריים גם בלוקים של פקודות) הפקודה הזו אומרת לא לבצע את הפקודות שמופיעות במקרים הבאים מבוצע אם לא נמצאה אף התאמה (זה חלק אופציונלי – לא חייבים לתת ברירת מחדל)

switch מבנה כללי של switch (ביטוי בדיד) { case קבוע1: פקודה או פקודות פקודה או פקודות break; (אופציונלי) case קבוע2 : פקודה או פקודות break; (אופציונלי) ….. default: (אופציונלי) פקודה או פקודות } בדיד – תוצאתו היא מס' שלם או תו

switch מבנה כללי של לא נשתמש ב- break כשנרצה לעשות אותו דבר בכמה מקרים. לדוגמא: לא נשתמש ב- break כשנרצה לעשות אותו דבר בכמה מקרים. לדוגמא: switch (tav) { case ‘0’: case ‘1’: case ‘2’: case ‘3’: case ‘4’: case ‘5’: case ‘6’: case ‘7’: case ‘8’: case ‘9’: printf(“It’s a digit\n”); printf(“It’s a digit\n”); break; break;default: printf(“It’s not a digit\n”); printf(“It’s not a digit\n”);} השורה תבוצע אם התו הוא סיפרה בכל מיקרה אחר

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

מערכים עד היום כדי לייצג 20 סטודנטים נאלצנו להגדיר עד היום כדי לייצג 20 סטודנטים נאלצנו להגדיר int grade1, grade2, …, grade20; int grade1, grade2, …, grade20; שימוש במערך מאפשר לנו להגדיר שימוש במערך מאפשר לנו להגדיר int grade[20]; int grade[20]; או לכל טיפוס נגדיר או לכל טיפוס נגדיר type name[100]; type name[100];

מערכים הפניה לאברי המערך נעשית באמצעות אינדקס. הפניה לאברי המערך נעשית באמצעות אינדקס. לאיבר הראשון נפנה כך: לאיבר הראשון נפנה כך: grade[0] grade[0] לאיבר האחרון נפנה כך: לאיבר האחרון נפנה כך: grade[19] grade[19] באמצעות הגדרה זו הגדרנו 20 משתנים מסוג int היתרון הגדול הוא שכעת ניתן לגשת אליהם באמצעות לולאה. באמצעות הגדרה זו הגדרנו 20 משתנים מסוג int היתרון הגדול הוא שכעת ניתן לגשת אליהם באמצעות לולאה.

אתחול מערכים אתחול באמצעות לולאה אתחול באמצעות לולאה #define SIZE 10 int main() { int i, arr[SIZE]; for(i = 0; i < SIZE; i++) arr[i] = 0; { נשים לב שהלולאה מתחילה מ 0. קבוע שקובע את גודל המערך איפוס המערך באמצעות לולאה

אתחול מערכים אתחול בשורת ההגדרה (אפשרי רק בשורת ההגדרה). אתחול בשורת ההגדרה (אפשרי רק בשורת ההגדרה). int main() { int arr[SIZE] = {0}; }

באמצעות אתחול בשורת ההגדרה ניתן לאתחל כל אחד מאיברי המערך למשל באמצעות אתחול בשורת ההגדרה ניתן לאתחל כל אחד מאיברי המערך למשל int arr[5] = {1,2,3,4,5}; int arr[5] = {1,2,3,4,5}; מה שקורה זה מה שקורה זה arr[0] = 1, arr[1] = 2,…, arr[4] = 5 arr[0] = 1, arr[1] = 2,…, arr[4] = 5 זה שקול לשורה באה זה שקול לשורה באה int arr[ ] = {1,2,3,4,5}; int arr[ ] = {1,2,3,4,5};

int arr[5] = {1,2}; int arr[5] = {1,2}; במקרה זה איברי המערך יקבלו את הערכים: במקרה זה איברי המערך יקבלו את הערכים: arr[0] = 1, arr[1] =2 arr[0] = 1, arr[1] =2 arr[2] = arr[3] = arr[4] = 0 arr[2] = arr[3] = arr[4] = 0 אם ניתן רשימה ארוכה מדי אז זו טעות. אם ניתן רשימה ארוכה מדי אז זו טעות.

נכתוב תוכנית המדפיסה את איברי המערך והיסטוגרמה של האיברים נכתוב תוכנית המדפיסה את איברי המערך והיסטוגרמה של האיברים לדוגמא: לדוגמא: אם איברי המערך הם אז יודפס אם איברי המערך הם אז יודפס 0 1 * 1 2 ** 2 4 **** מערכים

תוכנית המדפיסה את איברי המערך והיסטוגרמה שלהם #include #include #define SIZE 6 Int main() { int arr[SIZE] = {4, 3, 5, 7, 1, 3}; int i,j;

תוכנית המדפיסה את איברי המערך והיסטוגרמה שלהם for(i = 0; i < SIZE; i++) { printf(“%7d%7d “, i, arr[i]); for(j = 0; j < arr[i]; j++) printf(“*”);printf(“\n”);} return 0; }

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

מערכים #include #include int main() { inti,frequency[7]={0}; intgrade; printf(“Insert your grade\n”); scanf(“%d”,&grade); קלט ראשוני איפוס

מערכים …. while (grade != -1) {frequency[grade-1]++; printf(“Insert you grade\n”); scanf(“%d”,&grade);} לולאה עד 1-

מערכים for(i=1;i<=7;i++) printf(“The grade %d appears %d”, i, frequency[i-1]); return 0; } הדפסה

מחרוזות מחרוזות ב C הן פשוט מערכים שאיבריהם הם תווים. מחרוזות ב C הן פשוט מערכים שאיבריהם הם תווים. המוסכמה בנוגע למחרוזות היא שמחרוזות מסתיימות ב תו מיוחד אשר מסמן את סוף המחרוזת. תו זה הוא ‘\0’ שקוד ה ascii שלו הוא 0. המוסכמה בנוגע למחרוזות היא שמחרוזות מסתיימות ב תו מיוחד אשר מסמן את סוף המחרוזת. תו זה הוא ‘\0’ שקוד ה ascii שלו הוא 0.

מערכים – סיכום משמשים להגדרת קבוצות משתנים מאותו הסוג. משמשים להגדרת קבוצות משתנים מאותו הסוג. ניתן לפנות לכולם באמצעות שם המערך בצרוף אינדקס. ניתן לפנות לכולם באמצעות שם המערך בצרוף אינדקס. המערך מתחיל מ 0. המערך מתחיל מ 0. גודל המערך חייב להיות קבוע. גודל המערך חייב להיות קבוע. פניה לאיבר במערך עם אינדקס מחוץ לתחום המערך למשל בתוכנית הקודמת פניה ל frequency[7] לא תייצר טעות קומפילציה אלא טעות בזמן ריצה. פניה לאיבר במערך עם אינדקס מחוץ לתחום המערך למשל בתוכנית הקודמת פניה ל frequency[7] לא תייצר טעות קומפילציה אלא טעות בזמן ריצה.

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

פונקציות אוסף הפונקציות הללו מתחלק ל: אוסף הפונקציות הללו מתחלק ל: פונקציות שנכתבו ע"י המתכנת שכותב את התוכנית. פונקציות שנכתבו ע"י המתכנת שכותב את התוכנית. פונקציות שנכתבו ע"י מתכנתים אחרים או כותבי השפה. פונקציות שנכתבו ע"י מתכנתים אחרים או כותבי השפה.

תוכנית פשוטה שראינו בשיעור הראשון: #include int main() { int a, b, sum; printf(“Enter an integer\n”); scanf(“%d”, &a); printf(“Enter an integer\n”); scanf(“%d”, &b); sum = a + b; printf(“%d + %d = %d\n”, a, b, sum); return 0; }

הפונקציות בתוכנית #include int main() { int a, b, sum; printf(“Enter an integer\n”); scanf(“%d”, &a); printf(“Enter an integer\n”); scanf(“%d”, &b); sum = a + b; printf(“%d + %d = %d\n”, a, b, sum); return 0; } פונקציות ספרייה הנמצאות ב- stdio.h פונקציות הממומשות על ידנו

קריאה לפונקציה כותבים את שמה של הפונקציה ובתוך סוגריים מעבירים לה את הערכים שהיא אמורה לקבל. כותבים את שמה של הפונקציה ובתוך סוגריים מעבירים לה את הערכים שהיא אמורה לקבל. function_name(parameter1,..,parametern) function_name(parameter1,..,parametern) printf(“print the value of a %d”, a); printf(“print the value of a %d”, a); שם הפונקציה הערכים שמועברים לפונקציה

פונקציות ספרייה קלט/פלט – stdio.h קלט/פלט – stdio.h טיפול בזיכרון stdlib.h (בהמשך) טיפול בזיכרון stdlib.h (בהמשך) טיפול במחרוזות string.h (בהמשך) טיפול במחרוזות string.h (בהמשך) פונקציות מתמטיות math.h פונקציות מתמטיות math.h

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

NameUseExample fabs Returns absolute value db = fabs(db) cos Calculate cosine db = cos(2.4) sin Calculate sine tan Calculate tangent log Calculate natural logarithm log(e) log10 Base 10 logarithm log10(100) pow Calculate value raised to a power db = pow(db,3) sqrt Find square root db = sqrt(db)

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

הגדרת הפונקציות return_value_type function_name(parameter list) }declarationsstatements{ הפרמטרים מופרדים בפסיק גוף הפונקציה (מימוש)

הצורך בפונקציות - המחשה int main() { int x; printf(“x^3=%d\n”, x*x*x); …….. ……..} למה לחזור שוב ושוב על אותה פעולה? למה לחזור שוב ושוב על אותה פעולה? עדיף לכתוב פונקציה שמעלה בחזקת שלוש. עדיף לכתוב פונקציה שמעלה בחזקת שלוש.

הצורך בפונקציות נוסיף כעת לתוכנית שלנו פונקציה שמעלה בחזקת שלוש. נוסיף כעת לתוכנית שלנו פונקציה שמעלה בחזקת שלוש. int triple(int x) { return x*x*x; } int main() { int x; printf(“x^3=%d”,triple(x));printf(“x^3=%d”,triple(x));}

הצורך בפונקציות מהו סדר הפעלת השורה הבאה: מהו סדר הפעלת השורה הבאה: printf(“x^3=%d”,triple(x)); printf(“x^3=%d”,triple(x)); קודם תופעל הפונקציה של החזקה התוצאה שלה תועבר לפונקצית ההדפסה

double max(double x, double y) { double m = x; if (m < y) m = y; return m; } הגדרת משתנים עיבוד החזרת ערך סוג הערך החוזר רשימת המשתנים

#include #include double max(double x, double y) {…..} int main() { double a,b,m; scanf (“%lf%lf”,&a,&b); m = max(a,b); printf(“The max is %f\n”,m); return 0; }

הגדרת פונקציות – שם הפונקציה חלים עליו אותם כללים כמו שם של משתנה. חלים עליו אותם כללים כמו שם של משתנה. בפרט, הוא לא יכול להכיל סימנים (כמו +-*$% וכד'), חייב להתחיל באות, ואסור לו להיות מילה שמורה (אסור for,if, וכו'). בפרט, הוא לא יכול להכיל סימנים (כמו +-*$% וכד'), חייב להתחיל באות, ואסור לו להיות מילה שמורה (אסור for,if, וכו'). בדומה למשתנים, חשוב ששם הפונקציה יהיה משמעותי ויעיד על תפקידה. בדומה למשתנים, חשוב ששם הפונקציה יהיה משמעותי ויעיד על תפקידה. דוגמאות לשמות: max, print_table, is_prime, make_me_rich_1 דוגמאות לשמות: max, print_table, is_prime, make_me_rich_1

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

פונקציות – סיום הפונקציה אם הפונקציה אמורה להחזיר ערך, צריך לסיים אותה על-ידי פקודת return, שבה מוחזר ערך מטיפוס מתאים (ריצת הפונקציה נפסקת ע"י פקודת return). אם הפונקציה אמורה להחזיר ערך, צריך לסיים אותה על-ידי פקודת return, שבה מוחזר ערך מטיפוס מתאים (ריצת הפונקציה נפסקת ע"י פקודת return). אפשר לתת כמה אפשרויות לחזרה, למשל: אפשר לתת כמה אפשרויות לחזרה, למשל: int greater(int a, int b) { if (a>b) return 1; else return 0; } עם סיום ריצת הפונקציה, חוזרים למקום שממנו הפונקציה נקראה. כל המשתנים שלה מתבטלים ולא מוגדרים יותר. עם סיום ריצת הפונקציה, חוזרים למקום שממנו הפונקציה נקראה. כל המשתנים שלה מתבטלים ולא מוגדרים יותר.

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

double max(double, double); int main() { double a,b; …….. return 0; } double max(double x, double y) { double m = x; …… return m; } prototype מימוש הפונקציה main מימוש הפונקציה max

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

תוכנית למציאת מינימום ומקסימום #include #include float Maximum(float x, float y); float Minimum(float x, float y); int main() { inti,n; floatx, min, max; scanf(“%d”, &n); /*the number of numbers > 0*/ scanf(“%f”, &x); /*scanning the first number*/ min = max = x; /*Initializing min and max */

תוכנית למציאת מינימום ומקסימום for(i = 2 ;i <= n ; i++) { scanf(“%f”, &x); min = Minimum(min, x); max = Maximum(max, x); } printf(“The min is %f\n the max is %f\n”, min, max); return 0; }

תוכנית למציאת מינימום ומקסימום float Minimum(float x, float y) { if (x <y) return x; else return y; }

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

העברת מערך לפונקציה כיצד נכתוב פונקציה שמקבל כערך מערך ומבצעת חישוב על איבריו? כיצד נכתוב פונקציה שמקבל כערך מערך ומבצעת חישוב על איבריו? נניח שנרצה לכתוב פונקציה שמקבלת מערך של מספרים ומחזירה את סכום איברי המערך. נניח שנרצה לכתוב פונקציה שמקבלת מערך של מספרים ומחזירה את סכום איברי המערך. העברת מערך לפונקציה מתבצעת למעשה ע"י העברת כתובת ההתחלה של המערך. העברת מערך לפונקציה מתבצעת למעשה ע"י העברת כתובת ההתחלה של המערך. int sum(int a[ ], int size); int sum(int a[ ], int size); prototype

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

העברת מערך לפונקציה ההגדרות הבאות שקולות: ההגדרות הבאות שקולות: int f(float arr[]); int f(float arr[]); int f(float arr[5]); int f(float arr[5]); int f(float arr[100]); int f(float arr[100]);

העברת מערך לפונקציה int sum(int a[ ], int size) { int i, res = 0; for(i = 0; i < size; i++) res += a[i]; res += a[i]; return res; }

מחרוזות מחרוזות ב C הן פשוט מערכים שאיבריהם הם תווים. מחרוזות ב C הן פשוט מערכים שאיבריהם הם תווים. המוסכמה בנוגע למחרוזות היא שמחרוזות מסתימות ב תו מיוחד אשר מסמן את סוף המחרוזת. תו זה הוא ‘\0’ שקוד ה ascii שלו הוא 0. המוסכמה בנוגע למחרוזות היא שמחרוזות מסתימות ב תו מיוחד אשר מסמן את סוף המחרוזת. תו זה הוא ‘\0’ שקוד ה ascii שלו הוא 0.

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

מחרוזות int strlen(char s[ ]) { intcnt=0; while ( s[cnt] != ’\0’ ) cnt++; return cnt; } מה עושה הפונקציה הזו? איפה משתמשים בעובדה שמחרוזת מסתיימת בתו מסוים?