בסדר.
אז עכשיו בואו נדבר על משהו באמת שימושי בprogramming--
הצהרות מותנות.
ביטויים אז מותנים מאפשר לתוכניות שלך
לקבל החלטות ולקחת שונה מזלגות בכביש, משהו
רמזתי לקצת יותר מוקדם, בהתאם לערכים של משתנים,
או על סמך מה תשומות המשתמש ב מתכנת, בשורת הפקודה,
או אם יש לך הפקודה או משהו כזה.
יש C כמה דרכים שונות ל להביע את ביטויי תנאי, ש
גם אנחנו לפעמים קוראים סניף מותנה בתוכניות שלך.
וחלק מאלה הולכים להסתכל די מוכר לך מהתחלה,
כדי שאפילו למשוך אותם עד לצד זה, רק
אתה יכול לעשות את האנלוגיה שבראש שלך.
>> אז, אם if-- הוא די פשוט מותנה.
אם אתה זוכר מ שריטה על הזכות כאן
אתה יכול למלא שבהיא משושה עם ביטוי כחול אם עכבר למטה
או אם x הוא פחות מ -10, או משהו כזה.
ולאחר מכן, אם x היה פחות מ -10, או אם העכבר היה בעובדה, במורד,
כל הקוד הפנימי של פיסת הפאזל הייתה לבצע.
כל הדברים שמתאימים בתוך שצורת C.
>> כמו כן, יש לנו אם בצד השמאל יש.
אם ביטוי בוליאני, שאני רק משתמש
כתחליף לאחד בוליאנית ביטויים שהוסברנו קודם לכן,
סד פתוח מתולתל, מסולסל סד קרוב.
אז לחשוב על מתולתל פתוחים סד וסד מתולתל סגור
כסוג של אנלוגי לכריך השפעה של אם הבלוק בצד הימין
מאפס.
>> אם ביטוי בוליאני באם הטענה נכונה,
אז כל השורות של קוד בין הסוגריים המסולסלים
יבצע על מנת מלמעלה למטה.
אם ביטוי בוליאני הוא שקר, אנחנו
לדלג על מה שביניהם הסוגריים המסולסלים, כי אנחנו היחידים
רוצה ללכת את מזלג שבכביש אם ביטוי בוליאני הוא אמיתי.
>> אנחנו יכולים לקחת את זה צעד אחד נוסף עם אם אחר.
אז בלוק Scratch זה די דומה לזה
ראינו רק לפני שנייה, למעט זה לוקח שני נתיבים שונים המבוססים
על מה שקורה.
אז אם העכבר היה למטה, או אם x היה פחות מ -10,
אנחנו נעשה כל מה שביניהם שהמזלג הראשון, שג הראשון,
>> אחרת, אם העכבר הוא עד, או x הוא לא פחות מ -10,
נעשינו הכל במערכה השנייה.
וזה דומה למה שאתה רואה כאן לביטוי ג אם בוליאנית,
לעשות את הדברים בין הסט הראשון של סוגריים מסולסלים.
אחר, לעשות את הדברים בין שני קבוצה של סוגריים מסולסלים.
אז אם בוליאנית הביטוי נכון, אנחנו
תעשה כל מה שבין הסט הראשון.
אם ביטוי בוליאני הוא שווא, שיפעיל אחר,
ואנחנו אעשה כל מה של ב הסט השני של סוגריים מסולסלים.
שוב, מלמעלה למטה, כל קווים בין הפלטה.
>> ב C, זה אפשרי ליצור אם-אחר שרשרת אם-אחר.
למעשה אתה יכול לקבל-אחר אם אם-אחר אם-אחר, אם, וכן הלאה וכן הלאה וכן
על.
בסריטות, זה נדרש קינון בלוקים.
אתה מוסיף עוד אם-, והיה לך ל לשים עוד אחד בתוך אחר,
וכן הלאה, וזה קיבל סוג של מקונן ומסובך.
אבל C, אנחנו לא צריכים לעשות את זה.
יכול למעשה רק לנו זה יהיה שרשרת כמו זה.
שוב, כמו שהיית מצפה, כל סניפים אלה הם סותרים.
אתה היחיד שיכול ללכת את אחד מהסניף.
אם זה נכון.
אחרת, אם זה נכון.
אחרת, לעשות את זה.
אז כל ארבעת הסניפים בזה דוגמא היא סותרות.
זה שרשרת אם-אחר אם-אחרת.
>> למרות שזה אפשרי, ולפעמים מאוד שימושי,
ליצור שרשרת של לא סניפים סותרים.
בדוגמא זו, ושלישית רק הסניפים רביעי הם סותרים.
יכול להיות שאתה יכול לספק את התנאי הראשון,
ואתה יכול לספק התנאי השני,
ואתה יכול לספק את condition-- השלישי ובמקרה
היית יורד הסניף הראשון, אז אתה יורד סניף שני,
אז היית יורד סניף השלישי.
או אולי אתה לספק ראשון מצב, והתנאי השני,
אבל אתה לא לספק התנאי השלישי.
במקרה זה אתה יורד הראשון סניף והסניף השני,
ולאחר מכן את הסניף הרביעי,
>> הסיבה לכך היא שאחר רק להיקשר הקרוב אם.
אז למרות שיש אחר כאן, ש
לא בהכרח ליצור הדדי שרשרת בלעדית של כל דבר.
זה רק הביטוי יש עם וליאנית
ביטוי 3-- זה סותרים עם אחר.
אז זה אפשרי, ו לפעמים די שימושי,
כפי שאמרתי, כדי ליצור שרשרת של סניפים אינם סותרים.
בואו נסתכל שונה סוג של מותנה, ש
שלא ראה לפני בגרד.
יש משהו שנקרא ההצהרה הבורר.
ההצהרה הבורר היא סוג של מסודר כי זה
משפט תנאי המאפשר לך לציין מקרים שונים,
במקום להסתמך על וליאנית ביטויים לקבל החלטות בשבילך.
כך למשל, נניח ש שיש לי בתכנית זו,
ואני שואל את המשתמש לספק קלט לי.
אז אני אומר, int x = קבל Int (), ואם אתה לא מכיר עדיין,
לקבל int הוא פונקציה שהיא גם כלול בספריית CS50,
כך שאם אתה #include CS50.H יהיה לך גישה למקבלת Int () וכולה
cousins-- GetFloat, GetString, וכן הלאה.
בעיקרון אחד קבל פונקציה לכל סוג הנתונים שיש לנו כבר דן.
>> אז x Int שווה GetInt.
בעיקרון מה שקורה הוא אני במסוף.
אני מבקש מהמשתמש להקליד מספר.
>> וכאן אני עובר מה שאני עושה, בהתאם
על מה שהמשתמש הקליד בשורת.
אז אם הם הקלידו אחד, אני להדפיס את אחד.
ואז אני שובר.
אם הם להקליד שני, אני להדפיס את שתי.
ואז אני שובר.
זה חשוב ל לשבור בין כל מקרה ומקרה
כי אחרת אתה תיפול דרך.
אז אם לא היה לי כל הפסקות לשם, והמשתמש
מוקלד אחד, מה היה קורה זה היה להדפיס אחד, שתיים, שלוש, מצטער.
זה סוג של התנהגות מוזרה, נכון?
אתה עשוי לחשוב כך.
אבל למעשה יש מקרים מסוימים שבי זה יכול להיות דבר די שימושי.
אז הנה דוגמא נוספת של מתג הצהרה שבו אני להשמיט את ההפסקות.
אבל אני עושה את זה בכוונה.
>> אז מה קורה כאן?
תחשוב לרגע.
ייתכן גם רוצה להשהות את הווידאו.
>> מה קורה כאן אם סוגי המשתמשים ארבעה?
אז אני שאלתי את המשתמש לקלט.
והם מספקים את הערך 4.
מה יודפס כאשר אני עושה את זה?
בשקופית הקודמת, היו הפסקות בין כל המקרים.
ואז זה פשוט היית להדפיס ארבעה ואז להפסיק.
אבל במקרה הזה, זה לא יהיה.
מה שיקרה הוא ש ייפול דרך כל מקרה.
>> אז במקרה הזה אני כבר מאורגן מקרים שלי באופן כזה שאם המשתמש מקליד 4,
אני אדפיס ארבעה, שלוש, שתיים, אחת, פיצוץ ב.
ואם הם הקלידו 5, הייתי מתחיל בחמש ולעשות את אותו דבר.
אם הם הקלידו 1, הייתי פשוט לעשות אחד, זינוק.
>> אז במקרה הזה, אני משתמש ב מתג סוג של חוכמה כל כך
שאני מתכוון ליפול בכל המקרים.
אבל בדרך כלל אתה כנראה הולך רוצה לשבור בין כולם,
אלא אם כן יש לך מצב כמו זה שבו אתה נמצא
סוג של מינוף העובדה כי אתה נופל דרך מקרים ללא הפסקה.
אז זה השני של גדול סוגי דוחות מותנים.
האחרון שבן הוא:? אז יש שני קטעי קוד C כאן.
אחד בצד שמאל ואחד בצד הימין.
אחד בצד השמאל צריך כנראה יהיה די מוכר לך.
>> יש לי x Int.
ואני כנראה צריך ביקש המשתמש
for-- זה כנראה צריך להיות x Int שווה GetInt, או משהו כזה.
ואז אני עושה את החלטה.
אם חלק ביטוי בוליאני הוא נכון, להקצות x הערך 5.
אחרת, להקצות x הערך 6.
>> כי בצד השמאל כנראה צריך להיות מוכר למדי מהדיון שלנו
של אם אחרת רק לפני רגע.
האם אתה יכול להיות מופתע לדעת כי הקו בצד הימין
עושה בדיוק את אותו הדבר?
>> אז זה נקרא:? או לפעמים התקשר למרכזייה משולשת.
וזה די מגניב.
זה משמש בדרך כלל כטריק חמוד.
>> אבל מה זה מאפשר לך לעשות הוא לדמות אם אחר עם ממש קטן,
באמת קצר trivially סניפים מותנים.
אתה בדרך כלל לא משתמש ב:? אם אתה היו שש שורות של קוד בין כל סט
פלטה של ​​מתולתלת.
אבל אם אתה רק קבלת החלטה מהירה,
אם אתה הולך לעשות דבר אחד או אחרים וזה מאוד פשוט,
זה יכול להיות דוגמא לאופן ל לעשות את זה עם:? מפעיל המשולש.
אז x Int שווה ביטוי?
הדבר לאחר השאלה סימן ערך של מה x
יהיה אם הביטוי נכון.
>> הדבר לאחר מעי גס הוא מה הערך של x
יהיה אם הביטוי היה כוזב.
אז אני שואל את עצמי, הוא הביטוי אמיתי?
אם זה הוא, להקצות x הערך 5.
אם זה לא, להקצות x הערך 6.
שוב, כמו שאמרתי.
זה בדרך כלל רק טריק חמוד.
ולפעמים, אם אתה הופך באמת נוח עם זה,
אתה עושה את זה כי זה נראה סוג של מגניב בתוכניות שלך.
בדרך כלל אני מציג אותו ל עכשיו אתה כל כך אתה מכיר אותו
אם אתה רואה את זה.
אבל בהחלט יודע שאין לך לכתוב את זה בכל הקוד שלך.
אבל זה משהו שיכיר, כי אתה בהחלט תיתקל
קטעי קוד כאן ו יש בו זה:? תחביר,
AKA המפעיל המשולש, משמש.
>> סיכום כל כך מהר על מה התניות הם,
ומה זמינות האפשרויות לך בג לך אם ואם-אחר,
ואם אם אחר, וכולי.
אתה יכול להשתמש בביטויים בוליאנית עבור אלה לקבל החלטות.
>> עם הצהרות מתג אתה משתמש מקרים בדידים לקבל החלטות.
אתה במיוחד הייתי אומר, אם זה אחד, או אם זה שניים, או אם זה שלושה,
אני אעשה את הדבר הזה, או הדבר הזה, או את הדבר הזה.
ו:? יכול לשמש כדי להחליף סניפים אם-אחר פשוט מאוד,
או רשתות לאיפור אחרת אם הקוד שלך נראה קצת מפואר.
>> אני דאג לויד.
וזה CS50.