ב-C++, כאשר אנו צריכים לחזור על הבלוק של הקוד, אנו משתמשים ב'לולאות' במקום הזה. זה מקטין את הזמן שלנו להקליד את אותו הקוד שוב ושוב. אנו משתמשים ב'לולאות' ב-C++ כדי לחזור על קטע קוד. שיטת 'לולאות' היא תהליך מאוד יעיל וחוסך זמן בתכנות C++. ישנם סוגים שונים של לולאות המסופקות על ידי שפת C++ כמו 'ללולאה', 'לופ בזמן', 'לולאה לעשות תוך כדי', ו'לולאה מקוננת'. ה'לולאה המקוננת' פירושה שאנו מניחים שתי לולאות זו בתוך זו או שאנו יכולים גם לומר שלולאה אחת מכילה לולאה נוספת בתוכה.
כאן, נחקור רק את הלולאות 'המקוננות' ב-C++ במדריך זה. הקודים שבהם אנו משתמשים בלולאות ה'מקוננות' הללו הם כדלקמן:
דוגמה 1:
עלינו לכלול את קובץ ה-header תוך כדי עבודה ב-C++, אז אנו כוללים כאן את קובץ ה-header 'iostream'. קבצי הכותרות כלולים כך שנוכל להשתמש בשיטות או בפונקציות בקוד שלנו המוצהרות בהן. מתחת לזה, אנו מוסיפים את מרחב השמות 'std' וקוראים לשיטת 'main()' במקום הזה.
לאחר מכן, אנו משתמשים בלולאת 'for' בה אנו מניחים גם לולאת 'for' נוספת; זה נקרא 'לולאה מקוננת'. בלולאת 'for' הראשונה, אנו מאתחלים את המשתנה 'a' מסוג הנתונים 'int' עם '1'. גם כאן מוצב התנאי שאומר 'a <= 3' ואז מגדיל את '++a' בערך של 'a'. אנו מניחים את ה-'cout' מתחת ללולאת ה-'for' הזו כדי להדפיס כאן קצת טקסט. בלולאת 'for' הבאה, אנו מאתחלים משתנה 'b' מסוג הנתונים 'int' עם הערך של '1'. התנאי שנוסיף כאן הוא 'b <= 4' והוא גם מוגדל. אנו מניחים 'קאוט' נוסף מתחת ל'קינן עבור'.
קוד 1:
#includeשימוש במרחב שמות std;
int main ( ) {
ל ( int a = 1 ; א < = 3 ; ++א ) {
cout << 'לופ שלי עבור:' << א << endl;
ל ( int b = 1 ; ב < = 4 ; ++ב ) {
cout << ' הלולאה המקוננת שלי: ' << ב << endl;
}
}
לַחֲזוֹר 0 ;
}
תְפוּקָה:
התוצאה של 'לולאה מקוננת' נתונה כעת מוצגת כאן. משפט ה-'cout' הראשון מופיע שלוש פעמים בזמן שהתאמנו את מצבו ל-'3', והצהרת ה-'cout' השנייה מופיעה ארבע פעמים כאשר התאמנו את מצבו ל-'4' בקוד.
דוגמה 2:
הפונקציה 'main()' נקראת. לאחר מכן, אנו מאתחלים את המשתנים 'myNewWeek' ו-'weekDays' עם הערכים '2' ו- '7', בהתאמה. ה-'מקוננת ללולאה' שבה אנו משתמשים בהמשך מורכבת משתי לולאות 'ל' שאנו ממקמים אחת בשנייה. התנאי 'i <= myNewWeek' ותוספת '++i' בערך של 'i' ממוקמים כאן בלולאת 'for' הראשונה שבה אנו מאתחלים את המשתנה 'i' של סוג הנתונים 'int' עם '1'. אנו ממקמים את ה-'cout' מתחת ללולאת 'for' זו כדי להדפיס כאן קצת טקסט. אנו מאתחלים משתנה בשם 'j' מסוג הנתונים 'int' עם הערך '1' בלולאת 'for' הבאה.
כאן, אנו מוסיפים את התנאי 'j <= weekDays' ומגדילים אותו. 'קואוט' נוסף ממוקם מתחת ללולאה 'מקוננת' זו.
קוד 2:
#includeשימוש במרחב שמות std;
int main ( ) {
int myNewWeek = 2 , ימי חול = 7 ;
ל ( int i = 1 ; אני < = myNewWeek; ++i ) {
cout << 'השבוע הוא:' << אני << endl;
ל ( int j = 1 ; י < = ימי חול; ++j ) {
cout << ' היום בשבוע הוא: ' << י << endl;
}
}
לַחֲזוֹר 0 ;
}
תְפוּקָה:
כך מוצגת כעת ה'לולאה המקוננת' שהוזכרה קודם לכן. הקוד מציג כעת שלושה מופעים של הצהרת ה-'cout' הראשונה (שהמצב שלה קבוע ל-'2') וארבעה מופעים של הצהרת ה-'cout' השנייה (שהמצב שלה קבוע ל-'7').
דוגמה 3:
כאן, אנו רוצים להציג את הסמל '@' בתבנית משולשת עם הלולאה 'קינן עבור'. לשם כך, אנו מניחים את לולאת 'for' הראשונה ונתאים את מצבה ל-'i <= 6' לאחר אתחול המשתנה 'int i' בערך '1'.
לאחר מכן, אנו מיישמים גם את התוספת בערך של 'i'. מתחת לזה, יש לנו עוד 'for' שבו אנו מציבים תנאי נוסף שאומר 'j <= i' לאחר אתחול המשתנה 'j' בתור 'int' עם הערך של '1'. הערך של משתנה 'j' זה מוגדל גם כאן. כעת, אנו מוסיפים את ה-'cout' שבו ממוקם הסמל '@'. כעת, זה מציג את הסמל '@' במשולש.
קוד 3:
#includeשימוש במרחב שמות std;
int main ( ) {
ל ( int i = 1 ; אני < = 6 ; i++ ) {
ל ( int j = 1 ; י < = i; j++ ) {
cout << '@' ;
}
cout << endl;
}
לַחֲזוֹר 0 ;
}
תְפוּקָה:
אנו מקבלים תוצאה זו בגלל 'לולאה מקוננת' בה השתמשנו בקוד שסופק. כאן, אנו יכולים לראות שסמל '@' מופיע בתבנית משולשת.
דוגמה 4:
אנו רוצים להשתמש בלולאה 'מקוננת עבור' כדי להציג את הסמל '@' בתבנית משולש. לשם כך, אנו ממקמים את לולאת 'עבור' הראשונה. לאחר מכן, אנו מאתחלים את המשתנה 'int a' עם הערך של '1' ומגדירים את התנאי שלו ל-'a <= 8'. לאחר מכן, אנו גם מגדילים את הערך של 'a' במקרה זה. לאחר מכן, יש לנו עוד 'for' שבו אנו מאתחלים את המשתנה 'b' בתור 'int' עם הערך של '1' עם תנאי אחר שמציין 'b <= a'. הערך של 'a' גדל גם כן. ה-'cout' נוסף כעת במקום בו אנו מציבים את הסמל '*'. זה גורם כעת למסוף להציג את הסימן '*' בתבנית משולש.
קוד 4:
#includeשימוש במרחב שמות std;
int main ( ) {
ל ( int a = 1 ; א < = 8 ; a++ ) {
ל ( int b = 1 ; ב < = a; b++ ) {
cout << '* ' ;
}
cout << endl;
}
לַחֲזוֹר 0 ;
}
תְפוּקָה:
השגנו תוצאה זו על ידי שימוש ב'לולאה מקוננת' בקוד האמור לעיל. כאן, אנו יכולים לראות שסמל '@' מסודר במשולש.
דוגמה 5:
כעת, אנו רוצים להציג את המספר הראשוני בלבד. אז, אנו מכריזים על המשתנים 'x' ו-'y' כמשתני 'int'. לאחר מכן, אנו מניחים שתי לולאות 'עבור', אחת אחרי השנייה, שאמורות להיות הלולאה 'מקוננת עבור'. הלולאה הראשונה מכילה את התנאי שהוא 'x <= 50' לאחר אתחול המשתנה 'x' עם '2'. אנו גם מבצעים את ההגדלה על הערך של 'x' בלולאה זו.
לאחר מכן, יש לנו לולאה נוספת שבה נוסיף עוד תנאי שאומר 'y <= (x/y)' לאחר הקצאת ערך '2' למשתנה 'y'. אנו גם מעלים את הערך של 'y' בתוך הלולאה הזו. מתחת לזה, אנו משתמשים ב-'if' שבודק את התנאי '!(x%y)'. אם הגורם לא נמצא כאן, הוא לא ידפיס את הערך הזה כאשר נוסיף את המשפט 'שבירה' ונעבור לעבר ה'אם' השני שנוסיף בהמשך. כאן, הוא בודק שוב את התנאי שהוא 'y > (x/y)'. אם זה נכון, הוא מדפיס את הערך הזה וגם מדפיס 'הוא מספר ראשוני'.
קוד 5:
#includeשימוש במרחב שמות std;
int main ( ) {
int x, y;
ל ( x = 2 ; איקס < = חמישים ; x++ ) {
ל ( y = 2 ; ו ( איקס / ו ) ) cout << איקס << ' הוא מספר ראשוני.' << endl;
}
לַחֲזוֹר 0 ;
}
תְפוּקָה:
כעת, כל המספרים הראשוניים מוצגים כאן, אותם אנו מקבלים לאחר החלת לולאת 'מקוננת עבור' בקוד שלנו.
סיכום
מדריך זה עוסק כולו בלולאות המקוננות ב-C++ והסביר שאנו משתמשים ב'לולאות המקוננות' בכל פעם שאנו רוצים את החזרה על קטע הקוד. חקרנו ביסודיות את המושג הזה ולמדנו כיצד להשתמש ב'לולאות המקוננות' בקודים שלנו. הדגמנו מספר דוגמאות שבהן השתמשנו ב'לולאות המקוננות' יחד עם ההסברים שלהן וריפקנו את התוצאות של כל הקודים הללו כאן במדריך זה.