>> [השמעת מוסיקה]
דוד י מלאן: בסדר.
זה CS50, וזה הוא ההתחלה של שבוע שני.
אז הבה ותתחילו היום עם באג.
באג, כמובן, הוא טעות בתכנית,
ותקבל מאוד מכיר את המושג הזה
אם אף פעם לא מתוכנתים לפני. pset0 ועכשיו pset1.
אבל בואו נשקול משהו קטן ופשוט בהתחלה.
תכנית זו כאן שאני זרק יחד מראש,
ואני טוען שזה צריך להדפיס 10 כוכבים על המסך באמצעות printf,
אבל זה ככל הנראה מרכבה בדרך כלשהי.
>> בהתחשב במפרט ש זה צריך להדפיס 10 כוכבים,
אבל זה לא כנראה, מה ש היית טוען הוא באג?
כן?
אז זה את ידי שגיאה אחת, ומה אתה מתכוון לעשות את זה?
אישור.
מצוין.
אז יש לנו שצוינו להתחיל ערך של אפס עבור i,
ואנחנו כבר צוינו ערך n של 10, אבל אנחנו כבר בשימוש פחות או שווה ל.
והסיבה שזה שתי תווים ולא רק סמל אחד,
כמו בספר מתמטיקה, הוא שאין לך
דרך להביע שווה ערך תו אחד.
>> אז זה אומר פחות מ, אבל אם אתה מתחיל לספור על אפס,
אבל אתה סופר את כל הדרך דרך ושווה ל10,
אתה כמובן הולך לספור 11 דברים בסך הכל.
ואז אתה הולך להדפיס 11 כוכבים.
אז מה יכול להיות לתקן את זה?
כן?
>> אז פשוט להתאים את פחות מ או שווה רק כדי להיות פחות מ,
ויש, אני טוען, אולי פתרון אחר, גם.
מה שאתה יכול לעשות דבר אחר?
כן?
>> אז תתחיל שווה את זה ל1, ו להשאיר פחות או שווה ל.
ולמען אמת אני טוען כי, לאדם טיפוסי,
זה כנראה יותר פשוט.
מתחיל לספור ב1 ו לספור דרך 10.
בעיקרו של דבר לעשות את מה שאתה מתכוון.
>> אבל המציאות היא ב תכנות, כפי שראינו,
מדעני מחשב ומתכנתים בדרך כלל מתחיל לספור על אפס.
וכך זה בסדר פעם אחת אתה מתרגל לזה.
המצב שלך, בדרך כלל, יהיה משהו כמו פחות מ.
אז פשוט הגיוני שגיאה שאנחנו יכולים עכשיו
לתקן וסופו של דבר להדר מחדש זה ולקבל רק 10.
>> ובכן מה דעתך על הבאג הזה כאן?
כאן, שוב, אני טוען שיש לי מטרה של הדפסת 10 stars--
אחת בכל שורה הפעם, אבל זה לא.
לפני שנציע את מה ש התיקון הוא, מה עושה את זה
להדפיס מבחינה ויזואלית אם הייתי לקמפל והפעל תכנית זו, לדעתך?
כן?
>> כוכבים.
אז כל הכוכבים על אותו קו הוא מה ששמעתי,
ולאחר מכן את אופי הקו החדש.
אז בואו ננסה את זה.
אז להפוך את המרכבה-1, להיכנס, ואני רואה את פקודת הצלצול
שדיברנו עליו בפעם האחרונה.
./buggy-1, ואכן אני רואה את כל 10 כוכבים על אותו הקו למרות שאני טוען
במפרט שלי רק הערה על גבי הקוד שאני מתכוון לעשות לאחד
שורה.
אבל זה נראה תקין.
>> עכשיו שורה 15 זה נראה כאילו אני הדפסת כוכב, ולאחר מכן שורה 16
זה נראה כאילו אני הדפסה אופי קו חדש,
והם שניהם כל כך מסוכסך אני פנימי של הלולאה באופן ברור.
אז לא צריך אני עושה כוכב, חדש קו, כוכב, קו חדש, כוכב, קו חדש?
כן?
>> כן, בניגוד לשפה כמו פייתון, אם אתה מכיר,
כניסה לא משנה למחשב.
זה רק חשוב לאדם.
אז קווים ואילו כאן אני כבר המצאתי 15 ו16-- שנראים יפה,
אבל לא אכפת לי המחשב.
המחשב אכפת יש בעצם סוגריים מסולסלים
סביב שורות הקוד הללו.
>> אז שזה clear-- בדיוק כמו ב Scratch-- ששני קווים אלו של קוד
צריך להיות מוצא להורג.
כמו אחד מהפאזל הצהוב Scratch אלה חתיכות שוב ושוב ושוב.
>> זה אז עכשיו אם אני להפעיל מחדש program-- ./buggy-2-- Hm.
יש לי שגיאה עכשיו.
מה שכחתי לעשות?
כן, אז אני לא לקמפל אותו.
אז להפוך את המרכבה-2.
אין קובץ כזה, כי אני לא למעשה לקמפל את הגרסה השנייה.
אז עכשיו מעניין לא מוצהר variable-- לא 2.
אנחנו עושים 1.
הפוך ./buggy-1-- כרכרה-1-- ועכשיו כל אחד מהם הוא על אותו הקו.
>> עכשיו יש חריג ל התביעה אמורה הזה שלי
שאתה צריך סוגריים המסולסלים האלה.
מתי זה בעצם OK-- אם יש לך שם לב שבסעיף או textbooks--
להשמיט את הסוגריים המסולסלים?
כן?
>> בדיוק.
כאשר יש רק אחד שורת קוד ש
רוצה להיות מזוהים עם לולאה כמו בדוגמא הראשונה שלנו.
זה לגיטימי לחלוטין להשמיט את הסוגריים המסולסלים
בדיוק כמו סוג של נוחות מהמהדר לך.
כן?
שאלה טובה.
האם זה ייחשב שגיאה בסגנון?
היינו promote-- כמו בCS50 מדריך סגנון, את כתובת האתר שעבורו
הוא בpset1-- שתמיד להשתמש בסוגריים המסולסלים.
בוודאי אם אתה חדש בתכנות.
המציאות היא שאנחנו לא הולך לאסור אותך
מלעשות נוחות אלה.
אבל אם אתה רק מתחיל לתנופה של דברים,
בהחלט פשוט תמיד להשתמש במתולתל פלטה עד שאתה מקבל את העניין.
שאלה טובה.
>> בסדר.
כך שלאחר מכן היה באג.
לפחות במשהו פשוט למדי.
ובכל זאת אתה חושב שאולי זה הוא בסיסי למדי, נכון?
זה סוג של השבוע הראשון להסתכל על השפה
כמו, רואה באגים שלך בו.
אבל אלה המציאות הם נציג למעשה
של כמה בעיות די מפחידות שיכול להתעורר בעולם האמיתי.
>> אז כמה מכם אולי זוכרים אם אתה מבין את חדשות טק,
או אולי אפילו נתפס רוח של זה בחודש פברואר
של השנה האחרונה שהיה לי אפל עשה קצת טעות בשני iOS,
מערכת ההפעלה על הטלפונים שלהם, וגם
Mac OS, מערכת ההפעלה על המחשבים השולחניים והניידים שלהם.
ואתה ראה את כותרות כמו זו.
ולאחר מכן, אפל הבטחתי לתקן את הבאג הזה,
ועשה מהר מאוד לתקן את זה בiOS, אבל אז סופו של דבר זה קבוע בMac OS
גם כן.
>> עכשיו אף אחד מהכותרות הללו לבד באמת לגלות מה הייתה הבעיה הבסיסית,
אבל באג הופחת סופו של דבר ל באג בSSL, שכבת שקעים מאובטחים.
וסיפור ארוך קצר, זו היא התוכנה
שהדפדפנים שלנו ואחרים תוכנה המשמשת לעשות את מה?
>> אם אמרתי שSSL הוא מעורב, בכל פעם שאתה
לבקר URL המתחילה בHTTPS, מה אז אולי SSL להיות קשור ל?
הצפנה.
אז נדבר על זה בימים הקרובים.
הצפנה, האמנות ערבול מידע.
>> אבל סיפור ארוך קצרה, אפל מתישהו לפני שעשה טעות
ביישומם של SSL, תוכנה שסופו של דבר מיישמת
כתובות אתרים כמו HTTPS או מקסימום גם קשרים שיש.
התוצאה שלה היא ש חיבורים עלולים
ניתן ליירט.
ואת הקשרים שלך היו אינו מוצפן בהכרח
אם היה לך איזה בחור רע בבין אתה ואתר היעד ש
ידע איך לנצל את זה.
>> עכשיו אפל פורסם סופו של דבר לתקן לזה סוף סוף,
והתיאור של תיקונם היה זה.
תחבורה מאובטחת לא הצליחה לאמת האותנטיות של החיבור.
הנושא טופל על ידי שחזור צעדי אימות חסר.
>> אז זה הסבר גלי מאוד יד עבור פשוט אומר שאנחנו דפוקים.
יש פשוטו כמשמעו אחד שורת קוד שהיה מרכבה
ביישומם של SSL, ו אם אתם גולשים באינטרנט ולחפש את זה
למעשה אתה יכול למצוא קוד המקור המקורי.
לדוגמא, מדובר בצילום מסך של רק חלק מקובץ גדול למדי,
אבל זה פונקציה שנקראת ככל הנראה SSL לאמת החלפת מפתחות שרת סימן.
וזה לוקח חבורה של טיעונים ותשומות.
ואנחנו לא מתכוונים להתמקד יותר מדי על הפרטים הקטנים שם,
אבל אם אתה מתמקד בקוד בתוך של עליון שfunction-- בואו
להתמקד על ש.
ייתכן שכבר חושדים מה עלול השגיאה
אפילו אם אין לך מושג סופו של דבר מה שאתה מחפש ב.
יש סוג של אנומליה כאן, וזה מה ש?
>> כן, אני לא ממש אוהב המראה של שני goto נכשל.
למען האמת, אני לא ממש יודע מה goto להיכשל אמצעים, אבל יש שניים מהם
גב אל גב.
זה פשוט סוג של משפשף אותי מבחינה אינטלקטואלית בצורה לא נכונה,
ואכן אם להתמקד על רק את השורות האלה, זה הוא ג
>> אז הרבה קוד של אפל הוא עצמו נכתב בC,
וזה, ככל הנראה, הוא באמת equivalent--
לא שלכניסה היפה גרסה, אבל אם אתה מכיר בעובדה
שאין סוגריים מסולסלים, מה ש Apple באמת כתב היה קוד שנראה
כמו זה.
אז אני כבר זנקתי החוצה ואני פשוט קבוע הזחה במובן
כי אם אין סוגריים מסולסלים, ש goto השני ייכשל כי הוא בצהוב
הוא הולך לבצע ולא משנה מה.
זה לא קשור עם אם המצב מעליו.
>> אז גם שוב, אם אתה עושה לא ממש להבין מה זה אולי יכול
להיות עושים, יודע שכל אחד מאלה conditions-- כל אחד מהקווים הללו
הוא צעד חשוב מאוד בתהליך של בדיקה
אם הנתונים שלך הוא למעשה מוצפן.
אז מדלג על אחד מאלה צעדים, לא הרעיון הכי טוב.
>> אבל בגלל שיש לנו את זה goto השני ייכשל בצהוב,
וכי ברגע שאנו סוג של בחינה אסתטית
להזיז אותו לצד השמאל שבו מבחינה לוגית הוא ברגע, מה ש
זה אומר עבור הקו של קוד שלהלן שgoto השני
להיכשל היית חושב?
זה תמיד הולך להיות דילוג.
אז GOTOs בדרך כלל בעין יפה מסיבות שלא ממש ייכנסו ל,
ואכן בCS50 אנו נוטים שלא ללמדך לעמוד הצהרה זו,
אבל אתה יכול לחשוב על goto להיכשל כקפיצת דרכי משמעות
לחלק אחר של הקוד.
>> במילים אחרות לקפוץ מעל השורה האחרונה זה לגמרי,
ולכן התוצאה של זה טיפש טעות פשוטה שרק הייתה
תוצאה של כנראה מישהו העתקה והדבקה של אחד יותר מדי
פעמים רבות היו שכל ביטחון של iOS ומערכת ההפעלה Mac OS
היה פגיע ליירוט על ידי הרעים די הרבה זמן.
עד Apple לבסוף קבוע זה.
>> עכשיו, אם חלק מכם הוא למעשה בם פועלים גרסאות ישנות של iOS או Mac OS,
אתה יכול ללכת לgotofail.com ש הוא אתר אינטרנט שמישהו הקים
כדי לקבוע במהות תיכנותי
אם המחשב שלך הוא עדיין פגיע.
ולמען אמת, אם הוא, זה כנראה רעיון טוב
כדי לעדכן את הטלפון שלך או Mac שלך בשלב זה.
אבל יש, רק עדות לעד כמה הערכה של רמה הנמוכה אלה
פרטים ודי רעיונות פשוטים יכול באמת
לתרגם החלטות ובעיות ש
affected-- בcase-- זה מיליוני אנשים.
>> עכשיו מילה על ממשל.
סעיף יתחיל ביום ראשון הקרוב.
אתה תקבל הודעת דוא"ל על ידי סוף שבוע על סעיף, ובשלב זה
תהליך resectioning יתחיל אם יש לך
הבנתי עכשיו שיש לך כמה קונפליקטים חדשים.
אז זה קורה כל שנה, ואנחנו יהיה להתאים בימים הבאים.
>> משרד hours-- לעשות לשמור עין על לוח הזמנים הזה כאן.
משנה קצת השבוע, במיוחד את שעת ההתחלה
והמיקום, אז אל תתייעץ שלפני היציאה לשעתי עבודה
כל אחת מארבעה הלילות הבאים.
ועכשיו מילה על הערכה, במיוחד כפי שאתה לצלול לתוך בעיה
קובע אחת ומעבר.
>> אז למפרט, אלה הם בדרך כלל
הצירים שלאורכו אנו מעריכים את העבודה שלך.
היקף מתייחס למה כלי הקוד שלך במידה
התכונות הנדרשות על ידי המפרט שלנו.
במילים אחרות, עד כמה סט חתיכה עשה לך לנגוס.
האם אתה עושה שליש ממנו, חצי ממנו, ממנו 100%.
גם אם זה לא נכון, כמה עשה לך לנסות?
כדי שלוכד את הרמה מאמץ והסכום
שאליו אתה נגסת הבעיות של מערכת בעיה.
>> Correctness-- זה אחד, ל באיזו מידה, הוא הקוד שלך
עולה בקנה אחד עם שלנו מפרטים וללא באגים.
אז זה עובד בצורה נכונה?
אם אנחנו נותנים לו קצת קלט, עושה את זה לתת לנו את התפוקה שאנחנו מצפים?
Design-- עכשיו זה הוא ראשון מ במיוחד איכותיים אלה,
או את אלה שדורשים שיקול דעת אנושית.
ואכן, זו הסיבה שיש לנו צוות של עמיתי הוראה כל כך הרבה וכמובן
עוזרים.
באיזו מידה היא שלך קוד כתוב היטב?
>> ושוב, זה מאוד הערכה איכותית
שיעבוד איתך על דו directionally בשבועות קרוב.
כך שכאשר אתה מקבל לא רק ציונים מספריים, אלא גם
ציונים שנכתבו, או משוב שהוקלד, או בכתב משוב במילים באנגלית.
זה מה שאנחנו נשתמש להסיע אותך כיוון בעצם כתיבת קוד טוב יותר.
ובהרצאה וסעיף, ננסה להצביע לעתים קרובות ככל שאנו can-- out--
מה שעושה את תכנית לא רק נכון וטוב מבחינה תפקודית,
אבל גם מתוכנן היטב.
היעילה ביותר זה יכול להיות, או אפילו היפה ביותר שהוא יכול להיות.
>> מה שמוביל אותנו לסגנון.
סגנון סופו של דבר הוא שיפוט אסתטי.
האם לבחור בטוב שמות למשתנים שלך?
האם מסוכסך הקוד שלך כמו שצריך?
זה נראה טוב, ולכן, זה קל לאדם אחר
לקרוא בהתאמה שלך תקינותה.
>> עכשיו, בדרך כלל, ללימודים, אנו להבקיע את הדברים האלה בסולם של חמש נקודות.
ותן לי פטיש בית הנקודה כי שלוש הוא אכן טוב.
לעשות מהר מאוד אנשים להתחיל לעשות חשבון.
כשהם מגיעים שלוש מתוך חמש על נכונות לכמה pset
והם חושבים לעזאזל, אני הולך 60% שהיא במהות D או E.
>> זה לא הדרך בה אנו חושב על המספרים האלה.
שלושה הוא אכן טובים, ומה שאנו בדרך כלל מצפים בתחילת
במונח זה הוא שאם אתה מקבל חבורה של three's-- אולי כמה
ירידים, כמה fours-- או כמה זוגות, כמה fours--
זה מקום טוב להתחיל.
וכל כך הרבה זמן כפי שאנו רואים מסלול כלפי מעלה לאורך זמן,
אתה במקום טוב במיוחד.
>> נוסחתו אנו משתמשים כדי דברים במשקל הוא למעשה
זה לתכנית הלימודים, אשר רק אומר שאנחנו
לתת משקל רב יותר לתקינות.
כי זה מאוד לעתים קרובות תקינות שלוקח את רוב הזמן.
תאמין לי עכשיו.
אתה find-- לפחות בpset-- אחד שאתה
לבלות 90% מהזמן שלך עובד על 10% מהבעיה.
>> וכל מה שסוג של עובד למעט אחד או שניים באגים,
ואלה הם באגים ש אשמור אותך ער עד מאוחר בלילה.
אלה הם אלה ש סוג של בריחתך.
אבל אחרי השינה על זה, או ללמוד בשעות עבודה
או לשאול שאלות באינטרנט, הוא כשאתה מגיע למטרה ש100%,
וזו הסיבה שאנו במשקל התקינות ביותר.
עיצוב קצת פחות, ו סגנון קצת פחות מזה.
אבל לשמור על סגנון mind-- אולי הקל ביותר
אלה כדי לנגוס כמו לכל מדריך הסגנון.
>> ועכשיו, יותר רציני לב על יושר אקדמי.
יש CS50 ההבחנה המצערת של להיות היצרנית הגדולה ביותר של מודעות לוח
מקרים כמעט בכל שנה מבחינה היסטורית.
זה לא בגלל תלמידים לרמות ב CS50 כל, יותר מכל כיתה אחרת,
אלא משום שעל ידי אופי העבודה, העובדה שזה אלקטרוני,
העובדה שאנחנו מחפשים אותו, ו העובדה שאנחנו מדעני מחשב,
אני יכול לומר שאנחנו, למרבה הצער טוב מאוד באיתורו.
>> אז מה זה אומר במונחים ריאליים?
אז זה, לתכנית הלימודים, הפילוסופיה של הקורס
באמת מסתכם להיות סביר.
יש את הקו הזה שבין עושה את העבודה של אחד בעצמך
ומקבל קצת עזרה סבירה מידיד,
ועל הסף עושה את העבודה עבורך חבר, או שולח לו או לה את הקוד שלך
כך שפשוט שהוא או היא יכולה לקחת או ללוות אותה נכונה.
וזה חוצה את הקו שצוירנו בכיתה.
>> ראה, תכנית הלימודים סופו של דבר לקווים
כי אנו מפנים כסבירים והתנהגות בלתי סבירה,
אבל זה באמת עושה רתיחה עד למהות
העבודה שלך צורך להיות שלך בסופו של הדבר.
כעת, עם שאמרו, יש היוריסטי.
כי כמו שאתה עלול imagine-- משעתי עבודה והחזותיות
וקטעי הווידאו יש לנו CS50 כך far-- מוצג
נועד אכן להיות כשיתופי ושיתופי וכחברתי כ
ככל האפשר.
כשיתוף פעולה כפי שהוא קפדני.
>> אבל עם זה אמר, היוריסטי, כפי שתראה בתכנית הלימודים,
הוא שכאשר אתה נתקלת בבעיה כלשהי.
יש לך כמה באגים בקוד שלך שאתה לא יכול לפתור, זה סביר בשבילך
כדי להראות את הקוד שלך למישהו אחר.
חבר גם בכיתה, חבר יושב לידך בשעתי עבודה,
או חבר צוות.
אבל הם לא יכולים להציג את הקוד שלהם אליך.
>> במילים אחרות, לענות לquestion-- שלך
אני צריך help-- לא הו, הנה הקוד שלי.
תסתכל על זה ו להסיק מזה איך שתרצה.
עכשיו, כמובן, יש דרך ברורה למשחק
מערכת זו לפיה אני אראה לך הקוד שלי לפני שיש שאלה.
אתה תראה לי את הקוד שלך שלי לפני שיש שאלה.
אבל לראות את הסילבוס שוב ל פרטים עדינים של איפה הקו הזה הוא.
>> רק עכשיו לצייר את התמונה ו לשתף כשקוף ככל האפשר
איפה אנחנו נמצאים בשנים האחרונות, זה מספר מקרי מודעות לוח
CS50 שיש לו מעל העבר שבע שנים.
עם 14 מקרים נפילה האחרונה זו.
במונחים של התלמידים המעורבים, זה היה 20 כמה תלמידים מוזרים
בסתיו האחרון.
היה שיא של 33 סטודנטים לפני כמה שנים.
רבים מהם, למרבה הצער כבר לא כאן בקמפוס.
>> תלמידים מעורבים כאחוז מ כיתה שנעה מבחינה היסטורית בין 0%
ל5.3%, וזה רק כדי לומר זו היא שנה אתגר.
ולקראת הסוף ש, מה אנחנו רוצים לעשות הוא להעביר אחד
שdd-- רק FYI-- להשוות ב הגינות לתלמידים אלה ש
הם הבאים בתור בהתאם.
אנו עושים להשוות את כל נוכחי הגשות נגד כל המשימות האחרונות
מהשנים רבות בעבר.
>> אנחנו יודעים גם איך גוגל סביב ולמצוא מאגרי קוד
פורומים באינטרנט, דיון אתרי עבודה באינטרנט, באינטרנט.
אם תלמיד יכול למצוא אותו, אנחנו בוודאי יכולים מוצא את זה הרבה כמו שאנחנו בצער לעשות.
אז מה תראה בתכנית הלימודים למרות שהוא סעיף החרטה הזה.
בהחלט אני יכול מעריך, וכולנו יש
צוות שעשה את הקורס כמו זה, או זה עצמו לאורך זמן,
בהחלט יודעים מה זה כש חיים מקבלים את הדרך כאשר יש לך
כמה מאוחר בלילה deadline-- לא רק במעמד הזה,
אבל another-- כשאתה מותש לחלוטין, לחוץ,
יש לי מספר מופרז של דברים אחרים לעשות.
אתה תעשה בשלב כלשהו ב חיים בהחלט רעים, אולי מאוחר
החלטת הלילה.
>> אז לכל תכנית הלימודים, יש סעיף זה,
כך שאם בתוך 72 שעות של עשייה כמה החלטות גרועות, בבעלות אותך אליו
ולהגיע אליי ו אחד מהראשים של הקורס
ואהיה לנו שיחה.
אנו אטפל בדברים באופן פנימי בתקווה
זה הופך להיות יותר של רגע הוראה או לקח חיים,
ולא משהו עם השלכות במיוחד דרסטית
כפי שהיה אפשר לראות בתרשימים אלה כאן.
>> אז זה טון רציני מאוד.
בואו נעצור רק לכמה שניות כדי לשבור את המתח.
>> [השמעת מוסיקה]
>> דוד י מלאן: בסדר, אז איך זה היה עבור Segue?
לנושאים העיקריים של היום.
הראשון שבם הוא הפשטה.
נוסף של שהולך להיות ייצוג של נתונים, אשר בכנות
היא באמת דרך יבשה לומר איך אנחנו יכולים ללכת על פתרון בעיות וחשיבה
על פתרון בעיות?
אז אתה ראית בגירוד, ושיש לך ראה אולי כבר בpset1 עם C
כי אתה לא יכול להשתמש רק פונקציות, כמו printf,
שאנשים אחרים ב שנים האחרונות כתב בשבילך.
אתה יכול גם לכתוב פונקציות משלך.
>> ואף על פי שייתכן שאין לי עשה את זה בC, ולמען אמת בpset1
אתה לא באמת צריך לכתוב שלך פונקציה עצמו כי problem--
בעוד אולי מרתיע ב glance-- הראשון שתראה
סופו של דבר ניתן לפתור עם לא קווים כל שרבים מקוד.
אבל עם שאמרו, במונחים כתיבת פונקציה משלך,
מבין שC אין לתת אתה יכולת זו.
>> אני הולך ללכת בקוד המקור של היום, שכבר זמין כיום באינטרנט,
ואני הולך קדימה ופתוח עד תכנית בשם 0.C פונקציה,
ובפונקצית אפס אנחנו תראו כמה דברים.
בשורות הראשונות 18 דרך 23 היא הפונקציה העיקרית שלי.
ועכשיו שאנחנו מתחילים לקרוא קוד שאנחנו לא כותבים על לטוס,
אבל במקום שכתבתי מראש או שאתה בבעיה להגדיר
עשוי לקבל שיש נכתב מראש.
דרך טובה להתחיל קריאת קוד של מישהו אחר
הוא לחפש את הפונקציה העיקרית.
להבין איפה כניסה ש נקודה היא מפעיל את התכנית,
ולאחר מכן בצע אותו באופן לוגי משם.
>> אז תכנית זו הדפסים כנראה השם שלך ואחריו נקודתיים.
לאחר מכן אנו משתמשים בGetString מספריית CS50
כדי לקבל מחרוזת, או מילה או צירוף מילים מהמשתמש במקלדת.
ואז יש את זה PrintName here-- דבר.
>> עכשיו PrintName הוא לא פונקציה שמגיעה עם ג
זה לא בio.h. הסטנדרטי
זה לא בCS50.h.
זה די באותו הקובץ.
שים לב אם אני לגלול למטה קווי bit-- 25 ל27--
זה פשוט דרך יפה של להעיר הקוד שלך באמצעות הכוכבים וחתכים.
זהו קו רב להגיב, וזה רק
התיאור שלי בכחול של מה הפונקציה הזו עושה.
>> כי בקווי 28 דרך 31 ב, אני כתבתי פונקצית סופר פשוטה
ששמה PrintName.
זה לוקח כמה טיעונים הייתם אומרים?
אז argument-- אחד כי יש אחד טיעון מופיע בתוך הסוגריים.
סוג שהוא מחרוזת.
כלומר PrintName הוא כמו קופסא שחורה זה
או פונקציה שלוקחת כקלט מחרוזת.
>> ואת השם של מחרוזת ש נוח יהיה שם.
לא S, לא N, אבל שם.
אז מה עושה PrintName לעשות?
זה פשוט נחמד.
בדיוק כמו שורת קוד אחת ל printf, אבל כנראה שזה
מדפיס את "שלום," כך וכך.
איפה כך וכך מגיע מהטיעון.
>> עכשיו זה לא חדשנות עצומה כאן.
באמת, אני כבר לקחתי תכנית שיכלה נכתב עם שורה אחת של קוד
על ידי הצבת זה כאן, ושיניתי אותו למשהו
שיש בו כשישה או שבע או משהו כזה שורות קוד כל הדרך למטה כאן.
>> אבל זה התרגול של העיקרון הידוע כהפשטה.
סוג של מתמצת בתוך חדש פונקציה שיש לו שם, וטוב יותר
עדיין שם שממש אומר מה שהוא עושה.
אני מתכוון printf-- זה לא במיוחד תיאורים.
אם אני רוצה ליצור פיסת הפאזל, או אם אני
רוצה ליצור פונקציה שמדפיס את שמו של מישהו,
היופי של עושה את זה הוא שאני באמת יכול
לתת פונקציה ששם שמתאר את מה שהיא עושה.
>> עכשיו זה לוקח בקלט ש אני כבר נקרא באופן שרירותי את השם,
אבל גם זה בצורה נפלאה תיאורים במקום להיות קצת יותר
כללי כמו ס 'ו חלל, לעת עתה, רק אומר
שפונקציה זו אינה למסור לי את דבר.
זה לא כמו GetString ש פשוטו כמשמעו מושיט לי חזרה מחרוזת
כמו שעשינו עם פיסות נייר עם החברים לכיתה שלך בשבוע שעבר,
אלא פשוט יש תופעת לוואי.
היא מדפיסה משהו על המסך.
>> אז בסופו של היום, אם אני עושה פונקציה-0, ./function-0,
אנחנו תראו שהוא מבקש את השם שלי.
אני מקליד דוד, וזה סוגים את השם שלי.
אם אני עושה את זה שוב עם רוב, זה הולך לומר "שלום, רוב."
אז רעיון פשוט, אבל אולי להסיק מזה נפשי
שהתוכניות שלך לקבל קצת יותר מסובך,
ואתה רוצה לכתוב נתח של קוד ושיחה שcode-- Invoke
code-- שעל ידי כמה תיאורים שם כמו PrintName,
C עושה להרשות לנו את היכולת הזו.
>> הנה עוד דוגמא פשוטה.
לדוגמא, אם אני פותח את להגיש מהיום נקרא return.c,
שים לב למה שעשיתי כאן.
רוב הפונקציה העיקרית זו הוא printf.
אני ראשון באופן שרירותי לאתחל משתנה בשם x למספר 2.
אני מכן להדפיס את "x הוא עכשיו % I "עוברים בערכו של x.
כל כך פשוט שאני אומר מה שזה.
>> עכשיו אני רק באומץ טענה עם printf.
אני cubing שx הערך, ואני עושה זאת על ידי קורא לפונקציה
נקרא חולף קובייה בx כטיעון,
ולאחר מכן לשמור את הפלט במשתנה עצמו, x.
אז אני מחצתי את הערך של x.
אני דריסה ערך של x עם כל מה ש
התוצאה של קריאה פונקצית קובייה זו היא.
ואז אני פשוט להדפיס את חלק דברים רכים כאן ואומרים את מה שעשיתי.
>> אז מה אז היא קובייה?
שים לב מה ביסודו שונה כאן.
אני נתתי את הפונקציה שם כמו קודם.
אני כבר צוין שם לויכוח.
הפעם זה נקרא n במקום שם, אבל אני יכול לקרוא לזה מה שאני רוצה.
אבל פעם זה שונה.
הדבר הזה בצד השמאל.
בעבר זה היה מה מילת המפתח?
בנים.
עכשיו זה ברור int.
>> אז מה אולי לקחת?
בעוד מסמל חלל סוג של האין, וזה היה המקרה.
PrintName חזר שום דבר.
זה עשה משהו, אבל זה לא נותן לי גב
משהו שאני יכול לשים על צדו השמאלי של סימן שוויון
כמו שעשיתי כאן על קו 22.
>> אז אם אני אומר לעל קו 30, מה שכנראה רומז
על מה קובייה עושה לי?
כן?
זה מחזיר מספר שלם.
אז זה מחזיר לי, ל למשל, פיסת נייר
שבו כתב את התשובה.
2 קוביות, או 3 קוביות, או 4 cubed-- כל מה שאני עובר ב,
ואיך אני לא ליישם את זה?
ובכן, רק n פעמים n פעמים n איך אני יכול קוביית ערך.
אז שוב, סופר פשוט רעיון, אבל הפגנתי
עכשיו איך אנחנו יכולים לכתוב פונקציות כי בעצם לא הייתה לנו בחזרה
ערכים שעשויות להיות מעניין.
>> בואו נסתכל על דוגמא אחת האחרונה כאן נקרא פונקציה אחת.
בדוגמא זו, הוא מתחיל כדי לקבל יותר משכנע.
אז בפונקציה אחת, זה הודעת program-- סופו של דבר
קורא פונקציה שנקראת GetPositiveInt.
GetPositiveInt הוא לא פונקציה בספריית CS50,
אבל החלטנו שאנחנו היית רוצה שזה קיים.
>> אז אם אנחנו לגלול למטה מאוחר יותר בקובץ, שימו לב כיצד הלכתי על יישום
לקבל int החיובי, ואני אומר שזה יותר משכנע
בגלל זה הוא הגון מספר שורות קוד.
זה לא רק טיפשי תכנית צעצוע קטנה.
זה בעצם יש כמה בדיקת שגיאות ועושה משהו מועיל יותר.
>> אז אם כבר לא ראה את ההדרכה קטעי וידאו שיש לנו מוטבע בpset1,
יודע שזה סוג של לולאה בC, דומה ברוח
למיני סריטות דברים יכולים לעשות.
ולעשות אומר לעשות את זה.
להדפיס את זה.
אז קדימה ולקבל n-- לקבל int ולאחסן אותו בn,
ולהמשיך לעשות את זה שוב ושוב ו שוב, כל עוד n הוא פחות מאחוז אחד.
>> אז n הולך להיות פחות מאחד רק אם האדם לא משתף פעולה.
אם הוא או היא היא להקליד ב0 או -1 או -50,
לולאה זה הולכת לשמור ביצוע שוב ושוב.
וסופו של דבר שמתי לב, אני פשוט להחזיר את הערך.
אז עכשיו יש לנו פונקציה כי כבר היה נחמד
אם CS50 היה ליישם ב CS50.h וCS50.c בשבילך,
אבל כאן אנחנו יכולים עכשיו ליישם את זה לעצמנו.
>> אבל שתי הערות על כמה פרטים חשובים.
One-- למה אני מצהיר int n, אתה חושב ש, על קו 29
במקום רק עושה זה כאן, שהוא
מתיישב יותר עם מה שעשינו בשבוע שעבר?
כן?
מחשבה טובה.
אז אם היינו לשים את זה כאן, זה כאילו שאנחנו
לשמור הכריז עליו שוב ושוב.
שבפני עצמו הוא לא בעייתי, כשלעצמה,
כי אנחנו צריכים רק הערך פעם אחת ולאחר מכן
אנחנו הולכים לקבל אחד חדש בכל מקרה.
אבל מחשבה טובה.
כן?
>> לסגור.
אז בגלל שאני כבר הכריז n על שורה 29 מחוץ ללולאה,
זה נגיש בכל רחבי כל פונקציה זו.
לא פונקציות אחרות כי n הוא עדיין בתוך מתולתל אלה
פלטות כאן.
So-- בטוח.
>> בדיוק.
אז זה עוד יותר לנקודה.
אם אנחנו במקום שהוכרזו n ממש כאן על קו 32,
זה בעייתי כי ניחוש איפה עוד אני צריך לגשת אליו?
על קו 34, ו כלל אצבע פשוט הוא
כי אתה יכול להשתמש רק משתנה בתוך הסוגריים המסולסלים האחרונים
שבו אתה הכריז עליה.
>> למרבה הצער, שורה 34 היא שורה אחת מאוחר מדי,
כי אני כבר סגור הסד המתולתל על קו 33
שמתאים ל סד מתולתל על קו 30.
ואז זה דרך לומר שint משתנה זה scoped,
אם אפשר לומר כך, רק בתוך של סוגריים המסולסלים אלה.
זה פשוט לא קיים מחוץ להם.
>> אז אכן, אם אני עושה את זה בסדר, תן לי לשמור את הקוד
כפי שis-- באופן שגוי שנכתב.
תן לי ללכת קדימה ועושים פונקציה-1, ושגיאת notice--.
שימוש בn מזהה לא מוצהר על קו 35, שנמצא ממש כאן.
ואם אנחנו לגלול מעלה נוסף, עוד אחד.
שימוש בלא מוצהר n מזהה על קו 34.
>> אז מהדר, קלאנג, הוא שם לב שזה פשוט
לא קיימת למרות ש ברור שהוא שם מבחינה ויזואלית.
אז פשוט לתקן מכריז אותו שם.
>> עכשיו תנו לי לגלול ל החלק העליון של הקובץ.
מה קופץ עליך כ להיות קצת שונה
מהדברים שאנחנו נראים בשבוע שעבר?
יש לי שם, לא רק לעשות לא רק יש לי קצת חד כולל למעלה,
יש לי משהו שאני קורא אב טיפוס.
עכשיו זה נראה נורא דומה למה ש ראינו רק לפני רגע על קו 27.
>> אז בואו להסיק משונה הודעת שגיאה למה עשיתי את זה.
תן לי ללכת קדימה ו למחוק את השורות האלה יש.
וכך אנו לא יודעים כלום על אב טיפוס.
מהדורה מחודשת בקובץ זה.
הפוך פונקציה אחת.
ועכשיו, לעזאזל, ארבע שגיאות.
בואו לגלול עד ראשון.
>> הצהרה סמויה של פונקציה לקבל int החיובי הוא לא חוקי בC99.
C99 רק אומר 1999 גרסה של השפה
C, וזה מה שאנחנו משתמשים אכן.
אז מה זה אומר?
ובכן C-- ובאופן ספציפי יותר C compilers-- תוכניות די טפשים.
הם יודעים רק את מה שיש לך אמר להם, וזה
נושאיות למעשה משבוע שעבר.
>> הבעיה היא שאם אני הולך על יישום שם עד כאן,
ואני קורא לפונקציה שנקראת GetPositiveInt כאן על קו 20,
הפונקציה שעושה מבחינה טכנית לא קיימים עד מהדר רואה שורה 27.
לרוע המזל, מהדר הוא עושה דברים העליונים, למטה, שמאלה, ימינה,
כך משום שהוא לא ראה את יישום GetPositiveInt,
אבל זה רואה אותך מנסה כדי להשתמש בו עד כאן,
זה פשוט הולך bail-- לצעוק על אולי לך עם שגיאת message--
נסתר, ולא ממש לקמפל את הקובץ.
>> אז אב טיפוס עד שנקרא כאן הוא אמנם מיותר.
פשוטו כמשמעו, הלכתי לכאן והעתקתי ולהדביק את זה, ואני אשים אותה כאן.
Void יהיה נכון יותר, כך יהיו לנו פשוטו כמשמעו להעתיק ולהדביק את זה הפעם.
אני ממש להעתיק ולהדביק אותו.
באמת רק ככמו פירור לחם.
>> רמז קטן למהדר.
אני לא יודע מה זה עושה עדיין, אבל אני מבטיח לך
שזה יהיה קיים סופו של דבר.
וזה למה זה line-- ב שורת 16-- מסתיימת בנקודת פסיק.
זה מיותר על ידי עיצוב.
כן?
>> אם לא לקשר את הספרייה שלך לthe-- הו, שאלה טובה.
שארפ כולל תכלילים קובץ הכותרת.
צריך be-- צריך כמעט תמיד להיות בחלקו העליון
של הקובץ לsimilar-- ל בדיוק מאותה הסיבה, כן.
מכיוון שבתקן io.h הוא, פשוטו כמשמעו, קו
כמו זה, אבל עם המילה printf, ו עם הטיעונים שלה וטיפוס ההחזרה שלה.
וזאת על ידי עושה חד לכלול עד כאן, מה שאתה ממש עושה
הוא העתקה והדבקה של התוכן של מישהו אחר כתב למעלה.
כך cluing את הקוד שלך ל עובדה שפונקציות אלה אכן קיימות.
כן?
>> בהחלט.
אז מאוד חכם ונכון פתרון יהיה, אתה יודע מה?
אני לא יודע מה אב טיפוס הוא, אבל אני יודע ש
אם אני מבין את זה C הוא רק מטומטם וrethinks מלמעלה למטה.
ובכן בואו לתת לו מה שהוא רוצה.
בואו לחתוך קוד ש, להדביק אותו עליון, ועכשיו לדחוף עיקרי למטה.
גם זה יפתור את הבעיה.
>> אבל אתה יכול מאוד בקלות לבוא עם תרחיש שבו צריך לקרוא ב ',
ואולי B מתקשר בחזרה לא זה הוא משהו שנקרא רקורסיה,
ואנחנו נחזור לזה.
וזה יכול או לא יכול להיות טוב דבר, אבל אתה בהחלט יכול
לשבור את הפתרון הזה.
>> ויותר מכך, הייתי טוען סגנונית,
במיוחד כאשר התוכניות שלך להיות כל כך הרבה זמן וכל כך הרבה זמן,
זה פשוט סופר נוח לשים ראשי בחלק העליון
כי זה הדבר הכי מתכנתים הולכים אכפת.
ואז זה קצת יותר נקי, ניתן לטעון, לעשות את זה בדרך
אני במקור עשיתי את זה עם אב טיפוס אפילו
למרות שזה נראה קצת מיותר במבט ראשון.
כן?
מצטער, אתה יכול להגיד את זה בקול רם?
>> אם תעבור את מיקומם של יישום ואב הטיפוס?
כך שזו שאלה טובה.
אם אתה מחדש להכריז על זה למטה כאן, בואו לראות מה קורה.
אז אם אני מניח את זה כאן, אתה אומר.
אה, סליחה.
בקול רם יותר?
אפילו בקול רם יותר.
אה, שאלה טובה.
האם זה יבטל את הפונקציה?
אתה יודע, אחרי כל השנים האלה, אני מעולם לא הכניס את אב טיפוס לאחר מכן.
אז בואו לעשות לעשות פונקציה-1 אחרי עושה את זה.
>> [ממלמל]
דוד י מלאן: אה, רגע.
עדיין יש לנו לשים את הכל למעלה.
אז בואו נעשה את זה כאן, אם אני הבנת השאלה שלך בצורה נכונה.
אני שם את הכל, כולל אב הטיפוס מעל עיקרי,
אבל אני שם את אב הטיפוס מתחת ליישום.
>> אז אם אני עושה אחד, אני מקבל בחזרה n משתנה שאינו בשימוש error--.
אה, יש.
תודה לך.
בואו נראה, שנפטרנו מזה.
זה באג שונה, אז בואו נתעלם מכך.
בואו באמת מחדש במהירות זו.
>> אוקיי, אז ויכוח לא נתונים בשימוש על ידי מחרוזת פורמט
n-- הו, זה בגלל ש שיניתי לאלה כאן.
בסדר, אנחנו יודעים מה התשובה הולך to-- בסדר, הנה זה באנו.
אה, תודה על החיובית.
בסדר, אני אסדר את הקוד הזה after-- להתעלם באג המסוים הזה
מאז זה was-- זה עובד הוא התשובה.
>> אז זה לא לדרוס מה בדיוק עשית.
אני חושד מהדר כתוב בצורה כזאת
שהוא מתעלם מאב הטיפוס שלך מכיוון שהגוף, אם אפשר לומר כך,
של הפונקציה יש כבר יושם עד גבוה.
הייתי צריך להתייעץ למעשה המדריך של המהדר
כדי להבין אם יש אחר משמעות, אבל במבט הראשון
רק על ידי מנסה ומתנסים, נראה שיש לא הייתה השפעה.
שאלה טובה.
>> אז בואו לפרוץ קדימה עכשיו, נעו מתופעות לוואי ש
הן פונקציות שעושות דבר כזה מבחינה ויזואלית על המסך עם printf,
אבל לא מחזיר ערך.
ויש פונקציות שתמורה ערכים כמו שרק ראו כמה.
אנחנו כבר ראינו את המושג הזה של היקף, ואנו רואים את זה שוב ושוב.
אבל לעת עתה, שוב, להשתמש כלל אצבע
שמשתנה יכול לשמש רק בתוך נפתח לאחרונה
וסוגריים מסולסלים סגורים כפי שאנו ראה בדוגמא מסוימת ש.
>> וכפי שציינת, יש ability--
אתה יכול לפתור חלק מבעיות אלה על ידי הצבת משתנה ברחבי העולם
בחלקו העליון של קובץ.
אבל כמעט בכל המקרים היינו זעפתי על ש,
ואפילו אכן לא ללכת לפתרון כי לעת עתה.
אז לעת עתה, טייק אוויי היא ש יש לי משתנים רעיון זה של היקף.
>> אבל עכשיו בואו נסתכל על עוד דרך יבשה של מחפש למעשה
בחלק מעניין למדי פרטי יישום.
איך אנחנו יכולים לייצג מידע.
ואנחנו כבר הסתכלנו על זה בשבוע של המחלקה הראשונה.
כאשר מסתכל על קבצים בינאריים, ו להזכיר לעצמנו של עשרוני.
>> אבל זוכר משבוע שעבר שC יש סוגי נתונים שונים ואשכולות יותר,
אבל השימושי ביותר לעת עתה עשוי להיות אלה.
Char, או אופי, וזה קורה להיות בית אחד, או בסך הכל פיסות שמונה.
וזה אומר שהגודל של char הוא רק בית אחד.
בתים הוא שמונה סיביות, ולכן זה אומר ש אנחנו יכולים לייצג תווים כמה.
כמה אותיות או סימנים במקלדת
אם יש לנו בית אחד או שמונה סיביות.
היזכר בשבוע שאפס.
אם יש לך שמונה סיביות, כמה ערכים מוחלט
אתה יכול לייצג עם דפוסים של אפסים ואחדים?
One-- יותר מזה.
אז 256 סך הכל אם אתה תתחיל לספור מאפס.
אז אם יש לך שמונה bits-- כך שאם אנחנו היה לי הנורות בינארי שלנו כאן שוב,
אנחנו יכולים להפוך את הנורות אלה על ואת בכל 256 דפוסים ייחודיים.
>> עכשיו זה קצת בעייתי.
לא כל כך הרבה לאנגלית ו שפות רומנטיקה, אבל בהחלט
כאשר אתה מציג, ל למשל, שפות אסיאניות, ש
יש הרבה יותר סימנים מאשר כמו 26 אותיות האלפבית.
אנחנו בעצם אולי צריכים יותר מ ייט אחד.
ותודה לאל ב יש שנים האחרונות חברה
סטנדרטים אחרים אימצו המשתמשים בתים יותר מפעם אחת לכל תשלום.
>> אבל לעת עתה בC, ברירת המחדל רק בית אחד או שמונה סיביות.
שלם, בינתיים, הוא ארבעה בתים, הידוע גם ב32 סיביות.
מה שאומר מה הגדול ביותר האפשרי מספר שאנחנו יכולים לייצג עם int
ככל הנראה?
עם מיליארדים.
אז זה ארבעה מיליארדים פחות או יותר.
2 בחזקת 32th, אם תניח שלא מספרים שליליים
ורק להשתמש בכל חיובי מספרים, שזה ארבעה מליארד
לתת או לקחת אפשרויות.
לצוף, בינתיים, הוא סוג שונה מסוג הנתונים ב C. זה עדיין מספר,
אבל זה מספר אמיתי.
משהו עם נקודה עשרונית.
ומתברר ש C גם משתמש בארבעה בתים
לייצג ערכי נקודה צפו.
>> לרוע המזל כמה צף ערכי נקודה יש ​​בעולם?
כמה מספרים ממשיים יש?
יש אינסוף מספר, ולצורך עניין
יש מספר אינסופי של מספרים שלמים.
אז אנחנו כבר סוג של לחפור לעצמנו בור כאן.
לפי הנראה בcomputers-- ב תוכניות לפחות נכתבו בC ב them--
רק יכול לסמוך גבוה ככל ארבעה מיליארדים פחות או יותר,
וערכי נקודה צפה רק יכול, ככל הנראה,
יש כמות סופית של דיוק.
רק ספרות כל כך הרבה אחרי הנקודה העשרונית שלהם.
>> כי, כמובן, אם יש לך רק 32 סיביות,
אני לא יודע איך אנחנו הולכים ללכת על מייצג אחר מספרים אמיתיים כנראה
עם סוגים שונים של דפוסים.
אבל יש בוודאי סופי מספר הדפוסים כאלה,
אז הנה, גם זה בעייתי.
>> עכשיו אנחנו יכולים למנוע את הבעיה במקצת.
אם אתה לא משתמש במצוף, אתה יכול להשתמש כפול
בC, אשר נותן לך שמונה בתים, ש הוא דרך עוד דפוסים אפשריים של אפסים
ואלה.
אבל זה עדיין סופי, שהוא הולך להיות בעייתי אם אתה כותב תוכנה
לגרפיקה או למפואר נוסחות מתמטיות.
אז ייתכן שבאמת רוצה לספור עד יותר גדול מזה.
Named-- ארוך long-- טיפשות גם שמונה בתים, או 64 סיביות,
וזה פעמיים כל עוד int, וזה למספר שלם ארוך.
>> fact-- כיף אם int הוא ארבעה בתים, כמה זמן הוא ארוך בC בדרך כלל?
גם ארבעה בתים, אבל ארוך ארוך הוא שמונה בתים,
וזה מסיבות היסטוריות.
>> אבל האוכל המוכן עכשיו רק יש לו נתונים ש
להיות מיוצג בcomputer-- זה מכשיר פיזי עם חשמל,
זה בדרך כלל נוהג אלה אפסים וones--
עם כמויות מוגבלת של דיוק.
אז מה הבעיה אם כך?
>> ובכן יש בעיה של גלישת מספר שלם.
לא רק בC, אבל ב מחשבים באופן כללי.
לדוגמא, אם זה הוא בתים בשווי bit--
כך שאם זה שמונה כל bit-- מהם המספר אחד.
מה מספר זה מייצג אם נניח
זה כל הערכים החיוביים בינארי?
>> 255, וזה לא 256, כי אפס הוא המספר הנמוך ביותר.
אז 255 הוא הגבוהים ביותר אחד, אבל הבעיה
הוא מניח שאני רוצה להגדיל משתנה זה ש
משתמש שמונה סיביות יסתכם אם אני רוצה להגדיל אותו.
>> ובכן ברגע שאני מוסיף אחד לכל אלה אלה,
אולי אתה יכול לדמיין visually-- רק כמו שנשא את אחד באמצעות decimals--
משהו הולך לזרום לשמאל.
ואכן, אם אני מוסיף את המספר אחד לזה, מה שקורה בינארי
הוא שזה עולה על גדותיו בחזרה לאפס.
>> אז אם אתה use-- לא רק int, אבל לבית אחד לספור מספרים שלמים
בתכנית, על ידי default-- בהקדם אתה מקבל 250, 251, 252, 253, 254,
255-- 0 מגיע לאחר 255, שהוא כנראה לא מה ש
משתמש הוא הולך לצפות.
>> עכשיו בינתיים בצפתי עולם נקודה, גם יש לך בעיה דומה.
לא כל כך הרבה עם number-- הגדול למרות שזה עדיין בעיה.
אבל עם הכמות של דיוק שאתה יכול לייצג.
אז בואו נסתכל על דוגמא זו כאן גם מcode-- המקור של היום
לצוף-0.c.
>> ותשים לב שזה סופר תכנית פשוטה ש
כנראה צריך להדפיס את מה הערך?
מה אתה מתערב זה הולך להדפיס אף על פי שיש קצת של תחביר החדש
כאן?
אז אני מקווה 0.1.
אז המקביל של עשירית בגלל שאני עושה 1 מחולק ב10.
אני אחסון התשובה במשתנה שנקרא f.
משתנים זה של הטיפוס float, ש הוא מילת מפתח אני רק הצעתי היה קיים.
>> אנחנו כבר לא ראינו את זה קודם, אבל זה הוא סוג של דרך מסודרת בprintf
כדי לציין ספרות כמה אתה רוצה לראות אחרי נקודה עשרונית.
אז סימון זה רק אומר כי הנה מציין מיקום.
זה לנקודה צפה ערך, והו, דרך אגב,
להראות את זה עם הנקודה העשרונית עם מספר אחד אחרי הנקודה העשרונית.
אז זה המספר של ספרות משמעותית,
אם אפשר לומר כך, כי ייתכן שתרצו.
>> אז תן לי ללכת ולעשות להפוך את מצוף-0, ./float-0,
וככל הנראה 1 מחולק ב10 הוא 0.0.
עכשיו למה זה?
>> ובכן שוב, המחשב הוא לוקח לי באופן מילולי, ואני כתבתי 1
ואני כתבתי 10, ולקחת ניחוש מה הוא סוג הנתונים הניח לשני אלה
ערכים?
Int, זה מבחינה טכנית משהו קצת שונה.
זה בדרך כלל זמן רב, אבל זה סופו של דבר ערך נפרד.
לא ערך נקודה צפה.
>> כלומר שאם זה הוא int וזה int,
הבעיה היא שהמחשב אין לו את היכולת
אפילו לאחסון שנקודה עשרונית.
לכן, כאשר אתה עושה 1 מחולק על ידי 10 מספרים שלמים באמצעות
עבור שניהם המונה ו מכנה, התשובה צריכה להיות 0.1.
אבל computer-- כי אלה הם integers--
לא יודע מה לעשות עם 0.1.
>> אז מה הוא עושה בצורה ברורה?
זה פשוט לזרוק אותו, ומה שאני רואה סופו של דבר
הוא 0.0 רק מפני שהתעקשתי ש printf להראות לי נקודה עשרונית אחת.
אבל הבעיה היא שאם אתה לחלק מספר שלם על ידי מספר שלם,
אתה get-- על ידי הגדרה של C-- מספר שלם.
וזה לא הולך לעשות משהו נחמד ובנוחות
כמו עגול עד שזה הקרוב ביותר אחד למעלה או למטה.
זה הולך לחתוך כל מה שאחרי הנקודה העשרונית.
>> אז רק באופן אינטואיטיבי, מה כנראה לתקן?
מה התיקון הפשוט כאן?
כן?
בדיוק.
למה אנחנו לא פשוט לטפל באלה כ ערכי נקודה צפה ביעילות
להפוך אותם לצף או זוגות.
ועכשיו אם אני עושה לעשות צף-0, או אם אני לקמפל צף-1,
שהוא זהה ל מה בדיוק הוצע.
ועכשיו אני עושה צף-0, עכשיו אני מקבל 0.1 שלי.
>> עכשיו זה מדהים.
אבל עכשיו אני הולך לעשות משהו קצת שונה.
אני סקרן לראות מה באמת קורה מתחת למכסת המנוע,
ואני מתכוון לפרסם את זה אל 28 מקומות אחרי הנקודה העשרונית.
אני באמת רוצה לראות 0.1000-- infinite--
27 אפסים [לא ברור] לאחר 0.1 ש.
>> ובכן, הבה נראה אם ​​זה מה שאני אכן אקבל.
הפוך צף-0 אותו קובץ.
./floats-0.
בואו להתמקד על התשובה הדרמטית.
כל הזמן הזה, אתה כבר חושב 1 מחולק ב10 הוא 10%, או 0.1.
זה לא.
לפחות עד כה כ המחשב של מודאג.
>> עכשיו why-- אישור, זה מלא שקר 1 מחולק ב10 הוא 0.1.
אבל why-- שאינו האוכל המוכן היום.
אז למה המחשב חושב, שלא כמו כל אחד מאיתנו בחדר,
ש1 מחולק ב10 הוא למעשה כי ערך מטורף?
מה המחשב עושה כנראה?
מה זה?
>> זה לא עולה על גדות, כשלעצמו.
גלישה היא בדרך כלל כאשר אתה עוטף את ערך.
זה הנושא הזה של חוסר דיוק בערך נקודה צפה
שבו יש לך רק 32 או אולי אפילו 64 קצת.
אבל אם יש אינסוף מספר אחר מספרים אמיתיים
מספרים עם נקודות עשרוניות ומספרי thereafter-- בוודאי
אתה לא יכול לייצג את כולם.
אז המחשב נתן שלנו את ההתאמה הקרובה ביותר
לשווי זה יכול לייצג באמצעות ש פיסות רבות הערך אני באמת רוצה,
שהוא 0.1.
>> למרבה הצער, אם אתה להתחיל לעשות מתמטיקה, או שאתה
להתחיל מעורב מיני צפים אלה ערכי נקודה בprograms-- החשוב
תוכנה פיננסית, דבר software-- צבאי
שבו תפיסה היא די חשוב כנראה.
ואתה מתחיל להוסיף מספרים כמו זה, והתחלה
פועל תוכנה ש עם תשומות גדולות באמת
או להרבה שעות או הרבה של ימים או הרבה שנים,
טעויות קטנטנות האלה בוודאי יכול להוסיף למעלה לאורך זמן.
>> עכשיו במאמר מוסגר, אם יש לך אי פעם ראה סופרמן 3 או Office Space
ואתם אולי זוכרים איך החבר 'ה האלה גנב
הרבה כסף מהמחשב שלהם על ידי שימוש בערכי נקודה צפו
והוספתי את קטן שאריות, בתקווה שסרט
עכשיו הגיוני יותר.
זה מה שהם היו רמזתי בסרט ההוא.
העובדה שרוב חברות לא היו נראות
לאחר מספר מסוים מקומות עשרוניים,
אבל אלה הם שברים של סנט.
אז אתה מתחיל להוסיף אותם, אתה מתחיל לעשות הרבה כסף
בחשבון הבנק שלך.
אז זה שטח המשרד הסביר.
>> עכשיו למרבה הצער מעבר Office Space, יש
כמה מטריד באופן לגיטימי ואת השפעות משמעותיות
של מיני אלה החלטות עיצוב בסיסית,
ואכן אחת הסיבות אנו משתמשים C בקורס
הוא כל כך שבאמת יש לך קרקע זה עד הבנה של איך מחשבים לעבוד,
איך תוכנה עובדת, ולא לקחת שום דבר כמובן מאליו.
>> ואכן, למרבה הצער, אפילו עם כי הבנה בסיסית,
אנו, בני האדם עושים טעויות.
ומה שחשבתי שאני רוצה לחלוק הוא וידאו שמונה דקות זה כאן נלקח
מפרק פלאים מודרניים, שהוא מופע חינוכי על איך דברים עובדים
שמצייר שתי תמונות מתי שימוש לא ראוי
והבנה של ערכי נקודה צפה
הוביל לכמה משמעותי תוצאות מצערות.
בואו נסתכל.
[וידאו השמעה]
עכשיו 'אנחנו חוזרים ל" הנדסה אסונות "בפלאים מודרניים.
מחשבים.
כולנו כבר למדנו לקבל את בעיות לעתים קרובות מתסכלות ש
הגעתי עם them-- באגים, וירוסים, ו תוכנת glitches-- למחירים קטנים
לשלם עבור הנוחות.
אבל בהיי טק ובמהירות גבוהה יישומים צבאיים ותכנית החלל,
הבעיה הקטנה ביותר יכול להיות מוגדל לאסון.
>> ב -4 ביוני, 1996, מדענים מוכנים כדי להפעיל רקטת Ariane 5 לא מאוישת.
זה נשא מדעי לווינים שנועדו
להקים בדיוק איך אינטראקציה של השדה המגנטי של כדור הארץ
עם רוחות סולריות.
הרקטה נבנתה עבור סוכנות החלל האירופית,
והמריא מהמתקן שלה על החוף של גויאנה הצרפתית.
>> הה כ -37 שניות לתוך הטיסה, שהם ראשון
משהו שם לב שהשתבש.
כי החרירים היו מסתובבים בדרך בה הם ממש לא צריכים.
בסביבות 40 שניות לטיסה, בבירור הרכב היה בצרות,
ואז הם עשו ההחלטה להרוס אותו.
קצין הבטיחות, עם אומץ אדיר, לחץ על הכפתור
ופוצץ את הטיל לפני שהוא יכול הפך סכנה לביטחון הציבור.
>> -זהו היה הנעורים מסע של 5 אריאן,
וההרס שלה לקח מקום בגלל הפגם
משובץ בתוכנה של הרקטות.
-The בעיה על אריאן היה שיש
היה מספר שנדרש 64 סיביות להביע,
והם רצו להמיר אותו למספר 16 סיביות.
הם הניחו כי המספר אף פעם לא היה הולך להיות גדול מאוד.
שרוב הספרות אלה ב מספר 64 סיביות היו אפסים.
הם טעו.
>> -The חוסר יכולת של אחד תוכנה לקבל
הסוג של מספר שנוצר על ידי עוד היה בשורש הכישלון.
פיתוח תוכנה נעשה חלק מאוד יקר של טכנולוגיה חדשה.
הייתה לי רקטת אריאן 4 היה מוצלח מאוד.
כל כך הרבה מהתוכנה שנוצרה עבור זה היה בשימוש גם באריאן 5.
>> -The בעיה בסיסית היה שאריאן 5.
היה faster-- מואץ יותר מהר, ו התוכנה לא היוותה ש.
>> -The הרס של הרקטות היה אסון פיננסי עצום.
כל עקב שגיאת תוכנת דקות.
אבל זה לא היה ראשון בעיות המרת נתונים בזמן
הטריד את טכנולוגית טילים מודרנית.
>> ב-1991 עם תחילת של מלחמת המפרץ הראשונה,
הטילים פטריוטים חווה סוג דומה
של בעיית גיור מספר.
וכתוצאה מכך 28 people-- 28 soldiers-- האמריקאי נהרגו,
ועל מאה אחרים נפצעו.
כאשר הפטריוט, שהיה אמור כדי להגן מפני טילי סקאד נכנסים,
לא הצליח לירות טיל.
>> -כאשר עיראק פלשה לכווית, ובאמריקה השיק סופה במדבר בתחילת 1991,
סוללות טילים פטריוטים נפרסו כדי להגן על סעודיה וישראל
מהתקפות טילי סקאד עיראקיים.
הפטריוט הוא לטווח בינוני בארה"ב משטח אל אוויר מערכת
מיוצר על ידי חברת ריית'און.
>> -The גודל של פטריוט מיירט itself--
זה זמן רב על בערך 20 רגליים, והוא שוקל כ -2,000 ק"ג.
והיא נושאת ראש נפץ של כ, אני חושב שזה בערך 150 ק"ג.
וראש הנפץ עצמו הוא נפץ גבוה, ש
יש שברים סביבו.
אז המעטפת של ראש הנפץ היא נועד לפעול כמו כדורי עופרת.
>> -The טילים מתבצעים ארבע למכולה,
ומועברים על ידי קרוון למחצה.
>> -The מערכת נגד טילים פטריוטים חוזר 20 שנים לפחות עכשיו.
הוא תוכנן במקור כטילי הגנה אוויריים
להפיל מטוסי אויב.
במלחמת המפרץ הראשונה כאשר המלחמה שבאה על,
הצבא רצה להשתמש בו כדי להפיל את הסקאדים, לא מטוסים.
חיל האוויר העירקי היה לא כל כך הרבה של בעיה,
אבל הצבא היה מודאג לגבי הסקאדים.
וכך הם ניסו שדרוג הפטריוט.
>> -Intercepting אויב טילים הנעים במאך 5
הולך להיות מאתגר מספיק.
אבל כאשר הפטריוט הובהל לשירות,
הצבא לא היה מודע שינוי עיראקי ש
עשה הסקאדים שלהם כמעט בלתי אפשרי לזה.
>> 'מה שקרה הוא הסקאדים ש היו באים בהיו בלתי יציבים.
הם היו רעועים.
הסיבה לכך הייתה Iraqis-- על מנת לקבל 600 קילומטר החוצה
של missile-- טווח 300 קילומטר לקח משקל מראש הנפץ הקדמי,
ועשה את ראש הנפץ קל יותר.
אז עכשיו הפטריוט של מנסה לבוא בסקאד, ורוב time--
רובם המכריע של time-- זה יהיה לטוס רק על ידי סקאד.
>> -Once מפעילי המערכת הפטריוט הבנתי הפטריוט יחטיא את מטרתו,
הם פוצצו ראש הנפץ של הפטריוט להימנע מפגיעה אפשרית אם זה
היה מותר לנפול אל הקרקע.
>> -That היה מה שרוב האנשים ראו ככדורי אש גדולות בשמיים,
וטעות כ מיירט של ראשי נפץ סקאד.
>> -Although בשמי הלילה, פטריוטס נראה שהורס בהצלחה
הסקאדים, בדהראן יכולים להיות שיש אל תטעה את הביצועים שלו.
יש מערכת המכ"ם של הפטריוט מסלול אבוד של טיל סקאד
ומעולם לא השיק בשל לפגם תוכנה.
>> זה היה הישראלים שהתגלו לראשונה שהמערכת כבר לא הייתה על,
גדול יותר את פער הזמן הפך.
בשל שעון המשובץ במחשב של המערכת.
>> -About שבועיים לפני הטרגדיה בדהראן,
הישראלים דיווחו ל משרד ההגנה
שהמערכת הייתה מאבדת זמן.
לאחר כשמונה שעות של ריצה, הם הבחינו
כי המערכת של ההפיכה ניכר פחות מדויק.
משרד ההגנה בתגובה אומר לי כל הסוללות פטריוטים
לא לעזוב את המערכות על במשך זמן רב.
הם אף פעם לא אמרו את מה שזמן רב היה.
8 שעות, 10 שעות, אלף שעות.
אף אחד לא ידע.
>> -The סוללה הפטריוט מוצב בצריפים
בDhahran והפנימי הפגום שלה שעון היה בבמשך 100 שעות
בליל של 25 פברואר.
>> 'זה מעקב זמן לדיוק של כעשירית משני.
עכשיו עשירית שני הוא מספר מעניין
כי לא ניתן לבטא אותו בינארי בדיוק, ש
פירוש לא יכול לבוא לידי ביטוי בדיוק בכל מחשב דיגיטלי מודרני.
קשה להאמין, אבל להשתמש בזה כדוגמא.
>> בואו ניקח שלישי מספר אחד.
שליש לא יכול להיות בא לידי ביטוי בעשרוני בדיוק.
השלישי הוא 0.333 קורה לאינסוף.
אין דרך לעשות את זה עם דיוק מוחלט בעשרוני.
זה בדיוק הסוג של בעיה זה קרה בפטריוט.
עוד המערכת רצה, גרוע שגיאת הזמן הפכה.
>> אחרי ככלות של 100 שעות הפעלה, שגיאה בזמן הייתה רק כשליש
של שנייה.
אבל במונחים של מיקוד טילים הנעים במאך 5,
זה הביא למעקב שגיאה של מעל 600 מטרים.
זה יהיה שגיאה חמורה לחיילים בדהראן.
>> 'מה קרה הוא השקת סקאד היה זוהה על ידי מוקדם לוויני התרעה,
והם ידעו סקאד בא בכיוון הכללי שלהם.
הם לא ידעו מאיפה זה בא.
זה היה עכשיו עד לרדאר רכיב של המערכת הפטריוט
הגנת Dhahran לאתר ולשמור מסלולו של טיל האויב הנכנס.
>> -The רדאר היה מאוד חכם.
זה באמת היה לעקוב אחר עמדתו של סקאד
ולאחר מכן לחזות בי זה כנראה יהיה
בפעם הבאה רדאר נשלח דופק החוצה.
שנקרא שער הטווח.
>> -Then פעם הפטריוט מחליט יש לו מספיק זמן
עבר לחזור ולבדוק הבאים מיקום לאובייקט מזוהה זה
זה חוזר.
אז כשזה חזר להלא נכון מקום, אז זה לא רואה שום אובייקט.
והוא מחליט שאין אובייקט.
שיש זיהוי שווא וזה מפיל את המסלול.
>> -The סקאד הנכנס נעלם ממסך המכ"ם,
ושניות לאחר מכן, אותו פגע בצריפים.
סקאד נהרג 28.
זה האחרון פוטר בתקופת מלחמת המפרץ הראשונה.
באופן טרגי, התוכנה המעודכנת הגיע עם שחר ביום הבא.
היה לי פגם התוכנה היה קבועה, סגירה
פרק אחד במוטרד ההיסטוריה של הטילים פטריוטים.
>> [END הפעלת וידאו]
>> דוד י מלאן: זהו זה לCS50.
אנחנו אראה אותך ביום רביעי.
>> [השמעת מוסיקה]