>> לוקאס פרייטס: אוקיי, אני מניח עכשיו אנחנו בשידור חי.
ברוכים הבאים לCS50 Supersection.
אנחנו נוחים פחות.
השם שלי הוא לוקאס פרייטס.
אני אחד CS50 ראש TFS.
זוהי לורן.
>> LAUREN קרבאליו: היי, אני לורן.
אני גם TF הראש לCS50.
>> לוקאס פרייטס: היום אנחנו פשוט הולכים כדי לתת סקירה של כל מה שאתה
החבר 'ה שלמדו בשבוע אחד, בתקווה כדי לתת לכם טוב
הגיוני מה שאתה צריך לדעת לבעיה מוגדרת אחת.
>> רק כמה הודעות.
קודם כל, שעתי עבודה.
שעתי עבודה מתרחשות מיום השנייה עד יום חמישי בבתים שונים ב
אננברג בכל יום.
הם משאב טוב מאוד בשבילך החבר 'ה לבוא ולשאול שאלות, ו
לדבר עם TFS, ואפילו מטבע רעיונות עם סטודנטים אחרים.
אז כדי להיות בטוח לשימוש במשאב ש לטובתך.
>> הדבר השני הוא CS50 Appliance.
ל[ לא ברור] שעבר
אתם לא צריכים באמת יש מכשיר.
אתה פשוט עשית הכל ב המחשב האישי שלכם.
אבל לבעיה זו, בעצם יש לך יש מכונת וירטואלית, כדי להיות
הקפד להוריד את CS50 מכשיר ולהגדיר אותו.
>> והדבר השלישי הוא כדי להיות בטוח להתחיל את הבעיה בהקדם האפשרי להגדיר רק
כי זה הרבה יותר קל למצוא לעזור כשאתה ב
תחילת השבוע.
מכיוון שאנשים נוטים לחכות עד בשנייה האחרונה כדי להתחיל את סט הבעיה,
ואז אתה הולך לשעתי עבודה, ויש הרבה אנשים.
שבו אם אתה הולך ביום שני, אתה הולך כדי לראות שאתה יכול לדבר עם TFS
די הרבה במשך כל הלילה, והם הולכים להיות יותר מ
תשמח לעזור לך.
>> LAUREN קרבאליו: האם אני יכול פשוט להפסיק אתה רק שני אחת?
האם כולם הצליחו להוריד מכשיר CS50?
האם אנשים ניסו?
>> לוקאס פרייטס: כדי להוריד, על ידי אגב, אתה יכול לקבל הוראות ב
cs50.net/appliance.
>> LAUREN קרבאליו: נכון.
וזה לוקח קצת זמן לנו מנהלים sys כדי להביא לך רישיון
מפתח, כדי להירשם לקבלת ניסיון ללא תשלום ראשון.
בדרך זו תהיה לך אותו ל30 ימים, ולאחר מכן לחכות למפתח הרישיון שלך
שאמורה לתת לו לך לשנה.
>> לוקאס פרייטס: קודם כל, בואו נדבר קצת
על מכשיר CS50.
CS50 המכשיר הוא למעשה וירטואלי מכונה שאתה הולך
להפעיל במחשב שלך שהוא בעצם פועל מחשב אחר
בתוך המחשב שלך.
וזה די מגניב.
ולמעשה הוא משמש בכל מקום.
אנשים שלטק היו יודעים כי זה משמש כל הזמן.
אתה?
יכול להיות מספר מחשבים במכשיר אחד.
>> בואו באמת נסתכל במכשיר.
כשאתה הולך למכשיר לאחר רישום, אתה הולך צריך
לשים את השם שלך ולהיכנס להרווארד כדי שנוכל לקבל את כל מה שאתה רשום.
אתה הולך לראות בעצם רק טפטים, ולאחר מכן לבית ולאשפה,
ולאחר מכן הסמלים הקטנים האלה.
שלושה סמלים זו הם למעשה ביותר דברים חשובים שאתה יכול להיות ב
המכשיר שלך.
>> הראשון הוא gedit, שהוא טקסט עורך, בדיוק כמו פנקס רשימות או כמו
כל סוג של עורך טקסט.
זה פשוט משהו שאנו משתמשים כדי לכתוב קוד ולאחר מכן לעשות את הדברים עם זה.
>> הדבר השני שאנו יש כאן הוא Chrome.
אז אם אתה צריך להשתמש באינטרנט במכשיר, זה
מה שאתה יכול להשתמש.
>> והדבר השלישי הוא המסוף, שהוא למעשה מתוק מאוד.
אנשים בדרך כלל סוג של פחד מן המסוף בגלל זה זה מאוד
יישום ישן נושן שבו אתה פשוט הקלד בעצם כל דבר עם
המקלדת שלך.
אין הרבה אינטראקציה עם העכבר.
אבל בעצם המסוף עושה דברים טובים מאוד.
>> קודם כל, בואו פשוט לעבור חלק מפקודות שאתה
ניתן להשתמש במסוף.
>> LAUREN קרבאליו: ואל תהסס לעצור אותנו אם יש לך שאלות.
>> לוקאס פרייטס: כן.
אז הפקודה הראשונה שיש לנו למסוף הוא ls.
ls בעצם אומר הכל רשימה, כל קבצים וכל הדירקטורים,
שיש לי במקום שאני בבית.
אז אם אני עושה ls כאן, אני הולך לראות כי יש לי כמה ספריות.
יש לי על שולחן העבודה, הורדות, היומנים, וVHOSTs.
אלה הם בכחול משום שהם כל הספריות.
>> ואז יש לך כמה קבצים אחרים.
יש לך כמו שלום וhello.c, אשר הם רק קבצים, והם נמצאים ב
צבעים שונים.
אז זו פקודה חשובה מאוד פשוט אתה יכול לראות מה הם הקבצים
וספריות שיש לך במדריך זה
אתה נמצא בבית במסוף.
כאשר אתה רואה jharvard מכשיר ו אז הסמל הקטן שם,
טילדה, זה רק אומר שזה ספרייה שאתה נמצא באותו הרגע.
>> LAUREN קרבאליו: אז הקלדת ls היא כמעט כמו לחיצה על התיקייה
המופיע שם, במופעיו את כל התוכן שאתה
בתיקייה זו.
>> קהל: האם יש טקסט לאחר hello.c?
>> LAUREN קרבאליו: אה, אתה לא יכול רואה את זה, בגלל שזה כחול.
>> לוקאס פרייטס: זה אומר יומנים וVHOSTs.
>> LAUREN קרבאליו: אלה הם רק תיקיות אחרות.
אני מצטער, זה ממש קשה לראות.
אולי אם כיבו את האורות?
קולטון, האם אתה רוצה לנסות ו למצוא את מתג האור?
מצטער על זה.
אני לא חושב על זה.
>> לוקאס פרייטס: אבל זה בעצם -
כן, אם אתה יכול -
>> LAUREN קרבאליו: זום במסך שלך.
>> לוקאס פרייטס: אני לא יש תכונה זו.
>> LAUREN קרבאליו: [לא ברור].
על אישור.
ובכן, יש רק הרבה טבעי אור בחדר הזה גם כן.
>> לוקאס פרייטס: בואו פשוט להניח כי יש שתי ספריות אחרות שם.
>> LAUREN קרבאליו: רק לשאת איתנו.
זהו החלק היחיד שאתה יהיה מחפש במסוף.
>> לוקאס פרייטס: הפקודה הבאה היא בעצם אולי אתה רוצה לארגן
הקבצים שלך -
לדוגמא, כל קבצי C שלך באחד ספרייה, אבל אין לך
ספרייה רק ​​בשביל C קבצים עדיין.
אתה בעצם יכול ליצור ספרייה שימוש במסוף, כמו גם, שהוא
אותו דבר כמו לחיצה ימנית ואומר על תיקייה החדשה.
הפקודה היא להפוך את הספרייה, אשר הוא mkdir, אז בעצם "עושה" ו
"ספרייה".
>> ואז אתה יכול לשים שמו של המדריך.
נניח שאני רוצה שייקרא, אני לא יודע, נניח pset1 עושה
זה, אני פשוט יצרתי ספרייה.
בואו רק לבדוק שזה שם.
אז אם אני עושה ls, עכשיו אני רואה את יומנים, ו אז pset1, ולאחר מכן VHOSTs.
אז יש לי את הספרייה החדשה שם.
>> ואז אחרי שיש לך ספרייה חדשה, אולי אתה רוצה לנווט
לתוך זה, אז את הפקודה הבאה cd זה, אשר רק בעצם אומר ללכת
ספרייה מסוימת.
אז אם אני רוצה ללכת לpset1, אני רק יכול לעשות pset1 cd.
>> LAUREN קרבאליו: cd מייצג שינוי ספרייה, [לא ברור] מסוגל
תזכור את זה.
>> לוקאס פרייטס: ועכשיו אתה רואה את זה ולא רק שיש jharvard
מכשיר, יש לי jharvard מכשיר, ולאחר מכן pset1, כי זה מראה
לי איפה אני נמצא במחשב הזה.
>> עכשיו, אם אני רוצה לחזור ל ספרייה שהייתה לפני זה, אני
יכול לעשות נקודת נקודה cd, שרק אומרת ללכת לספרייה שהייתי בעבר,
כמו ההורה של זה ספרייה, בעצם.
ועכשיו אני רואה שאני חזרה לjharvard.
>> הדבר הבא שאני יכול לעשות את זה הוא rm, שהוא להסיר את קובץ.
לדוגמא, בואו נעשה ls הראשון כדי לראות מה יש לי כאן.
יש לי שלום וhello.c.
נניח שאני רוצה להסיר אותם.
אני יכול לעשות שלום rm.
זה הולך לומר "להסיר את הקובץ רגיל הלו? "ואני אומר" כן. "ועכשיו אם אני
לעשות ls, אני רואה שזה כבר לא שם.
>> אם אני מנסה להשתמש בrm לספרייה, אם כי, זה לא הולך
כדי לאפשר לך לעשות שום דבר.
זה הולך לומר, היי, אתה לא ניתן להסיר במדריך.
אז אנחנו צריכים לבוא זה אחר נקרא rmdir, אשר רק בעצם אומר
הסר את המדריך.
אני יכול, למשל, להסיר pset1.
ואם אני עושה ls, אני לא יש לו יותר.
>> כל שאלות על זה?
לא?
כן?
>> קהל: האם זה חשוב שאתה עוזב רווח אחרי - כל פעם שאתה
מתחיל להקליד משהו ב?
>> לוקאס פרייטס: כן.
אם אני עושה כמו CD והספרייה, אני צריך לשים את החלל.
מה שטח אתה מדבר?
>> LAUREN קרבאליו: המרחב שבין cd ו[ לא ברור].
>> לוקאס פרייטס: כן, יהיה לך ל לשים את הרווחים בגלל cd הוא
הפקודה, ולאחר מכן את המחרוזת הבאה ש סוגך הוא בעצם הספרייה.
אז זה כמו ויכוח.
כן?
>> קהל: כשאתה ברשימה, כל אלה מדריכים שונים, נכון?
>> לוקאס פרייטס: כן, הם נמצא בספרייה.
>> קהל: מה הוא ההבדלים בין הספריות?
>> לוקאס פרייטס: הם פשוט תיקיות שונות.
מדריך הוא תיקייה במחשב שלך.
>> קהל: פתח את תיקייה.
>> לוקאס פרייטס: כן, זה רק תיקייה פתוחה.
>> LAUREN קרבאליו: הנה, אלה כי הם בכחול הם בפועל
ספריות שאתה יכול להיכנס ו לאחר מכן רואה חבורה של דברים שהם
בתוך כך, וזה מצער כי אתה לא יכול באמת לקרוא
אלה בכחול.
ואת אלה בלבן הם רק קבצים הנמצאים בספרייה הנוכחית.
>> לוקאס פרייטס: אז ספריות הן תיקיות.
האחרים הם קבצים.
>> קהל: מה הפקוד כדי לאפס אותו או כדי לנקות אותה?
לוקאס פרייטס: כדי לנקות?
LAUREN קרבאליו: כדי לנקות?
לוקאס פרייטס: אני חושב זה "ברור". כן.
אז אתה פשוט להקליד ברור אם המסך שלך זה מבולגן מדי.
יש עוד שאלות?
ואתה תלמד חבורה של אחרים פקודות רק באופן טבעי במהלך
סמסטר בגלל שהם מאוד שימושיים.
>> אז עכשיו בואו נדבר על העריכה.
דברנו על pseudocode ו קוד מקור וקוד יעד.
ויש הרבה קודים, ואולי אתם מבולבלים לגבי זה.
בואו נדבר קצת על מה קורה כאשר אתה כותב תכנית,
ולך לעבד אותו, והוא הופך להיות קובץ הפעלה.
כל אלה הם מילות שאתם בטח שמע, ואולי אתה לא
ממש בטוח מה קורה.
>> נניח, למשל, שאני רוצה לכתוב תכנית שאומרת "הלו".
הדבר הראשון שעולה במוחך הוא אתה סוג של מנסה לחשוב על איך אתה
הולך לעשות את זה בראש שלך, ו אתה בטח חושב באנגלית או
לשון אחרת, כמו טבעי שפה, כנראה.
ואז אתה חושב, טוב, אם אני רוצה, למשל, לכתוב תכנית ש
אומר "שלום", הייתי מתחיל תכנית, אני נדפיס שלום, ואז אני
יציאה מהתכנית.
זה pseudocode.
זה פשוט בעצם אתה מנסה לבוא עם רצף של אירועים
כי אתה הולך לעשות כדי להיות מסוגל לכתוב תכנית.
>> אז יש לך את קוד המקור, ו קוד המקור לא חייב
במיוחד להיות בג אנחנו מדברים קוד המקור ב-C על כי זה
השפה שאנחנו לומדים, אבל כמובן קוד יכול להיות פחות או יותר בכל
שפת תכנות שיש לך.
מאוחר יותר בסמסטר, אתה הולך ללמוד שפות אחרות.
זה גם קוד מקור.
>> לדוגמא, הנה, זה המקור שלי קוד, ולאחר מכן אני כולל
ספרייה, ואז אני מתחיל ראשי, ולאחר מכן אני מדפיס.
ולורה הולכת לדבר קצת קצת על כל זה.
אז זה קוד המקור.
>> ומה הוא קוד האובייקט?
האובייקט הוא חבורה של אפסים ואלה, בעיקרון.
מה שקורה הוא בהתחלה יש לך pseudocode, שהוא כולו באנגלית.
ואני מתכוון, אתה מבין את זה.
כנראה החברים שלך מבינים את זה, ורוב האנשים היית עושה
להבין את הרעיון.
אבל מחשבים הם באמת מטומטמים, והם לא מבין אנגלית, כך שאתה
יש לתרגם את זה למשהו, בדרך כלל מתורגם לכמה
שפת תכנות.
>> ואתה יכול לחשוב על תכנות שפה כמו כמו סוג של שפה
שאתה אומר איך המחשב שלך לדבר ולהבין.
אתה בעצם אתה כותב משהו ב שפה שבה שניכם ושלך
מחשב מבין.
זה קוד המקור.
pseudocode צורה כל כך הולך למקור קוד, זה תלוי בך.
זה בעצם אתה עושה התכנית שלך.
>> אבל הבעיה היא ש עושה אפילו לא מחשב
להבין את שפת תכנות.
הוא לא מבין קוד מקור בכלל.
זה למעשה רק מבין אפסים ואחדים.
אז יש לנו הדבר מאוד קסם הזה שנקרא מהדר, אשר בעצם הוא
הולך לקבל בשם המקור שאתה כתב בשפה גם לך
והמחשב שלך לדבר, ועכשיו אתה הולך להפוך שב
אפסים ואחדים.
אז בעצם מה שעושה הוא מהדר הוא מקבל את קוד מקור, במקרה זה C,
זה הולך להפוך אותו לאפסים ואלה שהמחשב
מבין ויכול לעשות קובץ הפעלה מחוץ לזה.
>> האם זה הגיוני?
אתה רק יכול לחשוב עליו כמהדר איזה מתורגמן שהוא
עוזר לך תסביר למחשב בדיוק מה שהוא אמור לעשות.
>> אבל איך אני לקמפל.
בואו נחזור למכשיר, ו נניח שאני עושה את התוכנית.
ראשית אני הולך ליצור ספרייה כאן, ואני הולך לקרוא לזה
"בפועל". עכשיו אני הולך לניווט לספרייה, ולכן בפועל cd.
עכשיו אני בתוך תרגול.
>> עכשיו אני רוצה להתחיל gedit, אז איך אני עושה את זה?
אני יכול ללחוץ כאן, או פשוט שאני יכול פשוטו כמשמעו, הקלד "gedit," וזה הולך
כדי לפתוח לי.
>> עכשיו אני הולך לסוג התכנית שלי, אז בדיוק מה שכתבתי בשקופית.
אני מכריז על ספרייה.
אני עושה int ראשי, מבוטל.
ועכשיו אני עושה printf, הלו.
עכשיו אני הולך לשמור את זה.
תן לי לשים את זה לפועל, ו אני הולך להתקשר לhello.c זה.
אז עכשיו זה יישמר.
>> אם אני רוצה לקמפל את זה, אני בעצם יכול לעשות את זה בשני מקומות שונים.
אני יכול לעשות את זה בחלון מסוף, אז זה אחד גדול, או שאתה יכול
להשתמש gedit שלמעשה יש חלון מסוף ממש כאן.
אז אתה יכול מאוד נוח פשוט לעשות הקוד שלך, ואז אתה יכול פשוט להקליד
מה כאן, ולנסות לעבד אותו.
>> אז איך אני יכול לקמפל קוד?
הדרך הקלה ביותר שיש לנו היא על ידי שימוש לעשות, שהיא פונקציה ש
הוא בעצם הולך לקמפל את הקוד שלך.
אתה פשוט צריך להגיד לעשות שלום, ולכן "לעשות" ואת השם של התכנית.
>> אופס.
זה מביך.
>> LAUREN קרבאליו: אתה יכול [לא ברור]?
>> לוקאס פרייטס: מצטער.
אני לא לשמור אותו ב מדריך נכון.
בואו להתאמן, ועכשיו לשמור אותו כhello.c.
אני מצטער.
עכשיו זה יישמר.
>> תן לי רק לעשות ls ולהיות בטוח שזה כאן.
אוקיי, עכשיו זה כאן.
אז עכשיו אם אני עושה לעשות שלום, זה יורק הרבה דברים, אבל אז זה רק נותן לי
לי עוד קו למסוף, אשר אומר שזה היה מוצלח.
אז עכשיו אם אני עושה ls שוב, אני ממש לראות קובץ זה בירוק, המהווה את
קובץ הפעלה.
>> ואז אם אני רוצה להפעיל אותו, כל מה ש אני צריך לעשות הוא לחתוך נקודת שלום.
זה הולך להגיד שלום כאן, כל כך זה בדיוק מה שאני שואל אותו.
>> יש דרך אחת יותר של העריכה, אשר באמצעות צלצול.
צלצול הוא רק מהדר שיש לנו, וזה קצת יותר מפורט כדי
לעבד אותו.
אבל זה עובד באותה מידה.
אז אם אני עושה את הצלצול, ולאחר מכן-o, ולאחר מכן השם שאני רוצה לתת ל
את קובץ ההפעלה, אז בואו נגיד "שלום". ולאחר מכן את הקובץ שאני רוצה
לקמפל, hello.c.
זה גם הולך לקמפל.
ויש לך את הקובץ כאן, ו אני רק יכול לבצע את זה גם כן.
אז שניהם עובדים.
>> האם זה הגיוני?
כל שאלה?
>> קהל: אתה יכול להגדיל את התצוגה בקצת?
>> לוקאס פרייטס: סליחה?
>> קהל: הגדלה?
>> LAUREN קרבאליו: אני חושב שאתה רק יכול לפקד בתוספת.
>> לוקאס פרייטס: פיקוד מה?
>> LAUREN קרבאליו: פיקוד בתוספת.
>> לוקאס פרייטס: מס
>> LAUREN קרבאליו: אה, זה לא הולך לעבודה, כי -
זה בגלל שאנחנו להגדיר את הרזולוציה לדבר הזה.
>> לוקאס פרייטס: אני לא חושב שאנחנו יכולים להתמקד פנימה
כן, אנחנו לא יכולים להתקרב.
האם יש לך עוד שאלה?
סליחה.
>> קהל: אתה יכול לחזור על צלצול?
>> לוקאס פרייטס: הצלצול?
צלצול הוא אותו הדבר כמו איפור, אבל הבדל הוא שקודם אני הולך
לכתוב צלצול, שהיא פקודה, אז אני הולך לעשות -0, כל, שהוא
בדיוק מה שאנחנו הולכים ללמוד מאוחר יותר כדגל.
אז אחשוב רק שאתה תמיד צריך לשים-o.
>> ולאחר מכן ראשון, אתה הולך לשים את שמו של קובץ ההפעלה,
בעצם הקובץ שאתה הולך ליצור.
אז אני יכול לומר, למשל, וhello2 לאחר מכן את הקובץ שאני רוצה לקמפל,
המהווה את קובץ c..
אז זה hello.c.
האם זה הגיוני?
>> קהל: שלום מה?
מה זה?
>> לוקאס פרייטס: Hello.c.
ואם אני מתרגם אותו, ואם אל ls, אני גם יש לי
hello2 שאני רק הידור.
ואם אני מנסה להפעיל אותו, זה הולך לעשות בדיוק את אותו הדבר כמו שלום,
פשוט להדפיס את שלום.
>> קהל: איך לאיפור אתה יכול לשים את hello.c אחרי?
>> לוקאס פרייטס: באיפור, אתה לא צריך לשים. ג.
באיפור, אתה פשוט אומר שם של התכנית.
אתה לא צריך לומר. ג.
אבל לצלצול, אתה צריך.
>> קהל: עם צלצול אתה גם צריך להוסיף [לא ברור]
>> LAUREN קרבאליו: כן.
אז יש לך גם לספרייה.
>> לוקאס פרייטס: כן, זה משהו אנחנו הולכים להשתמש מאוחר יותר.
זה נקרא קישור, ואני חושב שאנחנו הולך לדבר על זה מאוחר יותר.
שאלה נוספת?
>> קהל: האם אתה לשים צלצול לוכסן נקודה?
>> לוקאס פרייטס: מס
לוכסן הנקודה הוא רק כדי לפתוח את קובץ ההפעלה.
אז צלצול, אתה פשוט לכתוב "צלצול", ו אז אם אתה רוצה לפתוח את
קובץ הפעלה שאתה פשוט הידור, אז אתה מנקדים
סלאש את השם.
האם זה הגיוני?
>> קהל: אם היית רק שינוי [לא ברור] לשלום עולם, אתה
יש להדר מחדש את זה?
>> לוקאס פרייטס: כן.
אם אני רוצה לומר, למשל, "שלום שם, "אני יכול פשוט לשמור אותו עכשיו, ואני
רק לקמפל אותו שוב.
אז תן לי לעשות איפור שלום.
ואם אני עושה שלום, זה הולך אומר "שלום לך." הגיוני?
יש עוד שאלות?
>> קהל: האם יש לך לכלול את I / O הסטנדרטי כדי לתאם את העבודה?
>> לוקאס פרייטס: כן.
I / O הסטנדרטי הוא בעצם הספרייה שיש
יישום לprintf.
אז זה דבר נכון על העליון כולל stdio.
כי הוא כולל ספרייה ה בעצם יש חבורה של שונה
כלים שאתה יכול להשתמש.
אחד?
מהם הוא printf שהוא פונקציה כי בעצם הדפסים
הודעות על גבי המסך.
>> יש עוד שאלות?
לא?
על אישור.
אז עכשיו בואו נדבר על -
>> LAUREN קרבאליו: בואו פשוט ללכת למדריך הסגנון.
האם אתה רוצה רק למצוא אותו כאן?
>> לוקאס פרייטס: אז אנחנו הולכים לדבר על סגנון.
>> LAUREN קרבאליו: אה, דוד לא סיים.
על אישור.
למה אנחנו לא חוזרים ל סגנון ממש בסוף?
זה בעצם עודכן כמו שאנחנו מדברים.
>> לוקאס פרייטס: כן.
בואו דרכו של דוד לכדי לסיים את זה.
>> LAUREN קרבאליו: Can אנחנו עוברים בעצם?
>> אז אני מקווה שכולם היה נהנה מסריטות.
למרבה הצער, זה הזמן להתרחק מזה -
למרבה הצער זה זמן להתרחק מהלוקים בתכנות האלה די
לג אבל למזלנו, כל תכנות בונה שיש לך
עובד עם בגרד הם ישירות לתרגום ל-C, ואנחנו
הולך להתחיל ללמוד על חלק מהם עכשיו.
השיחה הראשונה הבה על תנאים בביטויים בוליאנית.
>> זה פועל על מילואים כוח הסוללה.
>> לוקאס פרייטס: איך הוא שלא עובד?
על אישור.
אתה הולך לשם, אני הולך לקבל -
>> LAUREN קרבאליו: אז תנאים חשוב משום שהם מאפשרים לנו
להציג את ההיגיון בתוכניות שלנו.
הנה דוגמא של מצב בתוך תכנית C.
בואו שימו לב איך זה -
אז לחסום את המצב הזה כאן, זה שמירה על printf לא תבצע
אלא אם כן המצב בתוך סוגריים, n גדול מ 0,
מעריך לנכון.
>> עכשיו, כל התנאים בתוך f הצהרות הן ביטויים בוליאנית,
מה שאומר שיש רק שתי אפשרויות.
הם יכולים גם להעריך לנכון, או שהם יכולים להעריך לשווא.
אז הנה, אז זה הגיוני, נכון? n גדול מ -0, ופירוש דבר הוא חיובי
מספר, מה שאומר שהוא יודפס מתוך "בחרת מספר חיובי."
>> יש המון ביטויים בוליאנית כי יכול להיווצר המצב עם
שמירה על init.
יש לנו פחות מ.
זה פחות או שווה ל.
זה [לא ברור] פשוט מצחיק.
אם אתה רוצה printf להתרחש אם זה גדול או שווה ל -0, ולאחר מכן
היית בוחר את זה.
אז שווה פשוט מצרף תקין לאחר יותר משלט.
>> שווה שווה, וזה שונה מ רק סימן אחד שווה, שווה שווה
בעצם אומר שכל מה ששל על צד שמאל של זה הוא אותו הדבר כמו
מה יש בצד ימין של זה שבו סימן אחד שווה הוא מה?
מה הוא רק סימן אחד שווה?
הקצאה.
>> לוקאס פרייטס: מי אמר את זה?
האם זה ממתק?
הו, לא.
סליחה.
שניכם לקבל ממתקים.
אה, אוקיי!
שלושה אנשים מקבלים ממתקים!
>> LAUREN קרבאליו: אז זה אחד ממש כאן הוא מפעילת המפץ הקודמת
סימן השוויון, אז זה לא שווה.
אז אם זה היה בתוך המצב שלי, את גופתו של המצב היית
לבצע רק אם כל מה ששל ב השמאל הוא לא אותו הדבר כמו
מה בצד הימין.
>> אני יכול גם להיות פשוט סימן קריאה.
למעשה אנו רואים בתכונה החלק איך זה יהיה בשימוש.
>> לוקאס פרייטס: יש שאלות?
לא?
>> LAUREN קרבאליו: אנחנו יכולים לשלב הבאים ביטויים בוליאנית לבנות יותר
משפטי תנאי מורכבים.
אז הנה, אם כל מה ששל בצד השמאל צד של הסורגים כפולים או
כל מה שהוא בצד ימין של הברים כפולים ערך TRUE,
אז להדפיס את לא חוקי.
וכאן למטה אז, אם כל מה ששל בצד שמאל של שני
סימן חיבור וכל מה של בצד הימין צד של שני תווים האמפרסנד
מעריך לנכון, אז אנחנו להדפיס בתוקף.
הברים כפולים נקראים הלוגי או מפעיל סימן החיבור הכפול הם
נקרא אופרטור הלוגי AND.
כן?
>> קהל: האם אלה רק אותיות הקטנות l's?
>> LAUREN קרבאליו: לא.
הם בעצם -
אתה יודע את תגובת הנגד, כמו מעל מקש Return שלך?
האם אתה רואה את זה?
>> לוקאס פרייטס: זה בעצם בר.
>> LAUREN קרבאליו: זה בעצם רק שני ברים.
>> קהל: אתה יכול להשתמש שווה שווה למיתרים?
>> לוקאס פרייטס: מס
אנחנו הולכים ללמוד מאוחר יותר משהו על זה.
>> LAUREN קרבאליו: יש פונקציה כי אתה יכול להשתמש.
אבל אין לך לדאוג כי עדיין.
>> מה אם אני נותן בתכנית זו המספר 5?
מה להדפיס?
>> קהל: [לא ברור]
בתוקף.
>> LAUREN קרבאליו: תקף?
כן.
אני לא יודע מי קיבלתי את זה.
>> [שחוק]
>> LAUREN קרבאליו: זה סוג מפחיד [לא ברור].
>> קהל: אז כפול ו, זה רק אומר וש?
>> LAUREN קרבאליו: כן.
אז מספר 5 הוא גם גדול יותר מ 0 ופחות מ 100.
>> קהל: למה שזה יהיה אחד?
>> LAUREN קרבאליו: אמפרסנד אחת הוא בעצם משהו אחר, וזה
מפעיל ביטים, אשר תוכל ללמוד על מאוחר יותר.
אבל זה משהו שבאמת עובד עם הביטים של מספר נתון.
>> לוקאס פרייטס: רק חושב שהם עושים לא צריך לדאוג זה לעת עתה.
>> LAUREN קרבאליו: אני חושב שזה כנראה מגיע בשבוע הבא.
>> לוקאס פרייטס: יש עוד שאלות?
לא?
>> LAUREN קרבאליו: אז שראינו כי זה לחסום יכול לעמוד לבד, אבל זה יכול
גם להיות יחד עם ועוד בלוק.
אז במקרה הזה, אם n הוא גדול יותר מאשר 0, אנחנו הולכים להדפיס את "אתה
הרים מספר חיובי. "אחר, כלומר, אם זה הוא 0 או אם זה פחות
מ 0, אנחנו הולכים להדפיס, "אתה הרים מספר שלילי".
>> הדבר המעניין כאן הוא כי אלה הם בלעדיים של כל אחד אחר.
מעולם לא הולך להיות מקרה שבו זה ואת זה
יכול גם להדפיס.
>> אני בטוח שאתה עבד עם אם / אחר תיבה בגרד, כך זה צריך להיות
די מוכר.
כן?
>> קהל: האם אנחנו צריכים את המרחב שבין n int שווה GetInt אז חלל ב
אם הצהרה?
כמו שאנו משתמשים בקו [לא ברור]
>> LAUREN קרבאליו: אה, החלל לכאן?
>> קהל: כמו זה, אבל אתה להכפיל חלל.
לא, לעלות.
לעלות.
>> לוקאס פרייטס: רק את הקו?
>> קהל: כן.
>> לוקאס פרייטס: רק השורה הריקה?
>> קהל: כן.
>> LAUREN קרבאליו: שורה ריקה?
לא.
זה פשוט דבר סגנוני.
>> לוקאס פרייטס: זה בדיוק כמו לפעמים אתה פשוט לדלג על כמה שורות כל כך
שהקוד לא נראה כמו גוש טקסט ענק.
>> LAUREN קרבאליו: אני חושב שמה שקרה היה שהיו לנו תגובה כאן, אבל אני
הוצאתי אותו, כך שאתה חבר 'ה תצטרך לחשוב על הקוד ולא
מאשר רק לקרוא את התגובה שלי.
באופן כללי, לא יהיה מרווח באמת להשפיע על האופן שהתכנית שלך פועלת.
זה יותר עניין סגנוני.
וכאשר יש לנו המדריך לסגנון מעודכן ומוכן ללכת עד סוף
supersection, נדבר על זה יותר.
>> יש משהו לא בסדר עם תכנית זו, נכון?
בגלל 0 הוא לא ממש מספר שלילי.
אז בואו נראה אם ​​אנחנו יכולים לתקן את זה.
>> אתם בטח יכולים לתאר לעצמך עם זה אומר, נכון?
אם n הוא גדול מ 0, אנחנו מדפיסים, "אתה הרים מספר חיובי. "אז אחר
אם n הוא פחות מ 0, "אתה הרים מספר שלילי. "אחר," אתה הרים
0 ".
>> עכשיו הדבר המעניין הוא ש זה יכול להימשך לנצח.
יכול להיות לך אם לחסום, אחר אם בלוק, אחר אחר אם בלוק, אחר אם,
אם אחר, אם אחר, אחר, בעצם כל עוד אתה רוצה.
וכאשר נבנו כמו זה, כל אלה הולכים להיות
בלעדי של אחד את השני.
כן?
>> קהל: אז למה אתה לא יכול פשוט להשתמש אחר אם במקום [לא ברור]?
>> LAUREN קרבאליו: במקרה זה, כן אני אפשר להשתמש אחר אם, וזה יהיה
בסדר גמור, כי תנאים עצמם
בלעדי של אחד את השני.
אבל אם התנאים לא היו בלעדיים של כל אחד אחר, היית עושה את זה
להכריח אותם לעולם גם להעריך, אם זה נשמע הגיוני.
>> קהל: במקרה זה, יכול אנו קן השני, אם בתחילה אם?
>> LAUREN קרבאליו: אם - למה אתה מתכוון?
>> קהל: אם שני תנאים אינם סותרים?
>> LAUREN קרבאליו: אם התנאים אינם סותרים?
אבל אתה רוצה רק אחד מהם לרוץ?
>> קהל: אתה רוצה רק אם במקום אחר.
>> LAUREN קרבאליו: כן.
יש תמיד הולכים להיות הרבה דרכים שבן אתה יכול לעשות את זה.
אתה בהחלט יכול קינם.
ואתם תראו בשקופית שעתיד אתה יכול לקבל את טענות מרובות, רק אחד
בזה אחר זה.
אבל זו דרך של לוגי ארגון הזרימה של התכנית שלך.
>> לוקאס פרייטס: ויש עוד אחד דבר, הוא שאתה שאלת על לשים
אם ואז עוד אחד, אם.
שיעבוד בצורה מושלמת, אבל זה רע עיצוב משום שבעצם אם אתה
לבדוק תחילה אם, ושמתם לב ש המספר גדול מ 0, אתה
פשוט יכול לסיים את התכנית.
אתה לא צריך לבדוק אם זה פחות מ 0, נכון?
>> אבל אם ואם ואם, זה הולך לבדוק שניהם, בזמן שאם אני עושה אם אחר הוא,
זה הולך לבדוק אם זה גדול מ 0.
אם זה הוא, זה לא הולך אפילו להסתכל בקווים האחרים של הקוד.
אז אתה בעצם בודק את זה כמו פעמיים שלא לצורך, ולכן זו הסיבה שאנו
לעשות אם אם אחר.
יש עוד שאלות?
>> קהל: אז את הפונקציונליות של אחר אם זהה
אם זה היה רק ​​אם?
>> LAUREN קרבאליו: לא.
למעשה, אתם הולכים לראות בי הבאים החלק דוגמא שבו הוא יכול
להיות שונה.
במקרה זה, זה כמעט אותו הדבר.
>> אז הנה, יש לנו דוגמא של מספר אם הצהרות, ו
פונקציונלי הוא לא אותו הדבר כאילו יש לי רק אמר שאם
אחר, אם אחר, אם אחר.
בואו רק לחשוב על מה שהייתי להדפיס אם אני הזן את המספר 95
לתכנית זו.
>> קהל: [לא ברור]
>> LAUREN קרבאליו: ואז?
>> קהל: [לא ברור]
>> LAUREN קרבאליו: כן.
אז במקרה הזה, תנאים אלה הם אינו סותרים אחד את השני.
ומכיוון שאין שום דבר שעוצר מצב זה מהערכה אם זה
כבר יש אחד, הם רק כל הולך להדפיס.
אז איך אני יכול לתקן את זה?
>> קהל: IFS אחר?
>> LAUREN קרבאליו: אתה יכול להשתמש בטענות אחרת.
אני יכול לשנות את הסדר אלה, נכון?
אם אני עשיתי את זה קודם?
טוב, בעצם, לא.
זה לא יעבוד עבור 95.
>> לוקאס פרייטס: לא, רק טענות אחרת.
>> טענות אחרת: LAUREN קרבאליו היה קבוע זה.
האם זה להבהיר את הבלבול בין טענות ועוד טענות?
>> קהל: אני רק רציתי לשאול אותך, אם אתה לא משתמש אחר אם, היא תפסיק?
>> LAUREN קרבאליו: נכון.
אז רק זה ראשון.
אם אני נכנסתי למספר 95, רק זה היה מודפס, וזה אף פעם לא
היה התקדם לאחר.
>> לוקאס פרייטס: פשוט סוג של חושב זה כאילו זה קורה, לעשות את זה.
אחר הוא כמו אם לא, בדוק לזה, ולאחר מכן לעשות את זה.
אז כמו שכולם הדדי בלעדי.
אתה לא יכול להיכנס לשני פני אלה.
>> קהל: אתה יכול להשתמש לוגי ולמצב הזה?
>> LAUREN קרבאליו: כן.
זו דרך שאנחנו יכולים עוד תיקן את הבעיה הזו.
אנחנו יכולים להיות מוגדרים נע, נכון?
כדי שאוכל אמר שאם n הוא גדול יותר מ -90 ופחות מ -
טוב, אני מניח שזה אחד לא ממש משנה, אבל כאן אני יכול לומר אם
n הוא גדול יותר מאשר 80 ופחות מ 90.
יותר מ -70, פחות מ80.
זה היה יכול להיות גם עבד.
>> [שחוק]
>> לוקאס פרייטס: היא מפחדת.
>> LAUREN קרבאליו: אל תפחד.
>> לוקאס פרייטס: זה לא שזה יהיה בסדר.
זה פשוט שזה שלא לצורך מפורט.
כמו במדעי מחשב, אחד צריך להיות פשוט ככל האפשר, כל עוד
יש לך את הפונקציונליות.
האם אתה רוצה הסוכרייה?
>> קהל: לא צריך את זה.
>> LAUREN קרבאליו: אתה מפחיד את כולם, לוקאס.
>> לוקאס פרייטס: מצטער.
>> LAUREN קרבאליו: דוד מוזכר גם אלה לעבור שמירה בכיתה.
בעיקרון מה שקורה הוא המתג שמירה לוקחת משתנה.
במקרה זה, אנחנו לוקחים את מספר שלם.
>> אם המספר השלם הוא 1, אנחנו הולכים להדפיס, "אתה הרים קטן
מספר. "אם המספר השלם הוא 1," אתה הרים מספר בינוני. "אם
שלם הוא 3, "אתה הרים גבוה מספר. "והיה לי גם מקרה של ברירת מחדל
כאן למטה, אבל זה לא מראה למעלה, וזה חבל מאוד.
>> בעיקרון, זה רק תחביר אחר.
אנחנו יכולים ליישם את זה מדויק אותו דבר עם אם ואם אחר
הצהרות.
אבל כאשר יש הרבה שונה תנאים והרבה שונים
וריאציות על מה שאתה רוצה לעשות עבור כל קלט, זו אופציה.
אז זה רק תחביר טוב לדעת.
כן?
>> קהל: מדוע יש לא קו נטוי n בראשון?
>> LAUREN קרבאליו: לשם למעלה?
אין קו נטוי n שם למעלה בגלל GetInt -
אם תנסה את זה, זה יהיה אתן לך הנחיה זו.
תן לי את מספר שלם בין 1 ו -3.
ואם אני שם את n חריפה, זה היה לקחת אותי לשורה הבאה, אבל אני פשוט
רציתי שהם הקלד את המספר השלם מייד אחרי המעי הגס.
אתה יכול לשים את n התגובה החריפה.
זה לא עניין גדול.
כן?
>> קהל: לקוד הזה, הוא זו מקרה אחד, הוא שבגלל
זה המקרה הראשון?
כי -
>> LAUREN קרבאליו: לא, לא, לא.
אז זה נותן לי מספר שלם בין 1 ל 3.
אם n הוא 1, אני מדפיס את זה.
אילו הייתי שואל למכתבים, יש לי יכולים אמר לתת לי את מכתב בין
וג ואז זה יהיה מקרה א
>> קהל: [לא ברור].
המקרה הייתי פשוט [לא ברור]
>> LAUREN קרבאליו: כן, בטח.
כן?
>> קהל: מה אם אתה רוצה יש לי יותר מביטוי יחסי?
אז במקום לומר n שווה 1, [לא ברור]
n הוא גדול מ -1 במקרה הראשון?
>> LAUREN קרבאליו: למעשה, אם אני לא להגדיר חלק מהמקרים האלה, היית זה
ניתן לבצע כלפי מטה.
אז בעצם, אולי זה לא מה שאתה מבקש.
>> לוקאס פרייטס: אני חושב שהיא שואלת אם המקרה היה n גדול מ 0, במקרה
פחות מ 0.
>> LAUREN קרבאליו: אולי את המתג אמירה לא באמת מה שאתה רוצה
לשימוש במקרה זה.
>> לוקאס פרייטס: ההצהרה הבורר היא רק בשביל ערך, אז אתה בודק של
הערך הוא כמו זה או אחר.
אז אתה לא יכול באמת לשים תנאים.
>> קהל: מה אם האדם סוגים עם [לא ברור]?
>> LAUREN קרבאליו: זה היה יכול להיות מקרה ברירת המחדל שלי, שלמרבה הצער
אתה לא יכול לראות.
>> לוקאס פרייטס: [לא ברור] לגרום להם לראות.
>> LAUREN קרבאליו: למעשה, אתה יודע מה?
בואו פשוט ללכת ללמוד 50, ואני רק להתקרב בשקופיות על מחקר
50, כי זה פשוט מעצבן.
אז תן לי בעצם ללכת למצב.
זה רק הולך לקחת קצת זמן.
>> בסדר.
אז, אני מצטער.
לפחות עכשיו נהיה מסוגל לראות כל מה שבלי זה ניתוק.
בסדר.
>> אז אם הם שמים ב10, היינו ברירת מחדל כאן למקרה ברירת המחדל שלי, ואני
הייתי להדפיס רק חוקי, כי אני ביקש מהם להיכנס שלם
בין 1 ל 3.
יש עוד שאלות?
כן?
>> קהל: נניח למקרה אחד, במקרה שלוש, תגידו שאתה רצית שזה יהיה כל
אותו דבר, ולכן בחרת מספר זה לא מספר בינוני.
במקרה כזה, זה יהיה מיותר?
האם אתה יכול פשוט לשנות את הטקסט בשני מהם, או שיהיה כמה
יתירות?
האם יש דרך לשלב [לא ברור]?
>> LAUREN קרבאליו: ישנן דרכים לשלב אותם, אבל אני מאמין שאתה יכול
רק לשלב סמוכים אלה.
אז אם לא אני לא מגדיר שום דבר למקרה שניים, היית זה
חלים על שני המקרים.
אה, אם אני לא הכנסתי שום דבר למקרה אחד, זה יחול על שניהם
מקרה אחד ושתיים.
אם זה נשמע הגיוני.
>> קהל: אתה יכול לחזור על זה?
>> לוקאס פרייטס: אישור.
אם עשית בעצם, כאילו, יש לך את אותו הדבר, אבל אתה לא שמתי
שום דבר כאן, אתה רוצה להיות גם עבור מקרה אחד או במקרה שתיים, לעשות את זה.
נכון?
והפסקה זה אומר שאם אתה מקבל למקרה זה, פשוט לעזוב.
אז זה מה שאומר הבלם.
אז אם אני רק עשיתי את זה, אתה מסתכל, זה מקרה אחד, והיית עושה בדיוק את זה.
אם זה היה מקרה שני, זה גם היית פשוט לבוא לכאן ולעשות את זה.
>> קהל: אבל אתה יכול לעשות את זה?
אם יש משהו שעבור מקרה שני [לא ברור]
>> LAUREN קרבאליו: אני לא מאמין אתה יכול לעשות את זה.
אני לא חושב שאתה יכול לדלג בסביבה.
האם אתה יכול לעשות את זה, רוב?
לא נראה לי.
>> קהל: אז רק מספר אחד יכול ללכת אחרי מקרה, נכון?
לא יכול להיות שיש מקרה אחד, פסיק, שתי?
>> לוקאס פרייטס: לא, אתה לא יכול.
אתה בהחלט לא יכול.
>> LAUREN קרבאליו: אני מתכוון, הנקודה היא זו אופציה, וזה אולי לא
תתאים למקרה השימוש שלך, אז אתה ישתמש אם תנאים.
>> קהל: אז למה אתה עושה את זה?
המתג?
>> LAUREN קרבאליו: אני אשתמש בזה אם מאוד שהגדרת -
למעשה, לוקאס, הוא שאתה חוסם.
>> לוקאס פרייטס: אה, סליחה.
>> LAUREN קרבאליו: אם יש לך מאוד התנהגויות מוגדרות הרצויה עבור
כל קלט, זה יכול להיות קצת יותר תמציתי מאשר לכתוב את
אם הצהרה עבור כל אחד.
>> קהל: מה עושה לשבור אומר שוב?
>> LAUREN קרבאליו: הפסקת פירושו להפסיק.
זכור, אם לא היה לי הפסקה זה כאן, היינו פשוט נפלתי
למקרה הבא.
>> לוקאס פרייטס: הפסקה אומרת לקבל מתוך שמירה על המתג.
מכיוון שאם זה 1, אני רוצה כדי להדפיס את זה ולעזוב.
אני לא רוצה לבדוק שום דבר אחר.
>> קהל: אתה לא רוצה להדפיס כל דבר אחר.
>> לוקאס פרייטס: כן.
בגלל שזה סותרים.
>> קהל: והאם זה להמשיך רק למקרה הבא אם במקרה הראשון
לא נכון?
או שהיא לבדוק את כל המקרים באותו הזמן?
>> לוקאס פרייטס: לא, זה בדיקות ברצף.
ברצף, כן.
עוד שאלה אחת, אז אנחנו חייבים להמשיך הלאה כדי שנוכל לכסות את הכל.
כן?
>> קהל: אז למקרה, יכול להיות עשה משהו חוץ מזה רק אחד?
האם אתה יכול לתת לו מגוון?
>> לוקאס פרייטס: מס
>> LAUREN קרבאליו: אני לא חושב אתה יכול לתת לו מגוון.
>> לוקאס פרייטס: אתה לא יכול לך לא יכול לתת לו טווח.
>> קהל: המקרה ספציפי [לא ברור].
>> לוקאס פרייטס: החלף הוא סוג של ערכים.
אתה עושה דברים שונים בהתאם על ערך, ערך ספציפי.
אתה לא יכול לעשות טווח, אתה לא יכול לעשות שום דבר אחר.
זה רק עוד כלי כדי לראות.
>> LAUREN קרבאליו: רוב האנשים לא משתמשים לעבור הצהרות מאוד בCS50,
אבל זה שם.
>> בסדר.
אז הדבר הבא שאנחנו הולכים לדבר עליו הוא המפעיל המשולש.
זה רק סוג אחר ממותנה.
בעיקרון מה שקורה כאן הוא שאני מבקש שלם, ואם n הוא
יותר מ 100, אני הולך להדפיס את "גבוה". אם זה לא, אני הולך
להדפיס את "נמוך".
>> אז מה הוא עושה הוא התנאי ממש כאן בסוגריים, ואתה
סוג של יכול לחשוב על השאלה כמו שאני שואל אם
זה נכון או לא.
אם זה נכון, אני הולך לעשות את זה ראשון דבר, ואם זה לא נכון, אני
הולך לעשות דבר שני זה.
>> כל שאלות על מפעיל משולש?
>> לוקאס פרייטס: רק רוצה לציין מ דוד הוא שכל פעם שיש לך
מצב -
>> LAUREN קרבאליו: אני מניח שהדוד של צופה דרך הזרם החי.
>> לוקאס פרייטס: הוא עושה חיים זרם עכשיו.
אז בכל פעם שיש לך מצב, אתה אמור לשים סוגריים מסולסלים,
בדיוק כמו שיש לנו במתג אמירה כאן.
יש לנו סוגריים מסולסלים כאן.
לכל תנאים, אתה אמור גם לשים את זה.
>> LAUREN קרבאליו: אתה תראה זה במדריך לסגנון.
בעצם אין לנו מדריך סגנון עכשיו.
אני חושב שהדוד של עדיין עובד.
>> לוקאס פרייטס: הוא אמר כי זה פשוט עובד עכשיו.
>> LAUREN קרבאליו: אה, זה עובד עכשיו?
על אישור.
אז, ככל הנראה, בשנה זו בסגנון להדריך, גם אם אתה רק צריך שורה אחת,
אתה חייב לשים אותם סוגריים מסולסלים פנימה
אתה לא בהכרח צריך ל הפונקציונליות של התכנית.
ואולי אנחנו צריכים פשוט לקחת הפסקה לאחר התנאים וללכת ישר
למדריך הסגנון כדי לנקות עד כמה מהדברים האלה?
>> לוקאס פרייטס: כן.
האם יש לך שאלה?
>> קהל: לא, אני רק לחכות עד מדריך הסגנון.
>> קהל: האם אתה יכול לחזור למפעיל המשולש?
>> LAUREN קרבאליו: משולש, כן.
>> לוקאס פרייטס: מפעיל משולש הוא בעצם אמירה אם אחרת, אבל
במקום שיש שני קווים בדיקה אם ולאחר מכן
אחר, רק שיש לך שורה אחת.
אז בעצם, אם אני רוצה לתת לי מחרוזת ערך שלי גבוה או נמוך, ו
רוצה לעשות גבוה אם n הוא גדול יותר מאשר 100 או נמוך אם זה פחות, מה אני יכול לעשות
זה [לא ברור]
המחרוזת הולכת להיות, ואז אני לשאול את התכנית היא n גדולה מ 100?
>> אז בגלל זה יש לי את הביטוי הזה בסוגריים ולאחר מכן
סימן השאלה.
אני שואל את זה גדול יותר מ100?
אם זה הוא, שזה הולך להיות גבוה.
אם זה לא, זה הולך להיות נמוך.
>> אז בעצם מה שאתה חושב שאתה שואל שאלה, אז אתה שם בסוגריים
המצב.
ואז אתה שם את סימן השאלה בגלל שאתה שואל את זה.
ואם זה נכון, זה הולך להיות בערך הראשון [לא ברור] כאן.
אם זה לא, אני הולך לשים ערך שאחרי הנקודתיים.
האם זה הגיוני?
>> זה גם משהו שהוא כמו כלי ב-C, אבל אין לך
במיוחד להשתמש בו.
אבל אנשים בדרך כלל אוהבים שCS כי זה פשוט חוסך קווים.
>> LAUREN קרבאליו: זה מאוד אלגנטי.
הוא עושה הרבה רק משפט אחד.
>> קהל: אז סימן האחוזים הוא רק מה שאת התוצאות על
השורה הקודמת?
>> LAUREN קרבאליו: אה, אני מצטער.
סימן האחוזים זהו למעשה מציינים מיקום זה זה.
בהצהרת printf, יש לך את זה מחרוזת כאן, וזה מה שהולך
להדפיס, אבל אתה לא יכול פשוט לשים את זה בזה שם.
אחרת זה יהיה להדפיס מתוך ים, פשוטו כמשמעו.
אז אנחנו שמים אחוזים לכאן כדי לשמור על במקום זה נערך לכל מה
מגיע אחרי הפסיק.
>> אז למחרוזת, יש לך אחוזים של.
למספר שלם, אני אחוזים.
למצוף, f אחוזים.
אתה תראה אותם כפי שאנו ראה דוגמאות נוספות.
אבל אולי כדאי לך לדבר על מדריך סגנון לזמן קצר, עכשיו
כי זה תלוי.
>> לוקאס פרייטס: אם אתה הולך ל cs50.net/style, אתה הולך לראות
מדריך הסגנון.
לסטי בעיה, הציון שלך עבור סט בעיה מורכב מהיקפו,
אשר בעצם אומר שאם אתה עשית את כל החלקים של בעיה להגדיר או אם אתה
ניסיתי משהו.
הדבר השני הוא נכונותו, אשר אמצעי הוא התכנית שלך עושה את מה שהוא
היה אמור לעשות, או עושה את זה יש באגים, או שזה לא עושה את מה
זה אמור לעשות.
>> הדבר השלישי הוא עיצוב, שפירושו אתה מיישם זאת היטב, או שהם
אתה משתמש בהצהרות מיותרות?
כך למשל, אם ברצונך לחזור מספר 10 פעמים, אתה כותב
ללולאה או שאתה רק עושה את 10 פעמים באותה ההצהרה, פשוט עושה
העתקה והדבקה.
אז עיצוב הוא בשביל זה.
>> ולבסוף, יש לך סגנון.
סגנון הוא בדיוק כמו לשפוט אם הקוד שלך נראה
קריא וסוג של די.
זה פשוט בעצם אומר הוא הקוד שלך קריא?
הייתי מישהו אחר שחיפש הוא הקוד שלך להיות מסוגל להבין מה
הוא עושה?
האם יש לו הערות וכדומה?
>> בואו נדבר על הסגנון אתה אמור להשתמש בו.
הדבר הראשון הוא הערות.
תגובות הן מאוד חשובות עבורך קוד כי לפעמים אתה עושה
התכנית שלך, ואתה יודע בדיוק מה אתה רוצה לעשות, כך שאתה פשוט להתחיל
קידוד, פשוט הקלד את חבורה של C. אבל אם מישהו אחר מחפש אתה
קוד, הם לא הולכים להיות מסוגלים להבין את זה, כי הם לא יודעים
הדברים שהם בראש שלך, כמו pesudocode, אז אולי הם יהיו
מתקשה להבין מה הקוד עושה.
>> אז הערות הן באמת שימושיות כדי להסביר למי שמסתכל על
הקוד שלך מה הוא עושה, ו למעשה אפילו בשבילך,
הם מאוד שימושיים.
כמו שאתה הולך לPsets קשה יותר וקשה, אתה הולך לראות שהקוד מקבל
, ולאחר מכן הערות כבר באמת חשוב שתזכור מה כל אחד
חלק מהתכנית שלך עושה.
>> כדי לשים את תגובה, אתה יכול פשוט לעשות סלאש קו נטוי ולאחר מכן לכתוב תגובה.
והקו כולו הוא חלק מתגובה, ומה שאתה כותב למטה,
זה לא הולך להיות משמש לקוד שלך.
זה בעצם כמו מהדר הוא הולך להתעלם מזה.
האם זה הגיוני?
>> קהל: מה אתה עושה שוב כדי לכתוב תגובה?
>> לוקאס פרייטס: זה?
הלוכסן לקצץ?
בכל פעם שאתה מקליד קו נטוי קו נטוי, מה עולים בקנה אחד כי הוא לא הולך
כדי להיחשב ג כן?
>> קהל: אז אחרי התגובה, אתה רק להיכנס ולהתחיל שורה חדשה?
>> לוקאס פרייטס: כן, בדיוק.
>> LAUREN קרבאליו: הקו נטוי הקו הנטוי הוא על הערות שורה אחת.
>> לוקאס פרייטס: לדוגמא, כאן יש לנו -
תן לי להתקרב -
לדוגמא, הנה אני מכריז לצוף, אבל אולי אם אתה רק לשים את זה
בקוד שלך, כמוך אין לי מושג מה זה עושה, כמו בעצם
מישהו שמסתכל על הקוד הזה הוא הולך להיות, כמו, מה
לעזאזל קורה פה?
>> אם אתה שם את תגובה אומרת "להמיר פרנהייט לצלזיוס, זה עושה הרבה
יותר הגיוני.
אתה, כאילו, בסדר, אתה ביצוע המרה.
האם זה הגיוני?
אז זה פשוט משהו שעוזר לאנשים מוכן הקוד שלך וגם לבצע
שתוכל לארגן הקוד שלך טוב יותר.
>> הדבר השני הוא שאתה יכול לעשות הערות רב קווים, ולכן יש אחד
להגיב לחבורה של קווים.
במקום שיש לשים קו נטוי קו נטוי, הערות השורה הראשונה, לקצץ בקו נטוי,
השורה השנייה, וכן הלאה, אתה ניתן להשתמש בכוכבית הקו הנטוי.
הדרך שבה אתה עושה את זה היא שעבור השורה הראשונה של התגובה, אתה
הולך לעשות כוכב כוכב לוכסן, כך סתם ככה.
בדיוק כמו כאן יש לנו את תחילתו של תכנית, אתה בדרך כלל לשים מי אתה
הם, מה התכנית הזו עושה, ודברים כאלה.
זה כמו סוג של כותרת עבור התכנית.
>> שוב, זה לא משהו ש מהדר הולך אכפת, אבל
זה חשוב לך לדעת מה זה תכנית עושה או לאנשים אחרים
לדעת מה התכנית שלך עושה.
אז אתה לקצץ כוכב כוכב, ולאחר מכן השורה האחרונה אתה הולך לעשות כוכב
סלאש כדי להיות מסוגל לסגור ההערה הזאת.
אז בעצם לכל קווים האחרים, רק אתה יכול לכתוב מה, וזה
הוא כל הולך להתעלם ממנו.
>> וגם, בדיוק כמו סגנון, אתה רואה את זה כל אחד מהקווים יש כוכבים, וכל
הכוכבים מיושרים.
אלו דברים חשובים כל כך שהקוד שלך נראה יפה.
נשמע טוב?
>> עכשיו, תנאים.
מה דוד היה אומר שאנחנו צריכים ממש לשים בשקופיות אלה, הוא כי
כאשר יש לך כל סוג של אם דוחות או כל סוג של תנאים,
אתה צריך להשתמש בסוגריים מסולסלים כדי להראות כי זה מה שהולך לקרות
כאשר יש לך את המצב.
מבחינה טכנית, כאשר יש לך מצב ואז השורה הבאה היא רק אחד
קו, אין לך מבחינה טכנית לשים את הסוגריים המסולסלים.
>> בעיקרון מהדר היה מבין זה בכל מקרה כפי שמשתמע.
אבל עבור CS50, אנו מבקשים מכם לשים הסוגריים המסולסלים רק כדי ש
הקוד הוא מאורגן יותר וקריא יותר.
מכיוון שהקוד שמקבל זמן רב יותר אם אין לי פלטות וכזה מתולתלות.
זה נהיה ממש מבולגן.
>> LAUREN קרבאליו: זה בדיוק מה דוד רק ציין
בשקופיות הקודמות שלי.
זה בהחלט עובד ללא מתולתל פלטה, אבל מסיבות סגנוניות
אנחנו הולכים לבקש ש אתה לשים אותם פנימה
>> וכשאתה מתחיל לרוץ style50, שהוא סוג של הבדיקה 50 עבור
סגנון, זה יזכיר לך לעשות את זה.
>> לוקאס פרייטס: ועוד דבר לזכור לשים סוגריים המסולסלים לאורך
בכל שורה.
אז אתה עושה, למשל, l's.
עבור לשורה הבאה, פתח את המתולתל סד, ואז אתה הולך לשורה הבאה.
כניסה, שבו היא ארבעה חללים.
אז אתה כותב מה, ואז עוד הקו, וסגור את הסד המתולתל.
אז כדי להיות בטוח ששני אלה מתולתל פלטה נמצאות בקווים שונים.
>> קהל: אז אם היה את הקוד הזה כמו 10 טענות אחרת, צריך את זה
להיות 10 סטים של סוגריים?
>> לוקאס פרייטס: כן, לכל אחד מהם.
כן.
אז אם, אם אחר, וכן הלאה.
>> קהל: אתה יכול לא הקש Tab כדי להזיז?
>> לוקאס פרייטס: אנחנו שואלים אותך החבר 'ה כדי להשתמש בארבעה חללים.
עורכי טקסט מסוימים לתרגם כרטיסייה כארבעה חללים באופן אוטומטי.
gedit לא, אז יש לך ל לעשות חלל חלל חלל החלל.
זה גם משהו שקצת מתכנתים לעשות רק כרטיסיות, כמה
מתכנתים לעשות רק ארבעה חללים, וכמה אנשים אחרים אפילו לעשות
שניים או שלושה מקומות.
זה רק שכאן אנחנו מבקשים אתם לעשות ארבעה חללים.
>> קהל: יש כמעט בודאות חייב להיות דרך לgedit כדי
באופן אוטומטי [לא ברור].
אין כמותו [לא ברור] עושה את זה.
>> לוקאס פרייטס: כן.
אני חושב שאתה יכול ללכת להגדרות.
>> קהל: זה כבר עושה את כל זה.
>> לוקאס פרייטס: זה כבר עושה?
על אישור.
אז רק כדי להיות בטוח שאתה יש ארבעה חללים.
>> קהל: האם אנחנו צריכים לשים את מתולתל סוגריים ללולאות, כמו גם?
>> לוקאס פרייטס: כן.
>> LAUREN קרבאליו: בכל פעם שלך encapsulating בלוק של קוד, רק
אנא השתמש בסוגריים המסולסלים.
ולפני שאתה חושב שאנחנו פשוט להיות מהדרים על זה לא טוב
סיבה, אם אתם הולכים על מנת לקבל התמחויות טק בחברות גדולות,
הם יתנו לך מדריך סגנון, ו הם יגידו לך שזה מה ששלך
קוד צריך להיראות.
ואף על פי שלמדת לקוד כמו זה, אולי בהתמחות שלך
תצטרך לעשות משהו שונה לחלוטין.
הם מצפים ממך לציית לסגנון שלהם.
>> לוקאס פרייטס: דבר ועוד אחד הוא שמת לב איך יש לי כמו x,
חלל, פחות, חלל, 0?
בכל פעם שיש לך מפעיל -
זה יכול להיות כמו פלוס, מינוס, פעמים, פחות, כל מה שמפעיל גדול יותר, -
אתה צריך לשים את חלל בצד השמאל וזכותו של המפעיל.
>> LAUREN קרבאליו: אלה הם קרא האופרנדים בינארי.
רק לוודא שאתה תמיד החלל מתוך האופרנדים בינארי שלך.
>> לוקאס פרייטס: זה לא האופרנד בינארי.
>> LAUREN קרבאליו: זה הוא כי זה לוקח שתיים.
>> לוקאס פרייטס: הו, כן.
>> אוקיי, המתגים.
ראשית, אתה צריך לראות את זה בדיוק כמו בהצהרה אם או אחרת, יש לך
לשים את הסד המתולתל בשורה הנפרדת ותחת הסד המתולתל כאן.
שים לב שיש רווח יחיד אחרי ההפעלה, בדיוק כמו באם ועוד
היו לנו חלל אחד בין ושהסוגריים.
אז אתה צריך לשים את זה.
>> ואין שום מקום נכון לאחר כל של הסוגריים או לפני הסוף
של הסוגריים.
אז אתה רואה שזה כולם ביחד, וגם אוהב כאן.
>> כן?
>> LAUREN קרבאליו: אני חושב אנחנו צריכים להמשיך הלאה.
>> לוקאס פרייטס: אז זה חלק מ מדריך סגנון שיש לך לCS50.
הקפד ללכת לcs50.net/style ותסתכל על זה.
כל אלה הם חשובים מאוד לציון בסגנון שלך.
>> תן לי לחזור להצהרה.
>> LAUREN קרבאליו: אני מעדיף ש פשוט להשתמש style50.
אנחנו רק הולכים ישר ללולאות.
בסדר.
>> אז בואו נחזור לתוכן, עכשיו שעברנו על המדריך לסגנון.
לולאות, אתה ראית אותם בגרד, ו אנחנו הולכים לדבר עליהם ב
ג
>> ללולאה, יש שלוש מנות ל
הכרזה זו ללולאה.
יש לך האתחול שלך ב שאתה מגדיר את המשתנים שלך.
יש לך את המצב שלך, שהם בדיקה כדי לראות אם משהו הוא
אמת או שקר והאם לולאה צריכה להמשיך.
ויש לך העדכון שלך, שבו הוא מעדכן המשתנים שלך.
>> בואו רק נעיף מבט מהיר על כמה קוד C של זה ללולאה בפעולה.
מה קורה כאן ב אתחול, אנחנו הגדרת i ל -0.
במצב שאנחנו בודקים אם אני הוא פחות מ -10.
ובעדכון אנחנו להגדיל כל i.
אז מה תהיה תוצאה של זה ללולאה?
>> לוקאס פרייטס: למעשה, קודם כל, האם אתם יודעים מה + + הוא אני?
>> קהל: גדל ב 1.
>> לוקאס פרייטס: עלייה של 1, כן.
אז זה אותו הדבר כמו עושה לי שווה לי בתוספת 1.
ושים לב שאין לנו מקום ביני ו+ +.
>> אז תדע לכם מה זה יעשה?
מישהו יכול להגיד לי?
ואולי לקבל קצת ממתקים בגלל זה?
>> קהל: [לא ברור]
>> לוקאס פרייטס: אישור.
[לא ברור]
להראות לכולם בהמשך [לא ברור].
כן, זה הולך להראות "זה הוא CS50 "10 פעמים.
>> LAUREN קרבאליו: אני מניח שזה היה בכותרת של השקופית.
>> לוקאס פרייטס: הו, כן.
>> [שחוק]
>> לוקאס פרייטס: זה עוזר.
>> LAUREN קרבאליו: אז אלה הם ללולאות.
אנחנו הולכים לראות כמה דוגמאות יותר של לולאות בהמשך.
אבל בואו באמת נסתכל על סוג שני של לולאה תיתקל
ב-C, וזה נקרא תוך הלולאה.
>> בלולאה בזמן, יש לך פשוט יש לי מצב.
המצב הוא בדק ב מתחיל, ואם מצב זה
מעריך לנכון אז הקוד, בתוך הגוף של הבלוק תוך
יבצע.
והקוד ימשיך לבצע כל כך הרבה זמן כמו ש
המצב נשאר נכון.
>> הנה דוגמא ללולאה בזמן בג אנחנו הולכים להגדיר ספירה עד 10 ל
מלכתחילה.
כל זמן שהספירה היא גדולה מ 0, אנחנו הולכים כדי לשמור על דפוס את זה
משתנה כאן.
אנחנו הולכים להפחת ספירה ו לאחר מכן לבדוק את המצב שוב.
הדפסה, מפחית, צ'ק המצב שוב.
>> כאן יש לנו דוגמא שנוגעת לשאלתך קודם לכן.
היו לנו אחוזים של כשהיינו מדפיס את מחרוזת, ועכשיו
אנחנו מדפיסים את int, יש לנו אחוזים אני כמציין המיקום שלנו במקום.
האותיות צריכות להיות די אינטואיטיבית, זה למחרוזת, i עבור int.
>> אז אם הפעלת הקוד הזה, אתה צריך לספור את 10-0, הדפסה
כל מספר שלם.
>> לוקאס פרייטס: ואתה יכול לחשוב עליו אחוזים כפי שהוא מרגיש כמו ריק
חלל, ואז אתה שם את זה משתנה כאן בחלל ריק.
כך למשל, כאן יהיה לי רק ריק ולאחר מכן אני שם את
לספור ממש שם, ערך של הספירה.
האם זה הגיוני?
>> אני יכול פשוט לעשות כמו printf ולאחר מכן מצטט, לספור?
האם זה עובד?
>> קהל: לא.
>> לוקאס פרייטס: לא, כי זה יהיה בעצם להדפיס את המילה "ספירה"
במקום להדפיס את הערך.
זה איך אתה עושה את זה להדפיס את הערכים הכיוון משתנה במקום
רק את שמו של משתנה.
כל שאלה?
>> קהל: למה אתה משתמש עבור כמתנגד לזמן מה?
>> LAUREN קרבאליו: הייתי משתמש עבור לולאה אם ​​אני יודע בדיוק כמה
חזרות אני רוצה הלולאה שלי לרוץ.
במקרה זה, זה לא משנה, כי, אני מתכוון, אני רק מנסה
לחשוב באמת פשוט דוגמא לשקופית זו.
אבל בואו נגיד שאתה רוצה משהו כדי להמשיך ללכת בזמן -
>> לוקאס פרייטס: לדוגמא, אתה מבקש קלט עד שהאדם
נותן לך את הקלט הנכון.
אז כמו בזמן שהקלט אינו בסדר, כל זמן שואל על זה.
או כמו בזמן שאתה הורים לא נותנים כספך, כל זמן שואל על זה.
>> [שחוק]
>> LAUREN קרבאליו: אתה לא יודע איך פעמים רבות תהיה לך לעשות את זה.
>> לוקאס פרייטס: כי אתה לא יודע כמה פעמים זה
הולך להמשיך.
>> LAUREN קרבאליו: אבל ללולאה, אתה צריך לדעת כמה פעמים.
כן?
>> קהל: רק כדי להבהיר, אחוזים אומר שזה משהו שעומד
לקרות, אני של למספר השלם, וn הלוכסן ההפוך -
>> LAUREN קרבאליו: אמצעי?
מי יודע מה n הלוכסן ההפוך אומר?
קו חדש, כן.
בדיוק.
>> לוקאס פרייטס: אתה יכול לחשוב של n כקו חדש.
>> LAUREN קרבאליו: ניס.
>> קהל: מה לספור כי מקף מקף [לא ברור]?
>> לוקאס פרייטס: מינוס מינוס רוזן אותו הדבר בתוספת כתוספת, אבל
במקום להגדיל, זה ירידה של 1.
>> LAUREN קרבאליו: כל עוד ואילו שאלות לולאה?
לא?
אה, היינו אמור הייתי מדלג על.
>> זה לעשות בזמן לולאה.
דומה מאוד ללולאה בזמן, למעט ב מקרה זה אנחנו בודקים את המצב לאחר
הקוד בגוף לולאה מבצעת פעם אחת.
אז אנחנו לבצע את הקוד ראשון לא משנה מה.
אז לבדוק את מצבו, לבצע זה שוב אם התנאי מתקיים.
>> אתה תמצא את עצמך משתמש בזה בעת אתה שואל לקלט ממשתמש.
בגלל שאתה תמיד תצטרך שואל פעם אחת, ולאחר מכן, תלוי מה
קלט המשתמש הוא, שאולי יש לך reprompt ולשאול שוב ושוב אם
הקלט לא היה מה שאתה ציפיתי שזה יהיה.
>> קהל: אז זה כמו צורה עבור אנשים שצריכים למלא.
>> LAUREN קרבאליו: כן, בדיוק.
אתה תמצא, אני חושב, בך הראשון Pset, אתה הולך צריך
להשתמש בלולאה גם מטלות לאסוף קלט מהמשתמש.
>> קהל: בהתאם למצב, הלולאות בזמן שלך נוטות לרוץ יותר
לעתים קרובות יותר מאשר בזמן שלולאות, כמו על ידי אחד או משהו?
>> LAUREN קרבאליו: אם זה מדויק -
>> לוקאס פרייטס: הם תמיד צריכים לרוץ כמות פעמים המדויקת שאתה
רוצה את זה כדי לרוץ.
כמו שאנו משתמשים לעשות בזמן כי אנחנו באמת רציתי לקבל את הקלט לפחות פעם אחת.
בלולאות זמן מה, לפעמים אתה לא רוצה כדי לבצע את זה בכלל אם זה לא
המקרה לביצוע.
אז זה תלוי בעיצוב.
אני מתכוון, אתה יכול גם לעשות בזמן שימוש או בזמן שכל עוד הקוד שלך עושה את זה
זה אמור לעשות.
>> LAUREN קרבאליו: אבל אני עושה חושב שתשובה לשלך
שאלה היא כנראה כן.
נניח שהמצב היה כוזב.
במקרה אחד זה יהיה לרוץ פעם אחת, ו מקרה אחר זה הייתי רץ אפס פעמים.
אז, כן.
>> עוד שאלות?
כן?
>> קהל: יכול להיות מצב הלולאה ללולאה במונחים של משתנה אחר
מ [לא ברור].
>> LAUREN קרבאליו: כן, זה יכול להיות כל דבר.
כנראה לPsets מתחיל, אתה לא יצטרך להיתקל במקרה כזה, אבל
בהחלט זה יכול להיות כל דבר.
>> לוקאס פרייטס: אני חושב אנחנו עושים כאן.
>> LAUREN קרבאליו: האם אנחנו?
לא?
>> לוקאס פרייטס: לולאות?
כן.
>> LAUREN קרבאליו: אנחנו לא צריכים להיות.
אה, אנחנו נעשה עם לולאות.
על אישור.
>> למעשה, בגלל שדברנו כל כך הרבה, בואו בעצם כל לנווט
מעל לstudy.cs50.net/conditions.
ואתה הולך לניווט למטה לבעיות יישומון.
ובכן, למעשה, בזמן שאנשים מקבלים זה להגדיר, חקר CS50 הוא
הולך להיות כלי שTFS שלך יהיה להשתמש בו כדי להתכונן לסעיפים וכי
אתם יכולים להשתמש אם אתה מתגעגע חלקים.
זה הולך להכיל חבורה של שקופיות, כמה טיפים וטריקים עבור כל
נושא, וכמה בעיות בפועל עם פתרונות.
>> מדוע פשוט לא כולם נסתכל בבעיה זו כאן.
>> אני מצטער, הייתי צריך להזכיר לאנשים להביא את מחשבים ניידים היום.
אבל אם אין לך מחשב נייד, זה בסדר.
אתה פשוט יכול לרשום את זה על פיסת נייר או להסתכל על
כתפו של השכן שלך.
>> בואו ננסה ולכתוב תכנית ש מנחה את המשתמש לקחת ניחוש,
מספר ילדים ממוצע למשפחה יחידה בארצות הברית.
מספר זה הוא 2, אגב, כפי שאתה ניתן לראות מדוגמאות אלה.
>> אנחנו רוצים להדפיס את המספר ממוצע של ילדים למשפחה בארה"ב, אז אנחנו
רוצה מה?
אנחנו רוצים לאסוף קלט מהמשתמש.
ואז תלוי מה המשתמש של קלט הוא, אתה הולך להדפיס
גם זה נכון או שזה לא נכון.
>> והדבר הראשון שאתה תראה, אם תלחץ על החץ הקטן ב
תחתית יישומון הבעיה היא במקום לרשום כמה pseudocode.
אז אתה לא בתכנות עדיין.
אתה פשוט מקבל אותך רעיונות לפי סדר.
>> האם מישהו רוצה לעזור לוקאס לבוא עם הזכות
pseudocode לבעיה זו?
>> לוקאס פרייטס: מה הוא הדבר הראשון כי אנחנו כנראה צריכים לעשות כאן?
מה אתם חושבים?
>> קהל: [לא ברור]
>> לוקאס פרייטס: כן, בסדר.
לכן, הדפסה.
רק תגיד ההדפסה ממוצעת זה מספר האנשים?
על אישור.
שאלת הדפסה, נניח.
אחרי שאדפיס את השאלה הזאת, מה עליי לעשות?
>> קהל: קבל קלט.
>> לוקאס פרייטס: קבל קלט.
כל דבר אחר?
>> קהל: מצב.
>> לוקאס פרייטס: במצב.
>> LAUREN קרבאליו: מה זה מצב הולך להיות?
>> קהל: מספר [לא ברור].
>> LAUREN קרבאליו: נכון.
>> לוקאס פרייטס: אז מה אני הולך כדי לבדוק במצב?
>> קהל: אם זה שווה 2.
>> LAUREN קרבאליו: אם זה שווה 2.
בדיוק.
>> לוקאס פרייטס: האם יש משהו אחר שאני צריך לעשות?
>> קהל: רוזן.
>> לוקאס פרייטס: אז אם זה שווה ל 2, נניח -
תן לי רק לכתוב אם קלט שווה ל 2, אז מה אני הולך
לעשות הוא הדפסה נכונה.
ולאחר מכן אחר, אני הולך להדפיס שגוי.
כל דבר אחר?
לא?
>> LAUREN קרבאליו: אז אתה יכול ללחוץ על -
לכולם יש את זה?
>> לוקאס פרייטס: האם זה הגיוני?
אז עכשיו בואו ננסה את הקוד הזה.
>> LAUREN קרבאליו: אם תלחץ קצת חץ, זה באמת חוסך
pseudocode, וזה באמת מרגש.
ואתה יכול לעשות אותם לתוך הערות אם אתה רוצה רק להזכיר לעצמך
מה לעשות.
>> לוקאס פרייטס: כך למשל, ראשון אני הולך להדפיס את השאלה, ולכן
איך אני הולך לעשות את זה, בעצם?
printf.
אז printf, והשאלה היא ממוצעת מספר ילדים לכל
משפחה בארה"ב.
>> ואז אני הולך לקבל קלט מהמשתמש.
אז איך אני יכול לעשות את זה?
>> קהל: קבל Int.
>> LAUREN קרבאליו: GetInt.
>> לוקאס פרייטס: אישור.
אז להכריז ראשון, נכון?
int, בואו נקראים לזה n שווה GetInt.
>> ועכשיו מצבו.
אז הרשה לי לומר שאני הולך לכאן לבדוק את תשובה.
אז קודם כל, אם קלט, שהוא n, שווה ל-- איך אני הולך לכתוב את זה?
>> קהל: שווה שווה.
>> לוקאס פרייטס: מושלם.
אז n.
ושימו לב שאני עושה את החלל, שווה, שווה, מרחב, נכון.
ועכשיו מה אני צריך לעשות?
משהו חשוב מאוד לסגנון.
הסוגריים המסולסלים.
>> ואז אני הולך להדפסה.
כיצד אוכל להדפיס?
printf.
>> קהל: יכול להיות מהוון זה?
>> לוקאס פרייטס: מס
זה אמור להיות כל אותיות קטנות.
אז זה נכון.
>> האם זה יספיק לprintf הצהרה, או שאני מפספס משהו?
>> קהל: קו חדש.
>> לוקאס פרייטס: קו חדש, כן.
ועכשיו אחר.
>> קהל: האם יש מקום אחרי printf, או לא?
>> LAUREN קרבאליו: אנחנו צריכים בדוק את המדריך לסגנון.
>> קהל: זה לא צריך להיות.
>> לוקאס פרייטס: לא צריך להיות, על אישור.
אז אחר, printf, "זה לא נכון".
>> LAUREN קרבאליו: אופס, הציטוטים שלך.
>> לוקאס פרייטס: אישור.
כל דבר אחר?
האם זה נראה טוב?
>> LAUREN קרבאליו: יהיה לנו לנסות את זה?
>> לוקאס פרייטס: כן, בוא להפעיל אותו.
אז זה הידור, וזה נראה שזה עובד.
בואו ננסה את שני ילדים.
זה נכון.
ועכשיו בואו נרוץ שוב, אבל עכשיו במקום לשים את שני ילדים, בואו
אומר שאני הולך לשים כמו חמש.
זה לא נכון.
אז זה נראה שזה עובד.
>> LAUREN קרבאליו: למה שלא תראה להם מה קורה אם אתה שם משהו
מוזר, כמו כמה מכתבים.
>> לוקאס פרייטס: הו, כן.
בואו גם לבדוק את זה.
מה אם המשתמש מנסה בלגן עם התכנית שלך, והם פשוט
לכתוב, אני לא יודע שתיים.
זה הולך לומר נסה שנית.
>> LAUREN קרבאליו: אז GetInt הוא מבקש מהם לנסות שוב.
אנחנו לא צריכים לדאוג מזה בעצמנו.
>> לוקאס פרייטס: כן.
אז אלא אם כן אני ממש לשים מספר, זה הולך כל זמן שואל אותי לנסות שוב.
>> קהל: איך להפעיל אותו?
>> לוקאס פרייטס: פשוט לחץ כפתור כוכב זה.
>> LAUREN קרבאליו: אתה אמור לעלות.
הנה לך.
>> לוקאס פרייטס: הכוכב הלחצן ימני שם.
כן?
>> קהל: האם זה ינחה [לא ברור] עם מספרים עשרוניים מדי?
>> LAUREN קרבאליו: אני מאמין שזה יהיה.
>> לוקאס פרייטס: אם היא עושה מה?
>> LAUREN קרבאליו: אם הם מקלידים במספר עשרוני, אני חושב
זה הולך לבקש.
>> לוקאס פרייטס: בוא נראה.
>> LAUREN קרבאליו: כי זה לא int.
>> לוקאס פרייטס: כן.
>> LAUREN קרבאליו: אז זה זה לא int, קבל Int יבקש ממך לנסות שוב.
>> קהל: אז איפה בקוד זה יהיה המקום העשרוני, המנחה את
משתמשים שיש להם להיכנס שלם באופן ספציפי?
>> LAUREN קרבאליו: GetInt הוא למעשה עושה את זה בשבילנו.
>> קהל: לא, אני מתכוון אם אנחנו רוצים להיכנס [לא ברור]
>> לוקאס פרייטס: אתה יכול להגיד כמו ממוצע מספר הילדים בארצות הברית.
אני לא יודע.
אנחנו יכולים לומר, למשל, "בבקשה קלט מספר שלם. "
>> LAUREN קרבאליו: מספר שלם שווה למספר הממוצע.
אני מתכוון, זה רק איך אתה מילה זה, נכון?
>> לוקאס פרייטס: כן.
זה לא חלק מקידוד בפועל.
זה יותר כמו מה אתה הולך רוצה
לכתוב בתכנית שלך.
>> קהל: איך היינו להפעיל אותו אם הוא היה למעשה בgedit [לא ברור].
במקום ללחוץ על הצגה?
>> לוקאס פרייטס: אנו הראשון לעבד אותו.
אנחנו יכולים לעשות את זה על ידי עושה את האיפור ואת שמו של הקובץ.
ולאחר מכן להפעיל אותו, אנחנו נעשה את לוכסן נקודה והשם של התכנית.
>> קהל: אני מניח מה שהתכוונתי אליו היה אם אנחנו רוצים את התכנית כדי להגיב
הכניסה שלהם שגויה, לא חוקית, אתה לא צריך לשים ב--
>> לוקאס פרייטס: אנחנו לא תהיינה מסוגלים לעשות את זה כי הקוד זה אומר
נסה שוב מגיע מקבל Int שהוא פונקציה שכבר מיושמת
עבורנו באמצעות ספריית CS50, ומאז זה כבר מיושם שם,
לא יכול פשוט [לא ברור].
>> LAUREN קרבאליו: אם אתה לא משתמש GetInt, אז אתה יכול לעשות את זה.
>> לוקאס פרייטס: כן.
אבל אם אתה משתמש GetInt, אתה לא יכול.
יש עוד שאלות?
>> קהל: האם יש לך הלך עם כמו GetFloat ולאחר מכן להיות מסוגל לשים
זה בעשרוני?
>> לוקאס פרייטס: כן.
>> קהל: אישור.
ואז אתה פשוט יכול קלט לצוף שווים -
>> LAUREN קרבאליו: כן.
בדיוק אותו הדבר, פרט לצוף במקום int.
>> לוקאס פרייטס: פשוט לשים את זה כאן ולאחר מכן GetFloat שם.
>> קהל: כרצונך לראות או לא לראות -
>> LAUREN קרבאליו: יש לנו לא הגעתי לשם עדיין.
>> קהל: - עושה אי שוויון עם צף לא [לא ברור]
>> קהל: מה פסיק מתכוון?
>> LAUREN קרבאליו: פסיק פשוט משמעות הדבר היא כי הצהרה זו היא מוחלטת,
ואנחנו הולכים ללכת לשקופית הבאה.
>> קהל: אז זה הכרחי בכל פעם?
>> LAUREN קרבאליו: כן.
טוב, בסדר, אז לא לתנאים אלה, בגלל שהם
מתמצת משהו.
אז בעצם אם משהו גורם לאחר מכן כדי ליצור סד מתולתל
בלוק, לא לשים פסיק בסופו של הדבר.
>> לוקאס פרייטס: אבל הכל אחר, כן.
לאחר שתסיים את משפט, לשים פסיק.
ואם אתה שוכח פסיק, מהדר הולך לכעוס עליך,
ואתה הולך להיות כדי לנסות ולתקן את זה.
>> LAUREN קרבאליו: אם אני שם פסיק כאן, זה יהיה לעצור את זה, ואני
אף פעם לא היית מקבל לביצוע מה בפנים, דרך אגב.
אז זה אחד מאותם חרקים נפוצים.
>> קהל: תמיד ביצוע.
>> LAUREN קרבאליו: כן.
במקרה זה, אנחנו תמיד הייתם לבצע את מה שבפנים.
>> קהל: הסגנון שלך [לא ברור] לצרף את זה בשבילך, חשב.
>> LAUREN קרבאליו: אה, זה נכון.
>> קהל: [לא ברור] אחת דבר שורה [לא ברור]
>> קהל: כן?
>> קהל: האם יש לך מספר רב של תשומות עולות בקנה אחד?
אז כמו שאתה יכול לשאול את המשתמשים כדי להדפיס שני דברים?
>> LAUREN קרבאליו: לא משתמש -
>> לוקאס פרייטס: מס
נניח שאני רוצה גם כדי לקבל מ 'השלם הזה.
אני צריך לעשות את זה בקו שונה.
>> קהל: אם היית לרוץ כי, איך [לא ברור]?
זה יהיה להדפיס את הפקודה שם [לא ברור]
ואז היית נכנסים אחד ו--
>> LAUREN קרבאליו: טוב, להפעיל אותו.
אני מתכוון, אין שום דבר שעוצר אותנו מ פשוט מפעיל אותו ולראות מה
לא יקרה.
>> לוקאס פרייטס: אני חושב שזה הולך מתלונן עלינו
כי אנחנו לא משתמשים -
>> LAUREN קרבאליו: אופס.
>> לוקאס פרייטס: זה התלונן עלינו תקין עכשיו, כי אנחנו לא משתמשים בזה
משתנה, אבל אם אני עשיתי, למשל, n הוא שווה שווה, ושווה מ '
שווה, אז מה יהיה יקרה במקרה זה?
מה היית בתכנית זו עושה?
>> קהל: אני רק תוהה איך זה היית -
>> LAUREN קרבאליו: היא רק רוצה לדעת איך זה נראה
כמו, אני חושב, נכון?
אז זה לקח אחד מהם, ולאחר מכן זה לקח שנייה אחת.
>> אני חושב שאנחנו צריכים להמשיך הלאה, כי יש לנו עוד אחד
שקופיות ללכת לפני -
אתה רוצה למשוך את המתמטיקה?
>> לוקאס פרייטס: כן, במתמטיקה.
>> LAUREN קרבאליו: תן לי רק שני אחת.
>> ישנם כמה מספרי שונה משתנים בנתונים ג נומרית ב-C
ניתן לסווג לסוגים שונים, ואלה הם אלה שיצליחו
לראות בתדירות הגבוהה ביותר.
>> וint הוא מספר שלם.
אתה לא יכול להיות כל שברים עשרוניים.
במכשיר, זה לוקח 32 ביטים לאחסון int.
>> מצוף יכול להיות שברים עשרוניים.
זה גם לוקח 32 ביטים לאחסון לצוף במכשיר.
>> כפול הוא מספר עם נקודה עשרונית נקודה שלוקחת 64 ביטים לאחסן אותו,
מה שאומר שאתה יכול פשוט יש לי דיוק רב יותר, כי
אתה יכול לקבל יותר -
מה שאתה קורא לזה?
>> לוקאס פרייטס: כן, זה יותר.
>> LAUREN קרבאליו: מקומות נוספים לאחר הנקודה העשרונית.
ועוד ארוך הוא מספר שלם שלוקח 64 ביטים ל
זה כואב במכשיר.
>> לוקאס פרייטס: אז זה יכול להיות גדול יותר מints יכול להיות.
>> LAUREN קרבאליו: הדבר על נתונים סוגים בC הוא שהם יגידו לך מה
סוג של נתונים אתה יכול לאחסן במשתנה שלך.
הם אומרים לך איך אתה יכול להשתמש בזה משתנה בתכנית שלך.
זה חשוב מאוד רק כדי לעקוב אחר איזה סוג נתונים אתה משתמש, ואם
אתה צריך לעשות כדי להפיל מסוג הנתונים למשנו, לוודא שאתה יודע
בדיוק מה שקורה כאשר זה ליהוק מתרחש.
ואתם תראו דוגמא בהמשך בשקופיות של אלה
טעות שיכול להתרחש.
>> בואו נסתכל קצת מתמטיקה ב-C ו חושב באמת בזהירות, אני מניח,
על מה שקורה כאשר זה המתמטיקה מתקיימת.
בשורה הראשונה, מה קורה כאשר אני מצהיר x?
>> קהל: אתה מאפשר x להיות משהו?
>> LAUREN קרבאליו: כן.
ובכן, אני באמת שואל את ההפעלה מערכת ל32 ביטים של זיכרון, נכון?
שבו אני יכול לאחסן int, ו אני הולך לקרוא לזה x int.
>> לוקאס פרייטס: הולך בעיקרון לזכרו ומציאת מקום שיש 32
ביטים ואומרים, היי, אני רוצים את המרחב הזה, וזה הולך להיקרא x.
אז אתה פשוט פחות או יותר ממצא תיבה בזיכרון שלך כדי
ערכי חנות עבור x.
>> LAUREN קרבאליו: ואז אני לאתחל x, מה שאומר שאני פשוט לאחסן
ערך של 2 במקום הזה, שהנתח של זיכרון, שבקשנו הפעלה
מערכת ל.
וכאן מה שאנחנו עושים הוא אנחנו בעצם הכרזה ו
אתחול y בשורה אחת במקום בשתי שורות כמו שעשינו עד כאן,
אשר גם הוא בסדר גמור, אנחנו הוספת 1 עד x, ואנחנו אחסון ש
הערך בy.
>> לוקאס פרייטס: אז בעצם מה זה השורה עושה, הוא מוצא עכשיו תיבה עבור y,
ואז הערך שלו, כי הדבר אתה הולך לשים בתוך הקופסה, הוא
הולך להיות הערך של x בתוספת 1.
אז יש לו תיבה זו עבור y.
הוא מקבל את הערך של x, נראה כאן, ותראה שזה 2.
שים את זה שם, בתוספת 1, ולכן זה מכניס 3 שם.
האם זה הגיוני?
אז y יהיה 2 במקרה זה.
>> LAUREN קרבאליו: בסדר, מגניב.
ראינו כמה בנוסף לכך, אז בואו עכשיו חושבים על החלוקה בג הנה אני
הכרזה ואתחול לצוף בשם תשובה וחלוקת 1 על ידי 10,
ולאחר מכן אני מדפיס את התשובה לשני מקומות אחרי נקודה עשרונית.
ולציין כאן, בהצהרת printf שלי, כשאני רוצה להדפיס משהו לשני
מקומות עשרוניים,% f .2 היא מה שאני רוצה להשתמש בו.
אז הנקודה 2 היא רק אומרת אני זקוק לשני מקומות אחרי
עשרוני הדפיס.
>> עכשיו, מה הולך לקרות אם אני מפעיל את הקוד הזה?
האם יש למישהו רעיון?
מה היית להדפיס?
>> לוקאס פרייטס: מה הם אנו מצפים לקבל.
>> LAUREN קרבאליו: מה לעשות אנחנו קודם כל רוצים,?
>> לוקאס פרייטס: [לא ברור]
>> LAUREN קרבאליו: 0.1, כן.
אבל מה יהיה להדפיס?
>> קהל: [לא ברור]
>> LAUREN קרבאליו: ובכן, לא, בעצם.
זה מה שדיברתי עליו למה אתה צריך לעקוב אחר זהיר מאוד של
סוגי הנתונים שלך.
אז, מה נתוני סוג זה?
האם int, נכון?
אין מקום עשרוני.
10 הוא גם int.
אין מקום עשרוני.
>> אם אני מחלק int ידי int, אני מקבל int שאינו 0.1, כי ints
לא יכול להיות מקומות אחרי נקודה עשרונית, אבל רק 0.
בגלל int פשוט חותך מהמקומות אחרי הנקודה העשרונית.
>> לוקאס פרייטס: אז בכל פעם שאתה עושה פעולות עם ints, אתה הולך
לקבל int כתשובה.
אז בעצם, מה שהמחשב הוא עושה, זה מתחלק 1 על ידי
10, והוא מקבל 0.1.
אבל אז זה כמו, רגע, זה הוא אמור להיות מספר שלם, אז אתה פשוט
להתעלם 0.1, כך שזה עכשיו רק 0.
>> LAUREN קרבאליו: לכן, כאשר אני מדפיס את זה החוצה, אני מקבל 0.00 במקום 0.10.
>> לוקאס פרייטס: האם זה הגיוני?
>> LAUREN קרבאליו: זה סוג של מצער, נכון?
>> לוקאס פרייטס: אז איך אנחנו יכולים לתקן את זה?
>> LAUREN קרבאליו: בוא לנסות ולתקן את זה.
הנה דוגמא של איפה אני ליהוק 1 למעשה
ו10 לצפו.
אז עכשיו, 1 כבר לא int.
1 הוא לצוף.
דרך אגב, זה רק התחביר כאשר אתה רוצה להפיל מאחד
סוג הנתונים למשנו.
אתה יכול פשוט לשים את סוג הנתונים ב סוגריים ויש שפשוט להקדים
את הערך שאתה מטיל.
>> אז הנה, אני מחלק לצוף על ידי מצוף כדי לקבל תשובה לצוף.
וכן, זה היית ב למעשה להדפיס 0.10.
האם זה הגיוני?
>> לוקאס פרייטס: אז ליהוק הסוג הוא רק המרה מסוג אחד למשנו.
אז לצוף 1 הוא למעשה 1.000.
לא בדיוק זה, אבל זה משהו עם מקומות עשרוניים
כי הוא בעצם 1.
האם זה הגיוני?
כן?
>> קהל: מה אם עשה תשובה לצוף שווה 1.0 מחולק 10?
>> LAUREN קרבאליו: אתה באמת הולך לראות כי בשקופית הבאה.
זה בעצם השקופית הבאה מאוד שלנו.
זהו למעשה יותר נחמד הקלד ליהוק, אני חושב.
אז שני אלה הם צף רק על ידי טבעה של העובדה שהם
יש מקומות אחרי נקודה עשרונית.
כן?
>> קהל: מה אם עשה [לא ברור]
מחולק ב10?
>> LAUREN קרבאליו: למעשה לצוף מחולק בint בעצם נותן לך
לצוף, כך שיעבוד בסדר גמור.
>> חכה, זה שכולם מבין את זה?
כי זה הולך להיות באמת עסקה גדולה בPset1, בעצם.
כן?
>> קהל: האם אתה יכול פשוט במהירות תעבור על החלק האדום?
>> LAUREN קרבאליו: החלק האדום, כן.
לוקאס, אתה רוצה?
>> לוקאס פרייטס: אישור.
אז לזכור כי אחוזים הוא מציין מיקום.
זה כמו בחלל ריק.
אז בואו ננסה להבין הכל מה שקורה כאן.
אחוזים אומר שזה מציין מיקום.
ואז יש לך את f, כלומר מציין המיקום הזה הוא בשביל לצוף.
הדבר האחרון שיש לנו כאן הוא .2, מה שאומר שאני רוצה שיהיה שני
מקומות עשרוניים למצוף.
>> אם אני רק היה f%, שהם זה יהיה לשים חבורה של מקומות אחרי נקודה עשרונית.
אז רק אני יכול לשים .2 או .1 או .5, או מה, וזה הולך לשים את זה
מספר המקומות עשרוניים.
הדבר היחיד הוא שאם אתה מכניס כמו .100 או -1,000, זה לא ממש
הולך לשים את כל מקומות עשרוניים אלה כי זה אין לו מספיק זיכרון
יש דיוק ש.
>> יש עוד שאלות?
כן?
>> קהל: אז תצוף רק מאפשר לך ללכת מעבר למספרים שלמים?
>> לוקאס פרייטס: כן.
>> LAUREN קרבאליו: ובכן, לצוף רק מאפשר לך יש מקומות אחרי נקודה עשרונית.
>> לוקאס פרייטס: זה רק אומר שאתה עכשיו יכול להיות מספרים עשרוניים.
>> קהל: למה לנו אי פעם להשתמש במספרים שלמים?
>> לוקאס פרייטס: למה שיהיה אתה משתמש במספרים שלמים?
אולי אם אתה סומך 0-10, ברצונך להשתמש דווקא מספר שלם.
אתה לא צריך להשתמש במצוף.
במצבים מסוימים, שאתה לא יודע צריך בעצם -
>> LAUREN קרבאליו: אולי אתה לא רוצה שברים עשרוניים.
>> לוקאס פרייטס: אולי אתה לא רוצה להשתמש במצוף.
>> LAUREN קרבאליו: הדבר השני הוא, זוכר, גם את המצוף וint
לקחת 32 ביטים לאחסן אותם, ואולי אתה לא רוצה לבזבז ביטים על
מקומות אחרי נקודה עשרונית.
>> לוקאס פרייטס: כן.
אז כמו, רק לחשוב על זה.
יש לך 32 ביטים לשניהם int ולצוף.
עבור int, כל 32 ביטים אלה תלך לחלק המספר השלם.
אם אתה משתמש במצוף עם 32 ביטים, אתה יש חלק בשימוש הזיכרון הזה
למספר, למספר השלם, וחלק האחר בשימוש עבור
מקומות אחרי נקודה עשרונית.
אז זה אומר שאתה לא יכול להגיע אל מספרים גדולים מאוד עם צף בגלל
לצוף כבר משתמש הרבה זיכרון למקומות אחרי הנקודה העשרונית.
כן?
>> קהל: זה תשובה הראשונה, מה בדיוק הוא עושה?
האם זה הגדרת הערך של float שווה למיקום זה כדי שתוכל
זוכר אותו בשורה הבאה?
זה אומר לצוף תשובה.
>> לוקאס פרייטס: כן.
לכן, תשובה לצוף אומרת שאתה מקבל עכשיו קצת דלי בזיכרון
מחזיק לצוף, וזה הולך כדי להיקרא תשובה.
אז זה מה שתשובה עושה לצוף.
>> ואז אתה אומר שחלק פנימי של זה, אתה הולך לשים
התוצאה של זה.
אז אתה הולך לעשות 1.0 מחולק 10.0, אתה מקבל 0.1, ולאחר מכן אתה מכניס
בתוך זה של תשובה.
>> LAUREN קרבאליו: אז בשורה אחת, אנחנו הכרזה ואתחול לצוף זה
בשם תשובה.
>> לוקאס פרייטס: מעניין, אם כי זה רק קו אחד, הוא עושה
פעולות מרובות.
זה פשוט דרך של הקזת C אתה משתמש בפחות קוד.
זה אותו הדבר כמו משולש מפעיל, איך אתה יכול פשוט לעשות
[לא ברור] בשורה אחת.
זה בעצם עושה את אותו דבר כמו עושה תשובה לצוף, פסיק, ו
אז תשובה שווה את זה, אבל במקום גורם לך לעשות שני קווים על כך,
זה כמו קיצור דרך.
כן?
>> קהל: אז אם אתה רץ זה, זה יהיה 0.10?
>> לוקאס פרייטס: כן.
כן?
>> קהל: האם לענות למעשה קוד, או שזה רק שם?
>> LAUREN קרבאליו: זה הוא למעשה קוד.
זה מה שאנחנו הולכים לשם המשתנה שלנו.
>> קהל: אז זה פשוט שם [לא ברור].
>> LAUREN קרבאליו: כן.
אני יכול לומר x לצוף שווה 1.0.
>> לוקאס פרייטס: העניין הוא, כי השם המשתנה הוא
משהו שאתה משתמש.
זה חשוב לך.
לתכנית בפועל, הדבר היחיד מה שחשוב הוא הערך שאתה
יש בתוך הדלי.
הסיבה לכך שיש לך משתנה ו שמות של משתנים הוא כל כך היית יודע
עם, כמו מה שיש לך עסק איזה סוג של נתונים אתה
גישה בכל פעם.
אבל לקוד עצמו, אם אתה קורא זה ענה או שאלה או משהו כזה,
פחות או יותר, זה לא משנה.
זה לא משנה.
כל עוד אתה עולה בקנה אחד בכל ההתרחשות ואז אתה קורא לזה
משהו אחר.
כן?
>> קהל: האם המשתנים מעבר לפונקציה?
כמו אם היית ליצור סוגר , יכול [לא ברור] אתה פשוט
[לא ברור] לענות שוב?
>> LAUREN קרבאליו: לא.
>> קהל: [לא ברור]
>> LAUREN קרבאליו: לא.
זה יהיה מחוץ לתחום של המשתנה הזה בפרט.
ובעצם, זה סוג של מעניין, כי כאשר יש לנו
דברים כמו לולאות או אם אלה תנאים, אם אתה מכריז על משתנה
בתוך קבוצה נוספת של סוגריים מסולסלים, זה באמת קיים רק
בתוך הסוגריים המסולסלים האלה.
>> קהל: הערה אחת אחרון על [לא ברור] צף.
למה אתה בכלל רוצה להשתמש ints?
זה יותר מהערה צדדית מ שום דבר, אבל המחשב שלך הוא
טוב יותר באופן משמעותי בטיפול בints ממה שהוא בצף טיפול.
זה כמו סדר גודל מהר יותר.
אז אם אנחנו רק טיפלנו רק צף, דברים יהיו הרבה יותר איטיים.
>> LAUREN קרבאליו: למעשה, נראה להיות בעיה עם צף.
>> לוקאס פרייטס: סוג של הסיבה ל כי, אתה יכול לחשוב, הוא כיצד בינארי
אתה יכול לייצג מספרים שלמים על ידי הצבת של 0 ו -1 של.
>> LAUREN קרבאליו: זה הדבר הבא.
>> לוקאס פרייטס: אישור.
מדהים.
>> LAUREN קרבאליו: רק להחזיק את המחשבה הזאת.
>> לוקאס פרייטס: בסדר, אני להגיד לך מאוחר יותר.
>> LAUREN קרבאליו: לפני שנגיע למה לוקאס בדיוק אמר, מפעיל
קדימות.
זה שכל ישר.
אתם עשיתם את זה מספיק.
לכן, רק אם משהו לא בסוגריים, זה יקרה קודם.
זה הכפל גובר מעל בנוסף,
חיסור, דברים כאלה.
אז בעצם, רק האם מישהו רוצה תגיד לי מה מספר אחד בפועל
מוערך כ?
>> קהל: 27.
>> LAUREN קרבאליו: 27?
כן.
>> לוקאס פרייטס: תן לי לתת לי סוכריות לאנשים.
>> LAUREN קרבאליו: בסדר.
מה לגבי מספר שתיים?
>> קהל: 22.
>> LAUREN קרבאליו: 22, כן.
אני לא יודע מי קיבלתי את זה.
מספר שלוש?
>> קהל: 10.
>> LAUREN קרבאליו: 10, כן.
מגניב.
אז מודולו.
לוקאס, אתה רוצה להסביר מודולו?
>> לוקאס פרייטס: מודולו הוא מפעיל זה כי הוא בעצם מאוד שימושי עבור
חבורה של בעיות.
אם אני עושה 55 מודולו 10, מה שהיא עושה זה נניח שאני רוצה
לחלק 55 ידי 10.
מה אני מקבל?
זה מרגיש בדיוק כמו אם אני למעשה רק עושה את החלוקה, מה הוא
פעם הראשונה שיש לי את המספר השלם?
>> קהל: 5.
>> לוקאס פרייטס: 5.
ואז השארית היא 5, נכון?
אז זה כמו 5 פעמים 10 בתוספת 5.
בעיקרון, מה מודולו אין, הוא מנסה מחלק את המספר הזה על ידי זה, ו
היא רואה מה היא השארית של החטיבה.
>> LAUREN קרבאליו: אז זה פשוט מחזיר את השארית.
אז מספר אחד הוא מה?
5.
מספר שתיים?
>> קהל: 3.
>> LAUREN קרבאליו: 3.
מספר שלוש?
0.
וארבעה הוא 1.
בדיוק.
>> לוקאס פרייטס: פשוט, לא?
>> LAUREN קרבאליו: למה שלא לדלג על זה רק בגלל שבאמת אין לנו
זמן, ונראה שאנשים מבינים.
אז הנה מה שהיה לוקאס רק מדבר.
>> לוקאס פרייטס: עוד סיבה למה אני אשתמש ints במקום צף הוא
שצף הם מאוד לא מדויקים.
ומדוע הם לא מדויקים?
דוד אמר שכדי לייצג מספר שלם, לדוגמא, אנו משתמשים 0 ו
1 של, נכון?
ואז אתה בעצם עושה כפל, לעשות את כל אלה
פעולות לדעת מה מספר עשרוני יש לך במקום בינארי.
>> מה קורה עכשיו אם אני מנסה לשים נקודות עשרוניות?
למעשה, לדוגמא, אם יש לי המספר כמו 3.33333?
זה מרגיש כמו 10 מעל 3.
איך אני הולך לאחסן את כל 3 זה שיש לי אחרי זה?
זה ממש קשה, נכון?
אתה לא יכול פשוט לומר למחשב, היי, יש לי 3, ו
אז אתה עושה את זה לנצח.
למעשה המחשב אינו מספיק חכם בשביל זה.
>> אז בעצם את כל המחשב שלך עושה הוא שהוא מנסה לשים את ספרות רבות ככל
יכול אותו לזכר שיש לך.
אז בואו נגיד שזה הולך אומר 3.3333, וזהו זה.
אז זה לא מסוגל להביע את בעצם בדיוק מה הוא המצוף ש.
>> LAUREN קרבאליו: יש לנו מספר סופי של ביטים, מה שאומר שלא
כל מספר עשרוני הולך להיות תוכל להיות מיוצג באופן מדויק.
ולכן בדוגמא זו, אם ברצוננו להדפיס את 0.1, אנחנו עכשיו בהדפסה
20 את מקומות.
>> לוקאס פרייטס: בדיוק כמו שאני אומר לי חבר 'ה, אתה יכול לשים את כל מספר.
אבל אם אתה רק עשית שני מקומות, היית מקבל 0.10, אבל אם אתה שם את 20
מקומות, זה הולך להראות לכם חבורה מזה בגלל שזה מה שאתה יכול לשים
בזיכרון, נכון?
>> אבל כאן, עד 0, ולאחר מכן הוא פשוט לשים אותו
חבורה של מספרים אקראיים.
זה כמו סוג של כמה -
>> LAUREN קרבאליו: סיבה לכך הוא שאנחנו לא מסוגל לייצג עשרוני זה
דווקא עם המספר ביטים יש לנו.
>> לוקאס פרייטס: ואז מחשב הוא בעצם
נותן לך מספר אשפה.
זה לא ממש ערך של המספר.
>> קהל: זה קרוב ככל הוא יכול לקבל [לא ברור]
באמצעות [לא ברור].
>> LAUREN קרבאליו: אז המשמעות של זה הוא שיניח שבמקום
להיות 0.100014, לא משנה מה, מה אם זה היה .0999 -
כן, בסדר.
בואו נעמיד פנים שהתשובה בפועל לזה היו .9999999.
זה קרוב מאוד ל -1, אך זה לא בדיוק 1.
זה .99999.
>> זה אומר שאם אני לוקח את זה 0.999, ואני הסבתי אותו ל int, אני מקבל 0.
אני לא מבין 1.
>> לוקאס פרייטס: כי זוכר, ליהוק ממצוף לint, אתה פשוט
להתעלם מכל המקומות אחרי הנקודה העשרונית.
אתה פשוט להתעלם מהם.
אין דבר כזה כמו עיגול כזה או ריצה במורד כאשר אתה חומר מודפס.
למעשה, יש בפונקציה זו ש עושה עיגול, שהוא מאוד
חשוב, אבל אתה רק חושב שכאשר אתה עושה ליהוק שחקנים, זה פשוט
הולך למחוק את הכל.
אז גם אם יש לך .99999, זה הולך רק כדי לתת לי 0 אם חומר מודפס
[לא ברור] מספר שלם.
>> LAUREN קרבאליו: אז רק להיות ממש מודע נקודה הצפה בדייקנות,
במיוחד כאשר אתה מתחיל להשתמש צף בPset1.
אבל ההליכה בצריך להזהיר אותך שגם כן.
>> לוקאס פרייטס: ולמעשה זה באמת קשה, למשל, אם עשיתי
תשובה לצוף 1 שווה 1.0 מעל 10, ולאחר מכן תצוף תשובה 2
שווה 10.0 מעל 100.0.
הם אותו המספר, נכון?
0.1, נכון?
1 מעל 10 או 10 מעל 100.
אבל עכשיו אם אני מנסה לראות את השוויון, כמו אם התשובה 1 היא שווה לענות 2,
אולי זה לא ממש הולך להיות אותו הדבר.
אז צף הם כמו סוג של זה.
הם כמו עושים שוויון.