המדריך נכתב במקור על ידי עצמי, ופורסם לראשונה בפורום מתחרה. כל הזכויות שמורות. אין זכות להעתיק ללא רשות הכותב.
---------------------------------------------------------------------------------
מדריך זה הוא המשך למדריך למתחילים בC שנכתב לפני זמן מה בפורום.
תוכן העניינים:
-לולאות - מה ולמה?
-הלולאה For
-הלולאה While
-הלולאה Do While
-תרגיל סיכום
לולאות
לולאות הם אחד מהכלים החשובים והשימושיים ביותר של שפת C ושל התכנות בכלל.
מטרת הלולאות הם לבצע פעולה מסויימת פעמים רבות. הלולאות מתבצעות מספר מסויים של פעמים, ועושות פעולה מסויימת אותו מספר פעמים.
למשל אם תרצה להקליד את המספרים מ1 עד 5 לא תכתוב זאת כך:
קוד:
printf("1"); ... printf("5");
במקרה הזה זה אומנם פשוט, לכתוב את אותה הפעולה 5 פעמים. אך מה יקרה שתרצה לכתוב 30, 100, ו-1000 פעולות כאלו?
זהו בזבוז זמן מוחלט לכתוב זאת ידנית, וכאן בא לידי ביטוי השימוש בלולאות - שמתבצע בכמה שורות בודדות בלבד!
בשפת C, קיימים 3 סוגי לולאות - ובמדריך זה נכיר את כולם.
זה עשוי להשמע לא ברור, אך הכל יתבהר כאשר נבנה יחד לולאה פשוטה מכל הסוגים.
אם הבנת למה פחות-או-יותר משמשות הלולאות - התחל לקרוא, אחרת קרא שנית את הקטע הנ"ל ונסה להבין.
הלולאה For
הלולאה for היא הלולאה הנוחה והטובה ביותר לחזרה על פעולה מסויימת.
להלן מבנה הפקודה for:
קוד:
for(אתחול משתנים;תנאי הסיום ללולאה;קידום משתנים)
{
הפעולה אותה תרצה לבצע
}
בלולאה הזו עליך לעשות 3 פעולות: תחילה עליך לאתחל משתנה, אח"כ עליך יהיה לתת לו תנאי סיום, ולבסוף לקדמו. הכוונה בעצם בפעולה זאת היא לקבוע כמה פעמים הלולאה תתבצע.
לדוגמא, הלולאה הבאה תתבצע 10 פעמים.
קוד:
for(i=1;i<=10;i++)
// some code
ננתח את הקוד: תחילה אנו מאתחלים את המשתנה i בערך 1, התנאי שלנו הוא כל עוד i קטן או שווה ל10 בצע את קוד הלולאה, ובכל פעם המשתנה i יגדל באחד (i++).
לולאה זו תתבצע 10 פעמים. השורות הבאות מתארות את המתרחש בלולאה עד שהיא מסתיימת:
הלולאה מתבצעת בפעם ה-1, ערכו של i כעת שווה ל1, והתנאי 10=>1 אכן נכון.
הלולאה מתבצעת בפעם ה-2, ערכו של i כעת שווה ל2, והתנאי 10=>2 אכן נכון.
...
הלולאה מתבצעת בפעם ה-10, ערכו של i כעת שווה ל10, והתנאי 10=>10 אכן נכון.
הלולאה לא מתבצעת פעם נוספת, מכיוון שכעת ערכו של i שווה ל11 והתנאי (11 קטן או שווה ל10) אינו נכון.
ראינו, אם כך, שבלולאת ה-for מתבצעות 3 פעולות:
אתחול המשתנה, בו אנו מקצים למונה שלנו ערך מסויים (כמעט תמיד ערך מספרי)
התנאי, שנבדק בכל פעם אם הוא מתקיים, ואם הוא לא מתקיים תתבצע יציאה מהלולאה
הקידום, בו אנו מקדמים את המונה שלנו על מנת שההלולאה תיעצר מתישהו (אם לא נקדם את i ערכו יישאר 1 והתנאי 10=>i יתקיים ולא ייפסק לעולם)
כעת נציג בעזרת הלולאה for את המילה hello על המסך 5 פעמים:
קוד:
for(i=0;i<5;i++)
printf("hello\n");
בכל סיבוב של הלולאה גדל ערכו של i. מטרת הלולאה הזאת, כמו שנאמר, היא להקליד את המילה "hello" חמש פעמים. תוכלו להריץ את הקוד ולראות את התוצאה.
הלולאה הזו תתקיים 5 פעמים מפני שבכל פעם גדל ערכו של i ב-1, ז"א שאם ערכו של i אינו קטן מ-5, תיפסק הלולאה.
ראינו, אפוא, כי המטרה של הלולאה for היא לעשות פעולה מסויימת כמה פעמים, הדבר קורה ע"י פלט "hello" בכל סיבוב של הלולאה.
בלולאה for נשתמש כאשר אנו יודעים כמה פעמים הלולאה תפעל מראש.
הלולאה While
הלולאה While בדומה ללולאת ה-for, תבצע פעולה מסויימות כמה פעמים, עד שתנאי מסויים מפסיק להתקיים. בניגוד ללולאת ה-for, בלולאה זו בד"כ נשתמש כאשר איננו יודעים כמה פעמים תפעל הלולאה.
לולאה זו צריכה פרמטר אחד בלבד בשביל לפעול: תנאי הלולאה. במקרה בו צריך לאתחל את מונה הלולאה או לקדם אותו, זה יעשה לפני או בתוך הלולאה.
להלן מבנה הלולאה של הלולאה While:
קוד:
while(תנאי)
{
הפעולה אותה תרצה לבצע
}
כפי שניתן לראות, במבנה הלולאה, כמו שנאמר, אין קידום או אתחול מונה בניגוד ללולאת for.
הנה דוגמא ללולאת while פשוטה שתדפיס את המחרוזת "hello" חמש פעמים:
קוד:
i=0;
while(i<5){
printf("hello");
i++
}
והמשמעות היא: הדפס את המילה hello למשתמש כל עוד מונה הלולאה (i) קטן מ-5. על ערכו של i נכריז לפני פתיחת הלולאה, ונקדמו בגוף הלולאה.
אם כן, לולאת while משמשת אותנו לביצוע פעולה מסויימת כל עוד תנאי מסויים מתקיים. בניגוד ל-for האתחול והקידום של המונה אינם נכללים במבנה הלולאה, לכן אם ברצוננו לעשות זאת עלינו לעשות זאת בגוף הלולאה או לפניה.
הלולאה Do While
הלולאה Do While למעשה דומה מאד ללולאה While; השוני היחידי בין השניים, הוא שDo While יתקיים לפחות פעם אחת, אפילו אם התנאי התחילתי שלו לא נכון.
זה עשוי להשמע קצת מסובך, אך כשנעבור על תוכנית פשוטה הכל יובן.
להלן מבנה הלולאה של הלולאה Do while:
קוד:
do
{
הפעולה אותה תרצה לבצע
}
while(תנאי)
למעשה, בלולאה זו, קודם מתבצעות פעולות בלולאה, ורק לאחר מכן נבדק התנאי.
הלולאה הזאת תפעל פעם אחת בכל מקרה, אפילו אם התנאי שלה לא מתקיים. לאחר ביצוע פעולות הלולאה נבדק התנאי "כל עוד". אם התנאי עדיין תקף הלולאה תרוץ פעם נוספת, אחרת, הלולאה תיעצר והתוכנית תמשיך לרוץ.
הנה לדוגמא לולאת Do While שמדפיסה את המחרוזת "hello" חמש פעמים:
קוד:
i=0;
do
{
printf("hello");
i++
}
while(i<5)
גם בלולאה הזו, הקידום והאתחול של מונה הלולאה לא מתבצע במבנה הלולאה.
אז מה בעצם השוני בין הלולאה הזאת ללולאת while? למה קיימים 2 סוגים של לולאות? נסתכל על הדוגמא הבאה:
קוד:
i=5;
do
{
printf("hello");
i--;
}
while(i>2)
התנאי של הלולאה לא מתקיים, אך בכל זאת זה יהיה הפלט של הלולאה:
הדבר הזה קורה, מכיוון שבלולאת ה-do while, בניגוד ללולאת ה-while, קודם מתבצעים הפעולות ורק אז מתבצע התנאי.
ז"א שאפילו אם התנאי התחילתי של הלולאה לא מתקיים, הלולאה תפעל פעם אחת.
נשאלת השאלה: למה זה טוב? בשביל מה צריך את הלולאה הזאת?
אם כך, למעשה הלולאה הזאת היא הלולאה הכי פחות שימושית, אבל בכל זאת יש לה שימוש:
לדוגמא, אם למשל נרצה לקלוט מספר שלם בין 0 ל-100 מהמשתמש, ולשאול אותו להכנסת המספר עד אשר המספר שיוכנס יהיה נכון, במצב הזה לולאת ה-do while היא הלולאה הנכונה לשימוש:
קוד:
int number=180;
do
{
printf("Enter a number: ");
scanf("%d", &number);
}
while(number>100 Or number<0)
והמשמעות היא: קלוט מספר מהמשתמש כל עוד המספר שנקלט גדול מ-100 או קטן מ-0.
אם היינו משתמשים בלולאה while פה, הערך של Number לא היה מתקיים והלולאה כלל לא הייתה מתחילה לפעול.
אם כן, לולאת ה-do while דומה מאד ללולאת ה-while, ההבדל היחידי בין השתיים, הוא ש-do while יתקיים לפחות פעם 1, אפילו אם התנאי שלו לא מתקיים, ואילו while לא יתבצע כלל אם התנאי בו לא מתקיים.
משתמשים ב-do while בד"כ כשרוצים לבצע פעולה מסויימת עד שפרטים רצויים מסויימים מוכנסים, כגון מספרים, סיסמאות, וכו'...
תרגיל סיכום
כדי להיות בטוחים שהבנו את מטרת הלולאות ואת שימושיהן, נכין עתה ביחד תרגיל סיכום.
בתרגיל זה תחילה נבקש מהמשתמש להקשת מספר שלם בין 1 ל-100, במקרה בו יקיש המשתמש מספר "לא חוקי" הוא יתבקש להכנסת המספר עד אשר יקיש מספר תקין.
לאחר מכן, יתבצעו 2 לולאות: לולאת for ולולאת while. לולאת ה-for תציג את כל המספרים מ-1 עד למספר שהוכנס, לדוגמא: 1,2,3...50
ואילו לולאת ה-while תדפיס למשתמש את כל המספרים מהמספר הנקלט עד ל-1, לדוגמא: 50,49,48...1
קוד:
#include<stdio.h> //1
#include<conio.h> //2
int main(){ //3
int i; //4
int number; //5
do //6
{ //7
printf("Enter a number(1-100): "); //8
scanf("%d", &number); //9
} //10
while(number<0 Or number>100) //11
for(i=1;i<=number;i++) //12
{ //13
printf("%d, " i); //14
} //15
printf("\n\n\n\n\n\n"); //16
i=number; //17
while(i>1) //18
{ //19
printf("%d, ", i); //20
i--; //21
} //22
getch() //23
} //24
מסובך? הכל יובהר בהסבר התוכנית.
הסבר התוכנית:
בשורות 1-2 אנו מייבאים 2 סיפריות ע"מ שהתוכנית יפעל: stdio - פלט וקלט סטנדטי של כל תוכנית, ו-conio - לטיפול בפעולות מסך.
בשורה 3 אנו בעצם פותחים את ה-main בו תיכתב פרוצדורת התוכנית.
בשורות 4-5 אנו מכריזים על 2 משתנים: מונה הלולאה - i, והמספר שנקלוט מהמשתמש - number.
בשורות 6-7 אנו פותחים לולאת do while חדשה שמטרתה לקלוט מספר בין 1 ל-100.
בשורה 8 אנו מבקשים מהמשתמש להקליד מספר בין 1 ל-100, ובשורה 9 אנו קולטים מספר זה.
בשורות 10-11 אנו סוגרים את לולאת ה-do while ומגדירים ללולאה זו תנאי: בצע לולאה זו כל עוד המספר שנקלט יוצא מהתחום הרצוי.
בשורות 11-12 אנו פותחים לולאת for חדשה, מטרת הלולאה הזאת היא להציג את כל המספרים מ-1 עד למספר שנקלט. הלולאה הזאת תתבצע עד ש-i שווה למספר שנקלט, ובכל סיבוב של הלולאה ערכו של i יגדל ב-1.
בשורה 14 אנו מציגים את ערכו של מונה הלולאה (i) למשתמש.
בשורה 15 אנו מסיימים את לולאת ה-for.
למעשה לאחר סיום פעולות הלולאה הפלט יהיה בערך כזה: (המספר שנקלט בדוגמא זו - 5) 1, 2, 3, 4, 5
בשורה 16 אנו יורדים מספר שורות כדי לעשות הפרדה בין 2 הלולאות.
בשורה 17 אנו מציבים למונה הלולאה (i) את הערך של המספר שנקלט.
בשורה 18-19 אנו מתחילים לולאת while וקובעים לה את התנאי: בצע את הלולאה כל עוד ערכו של מונה הלולאה (i) גדול מ-1.
בשורה 20 אנו מציגים את ערכו של i למשתמש.
בשורה 21 אנו מחסרים את ערכו של i ב-1.
בשורה 22 אנו סוגרים את לולאת ה-while.
למעשה לאחר סיום פעולות הלולאה הפלט יהיה בערך כזה: (המספר שנקלט בדוגמא זו - 5) 5, 4 3, 2, 1
בשורה מס' 23 אנו "קולטים תו" ובכך מונעים מהתוכנית מלצאת אוטומטית לאחר ביצוע הפעולות.
בשורה מס' 24 אנו מסיימים את התוכנית.
המדריך הבא בנושא יעסוק בפקודות בקרה. והזה שאחריו יעסוק בפונקציות.
מקווה שהפקתם את המיטב ממדריך זה, טל.
[מדריך][C]הלולאות והשימוש בהן בשפת C
