דוגמה 1:
קובץ הכותרת 'iostream' כלול בקוד זה. קובץ כותרת זה משמש ב-C++ מכיוון שפונקציות הקלט או הפלט מוצהרות בקובץ הכותרת הזה. לאחר מכן, אנו מניחים את מרחב השמות 'std' ולאחר מכן מפעילים את הפונקציה 'main()'. אנו מאתחלים את המשתנה 'a' כסוג הנתונים של מספר שלם ולאחר מכן מניחים את הלולאה 'for'. בלולאה זו, נציב 'a = 0' והתנאי שנוסיף כאן הוא 'a <= 9'. לאחר מכן, אנו מגדילים את הערך של 'a'. בהמשך, אנו משתמשים בתנאי 'אם' שבו נוסיף 'a == 5' ומציבים את המשפט 'המשך' לאחר מכן. הצהרות 'המשך' עוזרות לדלג על הערך של '5' מהלולאה הזו. לאחר מכן, אנו מוסיפים את ה-'cout' ומדפיסים את המספרים הנותרים. זה מציג את כל המספרים מלבד ה- '5' מכיוון שהוספנו את המשפט 'המשך'.
קוד 1:
#includeבאמצעות מרחב שמות std ;
int רָאשִׁי ( ) {
int א ;
ל ( א = 0 ; א <= 9 ; א ++ ) {
אם ( א == 5 ) {
לְהַמשִׁיך ;
}
cout << 'המספר הוא ' << א << endl ;
}
לַחֲזוֹר 0 ;
}
תְפוּקָה:
כאן, כל המספרים מוצגים, אבל המספר '5' נדלג מהפלט הזה ולא מוצג כאן כי הוספנו משפט 'המשך' כדי לדלג על המספר '5' מהלולאה הזו.
דוגמה 2:
אנו משתמשים בהצהרת 'המשך' בתוך לולאת 'בזמן'. הקוד כולל את קובץ הכותרת 'iostream' מכיוון ששיטות הקלט והפלט מוצהרות בקובץ הכותרת הזה. לאחר מכן מתווסף מרחב השמות 'std', והפונקציה 'main()' נקראת כאן. לאחר מכן, אנו מניחים 'int' ומאתחלים משתנה מספר שלם עם השם 'num'. לאחר מכן, אנו משתמשים בלולאה 'while()' ומציבים את התנאי 'num <= 12'.
מתחת לזה, אנו שמים את 'אם' שמכיל תנאי נוסף שהוא 'num == 7'. לאחר מכן, אנו מניחים את 'num++' אשר יגדל באחד בערך של 'num'. לאחר מכן, אנו משתמשים בהצהרת 'המשך'. הצהרת 'המשך' זו מדלגת על המספר '7' מלולאת 'בזמן'. ה-'cout' מתווסף ושאר המספרים מודפסים. מכיוון שהכנסנו את ההצהרה 'המשך', היא מציגה את כל המספרים מלבד '7'. לאחר מכן, אנו שמים את 'num++' כדי להגדיל את הערך של 'num'.
קוד 2:
#includeבאמצעות מרחב שמות std ;
int רָאשִׁי ( ) {
int על אחד = 0 ;
בזמן ( על אחד <= 12 ) {
אם ( על אחד == 7 ) {
על אחד ++;
לְהַמשִׁיך ;
}
cout << 'אנו מציגים מספר באמצעות לולאת while' << על אחד << endl ;
על אחד ++;
}
לַחֲזוֹר 0 ;
}
תְפוּקָה:
מכיוון שכל המספרים מודפסים במקרה זה, המספר '7' מושמט מהפלט ולא מוצג מאחר שהצהרת 'המשך' מתווספת ללולאה כדי לדלג על המספר '7'.
דוגמה 3:
אנו מוסיפים את הצהרת ה-'המשך' הזו בתוך לולאת ה-'for' המקוננת. לאחר הכנסת קובץ הכותרת ומרחב השמות 'std', אנו מפעילים את שיטת 'main()'. המשתנים 'n1' ו- 'n2' מוכרזים כאן כסוג המספרים השלמים. כעת, אנו משתמשים בלולאה 'for' המכילה את התנאי 'n1 <= 4'. מתחת לזה, אנו מניחים שוב את לולאת ה-'for' שהיא לולאת ה-'מקוננת עבור'. לולאת ה-'for' השנייה מכילה את התנאי שאומר 'n2 <= 4'.
כעת, אנו משתמשים ב-'if' שבו אנו מוסיפים את התנאי ומשתמשים באופרטור '&&'. לאחר מכן, ה'המשך' נוסף כאן. הוא מדלג רק על הערכים שבהם 'n1' הוא '3' ו-'n2' הוא '3'. כאשר גם 'n1' וגם 'n2' הם '3', הוא מדלג על האיטרציה הזו של הלולאה כאן. לאחר מכן, אנו משתמשים ב-'cout' מתחת לזה כדי להציג את הערכים הנותרים.
קוד 3:
#includeבאמצעות מרחב שמות std ;
int רָאשִׁי ( )
{
int n1 , n2 ;
ל ( n1 = 1 ; n1 <= 4 ; n1 ++ ) {
ל ( n2 = 1 ; n2 <= 4 ; n2 ++ ) {
אם ( n1 == 3 && n2 == 3 ) {
לְהַמשִׁיך ;
}
cout << 'n1 = ' << n1 << 'n2 = ' << n2 << endl ;
}
}
}
תְפוּקָה:
מכיוון ששורת 'המשך' מתווספת ללולאה המקוננת כדי לדלג על האיטרציה שבה שני ערכי המשתנים הם '3' וכל שאר הערכים מודפסים כאן.
דוגמה 4:
המשתנה 'int' בשם 'num_1' מאותחל בערך '1'. לאחר מכן, אנו משתמשים בלולאת 'while' ומוסיפים את התנאי 'num_1 <= 9'. מתחת לזה, ה-'cout' נכלל ותנאי 'אם' מוצב שם. התנאי 'אם' בודק את שארית המספר השווה לאפס כאשר אנו מחלקים אותו ב-'2'. תנאי זה מתווסף כאשר אנו רוצים לבדוק את המספר הזוגי בקוד שלנו. מתחת, אנו מניחים את 'num_1++' כדי להגדיל את הערך של 'num_1'. כאן, אנו משתמשים ב'המשך' כדי לדלג על המספרים הזוגיים מהלולאה ולא להציג את ההודעה הנתונה עבור המספר הזוגי שקיים בלולאה.
קוד 4:
#includeבאמצעות מרחב שמות std ;
int רָאשִׁי ( ) {
int מספר_1 = 1 ;
בזמן ( מספר_1 <= 9 ) {
cout << 'המספר הוא =' << מספר_1 << endl ;
אם ( מספר_1 % 2 == 0 ) {
מספר_1 ++;
לְהַמשִׁיך ;
}
cout << 'המספר הוא ' << מספר_1 << 'שזה מספר אי זוגי' << endl ;
מספר_1 ++;
}
לַחֲזוֹר 0 ;
}
תְפוּקָה:
כאן, אנו יכולים לראות שהמספרים הזוגיים מושמטים מהפלט וההודעה עבור המספר האי-זוגי מוצגת כאן רק בגלל ההצהרה 'המשך' שהכנסנו בקוד שלנו.
דוגמה 5:
בקוד האחרון שלנו, אנו מקבלים מהמשתמש את הערכים הנמוכים מ-'45' ומסיימים את קלט המשתמש כאשר אנו מכניסים את הערך השלילי ומחשבים את סכום הערכים הנתונים. ראשית, אנו מאתחלים את ה'סיכום' וה'ערך' כסוגי הנתונים שלמים.
לאחר מכן, בדוק אם הערך חיובי או לא. לאחר מכן, החל 'סיכום + = ערך' אם הערך חיובי ועבד את ההודעה ל'הזן מספר עבור סכום'. מתחת לזה, אנו משתמשים ב-'cin' כדי לקבל את המספר ולשמור אותו ב-'value'. כעת, אנו מתקדמים ונראה אם 'ערך> 45'. אם תנאי זה מתקיים, עלינו לבצע את השורה הנתונה בה כתבנו הודעה להזין ערך קטן מ-'45'. לאחר מכן, הקצה 'ערך = 0' והצב את משפט ההמשך שמדלג על הערך הזה ומקבל ערך חדש מהמשתמש. לאחר מכן, אנו מחשבים את ה'סיכום' ומעבדים אותו. סיכום זה נעשה כאשר אנו מכניסים ערך שלילי.
קוד 5:
#includeבאמצעות מרחב שמות std ;
int רָאשִׁי ( ) {
int סיכום = 0 ;
int ערך = 0 ;
בזמן ( ערך >= 0 ) {
סיכום += ערך ;
cout << 'אנא הזן מספר עבור סכום:' ;
אֲכִילָה >> ערך ;
אם ( ערך > ארבע חמש ) {
cout << 'המספר שהזנת כאן גדול מ-45 אז לא נחשב אותו' << endl ;
ערך = 0 ;
לְהַמשִׁיך ;
}
}
cout << 'הסכום של המספר שהוזן הוא' << סיכום << endl ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
תוצאה זו מציגה כיצד הקוד שלנו מקבל את הקלט של המשתמש, מיישם את הסיכום ומציג הודעה כאשר אנו מכניסים ערך גדול מ-'45'. כאן, אנו עשויים לשים לב שהערכים שגדולים מ-'45' מדלגים ואינם מחושבים בתהליך הסיכום. הסיבה לכך היא שהחלנו את הצהרת 'המשך' באותו מקום בקוד שלנו.
סיכום
המושג 'המשך' בתכנות C++ נלמד ביסודיות במדריך זה. בדקנו כיצד הצהרת 'המשך' זו מסייעת בדילוג על הערך הרצוי מהפלט לעיבוד. השתמשנו בהצהרת 'המשך' זו בקודים שלנו והסברנו כל קוד כמו גם את התוצאות של קודים אלה. השתמשנו בהצהרת 'המשך' זו בתוך הלולאה 'עבור', 'תוך כדי' ו'קינן עבור'.