>> ג'ייסון הירשהורן: ברוכים הבאים לA5, כולם.
יש לנו שבוע מרגש לפנינו, בעיקר בגלל שיש כל כך הרבה חדש
פרצופים בחדר הזה.
זה נפלא.
הרבה מכם נמצאים כאן במקרה, וזה אפילו טוב יותר.
אז אני מקווה שתוכל לשמור על שהצטרף אלינו.
>> השבוע אנחנו הולכים לבלות את חלק הארי של סעיף
מתכונן לחידון.
אז לכל סדר היום שלנו, אנחנו הולכים לדבר קצת על משאבים לכיתה,
אלא גם עבור החידון, ולאחר מכן, שוב, מבלה את חלק הארי של דיבור בכיתה
על שאלות.
ברגע שנסיים לענות שאלות, או אם השאלות שלך
באופן טבעי להוביל אותנו לאיזה קידוד, אני יש להם בעיות דגימה מאמצע השליש
האחרון שאנחנו קוד חי בסעיף יחד כי גם להעלות כמה אחר
נושאים טובים לכיסוי.
>> אז קודם כל, כפי שאנו כבר עברנו ל הזוג האחרון של שבועות כדי להזכיר לך
חבר 'ה, יש טונות של משאבים זמין לקורס הזה.
רבים מהם יהיו מועילים מאוד אליך כפי שאתה ממשיך
ללמוד לחידון 0, כי זה יום שלישי אחר הצהריים.
אז כולכם היה לומד קצת.
>> יש סיכומי הרצאות ומקור קוד שאתה צריך
בהחלט לבדוק.
צפו במכנסיים הקצרים.
עזיבה study.cs50.net.
ולאחר מכן, המפורטים להלן, מספר של משאבים אחרים.
>> שוב, חידון 0 מחר בשעה 1.
אם לא עשה זאת כבר, לבדוק מתוך מסמך חידון 0 אודות על
בדף הבית של הקורס כדי להבין לאן אתה לוקח את החידון.
החידון מתחיל ב1:10 ו מסתיים 70 דקות מאוחר יותר.
אז אם אתה מגיע אחרי 1:10, אתה הולך לקבל פחות שרבים דקות
מ -70 לקחת את החידון.
אז לוודא שאתה שם בזמן.
אם אתה סטודנט הארכה או שיש לי כמה שיקולי בדיקות אחרים, זה
לא יכול להיות ב1:00 מחר.
אבל שוב, לבדוק את החידון אודות 0 מסמך כדי לוודא שאתה יודע כש
אתה לוקח את החידון.
כתבתי 75 דקות עד כאן.
אני חושב שזה נכון, לא 70.
>> זה מכסה את כל החומר משבוע 0 להרצאה בשבוע שעבר ביום רביעי.
ושוב, לחידון הזה, של מסמך, אתה מקבל אחד משני צדדים ו8
1/2 על ידי 11 גיליון נייר שאתה מקבל כדי להשתמש בו כהערות במהלך החידון.
אנשים רבים, אם לא רוב האנשים, יש לי מצא שהדרך המועילה ביותר
ללמוד לחידון הוא להפוך את גיליון מחקר,
אחד סדר, משלהם.
אז להסתכל על העבר אלה אם שראית בעבר אלה.
להושיט יד לחברים כדי לראות מה הם לשים עליהם.
>> אבל ידיים למטה, הדרך הטובה ביותר שאתה יכול מחקר הוא לעבור את הכל ו
לקצץ אותו למה שצריך או לא שייך בגיליון זה של
נייר, כי זה פשוט באמת דרך מועילה עבורך כדי לוודא
אתם עוברים את הכל ו יש להם היכרות מסוימת עם זה.
רוב האנשים, אנו מוצאים, למרות שהם יש גיליון נייר יושב ממש
לידם בחידון, לא פונה לזה, כי, שוב, שמאוד
תהליך עובר המידע עזר להם ללמוד את זה.
>> האם יש למישהו שאלות על חידון 0?
לכל אחד יש -
אני לא הולך לעשות הרמת ידיים.
אין דבר.
אני הולך לשאול מי התחיל ללמוד.
אבל אני לא רוצה לגרום לך כל לא להרים את הידיים שלך.
אז כמו שאמרתי - כן, אבי, קדימה.
>> אבי: מה יהיה דבר שימושי לשים על אחד הביפר?
>> תלמיד: זה תלוי בך.
>> ג'ייסון הירשהורן: אתה מקבל להשתמש בשיקול הדעת שלך.
דברים שימושיים לשים על אחד זימונית, אם אתה מבולבל לגבי O הגדול
ריצה סוגים שונים של חיפושים של ומינים, לשים את זה על שם ב
תרשים גנדרן שימושי.
בדרך זו, אם אתה ביקשת שעל חידון, אתה לא צריך לנסות ודמות
את זה או דרך סיבה זמן הריצה.
אתה יכול פשוט להעתיק אותו.
אם אתה מסתכל על עבר חידונים, הרבה פעמים, יש לפעול על שאלות זמן.
כדי שיהיה דוגמה לטובה דבר לשים על אחד הביפר שלך.
>> דברים טובים אחרים לשים על, אם אתה מבולבל לגבי איך להכריז
פונקציה או מה החלקים השונים של הכרזת הפונקציה הן, לכתוב
כי שם, גרסה הגנרית ואז אולי ירושלים.
אם אתה מבולבל לגבי מצביעים, תרשים של אופן עבודה של מצביעים היא
כנראה באמת מועיל.
אם אתה מבולבל לגבי רקורסיה, לטעום פונקציה רקורסיבית שם
גם יכול להוכיח להיות מועיל באמת.
האם זה ייתן לך כמה רעיונות?
>> AVI: אתה צריך להבין תהליך קומפילציה כולו, כמו
איך שכל העבודות?
>> ג'ייסון הירשהורן: הכל כי כבר כיסה את יכול
להופיע בחידון.
שאלות -
אבל שוב, יש דברים שיהיו משקל כבד יותר מאחרים.
יש דברים שצריכים לבוא שוב ושוב בכיתה, ב
הרצאה, וחתך.
דברים אחרים לא לבוא כי לעתים קרובות.
>> אנחנו כבר דיברנו הרבה על # include ו -L משהו ומה אלה מתכוונים ב
תהליך ההידור.
אנחנו כבר דיברנו הרבה על GDB, נצמדים, אלה דגלים שונים שאנו משתמשים בי
אנחנו לקמפל משהו, ומה make15, למשל, באמת
אומר ובאמת עושה.
אנחנו לא מדברים כל כך הרבה על כל צעד אחד ב
תהליך ההידור.
עדיין יש לנו דיברנו על זה.
אז זה עדיין משהו שאתה צריך להיות מוכר עם.
אבל שוב, אנחנו לא הולכים להיות -
דברים שעולים בתדירות גבוהה יותר בכיתה יש סיכוי גבוה יותר לבוא יותר
לעתים קרובות ולהיות יותר בכבדות משוקלל בחידון.
>> מגניב.
יש עוד שאלות על חידון 0?
>> אוקיי, אז שמתי את רשימה נושאים על הלוח.
עברתי את תכנית הלימודים.
עברתי את סעיף ביקורת מ אתמול בלילה ושקופיות אלה כדי לבוא
עם רשימה לא ממצה של נושאים כי יש לנו מכוסה עד כה בCS50
ודברים שאולי מופיע בחידון.
אז אני לא הולך לעבור כל אחד ואחד מאלה.
שתיקח הרבה יותר זמן ממה שיש לנו עכשיו.
אבל אני שם את זה כאן בתקווה לרוץ הזיכרון שלך כמו לדברים שעשויים
או לא יכול להיות מוכר כאיתך.
>> ואני אשמח לבלות את עיקר סעיף לענות על השאלות שלך על
נושאים, הנושאים האלה כי אינם מכוסים כאן.
אנחנו יכולים לכתוב קוד פסאודו.
אנחנו יכולים לכתוב קוד אמיתי כדי להבטיח לך -
אני יכול לענות על השאלה שלך ולעזור כולם ביסוד מבינים
הרבה נושאים אלה, כך שתרגישו מוכן ונוח להיכנס
החידון מחר.
אז לקרוא על הרשימה.
אתה מקווה שהגעת לסעיף עם כמה שאלות גם כן.
כשתהיה מוכן, להרים את היד שלך ואנחנו נתחיל.
>> זכרו, את השאלות שיש לך, אין שאלות טיפשיות.
שלנו שמענו את זה הרבה.
והשאלות שיש לך, אני מוכן להמר, אנשים רבים אחרים גם
יושב כאן וצופה באינטרנט יש גם כן.
אז אתה יכול רק לעזור לאנשים על ידי שואל שאלות.
מרקוס.
>> מרקוס: בין הערימה ו גל, האם יש שהוקצה מראש
אחוז הזיכרון שמוגדר כ זה לערימה או לערימה?
או איך זה עובד בדיוק?
>> ג'ייסון הירשהורן: שאלה גדולה.
אני הולך לחצר אחורית קצת.
האם כולם -
בבקשה להיות כנה כאן.
אני יודע שאני מבקש ממך להעלות אותך יד מול החברים שלך.
אבל יש אנשים שמרגישים שלא בנוח עם המחסנית וערימה
ואת רוצה ללכת על זה ומה אלה אומר?
הרם את ידך אם -
על אישור.
תודה.
אז אנחנו הולכים לעבור על הערימה ו הערימה ממש מהר ולאחר מכן
לעבור לתשובה לשאלה שלך.
>> אז אם אנו מפנים את תיבה לייצג זיכרון במחשב שלך, מה הם כמה
דברים שהולכים בתיבה זו?
ראשי.
פונקציה העיקרית.
לאן הולך עיקרי?
>> תלמיד: [לא ברור].
>> ג'ייסון הירשהורן: אז אנחנו לשים עיקרי כאן למטה.
מה עוד הולך בתיבה זו?
>> תלמיד: הפונקציות שאתה קורא.
>> ג'ייסון הירשהורן: הפונקציות שאנחנו קוראים.
ולאן הם הולכים?
>> תלמיד: בערימה.
>> ג'ייסון הירשהורן: הם ללכת בערימה.
אז אנחנו הולכים לקרוא לזה דבר כאן למטה את המחסנית.
ועד עליון, יש לנו את הערימה.
אז זיכרון הוא לא קופסא בדיוק כמו זה.
אבל זה בעצם די דומה.
זה הולך להיות הרבה תיבות על ושוב, תלוי כמה גדול שלך
מחשב הוא או כמה גדול הוא הזיכרון שלך.
>> ביסוד "" כביכול הזאת הוא הערימה.
ויש דברים מרובים כי ללכת בערימה.
ואלה תלויים בפונקציות יש לך בקוד שלך.
תמיד יש לך תפקיד אחד בך קוד נקרא עיקרי, ולכן תמיד יש
קטע כאן למטה ב מחסנית מוקדשת לעיקרי.
>> סעיפים אלה בערימה נקראים מסגרות מחסנית.
כשאתה קורא לפונקציה אחרת, אומרים עיקרי קורא פונקציית חיפוש בינארי,
אנחנו שמים את מסגרת אחרת בערימה.
באופן ספציפי יותר, אנחנו הולכים לתרום נתח של זיכרון עלינו
מחשב כדי לאחסן החיפוש של ינארי מקומי משתנים ולרוץ בינארי
קוד חיפוש.
>> אז אנחנו קוראים לחיפוש בינארי.
בנתח זה של זיכרון, אנחנו הולכים כדי לאחסן את המשתנים המקומיים שלה.
אנחנו הולכים לאחסן שיחות printf שלה.
מה שלא יקרה, הפונקציה שהיא הולך להיות מאוחסנים ממש שם.
החיפוש בינארי הוא הולך לבצע.
זה הולך להשלים את הביצוע.
מהי המילה בשפת C שמסמלת כי במקרה שפונקציה
להשלים את ביצועה?
>> תלמיד: שבות.
>> ג'ייסון הירשהורן: חזור.
אז בכל פעם שאתה רואה הצהרת תמורה, קצות הפונקציה
כאשר הוא יגיע זה.
החיפוש בינארי אז יפגע החזרתו.
חלק זה של זיכרון למעשה יהיה יתפנה.
ועיקרי יחזור להוצאת להורג.
אז עיקרי ישהה ​​בכל מקום הייתה, שיחה חיפוש בינארי, לקבל קצת ערך החזרה,
ולהמשיך ביצוע.
מסגרת מערך זה תיעלם.
>> אם אנחנו קוראים לפונקציה רקורסיבית, שבו היא פונקציה שקוראת על עצמו
ושוב, אנחנו עלולים לקבל - אומרים לנו עשה חיפוש בינארי באופן רקורסיבי.
אנו עשויים לקבל גרסת החיפוש בינארי אחד, שני חיפוש החיפוש בינארי, בינארי
שלוש, חיפוש בינארי ארבעה, החיפוש בינארי חמש.
ולאחר מכן חיפוש בינארי זה סופי חמש יפגע במקרה הבסיס, והמחסנית
המסגרות יחזרו ולשמור סגירה עד שנחזור לעיקרי.
אנחנו יכולים לעבור על רקורסיה בקצת.
אבל כל זה הוא אומר, אם אתה קורא פונקציות מרובות בו זמנית,
שם אהיה ערימה מרובה מסגרות בערימה.
>> גל, לעומת זאת, עד כאן, אינו עבור פונקציות,
לא למשתנים מקומיים.
זה בשביל שהוקצה באופן דינמי משתנים.
אז אלה הם משתנים שיכולים להיות אותחל באחת עיקרי או
פונקציה שהשיחות העיקריות.
בכל מקום בקוד שלך, הם ניתן לאתחל.
ולאתחל באופן דינמי משתנה שהוקצה.
מה פונקציה ב-C אנחנו משתמשים?
>> תלמיד: malloc.
>> ג'ייסון הירשהורן: malloc.
אתה קורא לmalloc.
אתה מקבל שטח של זיכרון.
ובמרחב זה של זיכרון הוא בערמה.
ובמרחב זה של זיכרון נשאר שם עד שאתה קורא בחינם.
>> משתנים כך שהוקצו באופן דינמי ב ערימה תהיה קיימת כל עוד אתה
רוצה שהם קיימים, והם לא יהיו תיעלם עד שאתה באופן מפורש
תגיד להם ללכת משם.
אתה יכול ליצור אותם בתפקיד אחד.
הערימה של הפונקציה ש המסגרת תיעלם.
אבל משתנים שעדיין קיימות בערימה עד שהוא השתחרר,
פוטנציאלי על ידי הפונקציה שנקראת חיפוש בינארי או משהו כזה.
>> אז משתני ערימה אלה להישאר שם במשך זמן רב ככל שאתה רוצה
להם להישאר שם.
ולקבל אותם כאן.
ולאחר מכן הבא מקבל לשים שם.
הם שומרים מקבלים מלאים ב, והם להישאר שם עד שאתה קורא בחינם.
>> ובעצם, הערימה והמחסנית, מקבל לשאלתו של מרקוס,
לגדול אחד כלפי שני.
ואם הם נתקלים זה בזה, יש לך נצל את כל הזיכרון בך
מחשב, והתכנית שלך להפסיק כי אין לך שום זיכרון יותר
עזב לשימוש.
ביניהם, יש דברים שעלולים להיות אחרים.
אבל להיקף של קורס זה, אתה לא צריך לדאוג בקשר לזה.
>> אז זה היה התשובה לשאלתך.
אל תדאגו.
אבל זה היה התשובה הארוכה.
כל מה שאתה צריך לדעת הוא ערימה והערימה יהיה -
אחד מתחיל בתחתית.
הערימה עושה.
הערימה נמצאת שם למעלה.
הם יגדלו יותר קרובים אחד לשני.
>> ואם הם נוגעים, זה בעיה.
אתה ברח מזיכרון.
אלא גם, בנוסף לידיעה שבי הם, מה מאוחסנים בשני
מחסנית וערימה.
קרטיס.
>> קרטיס: כאשר הם מתנגשים, היא שהצפת מחסנית?
>> ג'ייסון הירשהורן: כאשר הם מתנגשים, זה לא הצפת מחסנית.
הצפת מחסנית היא אזור אחר שאנחנו יכולים לעבור על אם אתה רוצה.
בסדר, אנחנו נחזור לזה בקצת.
>> תלמיד: מה המילה שנקראה כאשר הם פגעו זה בזה,
מחסנית והערימה?
>> ג'ייסון הירשהורן: לעת עתה, אל תדאגו.
פשוט יודע -
אני אענה על שאלה ש אחרי השיעור.
אם הם נתקלים זה בזה, אתה נגמר של זיכרון, כי אין יותר
מרחב שם.
>> תלמיד: סליחה, מה זה אשמת צינוק?
>> ג'ייסון הירשהורן: קטע אשמה יכולה להיקרא ל--
זה תלוי למה שנקרא של אשמת הצינוק.
לפעמים, הצפת הערימה שלך, זה יהיה אומר seg fault כטעות.
>> סטודנט: מה עם ביטול הפניה למבנה משתנה null?
האם זה באשמת צינוק?
>> ג'ייסון הירשהורן: ביטול הפניה מצביע null -
אוקיי, אז אם יש לך מצביע שאתה להגדיר שווה ל null, מצביעים, כזכור,
כתובות זיכרון חנות כערכים שלהם.
ומצביע null הוא למעשה אחסון 0, 0-th
לטפל במשתנה זה.
אז 0x, 0, 0, 0, 0, וכולי.
כי כתובת ה-0 בזיכרון זה לא בתמונה שלנו, זה שם למעלה
איפשהו, זה שמורות למחשב.
אסור לנו לגעת בו.
>> לכן, כאשר התכנית שלך שביצוע, אם משהו מנסה ללכת לזיכרון
כתובת 0, הוא יודע ש כי הוא ערך ריק.
הוא יודע שום דבר לא צריך להיות שם.
אז אם אתה מנסה להשתמש במשהו שיש ולטפל במשהו כמו שם או
מנסה ללכת למיקום זה, אתה הולך לקבל את אשמת צינוק או שגיאה.
האם זה עונה על השאלה שלך?
>> ועכשיו נלך אחורה לערום בגלישה.
דברים בערימה, כפי שיש לך חבר 'ה ראיתי לפני כן, ב-- בואו לצייר קרוב
ממסגרת מחסנית.
האם כל אחד יכול לראות את זה?
אז יש לנו מסגרת המחסנית שלנו.
אנחנו חוסכים במערך כמקומי משתנה בפונקציה זו.
אז אומר שיש לנו המערך של חמש נקודות.
כל חמישה מאלו יאוחסנו שבמסגרת המחסנית.
>> אם אנחנו מתחילים לכתוב מעבר גבולות של מערך זה -
כך שאם אנחנו מתחילים בכתיבה ל, נניח שתוצאה 0.
אלה הם חמישה אינדקסים של המערך שלנו.
אם אנחנו מתחילים לכתוב למדד 5, אשר אין לנו כאשר יש לנו
מערך של גודל 5, אנו מתחילים לכתוב לתוך מדד 6, 7, 8, 9, אנחנו יכולים לקבל סטאק
שגיאה בגלישה.
>> בדרך כלל זה לא -
אתה כנראה להיכנס לצרות אם אתה הולך על אחד.
אבל בדרך כלל, תוכל להיכנס רוב הצרות אם אתה הולך על ידי הרבה
ולך ללכת כל כך רחוק על שאתה כותב על כתובת השולח של אותו
פונקציה, הנמצאת ב תחתון של מסגרת המחסנית.
>> כי, נכון?
אתה - ב-- מצטער.
לא ", כי נכון".
>> במסגרת החבילה, יש לך המשתנים המקומיים שלך.
בתחתית הערימה מסגרת היא הכתובה השולח.
זה מקום שבי הפונקציה הולך כאשר זה נגמר.
ואם אתה מחליף תמורה ש כתובת, ואז כאשר מסגרת ערימה זו,
כשאתה עובר את המחסנית למסגר וביצוע כל שורה, אתה
הולך לכתובת השולח החדשה שלך שכתוב שם במקום
בפועל אחד.
וזה איך שראינו כמה פרצות אבטחה
יכול לקרות עם מחשבים.
>> הצפה אז ערימה, בקיצור, היא כאשר שלך להחליף את החלק במחסנית
אתה אמור להשתמש בו, מקומי משתנה שאתה אמור להשתמש בו, ו
בפרט כשאתה מתחיל להחליף דברים חשובים כמו
להחזיר את כתובת.
וזה שבו אתה מקבל הודעת שגיאה.
או שאולי אתה אפילו יכול להתחיל אפילו כותב ל--
אומר החיפוש בינארי היה ממש מעל עיקרי.
אם החליף את הרבה, אתה יכול לכתוב לעיקרי.
אבל בדרך כלל, אתה מקבל הודעת שגיאה לפני לאחר מכן, משום שהמחשב יודע
שאתה עושה משהו שאתה לא צריך לעשות.
כן.
>> תלמיד: מה ההבדל בין הצפת מחסנית
והצפת מאגר?
>> ג'ייסון הירשהורן: הצפת מאגר הוא סוג כללי יותר של
מה שתארתי זה עתה.
>> תלמיד: אז הצפת מחסנית היא דוגמא להצפת מאגר.
>> ג'ייסון הירשהורן: בדיוק.
זה מערך שאנחנו יכולים לחשוב עליו כ חיץ, מרחב לדברים להיכנס
זוהי גלישת מאגר ערימה.
יש לנו יכול הצפת מאגר ערימה.
אם היה חיץ, ששם לעתים קרובות הוא מערך הערימה, ואנחנו
החליף את אותם גבולות, ואז היינו יש הצפת מאגר ערימה.
>> ומעבר להיקף של קורס זה, הם זוהו בצורה מעט שונה.
יש מהדר מיוחד דרכים לזיהוי כל אחד.
אבל גלישת מאגר היא כללית יותר סוג של מה שתארתי,
שהיה הצפת מאגר ערימה.
האם זה עונה לשאלה שלך?
מתוק.
>> היה שם כל שאלות אחרות הקשורים לערימה או הערימה?
כן.
>> תלמיד: אני יודע שיש לך מיתרים בחינם בגלל שהם בערימה
ואתה לא רוצה לדליפת זיכרון.
אבל אתה צריך לשחרר את המשתנים גלובליים ודברים כאלה?
או שהם שחררו באופן אוטומטי?
>> ג'ייסון הירשהורן: שאלה טובה.
אז בCS50.H, אנו יוצרים את הדבר הזה בשבילך בשם מחרוזת.
מחרוזת היא באמת מה?
>> תלמיד: כוכב צ'אר.
>> ג'ייסון הירשהורן: כוכב char, מצביע לאופי, למצביע
מערך של תווים.
זה מה שהיא המחרוזת.
אז אנחנו צריכים לשחרר אותו, כי getstring, שבו השתמש הרבה -
שם מחרוזת שווה getstring -
שmallocs לנו כמה זיכרון על גל ולאחר מכן מחזיר את מצביע ל
התו ראשון של אותה מחרוזת, כוכב char.
>> אז, לכאורה, אם לא היה כתיבה חופשית על כל המיתרים שלך
כי אתה כבר קרא עד כה, יש לך כבר דולף קצת זיכרון.
כמובן שאנחנו לא דיברנו על את זה, אז אף אחד לא קיבל ב
צרות עושים את זה.
אבל הולך קדימה, כן.
כשאתה מתקשר getstring, אתה mallocing קצת מקום בערמה.
ואם אתה לא קורא חופשי מאוחר יותר כי מחרוזת, יש לך דליפת זיכרון.
זה עונה לשאלה שלך?
>> כן
>> תלמיד: אז לעשות את זה, אנחנו משתמשים זכות חופשית לפני התמורה?
בדומה, במסגרת, אני מניח שאם אנחנו אומרים, כאילו, int ראשי, בתוך
היקף הקוד זה בתוך אותם סוגריים מסולסלים, ממש לפני -
אתה יודע היכן אתה מעוניין בדרך כלל לשים תמורה.
האם אתה מכניס חופשי לפני זה?
>> ג'ייסון הירשהורן: אז אתה יכול לשים חופשי בכל מקום שאתה רוצה לשים חופשי.
כי אלה מוקצים באופן דינמי משתנים, כי הם יכולים
לחיות מעבר להיקף של בפרט פונקציה, אם אתה קורא malloc ב
פונקציה נפרדת, למשל, getstring, אתה יכול להתקשר חופשי בראשי.
אתה לא צריך לקרוא לזה בתפקיד הספציפי
בי malloc נקרא.
אבל אתה צריך לקרוא לזה לפני ההחזרים ראשיים.
>> וזה באמת תלוי.
זה תלוי במה אתה malloced כי מרחב במקום הראשון.
יש אנשים שיקראו לשחרר די מהר.
יש אנשים שלא להתקשר חינם עד סוף התכנית שלהם.
והם ילכו דרך והכל בחינם.
זה תלוי במה אתה נקרא malloc.
>> סטודנט: ומה היית אומר אם קרא getstring שימוש?
היית אומר חופשי מה?
>> ג'ייסון הירשהורן: אז התחביר בחינם הוא פשוט בחינם, paren הפתוח, קרוב
פארן, ואת שמו של המצביע.
כך שאם אתה כותב את השם של שווים מחרוזת getstring, אתה שם את השם כאן.
זה שמו של המצביע.
והוא יודע לשחרר את הזיכרון הזה.
>> תלמיד: אז כשזה משחרר שזיכרון, המצביע עדיין מצביע על מקום ש
בזיכרון?
או שהוא מצביע גם התרוקן מ הכתובת שהוא מצביע.
>> ג'ייסון הירשהורן: אנחנו צריכים לנסות את זה.
אנחנו צריכים לקודד את זה.
בואו נחזור כשנגיע ל הקידוד, ובואו קוד ש.
ואם אתה רוצה להבין את התשובה לזה, אתה יכול גם קוד ש
בינתיים.
אבל זה שאלה גדולה.
>> תלמיד: האם זה אפשרי משהו בחינם מוקדם מדי?
אז אתה עדיין צריך את זה לתכנית שלך, ואתה משוחרר שמקום בזיכרון?
>> ג'ייסון הירשהורן: כן.
זה אפשרי, אם משהו בחינם ואז אתה משתמש בו שוב, אתה יהיה
נתקל בשגיאה.
אבל זה עליך, כי אתה משוחרר משהו ואז קרא לזה מאוחר יותר.
אז זה היה הטעות של מתכנת.
אבל כן.
אתה יכול לכתוב את זה.
>> עוד שאלות על -
כן.
>> תלמיד: אז אם אתה אמור רק לשחרר אותו באופן כללי לפני
תכנית מסתיימת, זה אומר שאם תכנית מסתיימת ואתה לא לשחרר אותו,
זיכרון, שעדיין מוקצה?
>> ג'ייסון הירשהורן: אם התכנית שלך מסתיימת ואתה שוכח לשחרר משהו, ולאחר מכן
הזיכרון שהוקצה בכל חיים שלמים של התכנית שלך.
כאשר התכנית שלך נסגר לחלוטין, הזיכרון כי הוא לא הולך
להישאר שם לנצח.
המחשב הוא חכם מספיק כדי לדעת שכאשר התכנית נסגרת, זה
צריך להיפטר מכל הזיכרון ש היה קשור לאותה תכנית.
>> עם זאת, יש כלים שאתה יכול לרוץ בתכנית כדי לזהות אם, כאשר
תכנית הסיום, ששכחת כדי לשחרר קצת זיכרון.
ולבעיה הבאה שלך להגדיר בי אתה תהיה באמצעות malloc ושימוש
מצביעים, אתה יהיה פועל זה תכנית על התכנית שלך, כדי לראות אם,
כאשר תשואות עיקריות, היה לך כמה דברים שנותרו unfreed.
>> אז הם לא הולכים להישאר malloced לנצח במחשב שלך.
זה יהיה בזבוז, כי מהר מאוד, מחשבים
הייתי נגמרים של זיכרון.
אבל אם הם רצים עד סוף שלך לתכנת והם לא שחררו ו
תכנית יוצאת, זה עדיין בעיה כי כלי זה יעזור לך לטפל בם.
>> תלמיד: האם זה Valgrind?
>> ג'ייסון הירשהורן: זה קרא Valgrind.
ואתה תהיה -
>> סטודנט: אבל אנחנו לא צריכים לדעת כי לחידון, אם כי?
אני מתכוון, שזה דיבר על קצת בהרצאה.
>> ג'ייסון הירשהורן: אז Valgrind הוא שמו של כלי זה.
ידיעה מה שהיא עושה היא מספיק לחידון.
אבל אתה לא השתמשת בו עדיין עליך בעיה להגדיר, כי לא הייתה לנו
סט בעיה שעסק באופן מפורש עם malloc או שאתה משתמש בmalloc.
אז לא השתמשת Valgrind עדיין.
אבל תוכל להשתמש בו במוקדם ולא במאוחר.
>> תלמיד: את יכול לחזור מה הוא Valgrind?
>> ג'ייסון הירשהורן: סליחה?
>> סטודנט: אתה יכול לחזור על מה מטרת Valgring היא?
>> ג'ייסון הירשהורן: Valgrind הוא שם -
כמו GDB עוזר לך באגים בתכנית שלך, Valgrind עוזר לך להבין אם
דברים לא שוחררו כאשר התכנית שלך נסגר.
כך תוכל להפעיל אותו בתכנית שלך.
והתכנית שלך יוצאת, וזה יגיד התכנית שלך בשם malloc זה רבים
פעמים לבתים רבים זה, ואתה קראו רק בחינם את זה הרבה פעמים.
וכך עזב את בתים רבים אלה מבלי שישוחרר.
או שהוא יגיד לך ששחרר את הכל.
עבודה טובה.
>> סטודנט: אישור.
וזה נקרא Valgring?
>> ג'ייסון הירשהורן: V--L-G-R-I-N-D.
>> תלמיד: שאלה לגבי מצביעים.
אז אומר שיש לך n לככב x שווה משהו.
זה שווה, כל מה שאתה מכניס יש, זה מה שישים בתוך
מה x הוא מצביע ל, או המצביע של x?
>> ג'ייסון הירשהורן: האם אתה יכול לחזור על השאלה?
האם אנחנו יכולים לצייר את זה בזמן שאתה אומר את זה?
>> תלמיד: בחידון, למעשה, אחד ששלחת לנו, זה היה כמו, char
אמת כוכב שווה סלעי CS50, נכון?
אז זה אומר שזה סלעי CS50 מה האמת מצביעה?
>> ג'ייסון הירשהורן: אז אתה מדבר על כוכב char במחרוזת, איך
זה עובד?
כן.
על אישור.
בואו לצייר את זה לכאן.
>> [שיחת SIDE]
>> ג'ייסון הירשהורן: אז משתנה זה הוא הולך להיות כוכב סוג char.
כמה גדול הוא משתנה של כוכב הסוג char?
כמה בתים?
>> סטודנטים: ארבעה.
>> ג'ייסון הירשהורן: זה ארבעה בתים.
כמה זכויות הוא משתנה של כוכב int הסוג?
>> סטודנטים: ארבעה.
>> ג'ייסון הירשהורן: ארבעה בתים.
אם זה מצביע, אז זה תמיד ארבעה בתים, כי מצביעים, שלהם
ערך הוא כתובת זיכרון.
וכתובות זיכרון בCS50 מכשיר הוא ארוך בארבעה בתים.
לכן, כאשר אנו קוראים getstring, או כאשר אנו נניח, stringname שווה, ולאחר מכן ב
מרכאות כפולות לשים מחרוזת, אנחנו שמים -
טוב, זה קצת שונה.
אנחנו נעשה את getstring כדוגמא.
או משהו כוכב char שווה את המחרוזת.
סליחה, תן לי הדוגמא שאתה קורא?
>> תלמיד: אמת כוכב char שווה "סלעי cs50" במרכאות כפולות.
>> ג'ייסון הירשהורן: אז זה כוכב, זה אנחנו נתקשר x משתנה זה לשלנו
מטרות גנריות.
יצרנו משתנה בשם x.
זה כוכב סוג char.
זה הוא מצביע לסדרה של תווים.
אז כאן למטה -
>> אז ככה היית עושה את זה לעבוד בזיכרון.
זה יהיה לאחסן את כתובת זיכרון.
זה יהיה לאחסן את כתובת הזיכרון של התו הראשון במערך.
ואז כשאתה אחרי המצביע, שהיית
לקבל את התו הראשון.
>> ואם אתה קורא את הדבר הזה כמו מחרוזת, המחשב שלך היא חכמה
מספיק כדי לדעת, לקרוא את כל העניין הזה עד שהוא מגיע לתגובה 0.
אבל אם אתה קורא לו אופי ב זמן, אז אתה iterating דרך
מחרוזת זו, ואז תוכל פשוט לקרוא אופי בכל פעם עד שתגיע ל
קו נטוי הפוך 0.
זה אולי לא ענה שאלה, אם כי.
>> תלמיד: כן, אבל יש לך לא malloced חלל ש
עדיין למצביע ש.
>> ג'ייסון הירשהורן: אז אני לא ממש בטוח בדיוק מה שאתה מחפש ב,
כי אני לא עשיתי את החידון הזה.
זה היה אמור להיות מועיל משאבים מTF אחר.
אם אתה יוצר מחרוזת על מחסנית או כמשתנה מקומית, זה יהיה
פשוט להיות מערך של אישומים ולא בדרך כלל כוכב char מצביע על
מחרוזת אחרת.
אבל אני לא יודע.
זה יכול להיות סמן למשנהו מחרוזת על הערימה גם כן.
כן.
>> תלמיד: אני יודע שאתה צריך להקצות זיכרון אם המצביע הוא
מקבל הכריז בפנים של פונקציה אחרת.
האם אתה צריך לעשות את אותו דבר אם זה הכרזה בתוך ראשי,
אתה משתמש בו בתוך עיקרי?
>> ג'ייסון הירשהורן: אז כן.
אתה יכול להכריז על מצביע לכל כתובת זיכרון לזכרו.
זה יכול להיות הכתובת בזיכרון של מקומי משתנה, אם כי לעתים קרובות,
אנשים לא להכריז כתובות זיכרון למשתנים מקומיים, כי הם הולכים
משם ברגע שהפונקציה שמחזירה, אשר לכן אנחנו בדרך כלל malloc דברים.
אבל כן, אתה יכול להכריז על מצביע למשתנה מקומית אחרת.
זה פשוט בדרך כלל לא נעשה.
אבל אני יכול להעיף מבט באותו דבר ספציפי אחרי השיעור.
כן.
>> תלמיד: אני חושב שזה סוג של מה שבקש.
זה נראה מוזר להיות אתחול מצביע לא כ
כתובת, אבל כמו מה נראה כמו ערך.
זה נראה כמו CS50 הוא מה שבפנים הדבר שהצביע על ו
לא הכתובת האמיתית, נכון?
>> ג'ייסון הירשהורן: אז זה לא במקרה, אף.
זה לא מה שקורה.
כאשר אתה מצהיר על כוכב char, זה כתובת זיכרון.
מצביעים הם כל כתובות הזיכרון מצביע על משהו אחר.
משהו שעוד יכול להיות על מחסנית, אבל כמעט תמיד הוא על
גל בדרך בה אנו רואים את זה בשימוש.
אבל stringname שווה מרכאות כפולות "Getstring," אנחנו יכולים לראות את זה ואנחנו
יכול להסתכל דרך ושקוד.
מחרוזת getstring אינה נשמרת ב משתנה זה, או מה שהמחרוזת
שם הוא לא נשמרים בכי משתנה, כי זה לא איך
מצביעי עבודה.
האם זה הגיוני?
>> סטודנט: כן.
>> ג'ייסון הירשהורן: אישור.
יש לקוות, שלא היה מבלבל לאף אחד.
אבל אם זה היה, אנחנו יכולים להסתכל על זה שוב בקצת, כי אנחנו באמת הולכים
קוד משהו שאני מקווה שיהיה לעבוד עם מחרוזות ולעזור לך להרגיש
יותר נוח איתם.
>> כל שאלות אחרות הקשורות לאלה נושאים או נושאים אחרים ה
אני אשים את הגיבוי?
ו--
עכשיו.
כן, אלדן.
>> אלדן: אז זה לא קשור לחלוטין, אבל אנחנו יכולים פשוט ללכת על
ממש במהירות את מה שאנחנו צריכים לדעת על ההבדל בין 32 ו
מכונה 64 סיביות?
>> ג'ייסון הירשהורן: כן.
אז 32 ביטים הוא כמה בתים?
>> אלדן: זה ארבעה בתים.
>> ג'ייסון הירשהורן: זה ארבעה בתים.
ו64 ביטים הוא כמה בתים?
>> סטודנט: שמונה.
>> ג'ייסון הירשהורן: שמונה בתים.
אז שוב, שמונה ביטים הוא בייט אחד.
מכשיר CS50 שלך הוא מכונה 32 סיביות.
אז כתובות זיכרון הן ארבעה בתים ארוכים.
ישנם 2 ל32 כתובות זיכרון.
0 עד 2 למינוס 1 32.
ואני לא חיובי, אבל זה כנראה להיקף של מה שאתה צריך
יודע למכונה 32 סיביות, כי זיכרון כתובות הן, שוב, עוד ארבעה בתים,
וזה הסכום המקסימאלי של כתובות זיכרון.
>> כמו כן, סוגי נתונים -
זה יכול להיות משהו כמו גם זה ראוי לציון.
הגודל של סוג הנתונים תלוי המכונה שאתה עובד עם.
אז תו, תו בודד, הוא כיצד בתים רבים במכשיר CS50 שלנו?
בייט אחד.
וזה בעצם בית אחד כמו גם על מכונה 64 סיביות.
>> ורוב סוגי הנתונים הם אותו המספר בתים על שני המכונות.
אבל כמה סוגי הנתונים יהיו שונים על שני המכונות.
אז זה יהיה באופן פוטנציאלי רק דבר שאתם צריכים לדעת.
>> אבל גם זה, אני חושב, הוא מעבר לגבולות -
אני כמעט בטוח, אם אתה מסתכל אחורה בחידונים ישנים, הוא אומר, תניח ל
קידוד בעיות אתה משתמש מכונה 32 סיביות.
אבל יש, ללכת יחד עם זה ב מקרה שאתה מעוניין, יש
סוגי הנתונים שהם אותו הדבר גודל על כל המכונות.
>> אם ראית משהו כזה uint32_t, אתה יכול או
לא ראה את זה.
זה סוג הנתונים.
זה אומר, להיות 32 ביטים לא משנה מה מכשיר הזה הוא על.
לכן, כאשר אנשים כותבים ניידים קוד, שהם כנראה לא ישתמשו ints.
הם במקום ישתמשו נתונים אחרים אלה סוגים שהם יודעים לא יהיו אותו הדבר
גודל על כל מכונה.
Madhu.
>> Madhu: היה לי שאלה לגבי תהליך ההידור.
אז אם אתה כותב תכנית שמשתמשת ספרייה כמו CS50 או משהו
ככה, אני יודע שספרייה ש יש, בשלב מסוים, להיות
לוקט וקשור בו
אבל עד כמה שקורה במהלך האוסף של התכנית שלך?
מה חלק מתהליך שהספרייה מתרחש כאשר אתה
עריכת תכנית משלך?
>> ג'ייסון הירשהורן: אז בואו נלך על בדרך כלל את השלבים של תהליך זה.
אתה כותב. קובץ c שלך.
ב. קובץ c שלך, אתה # כולל ספריות כותרת, למשל, cs50.h.
מה זה כולל חד קו לעשות לתכנית שלך?
Akchar.
>> AKCHAR: זה מוסיף את אבות הטיפוס של הפונקציות מהכותרת
קבצים בספריות.
>> ג'ייסון הירשהורן: בדיוק.
זה מוסיף אבות טיפוס לפונקציות אלה לקוד שלך.
לכן, כאשר הקוד שלך הוא להיות שנאסף ב בשלבים המוקדמים, המהדר יודע
שהפונקציות האלה באמת קיימות, ו כי איפשהו הם הוגדרו.
הקבצים. שעות לא כוללים הגדרות עבור פונקציות אלה, או כיצד
הם עובדים בפועל.
Cs50.h פשוט כולל משהו שאומר getstring הוא דבר אמיתי ש
יכול לקרות.
וstandardio.h אומר printf הוא דבר אמיתי שיכול לקרות.
>> אז בשפת C שלך עם זה. כותרת קובץ מקבל הפך לחלק
קוד לקריאה במכונה, שסופו של דבר מקבל הפך לינארי
קוד, של 0 ו -1 של.
וזה הקוד שסופו של דבר מקבל להורג.
-L שורת cs50 - למשל, כשאתה כותב קלאנג -
ואז אתה כולל-l cs50, אתה מקליד שבי
ואתה רואה את זה.
כשאתה כותב עושה, אתה תראה את הקו שעד כאן.
ואנחנו תראו את זה בשני כאשר אנו קוד או מאוחר יותר כאשר אנו קוד.
>> אבל שורת cs50 ש- l עושה משהו קצת שונה ממה
# כולל cs50.h.
מה קו cs50 ש- l עושה?
אבי?
>> אבי: אני רוצה לומר שהוא מקשר הספרייה לפונקציה
קורא, כמו קבצי o..
>> ג'ייסון הירשהורן: אז מאוד קרוב, אם לא מדייק.
cs50-l לוקח הקובץ בינארי ו ממזג אותו עם הקובץ בינארי שלך.
אז cs50.h, שאין טעם בהפיכת cs50.h מהשפה C בינארית כל
פעם אחת הוא נמצא בשימוש.
זה יהיה מטופש, כי זה יהיה לבזבז הרבה זמן.
אז זה כבר הידור והפך להפעלה.
ועכשיו זה הולך להיות ממוזג עם הקובץ שלך בסוף.
אז 1 של 0 ושל אלה הולכים להתמזג עם אלה שלך
ו0 בסוף.
אז עכשיו אתה בעצם יש בפועל 1 של 0 ושל המגדירים כיצד getstring,
לדוגמא, עובד, או איך printf, לדוגמא, עובד.
>> ולמידע נוסף, יש מהדרים קצרים שנייט נותן כי
אתה צריך לבדוק שהולך באמצעות צעדים אלה.
אבל -
כן.
>> סטודנט: האם הם תמיד בקבצי o. כשהם בצורת הספרייה,
מוכן שימוזג, צמוד - כמו הם בקוד בינארי?
>> ג'ייסון הירשהורן: אישור.
מה -
>> תלמיד: האם זה תמיד המקרה עבור הספריות כשאתה מקשר אותם?
>> ג'ייסון הירשהורן: כן.
אז יש. של קבצים, אשר יהיו קוד המכונה, שיהיה גם
סתום אליך.
אתה לא צריך לדאוג לאלה.
אבל בדרך כלל, כן, הם יהיו להיות ב. o קבצים מוכן ללכת.
>> תלמיד: אז כשאתה ספינה ספרייה, אתה שולח רק
. שעות ו. o?
אתה לא עושה משלוחים. ג או. ים.
>> ג'ייסון הירשהורן: אז -
וזה בקצר זה, כמו גם, אם מידע זה נראה הקרוב
קטן במהירות.
אבל קצר על מהדרים מדבר על זה גם כן.
כשאתה שולח את ספרייה, אם אתה שולח את . שעות, קובץ הכותרת, אלה
אבות טיפוס לפונקציות, ו1 של ו 0, זה כל מה שאתה צריך לתת.
אתה לא צריך לתת כמה פונקציה עובדת, קובץ c..
מכיוון שהנקודה של הפשטה, או להצביע API, הנקודה שSPL זה,
הספרייה ניידת סטנפורד, זה לך לא לדאוג איך חדש
GRect עובד, או איך להעביר את העבודות, או איך להוסיף עבודות.
כל מה שאתה צריך לדעת הוא שתוספת היא פונקציה שאתה יכול
להשתמש בו, והוא עושה זאת.
אז אתה באמת לא צריך לדעת איך זה כתוב ב C. אתה רק צריך
יודעים, כאן הן הפונקציות, מה שהם לעשות, וכאן הם של 1 ו -0 של
כאשר אתה באמת רוצה להשתמש בם.
>> מגניב.
עוד שאלות על מהדרים או נושאים אחרים על הלוח?
>> סטודנט: יש לי שאלה יישום פונקציות רקורסיבית.
שאלה לגבי רקורסיה.
היה לי הרגשה שהיה באה.
אז בואו נלך במהירות דרך רקורסיה עם ספציפי
למשל, פונקצית עצרת.
בגלל זה הוא דוגמא ש לעתים קרובות מגיע למעלה או משמש
כדי להמחיש רקורסיה.
>> אז "4!" הוא קרא כ4 עצרת.
ומה 4 עצרת אומרת?
מה זה עושה?
איך אתה לחשב 4 עצרת?
4 פעמים 3 פעמים 2 פעמים 1.
>> אז עוד דרך לכתוב 4 עצרת הוא לכתוב את זה.
4 פעמים עצרת 3.
בגלל 3 עצרת היא 3 פעמים 2 פעמים 1.
אז 4 פעמים 3 עצרת היא 4 פעמים 3 פעמים 2 פעמים 1.
זו הסיבה שהעצרת היא גדולה מועמד לרקורסיה, כי זה
ברור שיש משהו ש קורה שוב ושוב ושוב על
מספר קטן יותר של דברים עד אתה מגיע לסוף.
כאשר אתם מגיעים ל1, עצרת 1 היא 1.
אתה לא יכול ללכת הרבה יותר רחוק.
0 עצרת מוגדרת גם 1.
לכן, כאשר אתה מקבל 1 או 0, אתה בסופו של הדבר, ושאתה יכול
להתחיל ללכת לגבות.
אז אם אנחנו רוצים לכתוב רקורסיבית פונקציה לחישוב עצרת,
אנחנו הולכים לכתוב כמה pseudocode לזה עכשיו.
לפני שאנחנו כותבים pseudocode כי -
אני אתן לך חבר 'ה כמה דקות כדי לכתוב את הקוד פסאודו או רק חושב
על זה - יש שני דברים שכל פונקציה רקורסיבית צריכה.
מה הם שני הדברים האלה?
>> ג'ק: זה חייב להתקשר לעצמו.
>> ג'ייסון הירשהורן: נח?
אה, ג'ק.
קדימה.
>> ג'ק: זה חייב להתקשר לעצמו.
>> ג'ייסון הירשהורן: אז רקורסיבית פונקציה צריכה קריאה רקורסיבית,
קורא לעצמו.
זה אחד.
ומה הדבר השני?
>> ג'ק: מקרה בסיס.
>> ג'ייסון הירשהורן: מקרה בסיס.
מקרה בסיס הוא, הנה כאשר אנחנו עוצרים.
אז הפונקציה שלך נקראת.
מקרה הבסיס מגיע ראשון.
אתה רוצה לדעת אם אתה בסופו של הדבר.
ואם אתה לא בסוף, אתה להפוך את הקריאה רקורסיבית שלך.
ואתה עובר את התפקיד הזה שוב, לבדוק מקרה הבסיס שלך שוב.
אם אתה לא בסוף, אתה עושה אחר קריאה רקורסיבית,
וכולי וכולי, וכולי.
>> לכן פונקציות רקורסיבית תמיד צריך בסיס מקרים אלה ואלה
שיחות רקורסיבית.
אם אין לך קריאה רקורסיבית, זה לא יהיה פונקציה רקורסיבית.
אם לא היה לך מקרה בסיס, היית הולך לנצח ו
לא יהיה סוף.
ומקרה הבסיס תמיד במקום הראשון, כי אתה תמיד רוצה לבדוק
אם אתה בסוף ראשון.
אז לפני שאנחנו עושים כמה pseudocode, למה אתה לא לקחת רגע כדי לחשוב על
איך פונקציה רקורסיבית עצרת יהיה כתוב?
>> כמו כן, רבים ככל שאתה עושה, כתיבה את זה על דף נייר הוא
מה שאתה הולך לעשות כדי לעשות על החידון מחר.
בפועל אז כנראה טוב לעשות בטוח שהקוד שאתה כותב
על גיליון נייר -
או שאתה יכול לעשות את זה.
אתה יודע איפה הוא פסיק.
אתה זוכר את התחביר.
בגלל שאתה לא להיות מסוגל לקבל מהדר להגיד לך שנעשה שגיאה.
>> כמו כן, לאורך שורות אלה, מחר, כש יש לך בעיות קידוד, אם אתה
הם מיהרו לזמן, או אם אתה מאוד מבולבל לגבי איך אתה אמור
לכתוב דבר המסוים בג, זה חובה עליך לכתוב פסאודו קוד
או לכתוב הערות בגם כן.
בגלל שיש זיכוי חלקי עבור הרבה שאלות בחידון.
אז אתה יכול להיות מיהר, או שאתה אולי פשוט להתבלבל.
כתיבה בהערות או פסאודו קוד לעתים קרובות דרכים שבן
יכול לקבל זיכוי חלקי.
>> אז אל תשאיר משהו ריק בחידון.
אין עונשים על לשים את הדברים פנימה
למעשה, לשים בפסאודו קוד או הערות הוא הולכת לעזור כיתה
להבין אם אתה באמת יודע מה אתה מדבר, ואולי הפרס
אתה קצת קרדיט חלקי לכך.
>> גם בכיוון הזה, לכתוב באופן ברור.
אם אנחנו לא יכולים באמת מה שאתה כותב, אנחנו לא מתכוונים להתקשר אליך
במחר בחצות לדמות את מה שכתבת.
אנחנו רק הולכים לקחת את נקודות.
לכתוב באופן ברור כדי שנוכל לשמוע, או ליתר דיוק, אנו יכולים לקרוא את מה שכתב.
>> ואם זה אומר שני משפטים, לא כותב פסקה.
עקוב אחר ההוראות.
לכתוב באופן ברור.
ולכתוב בהערות אלה או pseudocode לשאלות שיכולים
זיכוי חלקי בפרס.
>> אוקיי, בואו נלך לעצרת.
אז יש לנו עצרת פונקציה.
אם הייתי צריך לכתוב בעצם זה ב-C, מה אני צריך לשים לפני שם
של הפונקציה?
סוג ההחזרה, אשר, בזה מקרה, ניתן לו int.
ואז בתוך הסוגריים המסולסלים, הוא מה שקורה בתוך הסוגריים המסולסלים עבור
פונקציה?
>> סטודנטים: סוג טיעון.
>> ג'ייסון הירשהורן: טיעוניה.
אז עצרת תהיה כנראה לקחת ויכוח.
זה יהיה כנראה לקחת רק נימוק אחד.
ואנחנו נגיד את זה ייקח שלם נקרא x.
ושוב, בעת כתיבת אב הטיפוס של פונקציה או כתיבת הפונקציה
בקוד שלך לפני שהגדרתי אותה, אתה לכתוב את סוג הנתונים ואת שמו של
משתנה שבשביל זה פונקציה בלבד.
אז אתה יכול לעבור מספר כלשהו לתוך זה פונקציה, היא תהיי מכונה x
באופן פנימי.
>> יש לנו פונקצית העצרת שלנו.
אנו זקוקים לשני דברים, מקרה בסיס וקריאה רקורסיבית.
מהו מקרה הבסיס לעצרת?
מישהו שכתב את זה ושיש לו לא דיבר בכל זאת, מה הוא הבסיס
מקרה לעצרת?
>> תלמיד: אם n הוא פחות מ 2, בתמורה 1.
>> ג'ייסון הירשהורן: אם n הוא פחות מ 2, בתמורה 1.
אני אוהב את זה, כי זה דואג של 0 ו -1.
אז אנחנו נעשה את x <2, בתמורת 1.
אם אנחנו מקבלים עברנו 0, אם אנחנו מקבלים עבר 1, תהיה פונקציה זו
לחזור מייד 1.
אם אנחנו מקבלים עברנו חלק גדול יותר מספר או שווה ל 2, אנחנו הולכים
יש הקריאה רקורסיבית שלנו.
>> ואז איך זה הולך לעבוד?
האם מישהו אחר שעבד על זה שלא דבר עדיין לתת לי
קריאה רקורסיבית עבור פונקציה זו בpseudocode?
אם אנחנו מקבלים עברנו בx מספר וזה גדול מ -2, מה
אנחנו רוצים לעשות?
יש לנו גם דוגמא כתובה על צד שיכול לתת לך רמז.
>> תלמיד: התקשר פעמים x עצרת של 1 מינוס x?
>> ג'ייסון הירשהורן: בדיוק נכון.
אנחנו הולכים לחזור פעמים x העצרת של 1 מינוס x.
וזה, למרות שכתבתי למעלה, בעצם, מה שאמרת באנגלית,
פונקצית עצרת זו יקבל התקשר שוב.
זה יהיה לבצע על מינוס x 1.
זה יחזור עם כמה מספר שלם, ו אז זה יהיה להכפיל את שני אלה
יחד, וערך שיהיה חזרתי לכל מה שקרא לזה
פונקצית עצרת, שעשוי להיות מופע נוסף של
פונקצית עצרת זו.
>> אז זה הוא דוגמה לרקורסיבית פונקציה, מאוד
פונקציה רקורסיבית פשוטה.
אבל רובם יהיה כמו זה.
אם ברצונכם רקורסיבית טוב אתגר עבור החידון, נסה קידוד
חיפוש בינארי באופן רקורסיבי.
כי אם אתה לא עשית חיפוש בינארי עבור בעיה להגדיר שלוש, סביר להניח שעשית את זה
איטרטיבי בלולאה בזמן.
>> אבל גם יכול להיות שנכתב עליו באופן רקורסיבי.
אתה הולך צריך לכתוב בעצמך פונקציה נפרדת שלוקחת קצת
שורת הפקודה טיעונים שונים - או לא שורת הפקודה טיעונים, חלקם
טיעונים רגילים רק שונים.
אבל אתה יכול לכתוב חיפוש בינארי באופן רקורסיבי גם כן.
>> תלמיד: אז אתה יכול להיות גם בכתב, במקום מינוס x 1, אתה
גם היה יכול לכתוב מינוס x מינוס או שיש, אתה יכול
x מינוס מינוס בכתב.
אתה יכול רק להסביר באמת במהירות מדוע אלה יהיו דברים שונים,
כמו מה ההבדל בין מינוס x מינוס ומינוס x מינוס?
>> ג'ייסון הירשהורן: לא, אני לא הולך להיכנס לזה.
אבל אני אדבר איתך על זה אחרי כיתה. x מינוס מינוס, x מינוס מינוס
הפחת x על ידי 1.
אבל הם עושים את זה קצת אחר.
אבל אני לא רוצה להיכנס לזה.
שאלות אחרות על רקורסיה או בפונקציה זו?
זה לא באמת אפילו pseudocode.
זה בעצם הקוד ב C אתה היה כותב על זה.
>> בסדר, כל שאלות אחרות על נושאים עד כאן?
כן.
>> סטודנט: יש לי סקירה מהירה של נקודה צפה ודיוק.
>> ג'ייסון הירשהורן: צף נקודה ודיוק.
מישהו יכול ממש מהר לתת לי סקירה מהירה של
נקודה ודיוק צפים?
כל מה שאתה צריך לעשות את זה בשבילך בעיה מוגדרת, אז כל מה שאתה
מכיר את זה.
או שאולי לא כולכם.
אף אחד?
תן לי נקודת התחלה.
נקודה צפה ודיוק.
מה הבעיה?
כן.
ויקטוריה?
>> ונסה: ונסה.
>> ג'ייסון הירשהורן: ונסה.
סליחה.
>> ונסה: יש רק מספר סופי של מספרים שניתן לייצג
בגלל שאתה ב, בנו מקרה, מערכת 32 סיביות.
אז אתה סוג של חייב מרכיב כמה מספרים.
>> ג'ייסון הירשהורן: אז זה בדיוק נכון.
יש רק כמות מסוימת של מספרים שיכולים להיות מיוצג.
אם תכפיל שני מספרים גדולים מאוד, זה עלול לעלות על גדות הסכום
חללים שאתה צריך לייצג מספר שלם.
זו הסיבה שלפעמים אנחנו משתמשים ארוך ארוך במקום int.
כי יש יותר רווחים.
שיכול להכיל מספר גדול יותר.
>> דיוק נקודה צפה יש לעשות עם זה, אבל יש גם מה לעשות עם
עובדה שמספרים עשרוניים הם לא תמיד מיוצג.
סליחה.
תן לי להחזיר את זה.
המספר העשרוני 1.0 לא תמיד מיוצג כמו שהיית מצפה,
1.000000000.
לפעמים זה מיוצג כ 1.000000001 או .999999999.
זה יכול להיות אפילו 89 נזרק שם איפשהו.
אז מספרים העשרוניים אלה אינם ייצג בדיוק כמו שהיית
מצפה מהם להיות מיוצגים.
>> אז בבעיה להגדיר -
היה לה שתי? -
בעיה להגדיר שתי, שבו עסקנו ב מספרי נקודה צפה, כשרצינו
שלהם לייצג בדיוק מה שרצינו שלהם לייצג, המספר
של פרוטות, או מספר סנטים, נכפיל אותם על ידי 100.
אנחנו כנסנו אותם.
ולאחר מכן חתכנו את הכל מאחורי הנקודה העשרונית.
זה היה כדי לוודא שהם הייתם שווה בעצם בדיוק מה שרצינו
שלהם שווה.
>> כי כשאתה לוקח משהו שהוא לצוף ולהפוך אותו לint, אתה
לחתוך את הכל לימין לנקודה העשרונית.
בגלל שיש איזשהו נקודה צפה חוסר דיוק, 100.000 עשויים להיות
מיוצג כ99.999999999.
ואם אתה פשוט מנותק הכל כדי הזכות מייד, אתה הולך
לקבל את המספר הלא נכון.
כן.
>> תלמיד: לא הייתה לי שאלה על ליהוק.
מה כדי שהיא מתרחשת ב?
אם הייתי עושה את המצוף, בסוגריים, 1 מחולק על ידי 10, הוא עושה 1 מחולק ב10,
לאחר מכן לקבל 0.1, לאחר מכן הפעל אותו למצוף?
>> ג'ייסון הירשהורן: אם אתה עושה לצוף 1 מחולק ב10 -
>> סטודנט: כן, ולאחר מכן שווה -
כן, זה בדרך כלל היה יש לו שווה ב--
כן.
אתה רוצה לעשות את זה לצוף, נכון?
>> ג'ייסון הירשהורן: אוקיי, אז אנחנו הולכים להשתמש בו כדי לגלוש לחישוב
את התשובות לשאלות הללו באמצעות קידוד.
מכיוון שאתה בטח יש להם הרבה שאלות אלו דקות, ודרך טובה
כדי לפתור אותן הוא באמצעות קידוד.
אז אנחנו הולכים לקוד את זה עכשיו, ואז אנחנו הולכים לחזור ו
קוד השאלה שיש לך.
>> אז השורה הראשונה -
אני לא היית צריך לכתוב אותו - מה הוא הדבר הראשון שאנו רוצים לעשות כאשר אנו
לפתוח את הקובץ חדש בgedit?
>> תלמיד: כלול.
>> ג'ייסון הירשהורן: כלול מה?
>> תלמיד: ספריית CS50.
>> ג'ייסון הירשהורן: אישור.
מה עוד אנחנו צריכים לכלול?
אנחנו רק הולכים לבדוק מה קורה כאשר אתה מטיל משהו לצוף.
אבל מה שאנחנו צריכים לעשות כדי לכלול אם אנחנו הולך לכתוב תכנית C?
>> תלמיד: תקן I / O.
>> ג'ייסון הירשהורן: stdio.h.
אנחנו באמת לא צריכים, בשביל זה תכנית, cs50.h, למרות שזה
תמיד עוזר לכלול אותו.
אבל אנחנו תמיד צריכים stdio.h.
>> תלמיד: כאשר קידוד ב-C?
>> ג'ייסון הירשהורן: כאשר הקידוד בג
>> אז לשמור אותו כ. קובץ c זה.
אני מקבל כמה הדגשת תחביר נחמדה.
כתבתי חלל פנימי ראשי.
מה חלל זה אומר?
>> סטודנט: לא לקחת כל שורת הפקודה טיעונים.
>> ג'ייסון הירשהורן: אמצעי Void, בזה מקרה, עיקרי לא לוקח שום
שורת הפקודה טיעונים.
במקרים אחרים, זה אומר שהפונקציה לא לוקח טיעוני שורת הפקודה.
או הפונקציה, אם הייתי כותבת חלל העיקרי (void), שהייתי אומר עיקרי של
לא חוזר שום דבר.
אז חלל פשוט לא אומר כלום.
מה הייתי כותב אם הייתי לקחת טיעוני שורת הפקודה?
>> תלמיד: נ 'קשת מחרוזת int קשת ג
>> ג'ייסון הירשהורן: int argv argc מחרוזת.
האם זה נכון?
>> תלמיד: זה סוגריים argv כוכב char.
>> ג'ייסון הירשהורן: אז אתה יכול לכתוב סוגריים argv מחרוזת או argv כוכב char
בסוגריים, אבל אתה צריך סוגריים.
בגלל argv הוא מערך של מחרוזות, זוכר.
זה לא רק מיתר אחד.
אז argv המחרוזת הוא, הנה מחרוזת אחת הנקראת argv.
סוגריים argv מחרוזת, הנה מערך של מחרוזות.
סוגריים argv מחרוזת argc אז int יהיה משהו שאני
כנראה היה כותב.
>> אז אתה רוצה לחסוך במספר שלם?
>> סטודנט: כן, מספר שלם.
או במצוף.
>> ג'ייסון הירשהורן: במצוף?
כמו, x לצוף שווה 1 מחולק ב10.
>> ג'ייסון הירשהורן: אישור.
כיצד ניתן להדפיס את המצוף בprintf?
מה?
>> תלמיד:% f.
>> ג'ייסון הירשהורן:% f.
מה שלם?
ד או i.
מה מחרוזת?
>> תלמיד: ים.
>> ג'ייסון הירשהורן: s.
כיצד אוכל לקבל קו חדש?
>> תלמיד: n קו הנטוי ההפוך.
>> ג'ייסון הירשהורן: מה אני חוזר אם ריצות עיקריות בצורה נכונה?
>> תלמיד: 0.
האם אני צריך לכתוב את הקו, אם כי?
>> סטודנט: לא.
בסדר, אנחנו לא כותבים אותו, ולאחר מכן.
האם כל אחד יכול לקרוא את זה?
זה נראה קצת קטן.
האם כל אחד יכול לראות, או צריך אני עושה אותו גדול יותר?
אני חושב למצלמה, נבצענו למרות שזה קצת יותר גדול,.
>> ג'ייסון הירשהורן: אם אני רוצה להפוך את זה . קובץ C להפעלה, מה
אני כותב?
>> סטודנט: להפוך את הבדיקה.
>> ג'ייסון הירשהורן: סליחה?
>> סטודנט: להפוך את הבדיקה.
>> ג'ייסון הירשהורן: להפוך את הבדיקה.
אנחנו מדברים על קו זה קודם לכן.
קלאנג.
מה צלצול?
שמו של המהדר.
מה זה קו?
>> סטודנט: מגדיר אותו לשימוש של GDB.
>> ג'ייסון הירשהורן: סטים אותו לשימוש של GDB.
קו זה, מה זה?
>> תלמיד: קוד מקור.
>> ג'ייסון הירשהורן: זה קובץ מקור, קובץ c..
מה שתי שורות אלה עושות?
או שני אלה לא קווים.
>> סטודנט: זה שמות אותו לבדוק.
>> ג'ייסון הירשהורן: אז o המקף אומר, שם זה משהו אחר.
והנה אתה קורא לזה מבחן.
אם לא היה לי, כי ב, מה זה שם הזה?
>> תלמיד: a.out.
>> ג'ייסון הירשהורן: a.out.
מה זה עושה?
>> תלמיד: קישורים ספריית המתמטיקה.
>> ג'ייסון הירשהורן: זה קישורים בספריית המתמטיקה.
אנו לא כוללים את ספריית המתמטיקה, אבל מכיוון שזה כל כך נפוץ, יש להם
איפור נכתב תמיד לכלול ספריית המתמטיקה.
וכן, זה כולל ספריית CS50.
>> אוקיי, אז אם אנחנו ברשימה, עכשיו יש לנו הפעלה המכונות בדיקה.
כדי לבצע את זה, אני כותב במבחן.
אני רואה שצפתי נקודה שלי, כצפוי, שווה 0.
עושה את זה -
כך -
>> תלמיד: ואז אם אתה שם לצוף עכשיו, כמו שאתה מטיל אותו כמצוף -
>> ג'ייסון הירשהורן: יצוק 1 למצוף?
>> סטודנט: לא, להטיל את הדבר מלא -
כן.
אם אתה פשוט עשית את זה, היית עושה זה עושה את זה 0.1?
>> ג'ייסון הירשהורן: אוקיי, אז ממש מהר, 1 מחולק ב10, הם אלה
מספרים שלמים שמחולקים.
לכן, כאשר אתה מחלק את מספרים שלמים, הם 0, ואתה שומר את זה ב0
לצוף, כי הקו הנטוי הוא רק חלוקה של מספרים שלמים.
אז עכשיו אנחנו פונים משהו למצוף.
>> בואו לראות מה קורה.
אנחנו עושים בדיקה.
אז עכשיו אנו רואים כי הקו נטוי שלא היה חלוקת מספר שלם, הוא צף
חלוקת נקודות.
כי אחד הטיעונים שלה הוטל למצוף.
אז עכשיו היא אומרת, להתייחס לזה חטיבה כמו עם יש לנו עסק
נקודות צפות, לא עם מספרים שלמים.
וכך אנחנו מקבלים התשובה שאנחנו מצפים.
>> בואו לראות מה קורה -
אופס.
אם אני רוצה להדפיס יותר עשרוני כתמים, איך אני יכול לעשות את זה?
>> ו נקודת נקודה, או כפי שרבים: סטודנט מקומות עשרוניים כמו שאתה רוצה.
>> ג'ייסון הירשהורן: אז אני מדפיס 10 נקודות עשרוניות.
ועכשיו אנחנו רואים שאנחנו מקבלים כמה דברים מוזרים.
וזה חוזר לשאלה שלך על חוסר דיוק נקודה צף.
יש דברים מוזרים מאוחסנים כאן.
>> אוקיי, האם זה עונה על השאלה שלך?
מה עוד אתה רוצה קוד מהירות?
>> תלמיד: אני רק רציתי לראות אם לא, אם אתה משוחרר עד כמה מצביע,
אם מצביע שעדיין מאוחסן ב זה את הכתובת של מה שהיה
מצביע על העבר.
>> ג'ייסון הירשהורן: בסדר, אז בואו לעשות את זה.
PTR כוכב צ'אר, זה יוצר משתנה קרא PTR של כוכב סוג char.
כיצד אוכל לכתוב malloc?
אלדן?
>> אלדן: רק malloc.
אבל אז זה חייב להיות בגודל של, ו במקרה זה, אני מניח שהיית
תצביע להיחרך.
אז שזה יהיה char.
>> ג'ייסון הירשהורן: אוקיי, אז עוד הגנרי, בפנים -
בואו לערוך.
בתוך malloc, אתה רוצה את המספר בתים בערמה.
באופן כללי, מה שראינו שאנחנו עושה הוא שאנחנו הולכים malloc
מחרוזות, למשל, או מערכים של מספרים שלמים.
אז אם אנחנו רוצים 10 מספרים שלמים, או 10 תווים, 10 ייתן לנו 10.
ואז גודל של תווים היה נותן שלנו הגודל של תווים, אשר ב
מקרה זה הוא בתים 1.
אנחנו מקבלים 10 בתים.
אם היינו בגודל של int לכתוב, שייתן לנו 40 בתים.
>> אז באופן כללי יותר, בתוך malloc הוא מספר הבתים שאתה רוצה.
במקרה זה, אנחנו מקבלים בייט 1.
שנראה כמו שימוש מוזר של malloc, אבל עבורנו
מטרות הגיונית.
אז יש את זה.
>> אנחנו הולכים לקרוא בחינם.
אנחנו להיפטר ממנו ואנחנו משתמשים PTR שוב.
ומה שאתה לא רוצה לבדוק?
>> תלמיד: אני רק רציתי לבדוק אם היה או לא היה שום דבר
בתוכו.
>> ג'ייסון הירשהורן: אז אם זה הצביע על שום דבר?
>> סטודנט: כן, בדיוק, בין אם זה עדיין היה כתובת בזיכרון.
>> ג'ייסון הירשהורן: אז אתה רוצה כדי לבדוק את הערך של PTR?
>> סטודנט: כן, בדיוק.
>> ג'ייסון הירשהורן: מה שאני כותב כאן אם אני רוצה לבדוק את הערך של
נקודה - מה הוא, ירדן אמר, את הערך?
או מה מאוחסן בתוך של PTR?
>> תלמיד: כתובת זיכרון.
>> ג'ייסון הירשהורן: כתובת זיכרון.
אז אם אני כותב בדיוק את זה, זה יהיה לתת לי את הערך של PTR.
וכיצד אוכל להדפיס כתובת זיכרון?
מה מחרוזת הפורמט לכתובת זיכרון?
>> סטודנט: p%.
>> ג'ייסון הירשהורן: p%.
% S היא מחרוזת.
p% למצביע.
האם זה נכון?
זה נכון.
אז PTR שווה -
עדיין יש בזה משהו.
זה כנראה יותר שאלה מעניינת.
מה הקו שעושה?
>> תלמיד: תקלות Seg.
>> ג'ייסון הירשהורן: מה?
>> תלמיד: אני חושב שזה צינוק תקלות.
>> ג'ייסון הירשהורן: הממ?
>> תלמיד: אני חושב שזה צינוק באשמה.
>> ג'ייסון הירשהורן: אז את הקו הזה של PTR קוד, כוכב, מה
אין הכוכבים אומר?
>> תלמיד: תוכן.
>> ג'ייסון הירשהורן: כן.
ללכת כדי לקבל את התוכן.
אז זה הולך לזיכרון אתייחס לשם ולתת לי את זה.
אני משמש% ג נכון כאן, כי יש הם תווים מאוחסנים שם.
אז אנחנו הולכים ללכת לכי אנחנו כתובת פשוט ראה - או שזה בטח אהיה
זה קצת שונה פעם שאנחנו מפעילים את התכנית.
אבל אנחנו נלך לכתובת זו שבו אנו יודעים עדיין קיימים
ותראה מה יש שם.
>> אז זה לא צינוק באשמה.
זה פשוט לא נתן לנו שום דבר.
אולי זה בעצם נתן לנו משהו, אנחנו פשוט לא יכולים לראות את זה.
וזה חוזר לרעיון הזה -
ואנחנו לא הולכים לקבל יותר מדי לתוך זה, כי זה מעבר
היקף הקורס הזה.
אבל דיברנו על ממש כאן, אם אנחנו הלך מעבר לגבולות של המערך על ידי
1, אנחנו לא יכולים לקבל בצרות.
>> לפעמים, כשאתה פשוט ללכת על ידי 1, אתה עושה משהו לא בסדר, ואתה
יכול להסתבך בצרות.
אבל אתה לא תמיד מסתבך בצרות.
זה תלוי עד כמה דבר רע לך אין, אתה הולך להסתבך בצרות.
שלא לומר, להיות מרושל עם הקוד שלך.
אבל זה אומר, התכנית לא תהיה תמיד להפסיק, גם אם אתה הולך למקום
אתה לא אמור ללכת.
>> דוגמא טובה לכך היא, הרבה אנשים בבעיה שלהם להגדיר 3, אשר
היה 15, לא בדקו גבולות של הלוח.
אז הסתכלת לצד השמאל, נראה נכון, נראה לחלק העליון, נראה
עד לתחתית.
אבל אתה לא בדקת כדי לראות אם החלק העליון למעשה הולך להיות על הלוח.
והרבה אנשים שעשו את זה ו פנה בזה, התכנית שלהם עבדה
בצורה מושלמת, משום שבו לוח העץ שמונח מאוחסן בזיכרון, אם הלך אחד
מעליו או בדק כי זיכרון כתובת, לא היה שום דבר
נורא במיוחד על זה, אז התכנית שלך לא הייתה
הולך לצעוק עליך.
>> אבל אנחנו עדיין היו לוקחים את נקודות אם לא לך לבדוק את זה, כי אתה
היו עושה משהו שלא היית אמור לעשות, ואתה יכול להיות
קיבל בצרות.
למרות שרוב הסיכויים הם, אתה כנראה לא.
אז זה הוא להראות שכן, אנחנו עדיין יכולים ללכת אליו.
ואנחנו לא מקבלים ב צרות במקרה זה.
אם ניסיתי לעשות לקרוא 100 התווים הבאים, הייתי
כנראה להסתבך.
ואתה יכול קוד קריאת 100 הבאים תווים אם אתה רוצה על ידי ביצוע כמה
סוג של ללולאה.
כן.
>> תלמיד: מאז שהיינו מוקצה מרחב ערך ממשי, לא הייתי מצפים
בעצם להיות מסוגל לראות שום דבר.
האם עלינו לנסות את זה עם קביעת כי שווה כמו C או משהו?
>> ג'ייסון הירשהורן: שאלה גדולה.
כיצד ניתן להגדיר את הערך ש--
מה שורת קוד שאני כותב על קו שבע כדי לעשות את מה שאמרת?
>> תלמיד: הכוכבים PTR שווה אחת ציטוט ג בסופו ציטוט אחד.
>> ג'ייסון הירשהורן: אז זה לשים אופי, ג, במיקום זה,
כי שוב, כוכב פירושו ללכת לשם.
וכאשר משתמשים בו בצד שמאל של אופרטור ההשמה, כי שווה
לחתום, אנחנו לא מתכוונים לקבל את זה ערך כל כך הרבה כפי שנקבע ערך זה.
עכשיו בואו נראה מה קורה.
>> אנחנו שמים שם משהו והוא היה שם.
אנחנו קראנו לחינם.
כמה דברים כנראה קרו בערמה.
אז זה לא שם יותר.
אבל שוב, אנחנו לא מקבלים בצרות הולכים לשם.
>> אני עושה את זה בקוד כדי להמחיש כי הרבה מהם
שאלות שיש לך, הם באמת מעניין
עונה הרבה זמן.
והם שאלות ממש טובות.
ואתה יכול להבין אותם על שלך אם, למשל,
אנחנו לא בקטע.
כן.
>> תלמיד: כי אתה לא שולח מצביע בכל מקום, אתה צריך
להשתמש malloc?
>> ג'ייסון הירשהורן: אז זה חוזר לשאלה הראשונית שלך.
[? ?]
האם זה רק משתנה מקומי?
Malloc כאן הוא לא כל כך משכנע.
השימוש בmalloc כאן הוא לא שמשכנע כי זה
רק משתנה מקומי.
>> תלמיד: אז אתה יכול לעשות char PTR הכוכב שווה שלום?
>> ג'ייסון הירשהורן: אוה.
אז אנחנו הולכים לקבל עכשיו בחזרה לשאלה הראשונית שלך.
אני חושב שלא היה מרוצה עם התשובה שלי.
בסדר?
ככה?
>> סטודנט: כן.
חכה.
>> ג'ייסון הירשהורן: ואיפה אתה רוצה להדפיס?
כך תהיה לנו להדפיס את מחרוזת בצורה כזאת?
>> סטודנט: מעניין.
>> ג'ייסון הירשהורן: אז זה אומר שזה טיעון יש הסוג של אופי.
כך זה צריך להיות אופי.
>> סטודנט: פשוט לוקח את הראשון.
>> ג'ייסון הירשהורן: אז זה זה מה שאמרתי קודם.
כמו שאמרתי, זה לא אחסון מחרוזת בתוך מצביע משתנה.
זה אחסון -
>> תלמיד: הערך הראשון של המחרוזת.
>> ג'ייסון הירשהורן: הכתובת של הערך הראשון של המחרוזת.
אם היינו להדפיס את זה, אנחנו מקבל את הערך בתוך מצביע.
ואנחנו תראו את זה הוא, אכן, כתובת זיכרון.
>> האם זה הגיוני?
סליחה.
חכה, זה שתשובה שלך שאלה, אם כי?
>> סטודנט: כן.
>> ג'ייסון הירשהורן: קו זה של קוד הוא יצירת מחרוזת ולאחר מכן עוד
מצביע משתנה שמצביע למחרוזת ש, מערך זה.
כן.
>> תלמיד: אז אם הלכנו זיכרון אחד מענה נוסף, היינו מקבל את שעות?
האם זה נשמר כמחרוזת?
>> ג'ייסון הירשהורן: כמו, שעשינו -
אז זה חשוב לעשות.
זהו חשבון נקודה, שבה אתה חבר 'ה לא ראיתי לפני וצריך להיות
נוח יחסית עם.
זה דומה לכתיבה -
אם היינו כותב את שורת קוד הזאת, ראינו סימון מערך לפני.
זה אמור לתת לנו שני ערך במערך, h זה.
>> אם הייתי עושה את זה, זה צריך גם לתת שלנו את הערך השני במערך זה.
כי זה הולך לא לזיכרון כתובת של הדבר הראשון, אבל
כתובת זיכרון של הדבר אחד מעל.
ולאחר מכן dereferences מפעיל הכוכב מצביע זה.
ושוב, בואו נראה.
אנחנו מקבלים שעות שוב.
>> סטודנט: מה בדיוק עושה dereference אומר?
>> ג'ייסון הירשהורן: Dereference הוא מילה יפה לללכת.
עבור ושללקבל את מה שיש הוא dereference מצביע.
זה רק מילה יפה לזה.
>> תלמיד: אם אנחנו רוצים להדפיס כל המחרוזת, יכולות
לעשות מצביע אמפרסנד?
>> ג'ייסון הירשהורן: בסדר, אנחנו הולך תעצור כאן.
אנחנו הולכים בסופו כאן.
אמפרסנד נותן לך את הכתובת של מיקום, ולכן כאשר אתה עושה אמפרסנד של
משתנה, זה נותן לך את הכתובת שבו משתנה שמאוחסן.
מצביע אמפרסנד ייתן לך כתובת של PTR PTR שבו הוא בזיכרון.
>> אנחנו לא הולכים ללכת על עם דוגמא זו.
אתה יכול להבין את אלה דברים בעצמך.
אבל שוב, זה עשוי אפילו להיות על סף קצת מעבר למה שאתם צריכים לדעת על
היקף הטווח בינוני זה -
או החידון הזה, ולא.
סליחה.
>> אנחנו הולכים לעבור, כי אני היית עושה רוצה לעשות בעיה קידוד אחד
לפני הזמן הוא למעלה.
ואנחנו הולכים לקודד את מה שאני חושב הוא משכנע ביותר של אלה
דוגמאות, atoi.
אז זו הייתה שאלה על חידון לפני שנתיים.
ויש לי אותה על הלוח כאן.
>> אנשים התבקשו על החידון -
הם קבלו קצת יותר tesxt ב השאלה, אבל אני ביטלנו את
טקסט כי זה היה מיותר למטרות שלנו עכשיו.
זה היה רק ​​קצת רקע על מה atoi עשה.
אבל כל מה שאתה יודע והם מאוד מכיר atoi.
>> אני מציע לך את הקוד הזה על גיליון נייר.
אני גם מציע לך להשתמש באסטרטגיה שעברנו על
הרבה בחלק שלנו.
ראשית, ודא שאתה מבין מה atoi של עושים.
לצייר תמונה או לבוא עם כמה תמונה מנטלית של זה בראש שלך.
בשלב הבא, לכתוב את pseudocode לזה.
בחידון, אם כל מה שאתה מקבל הוא pseudocode, לפחות אתה
הניח משהו.
ולאחר מכן למפות pseudocode שעל ג אם יש לך סימון בך
pseudocode, כמו לבדוק אם משהו הוא 1, הממפה על גבי אם
מצבם וכן הלאה.
ולבסוף, קוד התכנית ב C.
>> אז לחזור לatoi ולקחת חמש דקות לקוד הזה על גיליון
נייר, שהוא כנראה על כמות הזמן שהיית לוקח על
חידון לatoi קוד.
חמישה עד 15 דקות, חמש עד 12, חמש עד 10 דקות, הוא על כמות
זמן שהיית מוציא על זה שאלה בחידון.
אז קח חמש דקות עכשיו, בבקשה.
ואם יש לך שאלות, להעלות היד שלך ואני נבוא בסביבה.
>> [שיחות צדדיות]
>> ג'ייסון הירשהורן: אוקיי, אז זה היה חמש דקות.
זה היה כנראה על כמות זמן שהיית מוציא על זה בחידון,
אולי בקצה הנמוך של אותה התקופה.
אנחנו לסכם בקצת.
תן לנו להתחיל קידוד זה.
ואם אנחנו לא מקבלים לאורך כל הדרך, את התשובות לזה ואת זה
שאלת חידון זמינות, שוב, סתיו 2011 הוא כאשר שאלה זו
הופיע בחידון.
>> וזה היה שווה שמונה נקודות בחידון אז.
שמונה נקודות היא בקצה הגבוה של הסכום של משהו נקודות שווה.
רוב השאלות הן בטווח של אחד לשש נקודות.
אז זה יותר מאתגר שאלה, זה בטוח.
מישהו יכולים תתחיל איתי?
>> באופן כללי, מה אנחנו הולכים לרוצה לעשות עם זה
לתפקד atoi, באופן הגיוני?
מה אנחנו רוצים לעשות?
אז אנחנו הולכים לכתוב כמה pseudocode.
>> סטודנט: המרת תווים למספרים שלמים.
>> ג'ייסון הירשהורן: המרת תווים למספרים שלמים.
על אישור.
אז כמה תווים אנחנו הולך צריך לעבור?
>> תלמיד: כל אחד מהם.
>> סטודנט: כל התווים במחרוזת.
>> ג'ייסון הירשהורן: כל תווים במחרוזת.
אז אם אנחנו רוצים לעבור את כל תו במחרוזת, מהו דבר
ב-C שראינו שאפשר לנו לעבור את כל
תו במחרוזת?
>> סטודנטים: ללולאה.
>> ג'ייסון הירשהורן: ללולאה.
אז אנחנו הולכים ללולאה דרך כל דמות בים.
>> אז מה אנחנו הולכים רוצים לעשות כאשר אנחנו מקבלים דמות מסוימת?
אומר שאנחנו מקבלים עברנו 90.
אנחנו מקבלים 9.
זה אופי.
מה אנחנו רוצים לעשות עם תו 9?
>> תלמיד: הפחת אותו מאופי 0?
>> סטודנט: הוסף 0?
>> ג'ייסון הירשהורן: חיסור זה מאופי 0?
>> סטודנט: כן.
>> ג'ייסון הירשהורן: מדוע אתה רוצה לעשות את זה?
>> תלמיד: [לא ברור]
ערך.
ערך int שלה.
>> ג'ייסון הירשהורן: אוקיי, אז אנחנו לוקחים את דמות 9, לחסר אותו מ
תו 0 כדי לקבל שלם בפועל 9.
מתוק.
ואיך אתה יודע שאופי 9 מינוס 0 דמות היא 9?
מה תרשים שאתה מסתכל?
>> תלמיד: יש באופן הגיוני תשע מקומות בין 9 ל 0.
או שאתה יכול להסתכל על טבלת ASCII.
>> ג'ייסון הירשהורן: טבלת ASCII.
אבל כן, אתה צודק גם כן.
אז אנחנו לחסר 0.
אז עכשיו יש לנו המספר השלם 9.
ומה אנחנו רוצים לעשות עם זה?
אם יש לנו 90, זה המספר השלם הראשון יש לנו, מה אנחנו רוצים לעשות?
>> תלמיד: אני רוצה לשים במספר שלם זמני מערך, לעשות אז מתמטיקה אליו
מאוחר יותר כדי להפוך אותו לסוף.
>> ג'ייסון הירשהורן: אישור.
>> סטודנט: אתה יכול להתחיל בסוף המערך ולאחר מכן להתקדם כל כך
כי כל פעם שאתה זז קדימה, אתה מכפיל אותו ב10.
>> ג'ייסון הירשהורן: אישור.
זה נשמע כמו די רעיון משכנע.
אנחנו יכולים להתחיל בסוף המערך שלנו, ואנו יכולים להשתמש strleng.
אנו יכולים להשתמש בstrleng כאן.
אנחנו נקבל את אורך המחרוזת שלנו.
אנחנו מתחילים בסוף.
ו+ הראשון, אנחנו פשוט לוקחים את זה מספר שלם, ואולי אנחנו יוצרים כמו
משתנה שלם חדש למעלה שבו אנחנו אחסון הכל.
אז אנחנו לולאה דרך כל תו בים מ בחזרה לחזית, אנו לחסר 0, ו
אז אנחנו לוקחים את זה, ובהתאם איפה זה, נכפיל את זה
על ידי כוחו של 10.
בגלל ראשון, מה לעשות אנחנו להכפיל את התו הימני ביותר על ידי?
>> תלמיד: 10 עד 0.
>> ג'ייסון הירשהורן: 10 עד 0.
מה שאנחנו כן להכפיל השניה התו הימני ביותר על ידי?
>> תלמיד: [לא ברור].
>> ג'ייסון הירשהורן: מה?
>> תלמיד: 10 עד 1.
>> ג'ייסון הירשהורן: 10 עד 1.
התו הימני ביותר השלישית?
>> תלמיד: 10 עד 2.
>> ג'ייסון הירשהורן: 10 עד 2.
>> תלמיד: מצטער, אני לא מבין מה שאנחנו עושים כאן.
>> ג'ייסון הירשהורן: בסדר, בואו נחזור, ולאחר מכן.
אז אנחנו הולכים לקבל עבר במחרוזת.
כי אנחנו כותבים atoi.
אז אנחנו מקבלים עברנו במחרוזת.
אומר שאנחנו מקבלים עברנו במחרוזת 90.
>> הדבר הראשון שאנחנו הולכים לעשות הוא להגדיר משתנה שלם חדש שאנחנו
פשוט הולך ליצור כשלם החדש שלנו.
זה מה שאנחנו הולכים כדי לחזור בסוף.
אנחנו צריכים לעבור את כל דמות ב המחרוזת כי אנחנו כבר נקבעו
שאנחנו צריכים לגעת בכל אחד ו לאחר מכן להוסיף אותו למספר השלם החדש שלנו.
>> אבל אנחנו לא יכולים פשוט להוסיף אותו כמספר.
אנחנו לא יכולים פשוט לקחת 9 ו מוסיף 9 למספר השלם שלנו.
זה תלוי מה מקום זה במחרוזת.
אנחנו הולכים צריכים להכפיל זה על ידי כוחו של 10.
כי ככה בסיס 10 עבודות.
>> אז אנחנו הולכים לקבל בפועל דמויות או שלם בפועל
מספר, על ידי הפחתת אופי 0 מאופי 9 כמו שעשינו עם
הפחתת הון דמות מ מה אופי שהיו לנו באחד
אלה בעיות.
אז אנחנו באמת נקבל מספר בין 0 ל 9 נשמרו כמספר אמיתי, ואנחנו
להכפיל את זה על ידי כוחו של 10 בהתאם על איפה אנחנו נמצאים במחרוזת.
ואז אנחנו הולכים להוסיף אותו בחזרה למשתנה השלם החדש שלנו.
>> אז מה זה היה נראה כמו היית להיות - אנחנו ניתן למשוך לכאן.
אם אנחנו מקבלים עברנו במחרוזת 90 -
>> תלמיד: [לא ברור].
>> ג'ייסון הירשהורן: אבל atoi לוקח מחרוזת.
אז אנחנו הולכים לעבור האחזקה.
אנחנו מועברים ב90.
אנחנו הולכים מהחלק האחורי לחזית.
אנחנו לוקחים את 0.
>> תלמיד: אני מצטער.
אולי זה טיפשי.
אם אנחנו מקבלים עברנו במחרוזת, למה הוא 90 מה שאנחנו
מקבל עבר ב?
בגלל 90 הוא מספר שלם.
>> ג'ייסון הירשהורן: כי atoi לוקח מחרוזת והופך אותו למספר השלם
ייצוג של מחרוזת ש.
אבל המחרוזת 90 אינה המספר השלם 90 או המספר 90.
המחרוזת 90 היא מערך של שתיים, או שלוש דמויות, ולא, 9
אופי, אופי 0, ו תו הלוכסן האחורי 0.
>> ואנחנו כותבים atoi כי, עבור למשל, כאשר אתה לוקח את הפיקוד
טיעון קו, והוא שמור ב argv, זה נשמר כמחרוזת.
אבל אם אתה רוצה להתייחס אליו כמספר, אתה צריך להמיר אותו
שלם בפועל.
זה מה שעשיתי אחד מסטי הבעיה שלנו.
זה מה שעשיתי במספר הסטים הבעיה שלנו.
כל מי שלקח מספר שלם כטיעון שורת הפקודה.
אז בגלל זה פונקצית atoi לוקח חוט.
>> אז שוב, בדוגמא שלנו כאן, אנחנו הולך לקחת את האחרון.
אנחנו הולכים להפחית את האופי 0 מזה, כי התווים 0
מופחתים על ידי הדמות 0 נותן לך המספר האמיתי 0, על פי
המתמטיקה ASCII שאנחנו עושים.
>> מכיוון שדמויות מיוצגות כ שונה משלהם בפועל -
אופי, למשל, אותיות קטנות הוא 97.
זה לא - אופס!
זה לא מה שהיית מצפה זה יהיה, 0, למשל.
אז אתה צריך להחסיר אופי כדי לקבל 0.
>> אז אנחנו הולכים לעשות את זה כאן כדי לקבל את המספר האמיתי.
ואז אנחנו הולכים להכפיל את זה על ידי כוחו של 10 תלוי איפה זה
הוא במחרוזת, ולאחר מכן לקחת את זה ולהוסיף אותו לבעל המקום שלנו
משתנה כדי שנוכל לבוא עם השלם החדש הסופי שלנו.
האם זה הגיוני לכולם?
>> אז אנחנו לא מתכוונים לקוד זה עכשיו, בגלל שאנחנו
מקבל קצר בזמן.
אני מתנצל על העיתוי זה.
אבל זה מה ש, בתקווה, שהיית להיות מסוגל לעשות על החידון - ב
הפחות, לקבל pseudocode זה נכתב החוצה.
>> ואז, אם היינו כותב pseudocode, בעצם, אנחנו יכולים לעשות את זה
די מהר.
כל שורה של הערות שכתבנו כאן מתרגם לכ
שורת קוד C אחד.
הכרזה על משתנה, כתיבה חדשה לולאה, כמה חיסור, כמה
כפל, ואיזו משימה.
היינו כנראה גם רוצה לכתוב שורת תמורה.
אנו עשויים גם רוצים לשים כמה בדיקות בכאן.
כן.
>> תלמיד: אז נוכל להתייחס אל של כמחרוזת בפועל?
כי אני יודע שזה רק כתובת.
כמו, איך היית מקבל את אורכו של המחרוזת שעברה?
>> ג'ייסון הירשהורן: אז איך עשה אורכו של חוט?
Strlen.
>> תלמיד: strlen, כן.
אבל אתה יכול לשים את זה כ ויכוח על כך?
>> ג'ייסון הירשהורן: אז strlen לוקח כוכב char.
ומסקנה הוא כי כוכב char, וזה שומר לספור עד שהוא מגיע ל
קו נטוי הפוך 0. strlen היה למעשה אחת מהתוכניות האחרות שאנו
היו הולכים לקוד.
זה עוד אחד טוב לקוד.
אחד זה קצת יותר קל, כי אם אתה הולך לחשוב על זה
מושגית -
אני רק אמרתי את זה בקול רם - strlen כדלקמן מצביע ושומר הולך ו
לספור ושמירה על מסלול עד אתה מגיע לקו נטוי הפוך 0.
>> תלמיד: בסדר, קיבל את זה.
>> ג'ייסון הירשהורן: אז הטוב ביותר של מזל על חידון 0 מחר.
אם יש לך שאלות, אני להיות בחוץ אחרי זה.
תרגיש חופשי לשלוח לי דוא"ל.
להגיע אל TF שלך אם אתה לא בקטע שלי, או לקבל אותי
שלח לי אם אתה רוצה את זה.
>> אם אתה רוצה להתחרפן ופשוט לשלוח לי דוא"ל, דואר אלקטרוני freakout, אני
לשלוח אותך בחזרה, כאילו, פרצוף מחייך, או, כאילו, בדיחה או משהו.
אז תרגיש חופשי לעשות את זה גם כן.
מזל טוב שוב, ואני לראות את כולכם בשבוע הבא.