>> [השמעת מוסיקה]
>> דוד י Malan: בסדר.
>> [שחוק]
>> ברוך שובך.
זה CS50.
וזה סוף השבוע חמש.
ועד עכשיו, יש לנו פחות או יותר כבר לוקח כמובן מאליו שיש
קיים מהדר זה, קלאנג, שיש לך כבר בדרך של פנייה זו
כלי אחר שנקרא הפוך שאיכשהו באורח פלא ממיר את קוד המקור שלך
לקוד יעד, את האפסים והאחדים כי המעבד שלך במחשבים, המרכזי
יחידת עיבוד, מבינה באמת.
אבל מתברר שיש מספר זה קורה מתחת למכסת המנוע ב
בין הקלט ופלט.
>> ואני רוצה להציע שאנחנו בשר את זה בפירוט קצת יותר לתוך
ארבעת השלבים הללו, יש משהו שנקרא טרום עיבוד, משהו
נקרא קומפילציה, אשר שראינו, משהו שנקרא הרכבה, ו
משהו שנקרא קישור.
אז עד עכשיו, בחלק משלנו תוכניות, שהיו לנו חד כולל.
לאחרונה היו לנו קצת חד מגדיר לקבועים.
אז מתברר שאת הדברים האלה, כי קידומת של הסמל או החשיש
סמל ק"ג הוא מראש מעבד הנחיות.
זה רק דרך מפוארת של להגיד זה שורת קוד שבעצם
הוסב למשהו אחר לפני מחשב גם מנסה להמיר שלך
תכנית לאפסים ואחדים.
>> לדוגמה, כולל חד סטנדרטי קלט / פלט. שעות, פחות או יותר רק אומרת ללכת
קדימה, לתפוס את התוכן של הקבצים stdio.h ולהדביק אותם שם.
אז אין אפסים ואחדים בשלב זה עדיין.
זה באמת רק חילוף.
ושזה נעשה במהלך מה שנקרא שלב עיבוד מראש, כאשר אתה
למעשה להפעיל קלאנג או באופן ספציפי הפוך ברוב המקרים.
אז כל זה כבר קורה ראשון באופן אוטומטי עד כה.
>> ואז מגיע שלב ההידור.
אבל אנחנו כבר פשטניות הידור.
להרכיב תכנית מתכוון באמת לקחת אותו ממשהו כמו C,
קוד מקור אנחנו כבר כותבים, למטה למשהו שנקרא הרכבה.
שפת הרכבה היא ברמה נמוכה יותר שפה זו, תודה לאל, אנחנו לא
יש הרבה הזדמנות לכתוב בסמסטר הזה.
אבל זה ברמה הנמוכה ביותר ב תחושה שאתה ממש מתחיל לכתוב
להוסיף ולהחסיר ורבתי ולטעון מזיכרון ולשמור בזיכרון,
הוראות בסיסיות מאוד שמחשב, מתחת למכסת המנוע,
מבין באמת.
>> לבסוף, ההרכבה לוקחת שפה ש לאפסים והאחדים שאנחנו כבר
תאר עד כה.
ובאמת לבסוף, יש את מה שנקרא קישור שלב, שבו אנו יהיו
לראות ברגע, המשלב האפסים ואחדים עם אפסים ושלך
אלה אנשים אחרים לפני שיצרת.
>> אז לשקול תכנית הפשוטה הזה סופר.
זה היה משבוע 1.
זה רק אמר, שלום העולם, על המסך.
רצנו את זה דרך קלאנג.
או שאנחנו ניהל אותו דרך להרוויח אשר רץ קלאנג.
וoutputted בזמן שבו כמה אפסים ואחדים.
אבל מתברר שיש שלב ביניים.
אם אני הולך לכאן - אופס, לא רוצה לראות אותו עדיין.
אם אני הולך לכאן למכשיר שלי ואני פותח את hello.c, כאן
היא כי אותה תכנית.
ומה שאני הולך לעשות במסוף שלי חלון כאן אני הולך
לרוץ קלאנג ולא הפוך, אשר אוטומציה של כל ארבעת
צעדים אלה עבורנו.
ואני הולך לעשות את הצלצול-S ו אז hello.c ואז להיכנס.
>> ואני מקבל את הפקודה מהבהבת שוב, וזה טוב.
ועכשיו בחלון מעט יותר גדול, אני הולך לפתוח את gedit בכאן.
ואני הולך לפתוח את קובץ, מתברר, נקרא hello.s זה
מכיל שפת הרכבה ש אני התייחסתי קודם לכן.
וזה מה שנקרא הרכבה שפת רמה, נמוכה למדי
הוראות שמעבד אינטל או מה שזה לא שיש בפנים
מבין.
וmov הוא למהלך. שיחה היא עבור קורא, תפקוד ברמה נמוך מאוד.
משנה להוא לחסר.
>> לכן, כאשר יש לך מעבד מסוים בתוך של המחשב שלך, מה שהופך אותו
ברורים, לעומת מעבדים אחרים על שוק, שהוראותיו
מבין ולעתים קרובות כמה יעיל זה הוא, כמה מהר זה הוא בביצוע חלק
מהוראות אלה.
ועכשיו למידע נוסף על זה, אתה יכול לקחת CS61 הסתיו הבא במכללה.
אבל כאן יש לנו, למשל, כמה מזהים שאולי נראים מוכר.
hello.c הוא שמה של התכנית.
>> . טקסט -
אין הרבה של עניין יש רק עכשיו, זוכר שהטקסט
קטע, כמו של יום שני, שבו הוא ב זכרון התכנית שלך מסתיימת למעשה עד.
כך זה לפחות במעורפל מכיר שם.
כאן, כמובן, הוא לאזכור הפונקציה העיקרית שלנו.
גלילה כלפי מטה, אלה מתייחסים לדברים אוגרים שנקראו, גושים קטנים מאוד של
בתוך זיכרון של המעבד שלך בפועל.
ואם אני לגלול למטה אפילו עוד יותר, אני רואה איזה
אזכור עקיף של ASCII.
ושם, אכן, היא מחרוזת ש, הלו, פסיק, עולם.
>> אז סיפור ארוך קצר, זה כבר קורה לך, באופן אוטומטי,
מתחת למכסת המנוע כל הזמן הזה.
ומה שקורה באמת פעם אחת אתה כבר לרוץ קלאנג, או בדרך של
הפוך, אתה מקבל ראשון, מקוד המקור,
מה שנקרא בשפה הרכבה.
אז קלאנג הוא המרת אסיפה זו שפה למטה לאפסים ואחדים.
וזה השקופית שהתחלנו הדיון שלנו בשבוע 0 על -
ולאחר מכן שבוע 1 ב.
ולבסוף, אותם האפסים ואחדים בשילוב עם אפסים והאחדים
מהספריות האלה אנחנו כבר לוקחים כמובן מאליו כמו קלט / פלט סטנדרטי או
ספריית מחרוזת או אפילו CS50 הספרייה.
>> אז כדי לצייר את התמונה הזאת יותר מבחינה ויזואלית, יש לנו hello.c.
וזה, כמובן, משתמש בprintf לתפקד לומר, שלום עולם.
צעד האוסף לוקח אותו עד קובץ שאנחנו רק ראינו hello.s, אפילו
למרות שבדרך כלל הוא נמחק באופן אוטומטי עבורך.
אבל זה קוד ההרכבה בשלב ביניים.
ולאחר מכן כאשר אנו להרכיב את המכלול שפה, כמו שאומרים, זה כשאתה
לקבל את אותם אפסים ואחדים.
אז יש לנו הגדלה ביעילות היום על מה שאנחנו כבר לוקחים כמובן מאליו,
הפירוש הולך קוד מקור להתנגד קוד.
>> אבל לבסוף, החברה שאותה תמונה - בואו לדחוף אליו
בצד השמאל.
ושים לב כי בחלקו העליון יש הזכרתי stdio.h.
זה קובץ שצרפנו כמעט בכל
תוכניות שכתבנו.
וזה קובץ שאת התוכנה לקבל עותק מודבק,
ביעילות על גבי הקוד שלך.
אבל מתברר כי, במחשב מערכת איפשהו, יש להניח
קובץ stdio.c שמישהו כתב שנים לפני שמיישם את כל
פונקציות שהוכרזו ב stdio.h.
>> עכשיו במציאות זה כנראה לא על Mac שלך או במחשב האישי שלך או אפילו ב
CS50 מכשיר הוא קוד C גלם.
מישהו כבר ערך אותו וכלל . קובץ לקוד אובייקט או o.
קובץ, המתייחס לספרייה משותפת זה כבר מותקן מראש ו
מראש נערך עבורך.
אבל נניח שאכן קיים על stdio.c המחשב שלנו במקביל
עם קלאנג.
זה שחבר את הקוד שלך ומורכב.
קוד של stdio.c הוא להיות לוקטו ו התאסף, כדי שזה האחרון
צעד, כאן למטה, יש לנו איכשהו קישור, אם אפשר לומר כך, האפסים והאחדים
עימו או שלה אפסים ואחדים לאחד תכנית פשוטה שסופו של דבר היא
קרא רק שלום.
>> אז זה כל הקסם של זה קרה עד כה.
וימשיך לקחת את אלה תהליכים למובן מאליו, אבל מבינים
יש הרבה פרטים עסיסיים קורה מתחת לשם.
וזה מה שעושה אותך מחשב עם Intel Inside
בעיקר ברור.
>> אז בנימה זאת, אם ברצונך הצטרף אלינו לארוחת צהריים ביום שישי הקרובה, לעשות ללכת
לcs50.net/rsvp המקום הרגיל, 13:15 יום שישי הקרוב.
ועכשיו כמה הודעות.
אז יש לנו חדשות טובות.
ויש לנו חדשות רעות.
תתחיל עם קצת חדשות טובות כאן.
>> [נאנק]
>> בסדר.
ובכן, מבחינה טכנית זה חג, ולכן זה לא כל כך הרבה במתנה מאתנו.
אבל אז חדשות הרעות כמובן.
>> [נאנק]
>> אני ביליתי הרבה זמן באנימציות אלה.
>> [שחוק]
>> תהיה פגישת ביקורת ביום שני הקרוב.
זה הולך להיות בשעה 5:30.
אנו להזכיר לך את כל הפרטים האלה באמצעות דואר אלקטרוני על המהלך של
אתר רק כמה ימים של זמן.
היא תצולם ונעשתה זמינה זמן קצר לאחר מכן.
אז אם אתה לא יכול לעשות כי ביום שני לילה חריץ, אל תדאג.
סעיפים בשבוע הקרוב יהיו גם להתמקד בביקורת לחידון.
אם הסעיף שלך הוא ביום שני, שהוא אכן אוניברסיטת חג, אנו
עדיין לפגוש בסעיף.
אם אתה פשוט לא יכול לעשות את זה סעיף בגלל שאתה הולך
משם, זה בסדר.
להשתתף ביום ראשון או סעיף או שלישי מנגינה-בסעיף של ג'ייסון, שהוא
זמין באינטרנט.
>> אז, עוד חדשות רעות.
אז לפי תכנית הלימודים, יש לנו הרצאה ביום שישי הבא.
אבל חדשות טובות -
באופן ברור, שביליתי יותר מדי זמן על זה.
>> [שחוק]
>> אנו נבטל הבאים ההרצאות של יום שישי.
אז זה יהיה מתנה עבורנו, כך שאתה באמת יכול להיות הפוגה נחמדה ב
בין השבוע לשבועיים, ומכאן.
אז לא בשבוע הבא הרצאות, רק זעיר חידון קטן, שעבורו אתה צריך להיות
התרגש יותר ויותר.
>> אז בואו עכשיו להפנות את תשומת הלב ל משהו שהוא אכן ויזואלית יותר
ויותר מרגש וכדי להגדיר את הבמה על מה הולך להיות באופק
תוך כמה שבועות של זמן.
לאחר החידון הראשון, נפנינו להתמקד בסטי הבעיה שלנו למקום אחר
בעיה ספציפית תחום, זה של זיהוי פלילי או בטחוניים באופן כללי.
>> למעשה, מסורת עם בעיה זו קבוצה היא בשבילי אחד
עמית הוראה או רשויות אישורים לחצות קמפוס לקחת כמה תמונות של
אנשים ברורים הניתנים לזיהוי, אך לא, מקומות או דברים, אז בכל שנה אני
איכשהו הצליח למחוק בטעות או ניזק לכרטיס המדיה הדיגיטלי
זה חלק פנימי של המצלמה שלנו.
אבל לא עניין גדול.
אני יכול להמשיך ולחבר כי למחשב שלי.
אני יכול להפוך את תמונת זיהוי פלילי שלו, ולכן לדבר, על ידי העתקה ואת האפסים
אלה הנחה של כרטיס זיכרון זה, בין אם שלו כרטיס SD או כרטיס קומפקט פלאש או
כל מה שאתה מכיר.
ואז אנו יכולים לחלק את זה.
>> ואז האתגר קדימה, בין השאר דברים בשבילך, יהיו לכתוב
קוד C שמשחזר חבורה שלמה של JPEGs עבורי וגילו יהיה
אותם אנשים, מקומות, או דברים.
ואנחנו גם נדבר, בבעיה זו להגדיר ובימים הקרובים, על
גרפיקה יותר בדרך כלל.
אנחנו כבר השתמשנו בהם, כמובן, ללפרוץ החוצה.
אבל שיש לך סוג של מובן מאליו קיימים מושגים אלה ברמה גבוהה
של מלבנים ואליפסות.
אבל מתחת למכסת המנוע יש פיקסלים.
ויש לך כבר להתחיל חשבתי על אלה.
או שאתה יהיה לP-4 סט צריך לחשוב על הפער בין הלבנים שלך, איך
במהירות שאתה נע על פני כדור המסך ללפרוץ החוצה.
אז יש את הרעיון הזה של נקודות שעל המסך זה
נכנסים לשחק כבר.
>> עכשיו מה שאתה רואה, אם כי, הוא מה אתה מקבל על מסך מחשב.
אם אי פעם צפו בכמה טוב או טלוויזיה רעה, רוב הסיכויים הם שהם פחות או יותר
טיפול בקהל כמו technophobes שלא ממש
יודע הרבה על מחשוב.
ואז זה קל מאוד למשטרה בלש לומר, שאתה יכול
לנקות את זה בשבילי?
או לשפר, נכון?
שפר הוא כמו מילה באז ב ביותר בכל תכנית בנושא פשע.
והמציאות היא שאם אתה לוקח מאוד תמונה מטושטשת של חשוד עושה
משהו רע, אתה לא יכול רק לשפר אותו.
אתה לא יכול להתקרב לאין שיעור.
אתה לא יכול לראות בנצנוץ של מישהו עין שהתחייבה כי
פשע מסוים, למרות שכיחות של זה בטלוויזיה.
>> וכך, עם שבואו להניע כי בעיה להגדיר הקרובה עם הצצה
כמה הופעות שבה אתה יכול להיות מוכר.
>> [השמעת וידאו]
>> -אישור.
עכשיו, בואו לקבל מבט טוב עליך.
>> -תחזיק את זה.
הפעל את זה בחזרה.
>> -חכה רגע.
ללכת ימינה.
>> לשם.
להקפיא את זה.
>> מסך מלא.
>> -אישור.
להקפיא את זה.
>> תהיה להדק על זה, יה?
>> וקטור על הבחור ש על ידי הגלגל אחורה.
>> -קרב ממש כאן במקום הזה.
>> -עם הציוד הנכון, הדמיה יכול להיות מוגדל ומחודד.
>> , מה זה?
>> -It של תכנית שיפור.
>> האם אתה יכול לנקות-עד שכל?
>> , אני לא יודע.
בואו לשפר אותו.
>> סעיף-6-שפר.
>> אני-משופר והפירוט -
>> -אני חושב שיש מספיק כדי לשפר.
לשחרר אותו למסך שלי.
>> , שפר את ההשתקפות בעיניה.
>> -בואו נריץ את זה דרך שיפור וידאו.
>> -אדגר, אתה יכול לשפר את זה?
>> -תחזיק מעמד.
>> -הייתי כבר עובד על השתקפות זו.
>> ההשתקפות של-מישהו.
>> השתקפות.
>> -יש השתקפות פניו של האיש.
>> -ההשתקפות.
>> -יש השתקפות.
>> זום על המראה.
>> , אתה יכול לראות את השתקפות.
>> -האם אתה יכול לשפר את התמונה מכאן?
>> האם אתה יכול לשפר-ממש כאן?
>> האם אתה יכול לשפר-?
>> האם אנחנו יכולים לשפר-הזה?
>> האם אתה יכול לשפר-?
>> -חכה שני, אני תשפר.
>> זום על הדלת.
>> -X10.
>> זום.
>> [שחוק]
>> -לנוע פנימה
>> -המתן, תפסיק.
>> הפסקה.
>> -השהה אותה.
>> -לסובב סביב 75 מעלות בבקשה אנכי.
>> [שחוק]
>> הפסקה, וחזרתי לחלק על הדלת שוב.
>> Got-משפר תמונה מפת סיביות שיכול?
>> -אולי נוכל להשתמש בסן Pradeep שיטה כדי לראות לחלונות.
>> -זה תוכנה היא המדינה של האמנות.
>> -ערך הסמל כבוי.
>> -עם שילוב הנכון של אלגוריתמים.
>> הוא נלקח-אלגוריתמים לתאורה השלב הבא, ואני יכול להשתמש בם כדי
לשפר את התצלום הזה.
>> נעילה על ולהגדיל את Z-הציר.
>> , שפר.
>> בהקפאה ולשפר.
>> [השמעת וידאו הסוף]
>> דוד י Malan: סט בעיה אז 5 הוא מה שלפנינו שם.
אז בקרוב תוכל לקבל הבנה טובה יותר מתי ומדוע אתה יכול
ושלנו לא יכול לשפר בדרך זו.
אבל קודם כל, בואו נחזיר את תשומת לבנו לחלק מאבני הבניין אנחנו
צריך להיות מסוגל לספר את הסיפור הזה.
>> אז זוכר שציירנו את התמונה הזאת על יום שני וקצת בשבוע שעבר.
וזה מתאר את הפריסה של דברים בזכרון המחשב שלך כאשר
הפעלת תכנית כלשהי.
קטע טק למעלה, כזכור, מתייחס לאפסים והאחדים בפועל
המרכיב את התכנית שלך.
יש, מתחת לזה, חלק או אותחל נתונים מאותחלים, אשר בדרך כלל
מתייחס לדברים כמו קבועים או מחרוזות או משתנה הגלובלית שיש לי
הוכרז מראש.
יש ערימה, אבל אנחנו נבוא אחזור לזה עוד מעט.
>> ואז יש את המחסנית.
הרבה כמו ערימה של מגשים ב קפיטריה, זה מקום שבו מקבל את הזיכרון
שכבות שכבות וכל פעם אתה עושה את מה בתכנית?
מהו השימוש לערימה?
>> כן?
>> Call of לתפקד.
בכל פעם שאתה קורא לפונקציה, זה נתנו לרסיס של זיכרון עבורו
משתנים מקומיים או הפרמטרים שלו.
וציורי, אנו רואים שעם כל פונקציה הנקראת ברציפות, כאשר
שיחות שיחות B C D שיחות, הם מקבל שכבות על גבי ערימה.
ובתוך כל אחד מאותם פרוסות זיכרון הוא למעשה היקף ייחודי
לתפקוד זה, אשר, כמובן, הוא בעייתי, אם ברצונך למסור
מתפקיד אחד למשנהו חתיכה מנתונים שברצונו
להשתנות או לשנות.
>> אז מה היה הפתרון שלנו מאפשרים ל פונקציה מיוצגת על ידי ערימה אחת
מסגרת כדי לשנות את הזיכרון פנימי ערימה של מסגרת אחרת?
איך לעשות את שני אלה דיבורים לעוד אחד?
אז בדרך של מצביעים או כתובות, אשר, שוב, רק לתאר בו ב
זיכרון, על ידי דרך של ספציפי מספר ביס, בפרט
ניתן למצוא ערך.
אז זוכר פעם האחרונה גם המשכנו הסיפור והביט בי
די תכנית מרכבה.
ותכנית זו היא מרכבה למעטים סיבות, אבל המדאיג ביותר הוא
משום שהוא לא מצליח לבדוק מה?
>> כן, היא לא מצליחה לבדוק את הקלט.
סליחה?
>> אם זה יותר מ -12 תווים.
אז מאוד בזריזות, כאשר קוראים memcopy, אשר, כפי שהשם מרמז, פשוט
זכרון עותקים מהטיעון השני שלה לטענה הראשונה שלה.
הטענה השלישית, מאוד בזריזות, היא בדק כדי לוודא שאתה לא יודע
יותר מעותק, במקרה זה, האורך של בר, מספר התווים,
ליעד, שהוא זה המערך C. אבל הבעיה היא שמה
אם C עצמו הוא לא גדול מספיק כדי להתמודד עם זה?
אתה הולך להעתיק את מספר בתים שאתה כבר נתון.
אבל מה בעצם יש לך יותר בתים מאשר שיש לך מקום ל?
>> ובכן, תכנית זו טיפשות מאוד פשוט עיוורון ממשיך לקחת את כל מה שזה
נתנו, הלו הוא קו נטוי 0 מחרוזת נהדרת אם הוא קצר
מספיק, כמו חמישה תווים.
אבל אם זה בעצם 12 תווים או 1,200 תווים, שראינו בפעם האחרונה
שאתה רק הולך לחלוטין לדרוס זיכרון ש
לא שייך לך.
והמקרה הגרוע ביותר, אם כי לדרוס חלק אדום יש שקראנו לי
לחזור כתובת -
זה רק בו המחשב באופן אוטומטי, עבורך, מאחורי
סצנות, שאיבת שומן משם ערך של 32 סיביות ש מזכיר אותו למה שהוא צריך את הכתובת
תחזור כאשר foo, תפקיד אחר זה, נעשה ביצוע.
זה פירור לחם מכל סוגים שאליו הוא חוזר.
אם תחליף את זה, באופן פוטנציאלי, אם אתה האיש הרע, יכול יכול
פוטנציאל להשתלט על המחשב של מישהו.
ואתה בהחלט תתרסק זה ברוב המקרים.
>> עכשיו הבעיה הזאת רק החמירה כשהתחלנו לדבר על זיכרון
ניהול באופן כללי יותר.
וmalloc, להקצאת זיכרון, הוא פונקציה שאנחנו יכולים להשתמש בו כדי להקצות
זיכרון כאשר אנו לא יודעים מראש שאולי צריכים קצת.
כך, למשל, אם אני חוזר למכשיר כאן.
ואני פותח את מhello2.c הפעם האחרונה, זוכר את התכנית כאן, שנראה
משהו קטן כזה, רק שלושה קווים -
תציין את השם שלך, ולאחר מכן שם המחרוזת בצד השמאל, שווה getstring.
ואז להדפיס אותו, שמו של המשתמש.
>> אז זו הייתה תכנית סופר פשוטה.
כדי להיות ברור, תן לי ללכת קדימה ולעשות שלום-2.
אני הולך לעשות את נקודת לוכסן שלום-2.
תציין את השם שלך -
דוד.
Enter.
שלום דוד.
נראה שזה עובד בסדר.
אבל מה שבאמת קורה מתחת מכסה המנוע כאן?
ראשית בואו לקלף כמה שכבות.
מחרוזת היא רק מילה נרדפת שיש לנו הבין בשביל מה?
כוכב צ'אר.
אז בואו לעשות את זה קצת יותר מסתורי אבל יותר נכון מבחינה טכנית שזה
הוא כוכב char, כלומר שם, כן, הוא משתנה.
אבל מה שחנויות שם היא הכתובת של char, שמרגיש קצת מוזר
בגלל שאני מקבל בחזרה מחרוזת.
אני מקבל בחזרה מרובה תווים לא להשחיר.
>> אבל כמובן, אתה צריך רק את הראשון הכתובת של char לזכור היכן
כל המחרוזת היא כי למה?
איך אתה להבין איפה סוף המחרוזת היא לדעת ההתחלה?
אפס הקו הנטוי.
אז עם שני הרמזים האלה לך להבין לפני התחילה ובסופו של
כל מחרוזת הן, כל עוד הם נוצר כראוי עם אפס ש
שליחות קטלנית, אפס קו נטוי ש.
>> אבל זה קורא getstring.
ומתברר שgetstring כל הזמן הזה היה סוג של
מרמה אותנו.
זה כבר עושה את העבודה הזאת, כדי להיות בטוח, מקבל מחרוזת מהמשתמש.
אבל איפה שהזיכרון כבר מגיע?
אם נחזור לתמונה כאן ו להחיל את ההגדרה מרק
לפני רגע, שהערימה היא מקום שבי זיכרון הולך כאשר פונקציות נקראות,
לפי ההיגיון הזה, כאשר אתה קורא getstring, ואז אני מקליד ב
D--V-I-D הזן, שבו הוא D-A-V-I-D מאוחסן קו נטוי אפס, המבוסס על
סיפור שספרנו לנו עד עכשיו?
>> זה היה נראה ב הערימה, נכון?
כשאתה מתקשר לקבל מחרוזת שאתה מקבל פרוסה קטנה של זיכרון במחסנית.
אז זה מתקבל על דעת כי D--V-I-D קו נטוי אפס מאוחסן
יש בערימה.
אבל חכה רגע, getstring חוזר מחרוזת ש, כביכול, שפירושו
זה מגש מקפיטריה הוא נלקח מהערימה.
ואנחנו אמרו בפעם האחרונה שברגע ש פונקציה מחזירה, ואתה לוקח את זה
מגש, אם אפשר לומר כך, את הערימה, מה אתה יכול להניח על שרידי
זיכרון זה?
אני די לשרטט מחדש אותם כסימני שאלה משום שהן הופכות
ערכיו לא ידועים.
הם יכולים לעשות בה שימוש כאשר חלק הפונקציה הבאה נקראת.
>> במילים אחרות, אם אנחנו יקרו כדי להיות לאחסון -
אני לצייר תמונה מהירה כאן הערימה.
אם יקרו לך להיות ציור תחתון הקטע של הזיכרון שלי, ואנחנו נגיד
כי זה המקום של זיכרון שנכבש על ידי ראשי ואולי ARG ג ו
ARG V וכל דבר אחר בתכנית, כאשר getstring נקרא,
ככל הנראה getstring מקבל נתח של זיכרון כאן.
ולאחר מכן D--V-I-D איכשהו בסופו של פונקציה זו.
ואני הולך בפשטנות יתרה.
אבל בואו נניח ש D--V-I-D קו נטוי אפס.
אז בתים רבים זה משמשים המסגרת לgetstring.
>> אבל ברגע שחוזר getstring, אנחנו אמרה הפעם האחרונה שהזיכרון הזה על
כאן הכל הופך להיות - woops! -
הכל הופך להיות נמחק בצורה יעילה.
ואנחנו יכולים לחשוב על זה עכשיו כמו שאלה סימנים כי מי יודע
מה הולך להיות של זיכרון זה.
ואכן, אני לעתים קרובות מאוד לקרוא לפונקציות מלבד getstring.
וברגע שאני קורא קצת אחר פונקציה מgetstring, אולי לא ב
תכנית מסוימת הזאת אנחנו פשוט נראים באבל חלק אחר, אין ספק שחלק אחר
פונקציה עלולה בסופו שניתנה הנקודה הבאה זה בערימה.
>> אז זה לא יכול להיות שמאחסן getstring D--V-I-D על הערימה כי אני היית
תאבד את הגישה אליו באופן מיידי.
אבל אנחנו יודעים שהם getstring מחזיר רק מה?
זה לא חוזר ל לי שישה תווים.
מה זה באמת לא חוזר אנו מגיעים למסקנה בפעם האחרונה?
כתובתו של הראשון.
אז איכשהו, כשאתה נקרא getstring, זה הקצאת נתח של זיכרון עבור
מחרוזת שהסוג והמשתמשים כתובת אז חוזר על זה.
ומתברר שכאשר אתה רוצה תפעל להקצאת זיכרון בזה
דרך ולחזור לאדם שהתקשר פונקציה ש, את הכתובת של
נתח זה של זיכרון, אתה בהחלט לא יכול לשים אותו בערימה ב
תחתון, כי זה רק פונקציונלי הולך לא להיות שלך מאוד
במהירות, כך שאתה יכול כנראה לנחש לאן אנחנו כנראה הולכים לזרוק אותו
במקום זאת, הערימה מה שנקרא.
>> אז בין החלק התחתון של הזיכרון שלך פריסה והחלק העליון של הזיכרון שלך
פריסה הן חבורה שלמה של מגזרים.
האחת היא הערימה, וזכות מעליו היא הערימה.
וגל הוא רק נתח של שונה זיכרון שלא רגיל לפונקציות
כשהם התקשרו.
הוא משמש לזיכרון לטווח ארוך יותר, כאשר אתה רוצה פונקציה אחת כדי לתפוס קצת
זיכרון ולהיות מסוגל להיאחז בו מבלי לאבד שליטה על זה.
>> עכשיו אתה יכול אולי באופן מיידי רואה שזה לא
דווקא עיצוב מושלם.
כמו התכנית שלך שהוקצתה בזיכרון המחסנית, או כמו שאתה קורא יותר ו
פונקציות נוספות, או כמו שאתה להקצות זיכרון בערמה עם malloc בתור
getstring הוא עושה, מה שבבירור נראה שיש בעיה בלתי נמנעת?
>> נכון.
כמו העובדה שחיצים אלו הם מצביעים אחד על השני
אינו מבשר טוב.
ואכן, אנו יכולים לקרוס מהר מאוד תכנית בכל מספר הדרכים.
למעשה, אני חושב שאולי יש לי עשה את זה בטעות פעם אחת.
ואם לא, בואו נעשה את זה בכוונה עכשיו.
תן לי להמשיך ולכתוב במהירות סופר תכנית בשם dontdothis.c.
ועכשיו אני אלך לכאן ו אין להכליל את stdio.h חד.
בואו נכריז הפונקציה foo לוקח אין טענות, שהוא
מצוין, כמו גם על ידי חלל ריק.
>> וזה הדבר היחיד foo הוא הולך לעשות שיחת foo, שכנראה לא
הרעיון החכם ביותר, אבל ניחא.
החלל מרכזי ent.
עכשיו הדבר היחיד שהראשי הולך לעשות הוא להתקשר foo גם כן.
וסתם בשביל כיף, אני הולך ללכת קדימה לכאן ולומר printf "שלום מ
foo ".
>> אישור.
אז אם אני לא עושה טעויות, הפוך dontdothis נקודת קו נטוי.
ובואו נעשינו את זה בחלון גדול יותר -
נקודת לוכסן, dontdothis.
נו באמת.
אה אה.
ככל הנראה, אתה יכול לעשות את זה.
לעזאזל.
אישור.
חכה.
לעמוד.
עשינו לנו -
אנחנו לא משתמשים בו עם הפוך.
>> [נאנח]
>> אני יודע, אבל אני חושב שאנחנו פשוט יימחק את זה.
אה, כן.
לעזאזל.
לפתור את רוב זה.
מה?
זה פשוט מאוד.
כן, פנינו אופטימיזציה מחוץ.
מניח את הדעת, עומד שלום.
עכשיו אני מרגיש טוב יותר.
אישור.
בסדר.
>> אז בואו הידור מחדש זה -
לגרום לך dontdothis.
ייתכן שתצטרך לשנות את השם הזה כדי dothis.c ברגע.
שם אנחנו הולכים.
תודה.
אישור.
אז העובדה שאני מדפיס משהו בעצם היה רק
להאט את התהליך שבאמצעותו אנו היה מגיע לשלב הזה.
אישור.
אוף!
>> אז מה בעצם קורה פה?
הסיבה לשם, בדיוק כמו בצד, היא עושה שום דבר במונחים של תשומות ו
פלט נוטה להיות איטיים יותר בגלל שאתה צריך לכתוב תווים
מסך, יש לו לגלילה.
אז סיפור ארוך קצר, היה לי ממש קרה כל כך חסר סבלנות, היינו צריך
וכן ראה תוצאה סופית זה.
עכשיו שיש לי נסיעה של עליות הדפסה, אנחנו רואים את זה מייד.
אז למה זה קורה.
ובכן, הסבר פשוט, כמובן, הוא שכנראה לא צריך foo
להיות קורא עצמו.
>> עכשיו באופן כללי, זו היא רקורסיה.
וחשבנו כמה שבועות לפני רקורסיבית הוא טוב.
רקורסיה היא הדרך הקסומה הזה של לבטא את עצמך סופר באופן תמציתי.
וזה פשוט עובד.
אבל יש תכונה מרכזית של כל התוכניות רקורסיבית שדברנו
על והביט עד כה, אשר היה שלא היה להם מה?
מקרה בסיס, אשר היה חלק מקודד קשה מקרה שאמר במצבים מסוימים
לא קורא foo, שהוא בבירור לא המקרה כאן.
>> אז מה באמת קורה במונחים של תמונה זו?
ובכן, כאשר עיקרי קורא foo, זה מקבל פרוסת הזיכרון.
כשקורא foo foo, זה נהיה פרוסה של זיכרון.
כשקורא foo foo, הוא מקבל פרוסה.
זה נהיה פרוסה.
בגלל foo לא חוזר.
אנחנו לעולם לא מוחקים את אחד מאלה מסגרות מהערימה.
אז אנחנו נושבת בערימה, ולא להזכיר מי יודע מה עוד, ו
אנחנו חורגים מגבולות שלנו מה שנקרא קטע של זיכרון.
שגיאה ללכת פילוח שווא.
>> אז יש פתרון באופן ברור לא עושה את זה.
אבל המשמעות הגדולה יותר היא שכן, בהחלט יש איזה גבול,
גם אם הוא אינו מוגדר היטב, באשר לאופן פונקציות רבות שאתה יכול להתקשר
תכנית, כמה פעמים פונקציה אפשר לקרוא לעצמו.
אז למרות שאנחנו עשינו להטיף רקורסיה כדבר שעלול להיות הקסום הזה
לפני כמה שבועות לסיגמא פונקציה, וכאשר אנחנו מקבלים את הנתונים
מבנים וCS50, תראה אחרים בקשות לזה, זה לא
בהכרח הדבר הטוב ביותר.
כי אם פונקציה קורא לעוצמה, קורא לעצמו, גם אם יש בסיס
מקרה, אם אתה לא פגע במקרה שהבסיס עבור 1,000 שיחות או 10,000 שיחות, על ידי
כי זמן שאולי יש לי נגמרים של חדר על הערימה ופגע כביכול שלך
כמה מגזרים אחרים של זיכרון.
אז גם הוא תחלופה עיצוב בין אלגנטיות ובין
חוסנו של הספציפי שלך יישום.
>> אז יש החסרון או אחר תפסתי אותך אחרת למה שיש לנו
עשה עד כה.
כשהתקשרתי getstring -
תן לי לחזור לשלום-2.
שימו לב שאני מתקשר getstring, שחוזר כתובת.
ואנחנו טוענים היום כי כתובת הוא מהערימה.
ועכשיו אני מדפיס את מחרוזת בכתובת זו.
אבל אנחנו אף פעם לא קראנו ההפך מgetstring.
אף פעם לא היו לנו לCALLL לתפקד כמו ungetstring, שבו אתה יד אחורית
זיכרון זה.
אבל בכנות, אנחנו כנראה היה צריך להיות.
כי אם אנחנו כל זמן שואלים את המחשב לזכרו, על ידי דרך של מישהו כמו
getstring אבל אף פעם לא ייתן לו בחזרה, ללא ספק גם זה חייב להוביל ל
בעיות לפיה אנו פועלים מתוך זיכרון.
>> ולמעשה, אנחנו יכולים להסתכל על אלה בעיות עם הכלי החדש שהשימוש
הוא קצת סתום להקליד.
אבל תן לי להמשיך ולהתיז אותו על המסך ברגע.
אני הולך קדימה ולהפעיל Valgrind עם הפרמטר ראשון שפקודה
ויכוח הוא קו השם של תכנית שלום ש- 2.
ולרוע מזל זה פלט הוא אכזרי
מורכב בלי שום סיבה טובה.
כך אנו רואים את כל הבלגן הזה.
דוד הוא לומר את השם שלי.
אז זה התכנית למעשה פועל.
ועכשיו אנחנו מקבלים את הפלט הזה.
>> אז Valgrind דומה ברוחו לGDB.
זה לא הבאגים כשלעצמה.
אבל זה בודק זיכרון.
זוהי תכנית שתפעל תכנית ולהגיד לך אם היית שואל
מחשב לזיכרון ולא מסר אותו בחזרה, ובכך משמעות שיש לך
דליפת זיכרון.
ודליפות זיכרון נוטות להיות רעה.
ואתה הוא משתמשים של מחשבים יש לי כנראה הרגיש את זה, בין אם יש לך
מק או PC.
האם אי פעם השתמש במחשב שלך עבור בזמן ולא אתחלתי בכמה
ימים, או שפשוט יש לך הרבה תוכניות פועלות, והדבר הארור
מאט לעצירה שחיקה, או לפחות זה סופר מעצבן לשימוש, משום
כל מה שיש רק סופר איטי.
>> עכשיו זה יכול להיות כל מספר סיבות.
זה יכול להיות לולאה אינסופית, בבאג הקוד של מישהו, או, יותר פשוט, זה
יכולים להיות שאתה משתמש יותר זיכרון, או מנסה, יותר משלך
יש במחשב של ממש.
ואולי יש באג בתכנית מסוימת שכל זמן שואל לזיכרון.
דפדפנים במשך שנים היו ידועים לשמצה זו, מבקש יותר ויותר זיכרון
אך מעולם לא מסר אותו בחזרה.
אין ספק, אם יש לך רק סופי כמות הזיכרון, אתה לא יכול לשאול
פעמים רבות לאין שיעור עבור חלק מהזיכרון הזה.
>> וכך, מה שאתה רואה כאן, למרות שוב הפלט של Valgrind הוא
מורכב שלא לצורך להציץ ראשון, זה החלק המעניין.
ערימה -
בשימוש ביציאה.
אז הנה כמה זיכרון היה בשימוש בערימה ב
זמן התכנית שלי יצאה -
כנראה שישה בתים ברחוב אחד.
אז אני הולכת לנופף ידי שלי באיזה בלוק הוא.
תחשוב על זה הוא רק נתח, יותר מילה טכנית לגוש.
אבל שישה בתים -
מה הם שישה הבתים ש היו עדיין בשימוש?
>> בדיוק.
D--V-I-D, חמש מכתב קו נטוי אפס שם תוספת שליחות קטלנית null.
אז התכנית הזאת Valgrind לב שאני ביקש שישה בתים, ככל הנראה, על ידי
דרך של getstring, אבל אף פעם לא נתן להם בחזרה.
ולמעשה, זה לא יכול להיות כל כך מובן מאליו, אם התכנית שלי היא לא שלוש
קווים, אבל זה 300 קווים.
אז אנחנו באמת יכולים לתת פקודה אחרת טענת קו לValgrind ל
לעשות את זה יותר מפורט.
זה קצת מעצבן שיש לזכור.
אבל אם אני עושה -
בואו נראה.
דליפה -
היה זה ידלוף -
אפילו אני לא זוכר מה הוא את היד.
>> - בדיקת דליפה שווה מלאה.
כן, תודה לך.
- בדיקת דליפה שווה מלאה.
Enter.
אותה תכנית פועלת.
הקלד בדוד שוב.
עכשיו אני רואה קצת יותר פירוט.
אבל מתחת לערימת הסיכום, אשר זהה לארבעה - אה,
זה די נחמד.
עכשיו הוא מחפש בעצם Valgrind קצת יותר קשה בקוד שלי.
וזה אומר כי, ככל הנראה, malloc בקו -
אנו להקטין את התצוגה.
בקו -
אנחנו לא רואים מה קו זה.
אבל malloc היא האשם הראשון.
יש בלוג בmalloc.
>> בסדר?
אוקיי, לא.
נכון?
התקשרתי getstring.
getstring כנראה קורא malloc.
אז מה שורת קוד היא ככל הנראה באשמה על כך
הוקצה הזיכרון הזה?
בואו נניח שכל מי שכתב malloc כבר בסביבה מספיק זמן, כי זה
לא באשמתם.
אז כנראה שזה שלי.
getstring בcs50.c - אז זה קובץ איפשהו במחשב -
בקו 286 נראה להיות אשם.
עכשיו בואו נניח שכבר cs50 מסביב לכמות הגונה של זמן, ולכן
גם אנחנו עושים את זה תמיד.
ואז זה כנראה לא בgetstring כי באג שקרים, אלא ב
קו שלום-ג .2 18.
>> אז בואו נסתכל מה היה הקו ש18.
אה.
איכשהו הקו הזה הוא לא בהכרח כרכרה, כשלעצמה, אבל זה הסיבה
מאחורי דליפת זיכרון זה.
כך סופר בפשטות, מה שהיית עושה באופן אינטואיטיבי להיות הפתרון כאן?
אם אנחנו מבקשים לזיכרון, אף פעם לא היו נותן אותו בחזרה, וכי נראה שיש
בעיה, כי לאורך זמן המחשב שלי אולי נגמרים של זיכרון, עשוי להאט
למטה, דברים רעים עלולים לקרות, טוב, מה הפתרון אינטואיטיבי ופשוט?
רק תן לו בחזרה.
>> איך לשחרר את הזיכרון הזה?
ובכן, תודה לאל שזה די פשוט רק כדי להגיד שם ללא תשלום.
ואנחנו אף פעם לא עשינו את זה קודם.
אבל אתה בעצם יכול לחשוב עליו ללא כהיפוכה של malloc.
החופשי הוא ההפך הקצאת זיכרון.
אז עכשיו תן לי הידור מחדש את זה.
הפוך שלום-2.
תן לי להפעיל אותו שוב. שלום דוד-2.
אז נראה שזה יעבוד ב בדיוק באותו אופן.
אבל אם אני חוזר לValgrind ולהפעיל מחדש אותה פקודה בחדשה שלי
הידור תכנית, הקלדה בשם שלי כמו בעבר -
נחמד.
סיכום ערימה -
בשימוש ביציאה -
אפס בתים בלוקים אפס.
וזה סופר נחמד, כל ערמה ששוחררה.
אין דליפות אפשריות.
>> אז מתקרב, לא עם סט בעיה 4, אבל עם סט 5 בעיה, את זיהוי פלילי
והלאה, זה גם יהפוך מידה של נכונות שלך
תכנית, או אם אין לך או שאין לי דליפות זיכרון.
אבל לשמחתי, לא רק יכולה לך הסיבה דרך אותם באופן אינטואיטיבי, אשר
הוא, ללא ספק, קל לתוכניות קטנות אבל קשה יותר לתוכניות גדולות יותר,
Valgrind, לתוכניות גדולות אלה, יכול לעזור לך לזהות
בעיה מסוימת.
>> אבל יש בעיה אחרת אחד שעלול להתעורר.
תן לי לפתוח את הקובץ הזה לכאן, שהוא, שוב, דוגמה פשוטה למדי.
אבל בואו נתמקד במה התכנית הזו עושה.
זה נקרא memory.c.
אנחנו מתכוונים לכתוב את זה מאוחר יותר היום ב zip של קוד המקור של ימינו.
ושים לב שיש לי פונקציה שנקראת F שלא לוקח ארגומנטים ו
מחזיר שום דבר.
בקו 20, שככל הנראה, אני מכריז מצביע int וקורא לזה x.
אני הקצאה היא התמורה ערך של malloc.
ורק שיהיה ברור, כמה בתיי אני כנראה מקבל בחזרה מmalloc
במצב כזה?
>> כנראה 40.
לאן אתה לוקח את זה?
ובכן, אם אתה זוכר שint הוא לעתים קרובות 4 בתים, לפחות את זה הוא ב
מכשיר, 10 פעמים 4 הוא כמובן 40.
אז malloc חוזר כתובת של נתח של זיכרון ואחסון ה
לטפל בסופו של דבר בx.
אז כדי שיהיו ברור, מה אז קורה?
ובכן, הרשה לי לחזור לתמונה שלנו כאן.
תן לי לא רק לצייר את החלק התחתון שלי הזיכרון של המחשב, תן לי ללכת קדימה
לצייר את כל המלבן ש מייצג את כל זיכרון RAM שלי.
>> אנחנו נגיד שהערימה נמצא בתחתית.
ויש קטע טקסט ב הנתונים לא אותחל.
אבל אני פשוט הולך לאלה מופשטים דברים אחרים משם כנקודה, נקודת נקודה.
אני רק הולך להתייחס לזה כערימה בראש.
ולאחר מכן בחלק התחתון של התמונה הזאת, לייצג ראשי, אני הולך
כדי לתת לו זכרון פרוסות במחסנית.
עבור F, אני הולך לתת לו פרוסת בזיכרון על המחסנית.
עכשיו, יש לי להתייעץ קוד מקור שוב.
מה הם המשתנים המקומיים לראשי?
כנראה שום דבר, כך שהפרוסה היא יעילות ריק או אפילו לא גדול
כפי שציירתי אותו.
אבל בF, יש לי משתנה מקומי, אשר נקרא X.
אז אני הולך קדימה, לתת F נתח של זיכרון, קורא לזה x.
>> ועכשיו malloc של 10 פעמים 4, אז 40 malloc, איפה ש
זיכרון מגיע?
לא אנחנו שציירנו תמונה אוהב את זה בעבר.
אבל בואו נניח שזה יעיל מגיע מכאן, כך שאף אחד,
שתיים, שלוש, ארבע, חמש.
ועכשיו אני צריך 40 מהם.
אז אני פשוט אעשה את נקודה, נקודה, נקודה להציע שיש אפילו יותר זיכרון
חוזר מהערימה.
עכשיו, מה הכתובת?
בואו לבחור שרירותי שלנו לטפל כמו תמיד -
Ox123, למרות שזה כנראה הולך להיות משהו אחר לגמרי.
זה את הכתובת של הבית הראשון ב הזיכרון שאני מבקש לmalloc.
>> אז בשורה קצרה, ברגע שמבצע 20, מה היא, פשוטו כמשמעו,
מאוחסן בתוך של x כאן?
Ox123.
והשור הוא לא מעניין.
זה רק אומר שהנה מספר הקסדצימלי.
אבל מה שמפתח הוא כי מה שיש לי חנות בX, שהוא משתנה מקומי.
אבל זה סוג הנתונים שלה, שוב, היא כתובת של int.
ובכן, אני הולך לאחסון Ox123.
אבל שוב, אם זה מעט מדי מסובך שלא לצורך, אם אני לגלול
בחזרה, אנחנו יכולים מופשטים זה משם די סביר ופשוט לומר שהוא X
מצביע לנתח זה של זיכרון.
>> אישור.
עכשיו השאלה שעל הפרק הוא הבא -
קו 21, כך מתברר, הוא מרכבה.
למה?
>> סליחה?
זה לא חייב -
אומר שפעם נוספת.
ובכן, זה לא בחינם.
אז זה שני אבל.
אז יש אחד אחרת, אבל באופן ספציפי בקו 21.
>> בדיוק.
שורה פשוטה זו של קוד היא פשוט גלישת מאגר, הצפת מאגר.
חיץ רק אומר שנתח של זיכרון.
אבל נתח זה של זיכרון הוא בגודל 10, 10 מספרים שלמים, מה שאומר שאם אנחנו
מדד לתוכו באמצעות הסוכר התחבירי סימון של מערך, הכיכר
בסוגריים, יש לך גישה x סוגר 0 x סוגר x 1,
סוגר נקודה, נקודה, נקודה.
x 9 סוגר הוא אחד הגדול.
אז אם אני עושה x 10 סוגר, שבו אני באמת הולך בזיכרון?
>> ובכן, אם יש לי 10 int -
בואו ממש לצייר את כל מכאן את אלה.
אז זה היה חמישה הראשונים.
הנה חמישה ints האחרים.
אז x סוגר 0 הוא כאן. x 1 סוגר הוא כאן. x 9 סוגר הוא כאן. x סוגר
10 היא כאן, מה שאומר שאני מספר, בקו 21, לשים את המחשב
מספר שבו?
המספר 0 שבו?
ובכן, זה 0, כן.
אבל רק העובדה ש0 הוא סוג של צירוף מקרים.
זה יכול להיות המספר 50, לכל מה שאכפת לנו.
אבל אנחנו מנסים לשים אותו בסוגר X 10, שבה זה
סימן השאלה נמשך, אשר זה לא דבר טוב.
תכנית זו עשויה היטב לקרוס כתוצאה מכך.
>> עכשיו, בואו נלך קדימה ולראות אם זה הוא, אכן, מה שקורה.
הפוך את הזיכרון, שכן הקובץ נקרא memory.c.
בואו נלך קדימה ולרוץ זכרון התכנית.
אז יש לנו מזל, באמת, זה נראה.
יש לנו מזל.
אבל בואו נראה אם ​​אנחנו עכשיו לרוץ Valgrind.
במבט הראשון, התכנית שלי אולי נראה שיש נכון בצורה מושלמת.
אבל תן לי לרוץ עם Valgrind - בדיקת דליפה שווה מלאה על זיכרון.
>> ועכשיו כשאני מפעיל את זה -
מעניין.
לא חוקי לכתוב בגודל 4 ב קו 21 של memory.c.
קו 21 של memory.c הוא איזה מהם?
אה, מעניין.
אבל הרגע.
גודל 4, מה שמתכוון?
אני רק אחד שכותב, אבל זה בגודל 4.
למה זה 4?
זה בגלל שזה int, אשר הוא, שוב, ארבעה בתים.
אז Valgrind מצא באג שאני, מעיף מבט בקוד שלי, לא עשה זאת.
ואולי TF שלך היה או לא.
מה Valgrind אבל בטוח מצא כי אנחנו עשינו טעות שם, אפילו
למרות שיש לנו מזל, והמחשב החלטתי, אה, אני לא הולך לקרוס
רק בגלל שאתה נגעת בבית אחד, אחד שווה של int של זיכרון שלא עשה את זה
למעשה עצמו.
>> ובכן, מה עוד כרכרה כאן.
כתובת -
זו היא כתובת מחפשת מטורפת בהקסדצימלי.
זה רק אומר שאי שם בערימה היא אפס בתים אחרי בלוק בגודל 40
מוקצה.
תן לי להתקרב לכאן ולראות אם זה קצת יותר מועיל.
מעניין.
40 בתים הם בהחלט הפסידו ברשומת הפסד של 1 1.
שוב, יותר מאשר מילים שימושית כאן.
אלא מבוסס על הקווים המודגשים, שבו אני צריך כנראה להתמקד
תשומת לב לבאג נוסף?
נראה כמו קו 20 של memory.c.
>> אז אם אנחנו חוזרים לקו 20, זה אחד שזיהה קודם לכן.
וזה לא בהכרח עגלה.
אבל יש לנו זה הפוך השפעותיו.
אז איך אני יכול לתקן לפחות אחת מהטעויות האלה?
מה אני יכול לעשות אחרי קו 21?
אני יכול לעשות ללא X, ולכן הוא לתת בחזרה זיכרון זה.
ואיך אני יכול לתקן את הבאג הזה?
אני בהחלט צריכה ללכת לא רחוק מ -0.
אז תן לי לנסות ולהפעיל מחדש את זה.
סליחה, בהחלט ללכת רחוק יותר מאשר 9.
הפוך את הזיכרון.
תן לי שידור חוזר Valgrind בחלון גדול יותר.
ועכשיו נראה.
נחמד.
כל הערמה ששוחררה.
אין דליפות אפשריות.
ומעל לכאן, אין שום אזכור יותר של הזכות חוקית.
>> רק כדי לקבל חמדן, ובואו לראות אם הפגנה נוספת
לא הולך כמתוכנן -
אני לא מקבל מזל לפני רגע.
ועובדה שזו היא אולי 0 שלא לצורך מטעה.
בואו פשוט נעשה 50, שרירותי למדי מספר, להפוך את זכרון לוכסן נקודת זיכרון -
עדיין לקבל מזל.
שום דבר לא מתרסק.
נניח שאני פשוט אעשה משהו באמת טיפש, ואני עושה את 100.
תן לי לסדר זיכרון, זכרון נקודת לוכסן -
לי מזל שוב.
מה דעתך על 1000?
ints מעבר, בערך, שבו אני צריך להיות?
הפוך זיכרון -
לעזאזל.
>> [שחוק]
>> אישור.
בואו לא יתעסק יותר.
שידור חוזר זיכרון.
שם אנחנו הולכים.
בסדר.
אז כנראה שאתה מדד 100,000 ints מעבר שבו אתה צריך להיות ב
זיכרון, דברים רעים קורים.
אז זה כמובן לא קשה, שלטון מהר.
הייתי סוג של שימוש במשפט וטעייה כדי להגיע לשם.
אבל זה בגלל, סיפור ארוך קצר, הזיכרון של המחשב מחולק גם
לדברים האלה נקראים מגזרים.
ולפעמים, דווקא המחשב נתן לך קצת יותר זיכרון
ממה שאתה מבקש.
אבל ליעילות, זה פשוט קל יותר לקבל יותר זיכרון, אלא רק לספר לך
שאתה מקבל חלק ממנו.
>> ואם אתה מקבל מזל לפעמים, לכן, ייתכן שתוכל לגעת
זיכרון שלא שייך לך.
אין לך שום ערובה לכך שמה ערך אתה מכניס לשם תישאר שם, כי
מחשב עדיין חושב שזה לא שלך, אבל זה לא בהכרח הולך
לרמה של תחום פעילות אחרת של זיכרון ב מחשב ולגרום טעות כמו
זה כאן.
בסדר.
כל שאלות אז על זיכרון?
>> בסדר.
בואו נסתכל כאן, ולאחר מכן, בשעה משהו שאנחנו כבר לוקחים על
מובן מאליו די הרבה זמן, אשר הוא בקובץ הזה שנקרא cs50.h.
אז זה קובץ.
אלה הם רק כל חבורה מהערות למעלה.
ושאולי יש לי הסתכל על זה, אם אתה חטטת במכשיר.
אבל מתברר שכל הזמן, כאשר אנו נהגנו להשתמש כמחרוזת
מילה נרדפת, האמצעי שבעזרתו אנו הכריזו שנרדפו היה עם זה
מילת המפתח typedef, להגדרת סוג.
ואנחנו בעצם אומרים, לעשות מחרוזת שם נרדף לכוכב char.
שבאמצעותו המחסנית יצר גלגלי עזר אלה המכונים
המחרוזת.
>> עכשיו הנה רק אב טיפוס לgetchar.
אנחנו יכולים לראות את זה בעבר, אבל זה אכן מה שהיא עושה. getchar
לא לוקח ארגומנטים, מחזיר char.
getdouble לא לוקח ארגומנטים, מחזיר כפול.
getfloat לא לוקח ארגומנטים, חוזר לצוף, וכן הלאה.
getint הוא כאן. getlonglong הוא כאן.
וgetstring הוא כאן.
וזהו זה.
קו סגול זה preprocessor אחר הוראה בגלל
hashtag בתחילתו.
>> בסדר.
אז עכשיו תן לי ללכת לcs50.c.
ואנחנו לא מדברים יותר מדי זמן על זה.
אבל כדי לתת לכם הצצה של מה היה הולך על כל זה
זמן, תן לי ללכת ל--
בואו נעשה getchar.
אז getchar הוא בעיקר הערות.
אבל זה נראה כך.
אז זו הפונקציה הממשית getchar שאנחנו כבר
לוקח כמובן מאליו קיים.
ולמרות שאנחנו לא משתמשים בזה כי לעתים קרובות, אם בכלל, זה לפחות
פשוט יחסית.
אז זה שווה לקחת מבט מהיר על כאן.
>> אז יש getchar לולאה אינסופית, בכוונה כך ככל הנראה.
לאחר מכן הוא קורא - וזה סוג של שימוש חוזר בקוד נחמד שלנו את עצמנו כתבנו.
היא מכנה getstring.
כי מה שעושה את זה מתכוון להגיע char?
ובכן, אתה יכול גם לנסות להשיג שורה שלמה של טקסט מהמשתמש ו
אז פשוט מסתכל אחד של דמויות אלה.
בקו 60, הנה קצת קצת בדיקת שפיות.
אם getstring חזר ריק, בואו לא להמשיך.
משהו השתבש.
>> עכשיו זה מעצבן קצת אבל קונבנציונלי בג char מקסימום כנראה
מייצג את מה בדיוק המבוסס על שמו?
זה קבוע.
זה כמו הערך המספרי של הגדול ביותר char אתה יכול לייצג עם
ביס אחד, שהוא כנראה המספר 255, המהווה את המספר הגדול ביותר שלך
מייצג שמונה סיביות, מתחיל מאפס.
אז אני כבר משתמש בזה, בפונקציה זו, כאשר כתיבת קוד זה, רק משום
אם משהו משתבש בgetchar אבל מטרתו בחיים היא לחזור
char, אתה צריך להיות מסוגל איכשהו כדי לאותת למשתמש כי
משהו השתבש.
אנחנו לא יכולים להחזיר null.
מתברר כי האפס הוא מצביע.
ושוב, יש getchar כדי לחזור לדמות.
>> אז האמנה, אם משהו לא לא נכון, הוא שאתה, המתכנת, או ב
מקרה זה, אותי עם הספרייה, היה לי פשוט להחליט באופן שרירותי, אם
משהו משתבש, אני הולך להחזיר את המספר 255, שהוא באמת
אומר שאנחנו לא יכולים, המשתמש לא יכול להקליד התו מיוצג על ידי
מספר 255, כי היו לנו לגנוב אותו כערך זקיף שנקרא ל
לייצג את בעיה.
עכשיו מתברר שדמות 255 זה לא משהו שאתה יכול להקליד על
המקלדת שלך, כך שזה לא עניין גדול.
המשתמש לא יבחין כי אני כבר נגנב הדמות הזאת.
אבל אם אי פעם תראו בדפי איש על מערכת מחשב התייחסות מסוימת ל
כל כמוסות מתמדת כמו זה שאומר, במקרים של טעות כוח מתמיד
יוחזר, זה כל מה שאדם מסוים עשה לפני שנים היה באופן שרירותי החליט
להחזיר ערך והמיוחד הזה קוראים לזה קבוע במקרה
משהו משתבש.
>> עכשיו הקסם קורה כאן למטה.
ראשית, אני מצהיר בקו 67 שתי דמויות, C1 ו-C2.
ולאחר מכן בקו 68, אין למעשה שורת קוד זה מזכיר
ידידנו printf, בהתחשב בכך שאותו אין לי אחוזים CS במרכאות.
אבל שים לב למה שקורה כאן. sscanf אומר סריקת מחרוזת -
משמעות הדבר היא לסרוק מעוצב מחרוזת, sscanf ergo.
מה זה אומר?
זה אומר שאתה עובר לsscanf מחרוזת.
וקו הוא כל מה המשתמש מקליד פנימה
אתה עובר לsscanf מחרוזת פורמט כמו זה שאומר לי scanf מה הם
אתה מקווה שהמשתמש הקליד פנימה
לאחר מכן אתה עובר-בכתובות של שני נתחי הזיכרון, במקרה זה,
כי יש לי שני מצייני מיקום.
אז אני הולך לתת לו את הכתובת של C1 ואת הכתובת של C2.
>> וזוכר שאתה נותן פונקציה כתובת של כמה משתנה, מה זה
המשמעות?
מה פונקציה שיכולה לעשות כתוצאה לתת לו את הכתובת של
משתנה, בניגוד ל את המשתנה עצמו?
זה יכול לשנות את זה, נכון?
אם היה לך מישהו למפה פיזית כתובת, הם יכולים ללכת לשם ולעשות
מה שהם רוצים באותה כתובת.
אותו הרעיון כאן.
אם אנו עוברים לsscanf, הכתובת של שתיים נתחי הזיכרון, אפילו זעירים אלה
נתחים קטנים של זיכרון, C1 ו-C2, אבל אנחנו אומרים לו את הכתובת שלהם,
sscanf יכול לשנות את זה.
>> אז המטרה של sscanf בחיים, אם אנו קוראים דף האדם, הוא לקרוא את מה
משתמש קליד ב, מקווה שלמשתמש יצטרך הקליד בתו ואולי
דמות אחרת, וכל מה שהמשתמש הקליד, התו הראשון הולך
כאן, התו השני הולך כאן.
עכשיו, במאמר מוסגר, זה, ושהיית רק יודע שזה מהתיעוד,
העובדה ששמתי את שטח ריק שיש רק אומר שלא אכפת לי אם
המשתמש לוחץ על מקש הרווח כמה פעמים לפני שהוא או היא לוקחת
אופי, אני הולך להתעלם כל חלל לבן.
כך שאני יודע מ התיעוד.
>> העובדה שיש% ג שני אחריו החלל לבן הוא למעשה
מכוון.
אני רוצה להיות מסוגל לזהות אם המשתמש דפוק או לא שתף ​​פעולה.
אז אני מקווה שמשתמש הקליד בלבד בתו אחד, ולכן אני מקווה
שsscanf הולך רק כדי לחזור ערך 1 כי, שוב, אם אני קורא
התיעוד, המטרה של sscanf ב חיים הוא לחזור למספר
משתנים שמולאו עם קלט משתמש.
>> אני עברתי בשני משתנים כתובות, C1 ו-C2.
אם כי אני מקווה,, שרק אחד שלהם מקבל נהרג כי אם sscanf
2 חוזר, מה יש להניח המשמעות הגיונית?
שהמשתמש לא רק תן לי אחד אופי כמו שאמרתי לו או לה.
הם כנראה הקלידו ב שני תווים לפחות.
אז אם אני במקום שלא הייתי לי שני % ג, פשוט היה לי אחד, אשר
כנות יהיה אינטואיטיבי יותר גישה, אני חושב שמבט ראשון,
אתה לא הולך להיות מסוגל לזהות אם המשתמש כבר נותן לך יותר
קלט ממה שאתה באמת רוצה.
אז זו צורה מרומזת מבדיקת שגיאות.
>> אבל שים לב למה שאני עושה כאן.
ברגע שאני בטוח שהמשתמש נתן לי אחד אופי, אני משחרר את הקו, עושה
ההפך מgetstring, אשר בתורו משתמש malloc, ולאחר מכן אני חוזר
C1, הדמות שקיוויתי סיפק למשתמש, ורק בתנאי.
אז הבחין מהיר בלבד, אבל שאלות על getchar?
אנחנו נחזור לכמה מהאחרים.
>> ובכן, תן לי ללכת ולעשות את זה - נניח עכשיו, רק כדי להניע אותנו
דיון בשבוע בתוספת זמן, זה הוא קובץ שנקרא structs.h.
ושוב, זה רק טעם של משהו שנמצאת קדימה.
אבל שים לב שהרבה לכך היא תגובות.
אז הרשה לי להדגיש רק את חלק מעניין לעכשיו.
typedef -
יש שאותה מילת מפתח שוב.
typedef אנו משתמשים כדי להכריז על מחרוזת כסוג נתונים מיוחד.
אתה יכול להשתמש בtypedef כדי ליצור מותג חדש סוגי נתונים שלא היו קיימות בעת
C הומצא.
לדוגמה, int מגיע עם ג char מגיע עם ג הכפול מגיע עם C. אבל
אין שום רעיון של תלמיד.
ובכל זאת, זה יהיה די שימושי כדי להיות תוכל לכתוב תכנית שמאחסנת
במשתנה, מספר תעודת הזהות של תלמיד, השם שלהם, וביתם.
במילים אחרות, שלוש חתיכות של נתונים, כמו int ו
מחרוזת ומחרוזת אחרת.
>> עם typedef, מה זה די חזק על זה וsturct מילת המפתח
מבנה, שאתה, המתכנת בשנת 2013, בעצם יכול להגדיר את עצמך
סוגי נתונים שלא היו קיימים שנים לפני אבל שתתאימו למטרות שלך.
וכן כאן, בשורות 13 עד 19, אנחנו מכריזים סוג הנתונים חדש, כמו
int, אבל קוראים לזה תלמיד.
ובתוכו של משתנה זה הולך להיות שלושה דברים - int, מחרוזת,
ומחרוזת.
אז אתה יכול לחשוב על מה שבאמת קרה כאן, למרות שזה
קצת פישוט להיום, תלמיד הוא בעצם הולך
כדי להיראות כך.
שלה הולך להיות חתיכה זיכרון עם תעודת זהות, שם
שדה, ושדה בית.
ושנוכל להשתמש באותם גושים זיכרון ולגשת אליהם באופן הבא.
>> אם אני נכנסתי לstruct0.c, כאן הוא יחסית ארוך, אך בעקבות
דפוס, קוד ש משתמש בטריק החדש הזה.
אז קודם כל, הרשה לי להסב את תשומת לבך לחלקים המעניינים למעלה.
שארפ מגדיר סטודנטים 3, מצהיר תלמידים קבועים הנקראים ובאי
זה באופן שרירותי את המספר 3, רק אז יש לי שלושה סטודנטים המשתמשים
תכנית זו לעת עתה.
הנה בא ראשי.
ושים לב, איך אני מצהיר מערך של סטודנטים?
ובכן, אני פשוט להשתמש באותו התחביר.
המילה הוא כמובן התלמיד חדש.
אבל סטודנטים, תלמידים בכיתה, סוגר.
>> אז לצערי יש הרבה של שימוש חוזר של מונחים כאן.
זה רק מספר.
אז זה כמו לומר שלוש.
כיתה היא בדיוק מה שאני רוצה לקרוא למשתנה.
אני יכול לקרוא לזה סטודנטים.
אבל בכיתה, זה לא בכיתה מונחה עצמים מסוג ג'אווה של דרך.
זה רק בכיתה של תלמידים.
ואת סוג הנתונים של כל אלמנט במערך שהוא תלמיד.
אז זה קצת שונה ומלומר משהו
ככה, זה פשוט -
אני אומר תן לי שלושה סטודנטים וקורא בכיתה מערך זה.
>> בסדר.
עכשיו הנה לולאה ארבע.
מכיר את הבחור הזה - לחזר מאפס בעד שלוש.
והנה הקטע של תחביר החדש.
התכנית הולכת להנחות אותי, האנושי, כדי לתת לו תלמיד
מזהה, שהוא int.
והנה התחביר שבה אתה יכול לאחסן משהו בשדה מזהה ב
מיקום כיתת א אז סוגר תחביר זה אינו חדש.
זה רק אומר שייתן לי את השמיני תלמיד בכיתה.
אבל הסמל הזה הוא חדש.
עד עכשיו, אנחנו כבר לא יכולים לשמש נקודה, לפחות בקוד כזה.
משמעות דבר הוא ללכת לstruct המכונה תלמיד ולשים שם משהו.
באופן דומה, בשורה הבאה, 31, ללכת קדימה ולשים את מה שהמשתמש מקליד
לשם כאן, ומה שהם עושים עבור הבית, אותו הדבר, קדימה,
לשים אותו ב. בית.
>> אז מה עושה תכנית זו סופו של דבר לעשות?
אתה יכול לראות טיזר קטן שם.
תן לי ללכת קדימה ולעשות structs 0 נקודת לוכסן struct 0, תעודת הסטודנט של 1,
אומרים דוד מאת'ר, תעודת סטודנט 2.
רוב קירקלנד, תעודת סטודנט 3.
לורן Leverit -
והדבר היחיד שעשתה את התכנית הזאת, וזה רק שרירותי לחלוטין, הוא
אני רוצה לעשות משהו עם המידע הזה, עכשיו שאני כבר לימד אותנו איך
להשתמש structs, הוא פשוט היה לי זה לולאה נוספת כאן.
אני לחזר על המערך של תלמידים.
הייתי חבר שלנו, אולי עכשיו המוכר, מחרוזת להשוות, stircomp ל
סימון הוא ביתו של תלמיד ה -8 שווה מאת'ר?
ואם כן, פשוט להדפיס משהו באופן שרירותי כמו, כן, זה הוא.
אבל שוב, רק נותן לי הזדמנויות להשתמש ולעשות שימוש חוזר ו
שימוש חוזר בסימון הנקודה חדש זו.
>> אז למי אכפת, נכון?
לבוא עם תכנית סטודנט הוא במידה מסוימת שרירותי, אבל מסתבר
שאנחנו יכולים לעשות דברים מועילים עם זו, למשל באופן הבא.
זה הרבה יותר מסובך struct בג יש לו תריסר או יותר שדות,
במידה מסוימת בשם ולא פרשתי.
אבל אם אי פעם שמע על גרפיקה פורמט קובץ שנקרא מפת סיביות, BMP, זה
מתברר שקובץ בפורמט מפת הסיביות פחות או יותר נראה כמו שזה.
זה פרצוף סמיילי קטן טיפש.
זה תמונה קטנה שאני כבר זנקתי ב על די גדול, כך שאני יכול לראות זה את
של נקודות או פיקסלים הבודדים.
כעת, מתברר שאנחנו יכולים לייצג נקודה שחורה עם, יניח, את המספר 0.
ונקודה לבנה עם מספר 1.
>> אז במילים אחרות, אם אתה רוצה לצייר פרצוף מחייך ולשמור את התמונה שב
מחשב, זה מספיק כדי לאחסן ואפסים אלה שנראים כמו זה, שבו,
שוב, אלה הם לבנים ואפסים הם שחורים.
וביחד, אם יש לך ביעילות לשנס של אלה ואפסים, יש לך
רשת של פיקסלים, ואם אתה שכב אותם, יש לך חמוד
פרצוף סמיילי קטן.
עכשיו, פורמט קובץ מפת סיביות, BMP, הוא יעילות שמתחת למכסת המנוע,
אבל עם יותר פיקסלים SOT שאתה למעשה יכול לייצג את הצבעים.
>> אבל כאשר יש לך יותר מתוחכם פורמטים של קבצים כמו BMP ו-JPEG ו-GIF
שבה אתה יכול להיות מוכר, אלה קבצים בדיסק בדרך כלל לא רק
יש אפסים ואחדים לפיקסלים, אבל יש להם קצת מטה וכן -
מטה במובן זה שהוא לא ממש נתונים אבל זה שימושי.
אז השדות האלה כאן הם רומזים, ו אנחנו תראו את זה בפירוט רב יותר בP-סט
5, שלפני האפסים והאחדים ש מייצג את הפיקסלים בתמונה,
יש חבורה של מטה כמו גודל התמונה ו
רוחב של התמונה.
ושים לב שאני תולש את חלק דברים שרירותיים כאן -
רוחב וגובה.
ספירה קצת ועוד כמה דברים אחרים.
אז יש איזה מטה בקובץ.
>> אלא על ידי הבנת אופן שהקבצים ערוכים בדרך זו, אתה יכול למעשה
לאחר מכן לתפעל את התמונות, לשחזר תמונות מדיסק, לשנות את גודל תמונות.
אבל אתה לא יכול בהכרח לשפר אותם.
הייתי צריך לצלם.
אז חזרתי לRJ כאן, שאתה ראית על המסך לפני די הרבה זמן.
ואם אני פותח את Keynote כאן, זה הוא מה קורה אם אתה מנסה להתקרב ו
לשפר RJ.
הוא לא משתפר באמת.
עכשיו מרכזי הוא סוג של טשטושו קצת, רק כדי לחפות על
עובדה שאינו מקבל RJ במיוחד משופר בעת להתמקד פנימה
ואם עושה את זה ככה, לראות את הריבועים?
כן, אתה בהחלט יכול לראות הריבועים על מקרן.
>> זה מה שאתה מקבל כשאתה לשפר.
אבל בהבנה כיצד RJ או הסמיילי מיושם יאפשר לנו
בעצם לכתוב קוד שמתפעל את הדברים האלה.
ואני חשבתי שאני רוצה לסיים בנקודה הזאת, עם 55 שניות של לשפר את זה,
אני מעז, אומר ולא מטעה.
>> [השמעת וידאו]
>> -הוא משקר.
על מה, אני לא יודע.
>> -אז מה אנחנו יודעים?
>> זה בשעה 9:15-ריי Santoya היה בכספומט.
>> -אז השאלה היא מה הוא עושה בשעה 9:16?
>> ירי תשעה המילימטר במשהו.
אולי הוא ראה את הצלף.
>> האור היה לעבוד איתו.
>> -המתן.
חזור אחד.
>> , מה אתה רואה?
>> , להביא את פניו, מסך מלא.
>> -משקפיים.
>> -יש השתקפות.
>> -זה קבוצת בייסבול Neuvitas.
זה הלוגו שלהם.
>> , והוא מדבר לכל מי שהוא לובש מעיל ש.
>> [השמעת וידאו הסוף]
>> דוד י Malan: זה להגדיר בעיה 5.
אנחנו אראה אותך בשבוע הבא.
>> רמקול גברי: בCS50 הבא.
>> [צרצרים מצייץ]
>> [השמעת מוסיקה]