[Powered by Google Translate] טומי MACWILLIAM: בואו נדבר על לולאות, האחד הנפוץ
תכנות בונה נראים לאורך CS50.
אנו נשתמש בלולאות כאשר אנו רוצים לבצע
משימה יותר מפעם אחת.
לדוגמה, אנו עשויים רוצים להדפיס "היי" 100 פעמים או הדפסה
את כל האותיות האלפבית.
בשני המקרים הללו, יש לנו דבר אחד שאנחנו רוצים לעשות
מספר רבות של פעמים, להדפיס משהו.
עם זאת, מה שאנחנו מדפיסים בכל פעם שיכולה להשתנות.
אז אנחנו יכולים לעשות משהו קצת שונה על כל אחד
איטרציה, או לרוץ דרך, של הלולאה.
נצטרך לראות שלושה סוגים שונים של לולאות ב-C, ואילו
לולאות, ללולאות, ולעשות בזמן שלולאות.
למרות ששלושה סוגים אלו של לולאות יש תחביר שונה,
רעיונות שמאחוריהם הם אותו הדבר.
אנחנו להגדיר מספר בלוק של קוד בתוך סוגריים מסולסלים,
נקרא הגוף של הלולאה, שאנחנו רוצים להיות מוצאים להורג
כמה וכמה פעמים.
על ידי שינוי הערכים של משתנים המשמשים בגוף, אנחנו
יכול לעשות הלולאה שלנו לעשות משהו שונה בכל פעם שהוא מפעיל.
עם כל לולאה שאנחנו כותבים, אנחנו גם צריכים להחליט מתי
לולאה תפסיק לרוץ.
אם אנחנו לא עושים את זה, אז המחשב הנאמן שלנו ימשיך
כדי להפעיל לולאה שעד שיהרגו את התכנית.
בהתחלה, אנחנו יכולים להשתמש חוזרים n הזמנים
לחסום כדי ליצור לולאה.
את כל החלקים בתוך בלוק שאמר חזור 10
יהיה לרוץ 10 פעמים.
ואז, הייתי עובר לחלקים לאחר שהלולאה.
אז המצב שלנו היה פשוט להפסיק, לחסום את זה כבר
לרוץ 10 פעמים.
אז בואו לשחזר את זה בג על מנת לגרד כדי להבטיח
שהחלקים בתוך הבלוק החוזר מבוצעים
בדיוק 10 פעמים, שריטה צריכה לעקוב אחר כל
ביצוע של הגוש החוזר.
כדי לעקוב אחר כמה פעמי גוף הלולאה שלנו כבר
להורג, בואו ליצור משתנה בשם i.
נתחיל אותי בשעת אפס, מאז לולאתנו
לא הופעל עדיין.
אישור
כעת אנו נשתמש במילת מפתח בזמן להתחיל הלולאה שלנו.
עכשיו אנחנו נצטרך להבין מתי הלולאה שלנו תפסיק, אבל
בואו נעזוב את זה עכשיו ואז לחזור אליו.
בסדר.
בתוך הלולאה שלנו, בואו פשוט להדפיס את הודעה, כמו
"היי". אנחנו יכולים להשתמש בפונקצית printf לזה.
בסדר.
אז עכשיו אנחנו נחגוג ושאיטרציה של גוף הלולאה יש
הוצא להורג.
אנחנו יכולים לעשות את זה על ידי הוספת 1 עד, או הגדלה, נגדנו
משתנה, אני.
כדי לעשות זאת, אנו יכולים לומר שאני שווה לפלוס 1, או יותר
פשוט, אני פלוס פלוס.
גדול.
אז עכשיו אנחנו יכולים לראות שבכל פעם שהלולאה שלנו היא לרוץ,
כמונה עולה באחד.
אז אנחנו יודעים בדיוק כמה חזרות אנחנו פגשנו עד כה.
לאחר איטרציה אחת מהלולאה, הערך שלנו
שלי יהיה 1.
לאחר שתי חזרות, אני יהיה 2.
ולאחר 10 חזרות, אני יהיה 10.
לכן, אם אנחנו רוצים להפעיל לולאה זה בדיוק 10 פעמים, ולאחר מכן
זה מתי שאנחנו רוצים לעצור.
אז אנחנו רוצים להריץ את זה לולאה בזמן שהוא פחות מ 10, ו
זה בדיוק מה שאנחנו כותבים, ואילו אני
הוא פחות מ 10.
מצב זה נראה בדיוק כמו התנאים שבם השתמשו באם
בלוקים אחרים.
אחרי שהגוף של הלולאה שלנו כבר להורג, התכנית שלנו
יקפוץ חזרה למצב הלולאות.
אם התנאי הוא אמיתי, ואז הגוף של
לולאה תהיה לרוץ שוב.
אם המצב הוא כבר לא נכון, אז הלולאה שלנו לא תהיה
לברוח יותר ויעבור לשורה הבאה של קוד
מתחת הלולאה שלנו.
בסדר.
אז בואו נסתכל על סוג שני של
לולאה, ללולאה.
ליד מילת המפתח בזמן, בסוגריים, יש לנו דבר אחד,
המצב שצריך להיות נכון עבור
גוף לולאה שיופעל.
זה אומר שאנחנו צריכים ליצור משתנים נגדנו מחוץ
של הלולאה ולזכור כדי להגדיל אותו בשלב מסוים
בתוך הלולאה.
הכותרת עבורנו ללולאה, לעומת זאת, יש שלוש
חלקים, שכל אחד מהם יהיו מופרדים בנקודת פסיק.
בשליש הראשון שלנו, אנחנו יכולים להכריז על כל תשובה או עוזר
משתנים שירצו להשתמש בלולאה שלנו.
בפועל, זה יכול להיות ממש מועיל.
אנחנו באמת לא צריכים את משתנה זה, אני, אחרי כמה הזמן שלנו
לולאה יש להפעיל, כדי שבאמת לא היית צריך להכריז עליה
מחוץ לעניינים.
השליש השני יהיה המצב שחייבת להיות נכונים
לגוף יבוצע שוב, בדיוק כמו
בלולאה בזמננו.
בשליש האחרון שלנו, אנחנו יכולים לרוץ הצהרה שתהיה
יבוצע לאחר כל איטרציה של הלולאה, ולכן אין לנו
כדי לבנות אותו בגוף הלולאה.
אז בואו נכתוב ללולאה שסופרת את 5-1.
נתחיל עם מילת המפתח.
אנחנו יכולים ליצור משתנים דלפק ראשון, שאנו נזכה
להגדיר זמן זה עד 5 מאז שאנחנו בספירה לאחור,
אחרי פסיק.
הבא הוא המצב שלנו, שאנחנו נחזור ל.
שלישית, אנחנו רוצים הפחה המונה לאחר
כל איטרציה של הלולאה.
אז במקום לומר לי בתוספת פלוס, אנחנו נגיד לי מינוס מינוס.
בסדר.
אז אנחנו רוצים גוף הלולאה לרוץ בזמן שהוא עדיין
גדול מ 0.
בגוף הלולאה, בואו להדפיס את הערך של i.
כדי לעשות זאת, תצטרך להשתמש בפונקצית printf, באמצעות% d
מציין מיקום.
זכור, שמציינים המיקום יוחלף
ערך של i.
לבסוף, בואו נוסיף הצהרה אחרינו ללולאה.
כאשר אנו מפעילים לולאה זה, אני אתחיל בשעת 5,
כך 5 יודפסו.
ברגע שאני מקבל 0, מצב ההמשך, אני הוא
גדול מ 0, כבר לא מחזיק.
אז הלולאה שלנו תפסיק ביצוע, וניתן לראותו
הצהרה אחרי הלולאה.
אז בואו להפעיל את הקוד הזה.
ראשית, אנחנו לקמפל
countdown.c עם לעשות ספירה לאחור.
עכשיו, אנחנו יכולים להפעיל את הקוד הזה עם. / ספירה לאחור.
בשתי לולאות זמן וללולאות, המשך אותנו
מצב ייבדק לפני הגוף
של הלולאה מבוצעת.
זה אומר שאם המצב שלנו הוא לא בתחילה
אמיתי, ואז הגוף של הלולאה שלנו לעולם לא לרוץ.
אז לפעמים כדאי לבדוק את המצב לאחר
גוף של הלולאה ולא לפניו.
אז בואו לכתוב לולאה להציג למשתמש למספר
עד מספר חיובי מסופק.
אם תשומות המשתמש מספר שלילי, אנחנו רוצים לשאול אותם
למספר אחר.
אז אנחנו רוצים שזה יהיה בתוך פקודה
גוף את הלולאה.
עם זאת, כאשר הלולאה לרוץ בפעם הראשונה, המשתמש
לא נתן לנו את המספר עדיין.
אז זה לא הגיוני כדי לבדוק אם זה חיובי.
במקום זאת, אנחנו רוצים לבדוק את המספר אחרי שהגוף של
הלולאה לרוץ.
אנחנו יכולים לעשות את זה עם הלולאה לעשות בזמן.
ראשית, תיצרו משתנה, n, שיקיים
הקלט של המשתמש.
כעת אנו נשתמש במילת מפתח לעשות, ואחרי סוגריים מסולסלים ש
יתחיל את הגוף של הלולאה שלנו.
בגוף, אנחנו יכולים לבקש ממשתמש מספר עם
GetInt פונקציה.
כעת, תרצו את הגוף של לולאה זה כדי להפעיל שוב אם
המשתמש הקליד מספר שלילי, ולכן אנחנו אומרים בזמן n
הוא פחות מ 0.
שים לב לפסיק כאן אחרי הצהרת הזמן מה.
אז בואו להפעיל את הקוד הזה.
ראשית, אנחנו לקמפל את זה עם להפוך חיובי.
עכשיו אנחנו יכולים להפעיל את התכנית עם. / חיובי.
אם אנחנו נותנים תכנית זה מספר שלילי, כמו שלילי
4, ואם כך נהיה אתבקש שוב מספר מאז
מצב של לעשות את שלנו, תוך הלולאה הייתה נכונה.
ברגע שאנו נותנים מספר חיובי, כמו 8, ולאחר מכן
מצב של לעשות את שלנו, תוך לולאה כבר לא תהיה נכונה.
אז הלולאה לא תבוצע שוב.
וזה הכל לשלושה הסוגים של לולאות אנו נשתמש בג
השמי הוא טומי, וזה CS50.