>> דוד J מלאן: כל נכון, אז זה CS50.
וזה ברור ביום שישי.
וזה הסוף של שבוע אחד.
אז אתם אולי זוכרים שהפסקנו, הפעם האחרונה, עם סחרור מסוכן של מיני.
לפיה אנו חושפים את השקר הזה, שלא עניין גובר מה שאתה כבר לימדת
עד, 1 מחולק 10 הוא לא, ב למעשה, 0.1 או 0.100 או .10000.
למעשה, אם אנחנו לקמפל זה תכנית, כפי שעשינו אתמול, עם,
להפוך את חוסר דיוק, ולאחר מכן לעשות נקודה, לקצץ, חוסר דיוק,
נודע לנו שזה מה שזה 1 מחולק 10 הוא למעשה.
אז זה לא באמת די במקרה.
אבל זה עושה רמז בכמה מגבלה בסיסית של מחשבים.
ואכן, בין דברים שאנחנו הולכים לעשות
היום הוא להעיף מבט במה זה יש קרה, מה השלכות שיש לכך,
איך האנושות נכשלה לתפוס את זה בחלק מאוד
situations-- הרציני התוצאה של ש
כבר די טרגי וexpensive-- וגם
תסתכל איך אנחנו באמת יכול להגן על
נגד סוגים של מגבלות אלה.
אז באופן אינטואיטיבי, אולי, מדוע מחולק 1 על ידי 10,
לפי המחשב שלי כאן, לא רק 1/10, 0.10?
כן.
מה אתה חושב?
>> חבר קהל: RADIX הוא שונה?
>> דוד J מלאן: מה הוא?
אה, RADIX הוא שונה?
אז לא ממש.
זה בעצם יותר בסיסי לחומרה.
מחשבות אחרות?
כן.
חבר קהל: הם לייצג מספרים שונים?
דוד J מלאן: אז they-- ימין.
הם מייצגים מספרים שונים.
לא מדויק, ככל הנראה.
כך שהוא-- ובכן, אחרת ממה?
או שממנו?
מאיתנו?
חבר קהל: כן.
הם לא משתמשים בעשרוניים מערכת ל[ לא ברור].
דוד J מלאן: אישור.
אז במובן מסוים, הם לא להשתמש בשיטה העשרונית.
מתחת למכסה המנוע, הכל, אכן, בינארי,
וזה קשור, למעשה.
אבל זה אפילו פשוט יותר הסבר מזה.
כן.
>> חבר קהל: הם יש רק חתיכות כל כך הרבה.
הם יכולים רק לאחסן עד מסוימים מידה, כמו עם שברים עשרוניים.
>> דוד J מלאן: כן.
זה מה שבאמת מקבל על זה.
מתברר כי מחשבים בדרך כלל, תמיד רק
להשתמש בכמות מוגבלת של מידע לייצג משהו.
נכון?
אחרי הכל, יש לנו קבוע רק כמות של שטח דיסק קשיח.
יש לנו רק סכום קבוע של זיכרון RAM, או זיכרון מחשב.
ואם יש לך רק סכום קבוע של משהו,
בוודאי שאתה לא ממש יכול לספור עד עד אינסוף או כל מספר שאתה רוצה.
אתה, סוג של, צריך לבחור מה טווח
ערכים שאתה הולך לתמוך.
>> וכך למשל, בשבוע או שניים לפני, כשדיברנו על ASCII,
ודיברנו על 8 סיביות, או בייט, כביכול,
המספר הגדול ביותר שיכולנו מייצג עם 8 ביטים היה מה?
255.
ואנחנו יכולים לייצג 256 ערכים מוחלט אבל לא אם אנחנו מבלים אחד מהם
על 0-- ובכן, אבל אם אנחנו להוציא אחד מהם על 0,
לאחר מכן את המספר הגדול ביותר הוא, כמובן, 255.
>> אז מתברר, שזה הוא המקרה מדי, בהקשר זה.
התחלנו לדבר בפעם האחרונה,, על מספרי נקודה צפה, ש
הם שונים ממספרים שלמים, ב כי יש להם נקודה עשרונית
וגם, בתקווה, כמה מספרים לאחר ש, אבל הם יותר מדי.
מחשב הוא רק בדרך כלל הולך להשתמש 32 סיביות, אולי 64 סיביות
לייצג ערך נקודה צפה.
אז למרות שאנחנו כבר גדלנו לימוד מתמטיקה ולדעת
כי אתה בהחלט יכול להיות מספר אינסופי של מספרים
לאחר הנקודה העשרונית, לא אם יש לך זיכרון סופי.
אתה, סוג של, צריך לעגל, או לבחור ש
מספרים שאתה הולך לייצג.
ואז אתה יכול לחשוב על, במובן מסוים, זה להיות במחשב הקרוב ביותר
קירוב לערך 1/10 ש הוא יכול לקבל, עם רק 32 או כך ביטים.
וזה לא רק 1/10.
>> לדוגמא, אם אני משנה את זה ל 1/3, שבו אנו חושבים הוא אפילו פשוט יותר.
אז 1 חלקי 3.
תן לי לשמור את הקובץ.
תן לי ללכת קדימה והדר מחדש את זה.
ותן לי להפעיל מחדש את זה.
גם כאן, ככל הנראה, 1/3 הוא לא 0.3 ולאחר מכן מספר אינסופי של 3 של
לאחר מכן.
יש לך חוסר הדיוק הזה בסוף.
אז אנחנו בני האדם הם נכונים, ומה ש אתה למדת הוא, למעשה, נכון,
אבל אנחנו נתקעים נגד כמה מגבלות.
>> ומה שחשבתי היינו עושה היום, הוא מתחיל
על ידי הסתכלות, בכנות, תוצאות טרגיות של זה
לפעמים, כאשר האנושות לא ממש ליישם
למציאות זו ומגבלות אלה.
ואנו רואים סדרה של ציורים מערוץ ההיסטוריה שלוקח
תסתכל איך דברים השתבשו.
זה זמן רב על 8 דקות, ואנחנו נחזור אחרי זה
ותסתכל בדיוק מה עוד יכול להשתבש.
אם היינו יכול לעמעם את lights--
>> [וידאו השמעה]
>> -Computers, כולנו באים לקבל הבעיות לעתים קרובות מתסכלות ש
ללכת איתם.
באגס, וירוסים, ותוכנה תקלות הן מחירים קטנים
לשלם עבור הנוחות.
אבל בהיי-טק ומהירות גבוהה יישומים צבאיים ותכנית החלל,
הבעיה הקטנה ביותר יכול להיות מוגדל לאסון.
ב -4 ביונים 1996, מדענים מוכנים כדי להפעיל רקטות אריאן 5 בלתי מאוישות.
זה נשא מדעי לווינים שנועדו
להקים בדיוק איך אינטראקציה השדה המגנטית של כדור הארץ
עם רוחות שמש.
הרקטות נבנתה ל סוכנות החלל האירופית
והרמתי את מתקניה על החוף של גויאנה הצרפתית.
>> -ואז כ -30 שניות ל הטיסה, שהם ראשון
משהו שם לב שהשתבש.
כי החרירים היו מסתובבים בדרך הם ממש לא צריכים.
כ -40 שניות לטיסה, בבירור הרכב היה בצרות,
ואז הם עשו ההחלטה להרוס אותו.
קצין בטיחות טווח עם אומץ אדיר לחץ על הכפתור,
פוצץ את הטיל לפני שהוא יכול להיות סכנה לשלום הציבור.
>> -זהו היה העלמה מסע של 5 אריאן,
וההרס שלה לקח מקום בגלל פגם
משובץ בתוכנה של הרקטות.
בחור' בעיה ב אריאן היה שיש
היה מספר שנדרש 64 סיביות להביע,
והוא רצה להמיר זה למספר 16 ביט.
הם הניחו כי המספר אף פעם לא הולך להיות גדול מאוד,
שרוב הספרות אלה ב מספר 64 הביט היה 0 של.
הם טעו.
>> בחור' חוסר יכולת של אחד תוכנה לקבלה
הסוג של מספר שנוצר על ידי עוד היה בשורש הכישלון.
פיתוח תוכנה הפך חלק מאוד יקר של טכנולוגיה חדשה.
רקטת אריאן 4 הייתה מאוד מוצלח, כל כך הרבה של התוכנה
נוצר עבורו היה גם שימוש באריאן 5.
>> בחור' בעיה בסיסית הייתה שאריאן 5 היו מהירים יותר, מהיר יותר מואצים.
והתוכנה לא הייתה אחריות לכך.
>> בחור' הרס של הרקטות היה אסון פיננסי עצום,
כל עקב שגיאת תוכנת דקות.
אבל זה לא היה ראשון בעיות המרת נתונים בזמן
הטריד טכנולוגית רקטות מודרנית.
>> -in שינה 1991, עם תחילת של מלחמת המפרץ הראשון,
הטילים הפטריוט חווה סוג דומה
בעיה המרת מספר.
כתוצאה מכך, 28 אנשים, 28 חיילים אמריקאים
נהרגו וכ 100 אחרים נפצעו,
כאשר הפטריוט, שהיה אמור כדי להגן מפני הסקאדים נכנסים,
לא הצליח לירות טיל.
>> -כאשר עיראק פלשה לכווית ואמריקה השיק סופה במדבר בתחילת השינה 1991,
סוללות טילים פטריוט נפרסו כדי להגן על סעודיה וישראל
מהתקפות טילי סקאד עיראקיים.
הפטריוט הוא ארה"ב, לטווח בינוני קרקע-אוויר מערכת
מיוצר על ידי חברת ריית'און.
>> בחור' גודל של המיירט הפטריוט, עצמו, הוא על, ארוך בערך 20 רגל.
והוא שוקל כ -2000 פאונד.
והוא נושא ראש נפץ של על-- אני חושב שזה בערך 150 פאונד.
וראש הנפץ, עצמו, הוא נפץ גבוה,
שבו יש שברים סביבו.
המעטפת של ראש הנפץ היא תוכנן לפעול כמו כדורי עופרת.
>> בחור' טילים בוצע, 4 למכולה,
ומועברים על ידי חצי קרוואן.
>> בחור' מערכת טילים אנטי פטריוט חוזר לפחות 20 שנים.
הוא תוכנן במקור כטילי הגנה אוויריים
להפיל מטוסי אויב.
במלחמת המפרץ הראשון, כאשר המלחמה שבאה,
הצבא רצה להשתמש בו כדי להפיל את הסקאדים, לא מטוסים.
חיל העירקי לא היה כל כך הרבה של בעיה,
אבל הצבא היה מודאג הסקאדים.
וכך הם ניסו שדרוג הפטריוט.
>> -Intercepting אויב טיל נוסע במאך חמש
הולך להיות מאתגר מספיק.
אבל כאשר הפטריוט הובהל לשירות,
הצבא לא היה מודע ל שינוי העירקי שעשה
הסקאדים שלהם כמעט בלתי אפשרי להכות.
>> -מה קרה, היא הסקאדים ש היו באים ב, היו לא יציבים,
הם מתנדנדים.
הסיבה לכך, היו העיראקים, כדי
כדי לקבל 600 קילומטרים מ טילים לטווח של 300 קילומטר,
לקח משקל מראש הנפץ מול ועשה את ראש הנפץ קל יותר.
אז עכשיו, הפטריוט של מנסים לבוא בסקאד, ורוב הזמן,
רובם המכריע של זמן, זה היה לטוס רק על ידי סקאד.
>> -Once מפעילי המערכת הפטריוט הבנתי הפטריוט החטיאה את מטרתה,
הם פוצצו ראש הנפץ של הפטריוט, כדי להימנע מנפגעים אפשריים אם זה
היה מותר לנפול אל הקרקע.
>> חייהם." היה מה שרוב האנשים ראו, כדורי אש הגדולים האלה בשמיים,
וטעות כ מיירט של ראשי נפץ סקאד.
למרות בלילה שמיים, פטריוטס הופיע
להיות בהצלחה להרוס הסקאדים, בDhahran,
לא יכולה להיות טעות על ביצועיה.
יש, מערכת המכ"ם של הפטריוט איבד את המסלול של סקאד הנכנס,
ומעולם לא השיק, בשל פגם תוכנה.
זה היה הישראלים שגילו ראשון כי המערכת כבר הייתה ב,
פער הזמן הגדול יותר הפך, בשל שעון המשובץ
במחשב של המערכת.
>> "בקשר 2 שבועות לפני הטרגדיה בDhahran,
הישראלים דיווחו ל משרד ההגנה,
כי המערכת מאבדת זמן, כי לאחר כ 8 שעות של ריצה,
הם שמו לב שהמערכת הייתה הופך באופן ניכר פחות מדויק.
משרד ההגנה הגיב ב אומר לי כל הסוללות הפטריוט
לא לעזוב את המערכות על במשך זמן רב.
הם אף פעם לא אמרו את מה שזמן רב היה.
8 שעות?
10 שעות?
1000 שעות?
אף אחד לא ידע.
בחור' סוללה הפטריוט מוצב בצריפים
בDhahran, והפנימי הפגום שלה שעון, היה על מעל 100 שעות
בלילה של 25 בפברואר.
>> 'זה מעקב זמן לדיוק של כ 1/10 של שנייה.
עכשיו 1/10 של שנייה היא מספר מעניין
כי זה לא יכול להיות בא לידי ביטוי בינארי, בדיוק.
מה שאומר, זה לא יכול לבוא לידי ביטוי, בדיוק,
בכל מחשב דיגיטלי מודרני.
קשה להאמין, אבל להשתמש בזה כדוגמא.
בואו ניקח את המספר, 1/3.
1/3 לא יכול לבוא לידי ביטוי בעשרוני, בדיוק.
1/3 הוא 0.333 קורה לאינסוף.
אין דרך לעשות את זה, עם דיוק מוחלט, בעשרוני.
זה אותו הסוג בדיוק של בעיה שקרתה בפטריוט.
עוד המערכת רצה, גרוע שגיאת הזמן הפכה.
>> אחרי ככלות של מבצע 100 שעות, השגיאה בזמן היה רק ​​על 1/3 משני.
אבל במונחים של מיקוד טיל נוסע במאך 5,
זה הביא למעקב שגיאה של למעלה מ -600 מטרים.
זה יהיה שגיאה חמורה לחיילים בDhahran.
>> -מה קרה, היא השקת סקאד היה זוהה על ידי לוויני התרעה,
הם וחדשים שסקאד היה מגיע בכיוון הכללי שלהם.
הם לא ידעו מאיפה זה בא.
>> 'זה היה עכשיו עד לרדאר רכיב של המערכת הפטריוט,
הגנת Dhahran, כדי לאתר ולשמור מסלול של טיל האויב הנכנס.
>> בחור' הרדאר היה מאוד חכם.
זה באמת היה לעקוב אחר העמדה של סקאד
ולחזות בי זה כנראה יהיה,
בפעם הבאה, רדאר נשלח דופק החוצה.
שנקרא שער הטווח.
>> -Then, פעם הפטריוט מחליט יש מספיק זמן
עבר לחזור ולבדוק הבאים מיקום לאובייקט מזוהה זה,
הוא חוזר.
אז כשזה חזר להלא נכון מקום, אז זה לא רואה שום אובייקט
והוא מחליט שלא היה אובייקט, זה היה גילוי כוזב,
ומפיל את המסלול.
סקאד הנכנס נעלם ממסך המכ"ם,
ושניות לאחר מכן, אותו טרק לצריפים.
סקאד נהרג 28 והיה האחרון אחד נורה במהלך מלחמת המפרץ הראשונה.
למרבה הצער, תוכנה המעודכנת הגיע Dhahran היום הבא.
היה פגם התוכנה היה קבועה, סגירה
פרק אחד במוטרד ההיסטוריה של הטילים הפטריוט.
>> [סוף ההשמעה]
>> דוד J מלאן: אז אנחנו נסתכל כמה מגבלות דומות במעט.
אבל קודם, בואו מעבר לכמה לידיעתך זה.
אז one-- בסוף השבוע הזה, יש יהיו קטעים סופר,
שנועדו לתפוס את המקום סעיפים סדירים, ש
יתחיל את שבוע ומכאן.
תסתכל על אתר האינטרנט של CS50 לקבלת מידע נוספת על אלה.
הם גם יהיו מצולמים וזרמו לחיות לאלה שאינם מסוגלים להשתתף.
בעיה להגדיר 1 היא ב אתר האינטרנט של הקורס כבר,
ואנחנו נסתכל כי בקצת.
ושעתי עבודה מדי, תיקח ביום שני זה עד יום חמישי.
>> אז זה היה הקנונית ביותר תכנית שנראינו בזמן האחרון.
זה כמו הפשוט תכנית שאתה יכול לכתוב ב- C,
ואפילו שזה קצת של תביעה נועזת.
נכון?
כי יש הרבה לכאורה מורכבות לזה.
אז בואו ניקח מבט מהיר ב מה חלקם של גורמים אלה
היו ולאחר מכן נסה לספק מודל המנטלי לאיך
הפשוט ביותר של תוכניות אלה לעבוד, ואז נתחיל
מסתכל על דברים יותר ויותר מורכב.
אז הקו הזה כאן, הדגיש החברה, בצהוב, מה שאנחנו לא אומרים, בפעם האחרונה,
כי זה עושה לנו?
מה המטרה שהוא משרת?
כל אחד מרחוק יותר בחזרה?
כן.
>> חבר קהל: [לא ברור]
דוד J מלאן: טוב.
אז זה נותן לך גישה לפקודות, או בואו
פונקציות קוראים להם, שמישהו אחר כתב, שהכריזו,
כביכול, בקובץ אחר.
אז אנחנו תראו בדיוק מה קובץ .h הוא מול קובץ .ג, סופו של דבר.
אבל לעת עתה, רק יודע printf ש, למשל,
הוא בין הפונקציות שהיו הכריז בקובץ אחר, אי שם
על הכונן הקשיח של הענן אחר ש מאפשר לנו הגישה printf ולהשתמש בו
מבלי להמציא מחדש גלגל בעצמנו.
בינתיים, עיקרי.
מה היה האנלוגי של שבוע ראשי, שעבר?
כן.
>> חבר קהל: הדגל ירוק נלחץ.
>> דוד J מלאן: כן.
שריטה של, כאשר הדגל ירוק לחץ.
זה כמו פיסת הפאזל כי בעיטות מחוץ דברים.
וכך באופן דומה, עשה העולם החלטתי לפני כמה שנים כי בC,
וחבורה של שפות אחרות, אם אתה רוצה לכתוב תכנית,
הפונקציה הראשונה שלך יש שייקרא, עיקרי.
ויש לה להיראות כך.
אבל אנחנו נחזור, בפעם אחרת, למה, int,
ו, חלל, אומר בהקשר זה.
לעת עתה, הסוגריים המסולסלים הם סוג כמו צורת פיסת הפאזל של Scratch
שמתמצת כמה מספר הקווים.
ובין על הקווים כאן, הוא זו אחת כאן.
printf הוא פונקציה שמטרתה ב חיים הוא להדפיס מחרוזת מעוצבת.
ועל ידי מעוצב, אני אומר שאתה יכול לחבר בערכים מציין מיקום,
ואתה יכול לציין כמה עשרוני נקודות, כמה מספרים כדי להדפיס
אחרי נקודה עשרונית וכדומה.
וprintf, כמובן, לוקח אחד או יותר טיעונים או פרמטרים,
ידוע אחר, יותר פשוט, כתשומות.
>> אז printf, כמו הרבה פונקציות, לוקחת תשומות.
ותשומות אלה אימצו על ידי שני הסוגריים כאן.
ובתוך אלה הוא קלט אחד.
זה מחרוזת, כפי שקראנו לזה, וזה רק רצף של תווים,
כמו מילה, או ביטוי, או כל מאמר גם, בין מרכאות כפולות.
וזה מה שהולך להשפיע התנהגות של printf כי, כמובן,
זה רק פונקצית הדפסה גנריות.
זה לא הולך לדעת מה להדפיס, אלא אם אתה אומר את זה.
ואז, כמה פרטי פרטים.
מה אמר זה מוזר רצף של סימנים הוא?
כן.
>> חבר קהל: קו חדש.
>> דוד J מלאן: קו חדש.
אז מתברר, שאתה לא יכול רק להכות, להיכנס, כאשר אתה כותב את התכנית.
בדרך כלל, המהדר הוא הולך לקבל קצת מבולבל לגבי מה שאתה אומר.
במקום זאת, יש לך, פשוטו כמשמעו, אומר, תן לי קו חדש כאן.
וכך / n הוא מה שאנחנו בדרך כלל קורא אופי בריחה.
אז n, לקו חדש.
והמהדר יודע כי כשהוא רואה / n,
זה בעצם צריך לגרום למחשב, סופו של דבר, או printf, במקרה זה,
להדפיס חדש בפועל קו, כמו להכות, להיכנס,
מקש במקלדת.
ולבסוף, מה שעשה אנחנו אומרים חתיכת התחביר הזה היא בשביל?
מה זה מייצג?
כן.
>> חבר קהל: [לא ברור]
>> דוד J מלאן: זה פשוט סוף השורה.
זה הסוף של ההצהרה.
ולהבין שאנחנו לא לשים אותם בכל מקום.
אנחנו בהחלט לא לשים אותם בקצוות של כל שורה.
לדוגמא, יש אף ב קו ראשון, שיש אף אחד על הקו
עם, עיקרי, יש אף אחד לאחר הסוגריים המסולסלים,
אבל אתה תתחיל לראות ולקבל מכיר בו הוא קרא ל.
וזה כמעט תמיד לאחר פונקציה להתקשר או הצהרה, פעולה כלשהי
שאתה בעצם לוקח.
>> ויודע עכשיו, במיוחד אם בין אלה פחות נוחים,
אלה הם מיני דברים מטופשים שתקבלו בסופו דופק בטעות
הראש בקיר מעל.
מכיוון שאתה אהיה לוגי בטוח בכמה בעיה
שפתרת לבעיה סט, והדבר הארור רק
לא לקמפל או אפילו לרוץ.
ולעתים קרובות כל כך, בשלב מוקדם, זה הולך להיות בגלל שפספסת סוגריים,
או שפספסת נקודה-פסיק.
וכל כך פשוט להיות זהיר סוגים של הדברים האלה,
ומנסה לא לקבל מתוסכל שלהם כי עושה מהר מאוד זה
הפך כובע ישן.
אבל זה קל מאוד להגיע מתוסכל בשלב מוקדם, כתוצאה מכך.
>> אז עכשיו, בואו נסתכל על איך קו זה הוא למעשה עובד
ואז להסתכל על מעט יותר מסובך אחד.
אז יש לנו כאן, היכולת לצייר על המסך הזה.
ובואו נניח ש זה מסך המחשב שלי,
אבל אני כותב שלום התכנית,, ולא אני מיושם, printf.
מישהו אחר יישם, printf.
מי הייתי רוצה לטעון ל יישמת, printf?
אם אנחנו עשויים?
בסדר, מה שמך?
>> סטודנט 1: [? גופאל. ?]
>> דוד J מלאן: גופאל, לבוא בעד.
בואו למעלה.
בסדר.
אז יש לנו, כאן, כמה תגים שם, מאז אנחנו נעשה את משחק קצת מזה.
ואנו קוראים לך, printf.
ואם אתה רוצה לבוא לכאן, מה בדיוק אני נמשך על המסך,
זה די פשוט, יש לי, זה.
>> בסדר, אז, שלום השם שלי הוא, printf, אם אתה רוצה לשים את זה על.
בסדר.
ואם אתה יכול ללכת לעמוד על ידי מסך המחשב
כאילו אתה הפונקציה ש הגיע עם מערכת מחשב זה.
והמטרה שלך בחיים היא למעשה להדפיס משהו.
אבל הרבה כמו התכנית ש פשוט היה על המסך, כאן,
אנחנו הולכים צריכים למעשה לתת לך כמה קלט.
>> וכך, אם הקלט שלי, כאן, הוא ככל הנראה, מה שהוא עבר לprintf,
בואו סוג של ללעוג אותו ככה.
אני הולך לכתוב, פשוטו כמשמעו, ב פיסת נייר, "שלום, עולם"
הקו הנטוי נ 'ושיהיה ברור, מה אני רק מצויר על פיסת נייר זה,
נראה כך.
לכן, כאשר אני מפעיל תכנית זו, וזה קו צהוב של קוד מקבל להורג,
זה כאילו אני, את תכנית שלום, אני מוסר כמה קלט לפונקציה
שמישהו כתב אחר.
>> ואם אתה, עם האצבע שלך, באמת יכול, עם האצבע שלך,
לצייר על המסך מה זה שיש לך נמסר,
למעשה, סופו של דבר, הוא לראות בדיוק את זה, על המסך.
ומקרה פינה קטן כאן.
וטוב, אנחנו לא צריכים לראות הקו, חדש, בשלב זה.
זה לא יהיה נכון בשבילך לצייר שורה חדשה באופן מפורש.
אבל אם אנחנו כל הזמן כותב את מילות על מסך, שהם בסופו של מתחת לזה.
>> אז תודה רבה לך, אבל מקל כאן לרגע אחד.
עכשיו אנחנו צריכים אחד אחר מתנדב, אם היינו יכולים,
זה הולך צריך לשחק את התפקיד ל-- זה אנשים היחידים בתזמורת
ברגע זה.
איך על-- אישור.
ממש כאן.
בואו למעלה.
מה השם שלך?
>> סטודנט 2: [? Ivay. ?]
דוד J מלאן: מצטער?
סטודנט 2: [? Ivay. ?]
דוד J מלאן: איתן, יבוא עליו.
לא?
האם אני מקבל לא בסדר, כי גם אחרי שאמרת את זה פעמיים?
בואו למעלה.
קשה לשמוע כאן.
אוקיי.
ואני מצטער, מה שמך?
>> סטודנט 2: [? Ivay. ?]
>> [? דוד J מלאן: Ivay. ?] אוקיי.
לעת עתה, אם לא מוח, אתה GetString.
>> סטודנט 2: אישור.
מגניב.
דוד J מלאן: אז אם אתה רוצה לעמוד כאן רק לרגע,
בואו נסתכל מעט תכנית מורכבת יותר, ש
עכשיו יש שלוש שורות של קוד.
אז יש לנו, אחד, לציין את השם שלך באמצעות printf; שני, קריאה לGetString,
אחרי משימה ל משתנים בשם, מחרוזת של, או בהשם של;
ואז שיחה נוספת ל, printf, אבל הפעם עם שתי כניסות.
>> אז כבר עשינו מדינה השם שלך, או לייתר דיוק, יש לנו
כבר עשה שיחת printf.
אז אני הולך לכתוב, מדינה את השם שלך.
וכך, מה שאני הולך עובר, printf, ברגע,
די פשוט, זו.
אז אם אתה רוצה ללכת קדימה ולצייר את זה על המסך, זה הקלט שלך עכשיו.
בסדר.
ותשכח מחרוזת, עכשיו יש לנו הקו שלנו של קוד כאן.
אז ב, GetString, אנחנו צריכים לקרוא למעשה, GetString.
אז המטרה שלך בחיים היא רק ללכת אל התזמורת, אם אתה יכול,
ולקבל את שמו של מישהו.
אבל בואו אתן לך משהו לשים על זה.
אם אתה רוצה, ללכת קדימה ולקבל מחרוזת,
לקבל את שמו של מישהו שב פיסת נייר, אם אתה יכול.
>> בסדר.
ואנו רואים, ברגע, ששמו שאנחנו מקבלים.
בינתיים, מה שאני הולך יש לי מוכן, היא פיסה ריקה
נייר, שבו, אני הולך לאחסון כל מה ערכו
הוא שGetString חוזר אליי, אני, להיות משתנה מחרוזת בשם, ים.
בסדר.
אז מה יש לך כאן?
ניק.
בסדר.
אז יש לנו את שמו של ניק כאן.
אז זה מה שממש הוחזר
לי, כביכול, על ידי GetString.
>> אני, עכשיו, אני הולך ל לבצע עזב הצד
ביטוי ש, שבו אני פשוט להעתיק למטה, למטרות של היום, ניק.
אז עכשיו, יש לי משתנים בשם, זה, אחסון שמו של ניק.
אני כבר נמסר ל printf, טיעון קודם.
אבל בשורה השלישית והאחרונה שלנו קוד, אני באמת צריך את היד printf
משהו קצת different-- "שלום,% s," n קו נטוי.
>> וכך את השורה האחרונה אני הולך לsend-- הדבר האחרון שאני
הולך לרשום עכשיו, היא זו.
אז שתי השורות של קוד, או ולא את השורה האחרונה של קוד,
שיחות לשני inputs-- אחד, זה, ושני, זה.
אז אם פונקצית printf עכשיו יכול לקחת אלה כקלט,
תן לי לנקות את המסך בשבילך.
למעשה לא, אתה יכול ללכת קדימה.
נשאיר את זה, שכן זה באותה התכנית.
אנחנו צריכים לראות, שלום, ניק.
בסדר.
אז זה היה לא מעט חישוקים לקפוץ דרך, רק
, לכתוב מדינה שלך שם, ו, שלום, ניק.
אבל הרעיון הפשוט הזה של פטירת הודעה, פטירת קלט ופלט קבלה,
הוא בדיוק המודל שאנחנו הולכים יש לי אפילו את הפונקציות המורכבות ביותר.
אז תודה לך כל כך הרבה לשניכם.
יש לנו מתח יפה כדור כאן בשבילך.
ותודה לGetString ומתנדבים printf כאחד.
תודה.
בסדר.
תודה לשניכם.
>> אז אנחנו כבר מדברים על עד כה, בעיקר על מיתרים.
ומתברר שC יכול למעשה להבין כמה סוגי נתונים שונים.
למעשה, בואו ניקח מסתכל על אלה כאן.
אז C, והרבה שפות, להבין דברים בשם תווים.
Char הוא בדרך כלל בית אחד, או שמונה סיביות.
והוא מייצג דמות אחת, כמו המכתב, או ההון
מכתב, או האות קטנה , או נקודה, סימן קריאה
או כל דמות שאתה יכול להקליד ב המקלדת שלך, ולפעמים אפילו יותר.
אנחנו גם לקרות כדי לראות צף.
לצוף הוא, בדרך כלל, ערך של 32 סיביות, או ארבעה בתים
כי שוב, בית אחד הוא שמונה סיביות.
>> אז לצוף הוא ערך נקודה צפה, משהו עם נקודה עשרונית.
ואכן, זה מה ש הסרט מדבר
על כשהם דיברו על צפים ערכי נקודה, כמה מספר קבוע של ביטים
בשימוש כדי לייצג מספר אמיתי.
אבל יש גם דברים שנקראים זוגות.
אלה קיימים ב- Java, אם אתה כבר לקח נגמ"שים,
וכפי ששם כפול, לשמחתי מרמז, הוא פעמיים גדולות כמו לצוף.
זה עדיין מספר אמיתי, רק יש לו יותר ביטים
עם שיהיה יותר ויותר מדויקים, או לאחסן מספרים גדולים עוד יותר.
int הוא קל.
דברנו על זה בפעם האחרונה.
זה פשוט שלם.
וזה בדרך כלל 32 ביטים, או ארבעה בתים.
>> וכך, אם יש לך, בואו נראה עכשיו, 32 bits-- ועשינו את זה בשבוע 0,
פעם כל כך briefly-- אם יש לך 32 סיביות, מה הגדול ביותר
מספר שאתה יכול לייצג כמספר שלם?
לתת או לקחת?
זה כמו 4 מליארד דולרים, וזה רק אם אנחנו
ייצוג מספרים חיוביים בלבד.
אם יש לך 32 סיביות, ואתה רוצה לייצג מספרים שליליים, כמו גם,
הטווח שלך הוא, בעצם, שלילי 2 מליארד למיליארדים חיובי 2.
אבל בדרך כלל, נתחיל ב 0 ללכת עד 4 מליארד דולרים.
>> אתה לא צריך לדעת בדיוק, אבל אנחנו יכולים לראות את זה, למעשה, אם אני רק
לפתוח קצת מחשבון, כאן.
אני יכול לעשות 2 32, ו זה בדיוק עד כמה גדול,
כמה ערכים שאתה יכול מייצג, עם 32 סיביות.
וזה בערך 4 מיליארדים.
אז אנחנו נשמור רואים מספר ש בכמה מקומות שונים.
אבל אם אתה צריך עוד מספרים מזה,
מתברר של שם משהו שנקרא ארוך ארוך.
וארוך ארוך הוא בדרך כלל 64 סיביות, ש
אומר שזה סדר הגודל אפילו גדול יותר מint.
>> אז אני אפילו לא יכול לבטא את הכי גדול מספר שאתה יכול לייצג,
אבל זה במידה ניכרת יותר.
עכשיו כצד, מבחינה היסטורית, אם int הוא 32 סיביות,
וארוך ארוך הוא 64 סיביות, איך הגדול הוא ארוך, לא ארוך ארוך?
היית חושב שזה יותר מint אבל אולי פחות ארוך ארוך ארוך מ,
אבל זה תלוי בעצם.
>> וכך מתברר אחד של התסכולים מדי,
עם כתיבת קוד במערכות מסוימות, הוא שלא כל אלה סוגי נתונים
יש לי ערכים נקבעו מראש.
לפעמים זה ביטים רבים זה.
לפעמים זה שפיסות רבות.
אז אתה באמת צריך לדעת, לפעמים, מה חומרה
אתה מפעיל את התוכנה שלך על.
למרבה המזל, שפות אחרות ו סוגי נתונים אחרים שקיימים כיום,
תאפשר לך להיות מדויק יותר.
ובכן, ראינו מחרוזת, וראינו בול, גם,
אבל מסתבר לבוא אלה רק עם ספריית CS50.
אז אלה לא בנויים לג אלה במקום,
מגיע בקובץ שנקרא CS50.h, שסופו של דבר ימצא
לקלף את השכבות של.
אבל לעת עתה, הם פשוט סוגי נתונים נוספים.
בול הוא אמת או שקר, ו מחרוזת היא רצף של תווים,
כמו מילה.
עכשיו printf, שראינו, יש מצייני מיקום,% s הוא אחד.
וייתכן שתוכל, לחברה, להסיק מדוגמאות אלה אחרים, איך
יש לך יכול מציין מיקום עבור סוגי נתונים שונים.
לדוגמא, לקחת ניחוש, אם אתה רציתי להדפיס את char בודד באמצעות
printf, מציין המיקום הוא כנראה% ג.
ואם אתה רוצה להדפיס שלם עם מציין מיקום, אני%.
LLD% הוא ערך עשרוני ארוך ארוך, אבל ארוך ארוך, כך שממפה לזה.
ואז f% לצפים ערך נקודה או לכפול,
אז לפעמים הם בשימוש מחדש בהקשרים שונים.
אז אנחנו תראו ולהשתמש כמה מאותם לאורך זמן.
וprintf ופונקציות אחרות גם רצפי הבריחה של אחרים תמיכה,
ולפעמים, אלה נחוצים.
אז n הקו הנטוי הוא קו חדש.
לא סרק, עושה כל אחד רוצה לקחת דקירה?
חבר קהל: כרטיסייה.
דוד J מלאן: כרטיסייה.
אז אם אתה באמת רוצה להדפיס את כרטיסייה, לא
מספר קבוע של חללים אך בפועל אופי כרטיסייה, אתה לא פגעת,
כרטיסייה, מקש במקלדת, בדרך כלל, אתה בעצם לעשות לא קו נטוי.
ציטוט כפול קו נטוי, למה שאני אי פעם היה רוצה את זה?
נכון?
למה אני לא יכול פשוט להקליד ציטוט כפול על המקלדת שלי?
חבר קהל: כי, אחרת, זה
הולך חושב שזה הסוף של רצון [ההדפסה שלך? טקסט. ?]
>> דוד J מלאן: בדיוק.
זכור, עם שלנו דוגמאות printf, כאשר אנו
עברו לprintf בקלט, בצד השמאל של שמחרוזת הקלט
ועל זכותם של הקלט ש האביב, כמובן, היה ציטוט כפול.
אם הקלט שלך יש כפול ציטוט באמצע ש,
פוטנציאל למחשב מתבלבל, כמו ל,
עושה ציטוט הכפול הזה שייך באמצע?
עם השמאל אחד האם זה שייך?
עם האדם הנכון האם זה שייך?
וכך, אם אתה רוצה לעשות את זה סופר ברור, אתה עושה קו נטוי ציטוט כפול,
כך שזה נמלט, כביכול, ו זה לא conflated למשהו אחר.
ויש עוד כמה אחר כאן, r קו נטוי, בגרשיים בודדים, 0,
כי אנו עשויים לראות לאורך זמן, כמו גם.
ועכשיו, מה לגבי פונקציות?
>> אז פעולות שאנחנו יכולים לקחת עד כה בשפה זו, C, גם, שראינו,
printf, כמובן, וכל של אחרים על המסך,
כאן, שאנו נשתמש ל השבועות הראשונים של הקורס בלבד,
תבוא ספריית CS50.
והם עושים את זה הרבה יותר קל, ב C, למעשה כדי לקבל קלט משתמש.
מתברר כי ב- C, ו בכנות בכמה שפות,
זה כאב אמיתי בצוואר לעשות משהו פשוט, כמו לבקש מהמשתמש
למקלדת, לקלטו או שלה.
וכך בפונקציות אלה לעשות את זה יותר קל.
>> ויש לה גם שגיאה בדיקה לאורך כל דרך,
כך, שכאשר אתה זוכר ביום רביעי, אנחנו
ראה, לנסות שוב, אזהרה, כשלא שיתפתי פעולה,
ואני הקלדתי מילה, במקום מספר?
אנחנו עשינו את העבודה שחורה מוקדם על מנת לוודא שהמשתמשים משתפים פעולה.
אבל אלה הם רק אימון גלגלים שסופו של דבר אנו,
ובמהירות, להמריא.
>> אז לסיכום, אם כן, בואו ניקח מבט מהיר,
כמו שעשינו עם שריטה, ב כמה מבנים הקנונית בג
זה נועד, סוג של, להיות סיור סופה,
רק כך יש לך התייחסות ושראית את הדברים בהתחלה.
אבל אז אנחנו מסתכלים קידוד בפועל להשתמש בחלק מאבני בניין אלה.
כל כך הרבה כמו בגרד, כאשר היינו לנו הצהרות כמו,
אומר או, לחכות, בC, יש לנו פונקציות, כמו גם, כמו printf.
>> אם אנחנו רוצים להביע את מצב ב- C, זה דומה, ברוח,
שלפיסת הפאזל ש נראה כמו זה בהתחלה.
אבל במקום זה, אנחנו פשוטו כמשמעו רק לכתוב, אם.
ולאחר מכן, בסוגריים, אנחנו שמים את מצב,
שבו המצב שהוא מה שנעשינו קורא, שוב, ביטוי בוליאני.
ושוב, זה סוג של פסאודו קוד.
ואכן, // היא תגובה.
זה רק מילות אנגלית לעצמי.
אבל זה בכלל מבנה, אם, מצב.
אבל אנחנו תראו בטון דוגמאות ברגע.
>> אם אתה רוצה יש לי מזלג דו-כיווני בכביש,
כמו שעשינו עם המתנדב שלנו ב יום רביעי, אתה יכול להיות, אם אחר.
ואם אתה רוצה להיות שלישי ו מצב סופי, או מצב ברירת מחדל,
אתה יכול לקבל רק בלוק אחר, יש.
ובאופן דומה, עם ביטויי בוליאני, אתה יכול, ו, אותם יחד.
וראינו ביום רביעי, ש זה לא אמפרסנד יחיד,
זה שני, מסיבות ברמה נמוכה יותר ש סופו של הדבר יראו ולשחק איתו.
או-ing דברים ביחד הוא 2 קווים אנכיים.
על מקלדת ארה"ב, זה הוא בדרך כלל מפתח
עם מקש Shift מעל שלך מקש Enter או Return מפתח.
>> ואז יש את הדברים האלה ש אנו נשתמש אולי פעם או פעמיים.
הם פונקציונלי שווי ערך ל מה אתה יכול לעשות עם, אם, אם אחר,
אחר אם אחר, לבנות, אבל הם נקראים מתג.
הם נראים שונים מאוד, אבל אנחנו לראות בחלק מקוד ההפצה שלנו,
עבור קבוצת בעיה בעתיד, סביר להניח, שזה לפעמים פשוט יפה
דרך להביע כל חבורה של תנאים,
מבלי הרבה סוגריים מסולסלים ו הרבה סוגריים וכניסה.
אבל הם נותנים לנו לא יותר כוח מאשר יש לנו כבר.
ועכשיו לולאות.
וזה אחד, נבחן בקצת יותר לאט.
אבל אז, נתחיל להשתמש אלה, במיוחד עבור מי שמכיר כבר.
זוהי הדרך הקנונית, אם להפליא דרך מסתורית, לכתוב לולאה בג
>> עכשיו לולאה בScratch הייתה די פשוט.
יש לך, לנצח, בלוק.
יש לך, חזור על, בלוק עם רק מספר שאתה צריך להקליד.
ועם ללולאה,, אתה יכול ליישם את שני רעיונות אלה,
אבל זה קצת יותר טכני.
אבל בכנות, זה גם יחסית פשוט.
ברגע שאתה יודע את סדר פעולות, אתה ממש
הם פשוט הולכים לחבר ערכים ולומר למחשב מה לעשות.
אז הנה דוגמא.
זה לולאה ש, די פשוט, סופר ממספר אחת למעלה
דרך אחר.
ורק על ידי צצה בזה, גם אם יש לך
ללא ניסיון קודם עם שפה זו, מה מספר
אין זה כנראה מתחיל לספור ב?
אישור, 0.
ואני מנחש שזה בגלל שאתה רואה שיש int ואני,
שהוא משתנה.
זה אותחל ל0.
>> ומאוחר יותר, זה נראה כמו אנחנו עוברים printf, ערך.
ואכן, עשיתי קצת טעות דפוס כאן.
אבל זה קבוע בקלות.
הרשה לי להוסיף ב, אני כאן.
עכשיו יש לנו בן printf עבר שערך מציין מיקום.
ומה קורה לספור דרך?
קהל: 50.
50.
49.
דוד J מלאן: 49.
50 אז, במבט ראשון, נראה תקין.
אבל זה, מתברר, הולך להיות המצב שלנו שאנחנו להמשיך לבדוק.
ואנחנו הולכים לעצור פעם אחת אני כבר לא פחות מ -50.
אז לולאה זו, לעומת זאת, צריכה לבצע, כל עוד הוא אני פחות מ -50.
אבל ברגע שזה הופך להיות 50, או 51, או גרוע מזה, זה צריך להפסיק באופן אוטומטי.
בסדר.
>> אז מה בעצם קורה כאן?
אז זה בסדר פעולות ללולאה.
אחד, יש לך את מה שנקרא אתחול.
נתח מודגש צהוב זה קוד מבוצע ראשון,
ויש לה ההשפעה ש, ל יום רביעי, אתה בטח מתאר לעצמי.
זה יוצר משתנה בשם i ו חנויות במשתנות שהערך 0.
אז הוא אני 0 בנקודה זו בסיפור הזה.
>> הדבר הבא ש קורה במבנה זה,
הוא שהמצב מקבל בדק.
אז אני בודק באופן מיידי, הוא אני פחות מ 50?
וכמובן, התשובה לעת עתה הוא, ללא ספק, כן.
כן, כי אני הוא 0, ו זה בוודאי פחות מ -50.
אז מה קורה, הוא שזה שורת קוד מקבלת להורג.
ולמעשה, אם יש מספר רב של שורות קוד בסוגריים המסולסלים אלה,
כל מה שהם מקבלים להורג בזה אחר זה.
>> ובהשפעה כאן, הוא ככל הנראה, להדפיס
אני המספר, שהוא הולך להיות 0, ולאחר מכן 1, ולאחר מכן 2.
אבל למה?
למה זה לקבל מוגדל?
ובכן, הדבר הרביעי ש שקורה הוא שתחביר זה
מקבל להורג, לאחר פסיק.
i ++ היא דרך קצרנות לומר; לקחת את הערך של i, ולהוסיף 1 לזה;
ואז בפעם הבאה, להוסיף 1 אליו; והפעם הבאה,
להוסיף 1 לזה.
>> אז אם אנחנו ממשיכים ללכת, מה הולך לקרות
הבא אני לא הולך ל לאתחל אני אי פעם שוב.
אם אני כל הזמן אתחול אני 0, דוגמא זו
אף פעם לא היה בסופו, כי אני יהיה תקוע על 0.
אבל מה שהולך לקרות הוא כי התנאי ייבדק,
שורת קוד יקבל להורג, אני יהיה מוגדל,
מצב ייבדק, קוד יקבל להורג.
וזה המשיך רכיבה על אופניים שוב, ושוב, ושוב,
עד ש++ גורם ערך של 50.
>> המצב אז אומר, 50 פחות מ -50?
התשובה, כמובן, היא לא, ו כך שכל הקוד מפסיק ביצוע.
ואם יש לך יותר קוד על המסך למטה, זה מה שקורה עכשיו.
זה קופץ החוצה של סוגריים המסולסלים אלה ו ממשיך להדפיס יותר אחרי זה.
>> אז בדיחה עכשיו, מFoxtrot, ש אתה אולי עכשיו תבין.
זה תמיד מצחיק.
זה כמו המגחך סוג של לחלחל,
ואז אתה מבין שאתה לא צריך להיות צוחקים על הומור כזה.
אבל יש כמה ממסעדה כאן, מבחינה פדגוגית, מדי.
אז מתברר שאני חסר חתיכת התחביר,
או Foxtrot של חסר חתיכת התחביר כאן.
מה שחסר, שהיו לנו בכל דוגמא אחרת, עד כה?
חזור, הוא שם, כל כך זה משהו אחר,
שנחזור לזמן קצר.
מה שחסר, למרות ש?
כן.
>> חבר קהל: אתחול של [לא ברור].
>> דוד J מלאן: אישור.
אז כן.
אז בעצם, זה הוא-- ובכן, וספירה מאותחלת
למעלה, או לייתר דיוק, הכריז מעל.
אז זה הוא דרך נוספת של עושה את זה.
אבל לא בקו אחד זה כאילו זה בתוקף.
מה דעתך על כאן?
>> חבר קהל: האם זה סוגריים המסולסלים?
>> דוד J מלאן: כן.
אז הסוגריים המסולסלים חסרים.
אבל הקוד הזה, אני מתכוון, לאשראי שלהם, הוא למעשה, מבחינה תחבירית בתוקף.
מתברר, שאתה לא צריכים סוגריים המסולסלים
אם יש לך רק שורה אחת של קוד ש אתה רוצה לבצע בתוך הלולאה.
עכשיו אנחנו תמיד, בכיתה וב כל קוד ההפצה שלנו,
כוללים סוגריים המסולסלים בכל מקרה, רק למען הבהירות.
אבל מבין שבספרי לימוד ודוגמאות באינטרנט,
ייתכן מאוד לראות מתולתל פלטה חסרה מתישהו.
וזה בסדר, אם מה שאתה יש מסוכסך ונועד
רק שורה אחת של קוד, ולא מספר שורות הקוד, שעלול להיות.
בסדר.
כל כך קשור לנושא של חוסר דיוק, הוא נושא של גלישה,
במובן זה, דומה, יש לי מספרים שלמים גבולות אליהם
בדיוק כמו ערכי נקודה צפה?
בעולם נקודה צפה ערכים, אנחנו יכולים רק להיות כל כך מדויקים,
לאחר ש, לפעמים דברים רעים יכולים לקרות,
והתוכניות שלנו יכולות להיות מרכבה וטעייה.
עכשיו גם עם מספרים שלמים, אתה יכול נתקלת בבעיות.
עכשיו שלם אין נקודה עשרונית או מספרים אחרי זה.
זה רק מספר טבעי, בדרך כלל.
אז מה יכול להשתבש עם int?
אם אני משתמש int ל רוזן, מה יכול להשתבש?
נראה הרבה יותר פשוט.
כן.
>> חבר קהל: אם מספר מקבל [לא ברור]
>> דוד J מלאן: כן.
מה אם סופר כל כך גבוה, ש לא יכול להביע את שהמספר גדול באמת.
נכון?
בשלב מסוים, אתה הולך יעלה על הגבולות
של ערך של 32 סיביות או ערך של 64 סיביות.
עכשיו שוב, אני לא בטוח איך לבטא ערך של 64 סיביות,
אבל אני יודע שעם שלם של 32 סיביות, הערך הגדול ביותר שהוא יכול להיות,
אם זה רק חיובי ערכים, הוא כ -4 מליארד דולרים.
אז אם אני מנסה לספור עד 5 מיליארדים, משהו הולך לקרות.
אבל בואו נראה מה, למעשה, יכול לקרות.
בעולם של מספר שלם גלישה, שבו אתה, במובן מסוים,
גדות הקיבולת של שלם, מה שעלול לקרות?
>> אז הנה מספר בינארי, זה מחזיר אותנו ל0.
זה כל של 1, ומצייני המיקום שם, הן סמכויות של 2,
אז זה בינארי.
אז אלה הם 8, 1 סיביות על המסך.
ואם אתה זוכר או אתה עושה במהירות במתמטיקה,
מה הערך שאינו מיוצג כאן עם שמונה 1 הביטים האלה?
255.
ואפילו אם לא היית די בטוח של המתמטיקה, אתה יכול לעשות את זה.
או שאתה יכול פשוט סוג סיבה דרכו,
חכה רגע, אם אני מייצג ערך 8 סיביות,
ויש לי 256 ערכים אפשריים, אבל הראשון שבם הוא 0,
אני רק יודע ש גדול הולך להיות 255,
וזה מה שזה אחד יכול להיות.
>> אז נניח שאני מנסה להוסיף 1 לערך זה.
מה היית עושה בכיתה בית הספר בעת הוספת 1, וזה
לא ממש בכושר, כי אתה צריך לסחוב 1?
מהו מספר זה הולך להפוך כאשר אתה מוסיף 1?
זה הולך להיות 0.
נכון?
כי אם היה לך bits-- יותר ואני יהיה אנסה, סוג של, הקלד אותו כאן--
אם היו לנו יותר ביטים, מה ש יכל לעשות כאן הוא להוסיף 1,
ואז הייתי מקבל את זה.
אופס.
הייתה לנו קצת 1 כל הדרך לכאן.
>> אבל אם זה סופי ערך, זה רק 8 סיביות,
וזה לפני שנקבע על ידי המחשב,
כי 1 הוא למעשה לא קיימים.
זה פשוט סוג של נופל מצוק.
ולכן אם אתה מוסיף 1 עד 255, מה ש ערך שאתה כנראה מקבל?
0.
וכך מספרים בטעות, ואולי, שלא במתכוון,
בסופו של עטיפה סביב כמו זה.
אז מה יכול להיות המשמעות של זה?
ובכן, יש כמה דברים שונים.
אז אחת, זה בסופו של מחפש כמו 0, שלא במתכוון,
אבל אתה סוג של יכול לראות, אפילו בעולם האמיתי,
לטוב או לרע, גילויים של הרעיון הזה של גבול.
לדוגמא, כל אחד מכם ש אי פעם שיחק לגו מלחמת כוכבים,
האם מישהו יודע במקרה המספר המרבי של מטבעות
אתה יכול לאסוף בגו מלחמת כוכבים?
קח ניחוש המבוסס על השאלות מובילות של היום.
הוא גדול יותר 256 או 255.
זה 4 מיליארדים.
אז מתברר, ו יש כמה אנשים--
כמה night-- האחרון אישר googling מקבל 4 מליארד מטבעות זהב,
או מה שלא, בגו מלחמת כוכבים.
למרות שככל הנראה, יש דרך להערים המשחק,
יש באג או תכונה, המאפשר לך רק צובר המון המון נקודות.
אבל הגדול ביותר האפשרי ערך, לפי
לצילום מסך שלי מישהו מצאו באינטרנט, הוא אכן, 4 מיליארדים.
>> עכשיו למה זה?
זה בדיוק 4 מליארד דולרים, כנראה בגלל שמישהו החליט,
שכתב את המשחק הזה, שהם יכולים לעשות 4 מליארד דולרים,
משהו, משהו, משהו, כמו הערך שמתי את
עם המחשבון קודם לכן, אבל זה פשוט נקי קטן לבני אדם
לומר את המספר המרבי של coins-- או חתיכים,
כפי שהם מכנים them-- ש יכול לאסוף הוא 4 מליארד דולרים.
וכך, למה זה?
איך הוא משחק לגו יישום הדלפק
זה שמירה על המסלול של מספר המטבעות שיש לך?
הם משתמשים במה?
חבר קהל: זה מפסיק ספירה לאחר 4 מיליארדים.
דוד J מלאן: זה מפסיק ספירה לאחר 4 מליארד דולרים,
מה שאומר שאתה יכול להסיק, כמתכנת,
כי הם כנראה באמצעות מספר שלם 32 ביט.
כמו מתכנת, פשוטו כמשמעו, רק מוקלד, int, בקוד שלו או שלה,
וזה הסוג של משתנה ש הם משתמשים לאחסון הקוד של מישהו.
אז יש ביטויים אחרים סוגים של מגבלות אלה.
>> אז אני לא שיחקתי game-- זה ואני קורא על ההיסטוריה
כדי לאשר כmuch-- אבל ב גרסה המקורית של ציביליזציה, שבו
אתה כנראה אינטראקציה זה עם זה אחר ויכול לנהל מלחמה או שלום יש לי,
גנדי היה אמור להיות אחד מ הדמויות השלוות ביותר, כפי ש
מבין את זה, בראשון גרסה של ציביליזציה.
ואכן, בסולם של 1 עד 10, התוקפנות שלו הייתה רק 1.
אז אי פעם כל כך בלשון המעטה אגרסיווי, ככל הנראה.
>> אבל בשלב מסוים, אתה כנראה יכול להתקין דמוקרטיה בגאוגרפיה שלך.
ואם תתקינו דמוקרטיה לגרסה של המשחק שלך,
אז רמת התוקפנות שלך יורדת.
זה דבר טוב.
אנשים שלווים יותר ככל הנראה, במצב ש.
אבל ככל הנראה, מישהו עשה אין לי, אם, מצב
בגרסה המקורית של הקוד.
>> אז רמת התוקפנות של גנדי הלכה מ 1 חיובי, מינוס 2, לשלילי 1,
אבל המשחק לא להבין מספרים שליליים.
אז מה שקרה הוא תוקפנותו של גנדי רמה הלכה מ1, 0, 1 לשלילית,
שהיה האפקט של עטיפה סביב להיות
האופי האגרסיבי ביותר במשחק, בשווי של 255,
בסולם של 1 עד 10.
ומאז, יש כבר יותר גלגולים של המשחק הזה,
והם שמרו אותו כ סוג של ביצת פסחא,
שגנדי הוא כנראה כך אגרסיווי מאוד.
אבל זה היה התוצאה של שגיאת תכנות פשוטה מאוד
שבגרסה מאוד מוקדמת של המשחק.
>> עכשיו יותר מטריד, יותר לאחרונה, בואינג 787
תועד כבעל באג, לא מהסוג של מכשיר
אתה במיוחד רוצה להיות באג.
והתסמינים, שאני אקרא כאן, ממאמר באינטרנט,
היה, מטוס 787 מודל זה שכבר מופעל ברציפות
לימים 248 יכולים לאבד את כל זרם חילופין, AC,
חשמל, בשל יחידות גנרטור שליטה,
GCUs, בו זמנית הולך למצב Fail-בטוח.
אז זה היה אזהרה כאשר בעיה זו התגלתה.
מצב זה נגרם על ידי דלפק תוכנה,
פנימי לGCUs, כך מספר שלם או משתנים,
כי הצפת רצון אחרי 248 ימים של כוח רציף.
בואינג הוא בתהליך של פיתוח שדרוג תוכנת GCU ש
יהיה לתקן את המצב בטוח.
>> כל כך הרבה כמו הטיל תרחיש, שבי
היה להם כמה סוג של משתנה שספירה, וספירה,
ולספור, אבל עולה על גדותיו בהדרגה גבולות היכולת שלה,
באופן דומה עשה מטוס הארור יש לי גלישה משתנה
אחרי מספיק זמן של ריצה.
ולכן דרך לשון-בלחי של עובד סביב נושא זה
הוא באמת, אתחול מחדש, המטוס שלך בכל 247 ימים, כך שהזיכרון מקבל ניגב
ומשתנה חוזר ל0.
אבל מבין, זה הוא מאוד גלגול גדול של תוכנה,
אבל במיוחד כאשר אנו שומעים על אפל מערכות הפעלה הולכת למכוניות,
ועצמי נוהג במכוניות מגוגל, ו כל מספר גלגולים של תוכנה
בחיי היומיום של, הטלוויזיות שלנו ושעונים, ועוד,
מבין היו מוקפים תוכנה, כל שנכתב על ידי, בני אדם.
>> וכפי שכולנו בקרוב לגלות, זה מאוד קל ומאוד אופייני
לעשות טעויות בעת כתיבת תוכנה.
ואם אתה לא תופס אותם, כמה דברים רעים יכולים לקרות.
עכשיו לפעמים, כמה דברים מצחיקים יכולים לקרות,
או לפחות לפעמים אנחנו יודע לצפות כמה רוע.
אז 0 מחולקים 0, מכיתה בית ספר, הוא בדרך כלל דבר רע.
זה לא מוגדר.
ומתברר out-- ובואו נראה אם המיקרופון שלי יכול להרים את זה up-- כי אפל
היה להם קצת כיף עם זה לאחרונה.
אז יש לי iPhone כאן.
אני הולך לדבר עם Siri ולשאול אותה לתת לי תשובה ל0 מחולקת 0.
מה 0 מחולקים 0?
>> SIRI: תארו לעצמכם שיש לך 0 עוגיות, ואתה לפצל אותם באופן שווה
בין 0 חברים.
כמה עוגיות כל אדם לקבל?
רואה?
זה לא הגיוני.
ועוגי הוא עצוב שאין עוגיות.
ואתה עצוב ש אין לך חברים.
דוד J מלאן: זהו סוג של מעצבנת.
אז זה מה שרק אמר שיש.
זה לא מוגדר, זה לא מוגדר, ואכן, שפות תכנות רבות
או, באמת, מהדרים יהיו לזהות כאשר אתה, בתכנית,
מנסה לחלק 0 על ידי 0.
יותר כיף מאשר אף זו, הוא שככל הנראה, עוגי
הוא בטוויטר בימים אלה.
והוא השיב לזה, עם זה, שהוא מקסים לחלוטין.
אבל בואו ניקח מבט מהיר ב כמה מבנים אחרים,
ואז לשים חלק מזה קוד לשימוש, בדרכים טובות.
אז מתברר, מלבד ללולאות, יש
משהו שנקרא לולאה בזמן, ש נראה שונה ומיושם
וקצת differently-- סופו של דבר יראו examples--
אבל במובן מסוים, זה פשוט כי זה
אינו מאפשר לך לאתחל ו לעדכן בתוך הגבולות של הלולאה.
אתה עדיין יכול ליישם את זה.
אז אתה יכול לעשות בדיוק את אותם דברים עם לולאה בזמן, כמו עם ללולאה,
אבל התחביר שלך, ultimately-- וכבסוף
see-- הולך להיות שונה.
יש אפילו לעשות בזמן לולאה, ש הוא למעשה קצת שונה,
בכי בעוד ללולאה ולולאה בזמן תמיד
לבדוק את מצבם הראשון, אם אתה קורא את הדבר הזה למעלה עד למטה,
זה נראה כמו סוג של זה הולך לבדוק את המצב שלו אחרון, כי זה
באמת השורה האחרונה של קוד.
ואכן, זה הולך להיות שימושי בתוכניות מסוימות שאנחנו כותבים,
אם אתה רוצה לעשות משהו פשוט עיוור וסופו של דבר לבדוק את מצבו.
זה לא בהכרח דבר רע.
אם אנחנו רוצים משתנים, אנחנו יכולים לעשות זה בכמה דרכים שונות.
וראינו בFoxtrot קריקטורה, דרך אחת לעשות את זה,
שבו אתה מצהיר משתנה, כמו פסיק דלפק int,
ואז אולי later-- הבא קו, אולי 10 קווים later--
אתה בעצם לאתחל אותו.
אז אלה 2 שורות קוד להצהיר על משתנה מסוג int
וקורא לזה דלפק, כך שזה נותן לי מספיק ביטיי להחזיק int.
ואז בסופו, היא מעבירה הערך 0 למשתנים ש.
זה מסדיר את של 0 ו -1 של ב דפוס, שאנחנו יודעים משבוע שעבר,
מייצג את המספר שאנו מכירים כ0.
או בכנות, אתה יכול לעשות את זה הרבה באופן תמציתי יותר, פשוט אהבתי את זה.
>> עכשיו יש לנו גם יכולת לקרוא לפונקציות.
ולמעשה, הנה קו 2 תכנית, או קטע ממנו,
המאפשר לנו למעשה לכתוב קצת קוד ש
מקבל מחרוזת מuser-- הרבה כמו ההתנדבות שלנו רגע ago--
אחסון התוצאה ב משתנה בשם שם,
ואז-- הרבה כמו עם המתנדב שלנו עם הדפסים מתוך ערכים אלה printf--
על ידי עובר בשתי טענות, מחרוזת, ואחריו משתנה
בשם, שם, את עצמו.
אז בואו נסתכל, לפני אנו חוזרים למריו יש,
בכמה עכשיו, דוגמאות לכך.
>> אני הולך קדימה ופתוח עד, נניח, פונקציה-0.c.
וכמו תמיד, את הקוד הזה הוא זמין באתר האינטרנט של הקורס,
כך שאתה יכול לשחק יחד ב הבית ומסתכל על זה מאוחר יותר.
אבל הנה התכנית בזה מהות, מקו 17-22.
התכנית העיקרית היא שבו התכנית תמיד עומדת להתחיל.
תכנית זו, ככל הנראה, הוא הולכת להדפיס את השם שלך, מעי גס.
זה אז הולך לקרוא GetString, בדיוק כמו שעשינו עם המתנדבים שלנו.
ואז, זה מעניין, זה הולך לקרוא PrintName.
מתברר, כל הזמן הזה, יש נראה שיש פונקציה שנקראת PrintName.
שמדפיס את שמו של מישהו.
אנחנו לא צריכים להשתמש printf מ פעם, יש PrintName.
>> אבל זה מטעה כי PrintName לא
מגיע עם ג אנשים לא להמציא אותה לפני כ -40 או 50 שנים,
אני עשיתי, במקום.
ולמעשה, אם אני לגלול מטה נוסף, הודעה
איך אני יכול לכתוב שלי פונקציות בסופו של דבר ימצא .ג
להסביר למה אנחנו כל הזמן אומרים, חלל, בכמה מקומות,
אבל היום, בואו רק להסתכל על השם.
>> על קו 24, אם אתה רוצה ליצור הפונקציה שלך,
אתה ממש לכתוב שמו של הפונקציה.
אני בחרתי PrintName.
בסוגריים, אתה לאחר מכן ציין אילו סוגים
תשומות, וכמה אתה רוצה בפונקציה זו כדי לקחת.
במקרה זה, אני רוצה לקחת את משתנה 1 נקרא, שם,
וזה הולך להיות של סוג, מחרוזת, כך שזה הולך
להיות חלק רצף של תווים.
ולאחר מכן, program-- זה כמו בגרד,
אתה יכול להיות חידה מותאמת אישית pieces-- הוא הולך להיות זה התנהגות מותאמת אישית.
זה הולך לקרוא printf עובר ב, שלום, מציין מיקום,
ואז זה הולך לחבר בכל מה שהמשתמש בשם.
>> אז זה דוגמא למה ש מדען מחשב היית
הפשטת שיחה או פונקציונלית פירוק, שהם רק
דרכים מפוארות של saying-- האם אם אתה אוהב את רעיון ברמה גבוהה זו,
כמו שאני רוצה פונקציונלי ש מדפיס את שמו של מישהו, אתה בהחלט
ממש יכול לכתוב printf ולאחר מכן לעבור בטענות שאתה רוצה,
והתכנית תעבוד, שכן יש מאז יום רביעי.
אבל אתה יכול להתחיל משם מופשט הרעיון של הדפסה שם.
אתה יכול לתת לו שם, כמו PrintName, וזה
רעיון זה של שכבות משבוע 0.
>> מכאן ואילך, אני ואתה לא צריך לדעת או אכפת איך PrintName מיושם.
כן הוא משתמש printf, אולי זה לא, מי יודע מה משתמש?
למי איכפת?
עכשיו אני מדבר כאן, במקום כאן למטה.
ואכן, כפי שהתוכניות שלנו לקבל יותר מתקדם ומתוחכם,
אנחנו הולכים להמשיך לקחת כמובן מאליו שחלקי הפאזל רמה נמוכים יותר קיימים.
בגלל שכתבנו אותם או מישהו אחר עשה, ולכן
כי אז אנחנו יכולים לבנות עליהם.
בואו נסתכל על זה גרסה, פונקציה אחת.
>> אז זה אחד זה קצת יותר מתקדם, אבל מתברר
כי בספרייה של CS50, יש רק פונקצית GetInt.
לא חשבנו, לפני שנים, ל ליישם פונקצית GetPositiveInt.
וזה קצת מעצבן כי אם אתם כותבים תכנית שבי
אתה רוצה לקבל חיובי מספר שלם מהמשתמש,
בהחלט אתה יכול להשתמש GetInt.
ואתה בהחלט יכול לבדוק עם המצב ואולי לולאה
אם int שהוא גדול יותר מ 0 ולצעוק על המשתמש
אם הוא או היא לא נותנת לי לך מספר חיובי.
אבל בואו לבנות את זה בניין לחסום את עצמנו,,
חתיכה מותאמת אישית Scratch, אם תרצה.
אני הולך יש לי תכנית כאן שסופו של דבר, אני
רוצה להיות מסוגל לקרוא GetPositiveInt, ואני רוצה להיות
תוכל להדפיס את מה שהוא int.
אבל זה מפוזר משם עכשיו.
זה פשוט קיבל רמה גבוהה שם שאומר את מה שהוא עושה,
וזה נפלא, כי זה מאוד אינטואיטיבי עכשיו לקרוא.
ואם אני עושה אכפת מה יש מתחת מכסה המנוע, תן לי לגלול למטה.
וזה קצת מפחיד בהתחלה, במיוחד
אם זה התכנית הראשונה שלך, אבל בואו נסתכל.
>> אני כבר לא אומר, חלל, כי מתברר פונקציות,
הרבה כמו GetString, יכול להחזיר ערך לי.
לא רק שיש להם להדפיס למסך,
הם באמת יכולים למסור שלי משהו בחזרה.
ואילו לפני PrintName, אני לא צריך שום דבר בחזרה.
אני צריך תופעת הלוואי של משהו להופיע על המסך,
אבל אני לא צריך אדם למסור לי משהו בחזרה.
כאן, עם GetPositiveInt, כמו עם GetInt,
אני רוצה להימסר משהו בחזרה.
אז אני אומר לא, חלל, על קו 23, אך int,
שאומר, בפונקציה זו שאני כותב,
נקרא GetPositiveInt הולך למסור לי את מספר שלם, לא שום דבר,
לא מבוטל.
>> בינתיים, זה הולך לקחת לא תשומות, כך ש, סוג של, התהפכו זה.
אני לא נותן GetPositiveInt כל קלט, אני רוצה שזה ייתן לי את התפוקה שלה.
ואז מה קורה עכשיו?
אז הנה איך אני יכול להצהיר על משתנה.
אני כבר עשיתי את זה מחוץ ללולאה, מסיבות שסופו של דבר יראו,
אבל זה רק נותן לי שלי 32 סיביות נקרא, n,
ויש לי מראש קביעה- שלהם כדי לאחסן מספר שלם.
והנה ש, לעשות בזמן לבנות, וזה למה זה שימושי.
פשוטו כמשמעו לעשות את זה, בעוד n הוא פחות מ 1.
אז בואו לראות מה קורה.
אני להדפיס, בבקשה תן לי int חיובי.
אז אני מקבל int, באמצעות CS50 של לתפקד ומאוחסן בn.
>> ואז, מה שורת קוד כנראה מקבל להורג הבא, באופן הגיוני?
איזה קו מספר?
כן, אז 31.
אתה לא יודע את זה עד שיש לך נאמר לי או סוג של להסיק את זה,
אבל זה נכון.
זה הולך מלמעלה למטה ולאחר מכן חוזר על.
אז אם יש לי הקליד למשל, המספר שלילי 1, הוא פחות מ n שלילי 1?
כן.
בגלל שלילי 1 הוא פחות מ 1.
אז מה צריך לקרות?
אני הולך לעשות את זה בעוד n הוא פחות מ 1,
אז אני הולך לחזור לקו 28.
>> וכל time-- ובואו לרוץ זה-- להפוך את פונקצית 1 לקמפל אותו,
ועכשיו נקודה לקצץ פונקצית 1.
אם אני מקליד 1 שלילי, זה הולך לשמור לצעוק עליי
עד שאשתף פעולה, כי כל התשומות שלי הוא פחות מ 1
ואם זה תוך פחות מ 1, אני הולך להמשיך לעשות את זה.
אם אני סוף סוף נותן לו מספר כמו 50, לשמחתי, זה אומר, תודה על 50.
למה?
כי ברגע שn הוא לא פחות מ 1, אני מפסיק להיתקע בלולאה זו,
ומילת מפתח חדש זה היום, התמורה, פשוטו כמשמעו עושה את זה.
אז פשוט אני כבר מיושם, ב תחושה, את המקבילה של GetString,
לאן אני מסרתי בחזרה ל מי שמשתמש בי, כמה ערך.
זה לא חייב להיות מחרוזת, זה int.
אז פשוט, מהיר למשל, אבל אנחנו בקרוב
לראות כמה מתוחכם יותר גרסאות עדיין.
למעשה, בואו נסתכל מספרי אחד, הנקרא return.c.
וזה אחד בעצם קצת יותר פשוט.
אז המטרה של תכנית זו ב life-- בואו לקמפל ולהריץ אותו,
כך להפוך את התמורה, נקודה קו נטוי, הודעת return--
התכנית פשוט קוביות הערך 2.
זה די טיפשי, זה קשה קוד, זה לא לוקח כל תשומות,
אבל זה מדגים אחר פונקציה שכתבתי בעצמי.
אז הנה, אני כבר הכריז משתנה, נקרא X, של int הסוג,
שווה למספר 2, שרירותי לחלוטין.
זהו רק חלק הדפסה רכה.
זה אומר x הוא עכשיו, וכאלה , נקודה כזו עִקוּב נקודת נקודה.
והקסם הוא כנראה בקו 21.
אני קורא לפונקציה בשם, קובייה, אני מושיט אותו גיליון נייר
עם מספר 2 שנכתבו עליו, ומה ערך, מבחינה מתמטית,
אני רוצה לצאת מזה?
רק כבדיקת שפיות?
8.
נכון?
אני רוצה 2 קוביות בחזרה, 2 ל הכח של 3, אז חזרה 8.
>> אז איפה מיושמת קובייה?
ובכן, שים לב שזה מיושם כאן למטה.
ובדיוק כמו בעבר, באופן הגיוני, למרות שהתחביר הוא כנראה
מאוד חדש לרבים מכם, אני רוצה בפונקציה זו
להחזיר לי גיליון של נייר עם int על זה.
אז יש לי int, שם הוא באופן שרירותי,
אבל בשם נוחות קובייה.
הקלט אליו, הוא n של הקלד מספר שלם, אז זה
איך אני יכול לעבור במספר 2 על גיליון נייר.
ואז מתברר תומך C מתמטיקה, כך אין לך X של פעמים,
אתה פשוט להשתמש בכוכבית לכפל.
וזה מחזיר פעמים n n פעמים n, וזה פשוט ערך קוביות.
>> אז לאן אנחנו הולכים עם כל זה?
זה בהחלט סיור סופה, היה סמוך ובטוח,
כי בסעיפי הסופר ובבעיה להגדיר 1,
אתה תהיה הלך ב כל זה עוד יותר.
ובבעיה להגדיר 1, אנחנו מעבר מהעולם הגרפי של Scratch
למשהו שורת הפקודה יותר בC. אבל אנחנו שואבים את ההשראה
מכאן המשחק הזה מפעם, שבי
באמצעות C והמהדורה הסטנדרטי של סט עמ אתה ליישם הפירמידה של מריו.
ובמהדורה של ההאקר סט עמ ', אם אתה כל כך לבחור לבחור,
תוכל ליישם קצת יותר מאתגר את הפירמידה עם שתי פסגות.
כמו כן תוכל ליישם אלגוריתם, אלגוריתם חמדן.
מתברר של שם איזה היגיון מעניין
מאחורי התהליך פועל תחנה של קופאית
ומסירה בפועל מישהו שינוי בחזרה.
יש אלגוריתם זה די פשוט, כי אתה אולי אפילו
לתפוס באופן אינטואיטיבי כאשר אתה קורא ראשון it-- הבין שזה מה שתמיד
עשה כל זמן שנתתי למישהו מסוים הכסף back-- שמאפשר לך תמיד
לצמצם את מספר הערות נייר או מטבעות מתכת
שאתה מסרת בחזרה למשתמש.
וזה, כמובן, הוא משכנע כי אם אתה הולך לCVS או מה שלא,
אתה לא רוצה להיות בידיים חבורה של אלה כל
או חבורה של פרוטות כולה.
אתה רוצה הכי פחות מטבעות, כנראה, אפשרי.
>> לבסוף, תוכל גם להיות מאותגר להשתכשך בעולם מים
ולמעשה לקבל את ההערכה למיפוי בין שיעורי זרימה,
של רצון, מים במקלחת, רק כמה מים משמש.
והרמז בו, יהיה קליפ זה כאן,
שאנחנו בסופו של ל רק 60 שניות, ש
מצייר תמונה של ראשי מקלחת זרימה נמוכה.
>> [וידאו השמעה]
-בסדר.
יש לי הכל כאן.
יש לי את הסדרה ו 'ציקלון, הידרה, Jetflow, שטוקהולם
Supersteam, אתה שם את זה.
>> ומה באתם ממליצים?
>> -מה אתה מחפש?
>> איש -Power.
כוח.
הדמוי סילקווד.
חייהם." בשביל קרינה.
-זה נכון.
-עכשיו מה זה?
"אלוהים." -זה הקומנדו 450.
אני לא מוכר את זה.
>> -אבל זה מה שאנחנו רוצים.
זה קומנדו 450.
>> -לא יאמין לי.
הוא משמש רק בקרקס.
זה לפילים.
>> "אני אקה לשלם כלום.
>> מה בנוגע ג'רי?
>> -הוא לא יכל להתמודד עם זה.
הוא עדין.
או כן.
[סוף ההשמעה]
דוד J מלאן: בסדר.
זה אם לCS50.
נתראה בשבוע הבא.
>> 1 מרצה: [? סקאלי?], [? איאן,?] ככל פרויקט outro זה,
מה יש לכם לבוא עם?
>> SPEAKER 2: טוב, שנתנו זה מגוון של מחשבה,
ואנחנו חושבים שהדרך הטובה ביותר צריכה--
>> SPEAKER 3: מאי אני?
>> SPEAKER 2: כן.
בכל האמצעים, למעשה.
>> 3 דובר: אז אני חושב אנחנו יכולים לסכם את הרעיון שלנו
לoutros עם דבר אחד word--.
>> דוד J מלאן: שום דבר?
SPEAKER 3: שום דבר.
דוד J מלאן: מה זה אומר?
SPEAKER 3: outros הם על לא מאומה.
SPEAKER 2: טוב, אני מתכוון, בפילוסופיה, אני מתכוון, לא תמיד יש משהו.
1 דובר: אז what's-- מה ההנחה?
3 דובר: אז זה כמו חיים.
אוקיי.
מה עשית היום?
>> דוד J מלאן: קמתי, היה לי ארוחת בוקר, ובא לעבוד.
>> SPEAKER 3: זה outro.
SPEAKER 2: אבל, אני מתכוון, לא צריך משהו יקרה לו בכל--
SPEAKER 3: לא, לא, לא, לא.
שום דבר לא קורה.
>> 1 דובר: אז למה אנחנו צופים?
>> 3 SPEAKER: מכיוון ש זה outro לCS50.
>> דוד J מלאן: עדיין לא.