>> [השמעת מוסיקה]
>> דווין: בסדר, בחורים.
אז זה הסקירה לחידון הראשון.
האם כולם מוכנים ל החידון ביום רביעי?
אליסון: וו!
תלמיד: וו!
דווין: כן.
אליסון: כן!
דווין: s מוכן הבחור הזה.
בחור ש, שתי ידיים, נחמד.
אז סקירת חידון היום, זה הולך להיות כשעה וחצי.
אנחנו הולכים לעבור על כל גדולים מושגים שאתם צריכים לדעת לחידון.
אנחנו הולכים לעבור על כמה קידוד על ידי דוגמאות יד, הנמצאות בכל חידון.
ואם יש לך שאלות, תרגיש חופשי להרים את היד שלך והכל
כמו ש.
ובכן, לוגיסטיקה על החידון מקוון.
אז אנחנו הולכים לפצל אנשים עד לחדרים שונים.
הוא מבוסס על שמם.
אז אם יש לך שאלות לגבי איפה ללכת או על מה הוא חומר, כמו,
המילה הרשמית על מה שקורה כדי להיות בחידון, לבדוק באינטרנט.
וזה כל מה מעודכן.
אז אם אין שאלות ל ראשית, אנחנו הולכים להתחיל.
והנה אליסון.
>> [מחיאות כפות]
>> אליסון: בסדר, תודה, רוב.
מעריך את זה.
דווין צריך התהפך לזה.
זוהי הרשימה בלתי ממצה של נושאים, כמו תמיד, כמו דווין אמר רק.
עיין בתיעוד של באינטרנט על חידון אפס.
אבל זה די much-- זה הופיע בתכנית הלימודים
הוא כל מה שעברנו על עד כה.
הכל כאן משחק הוגן, כמו גם כל דבר אחר
שייתכן שהוזכר בהרצאה.
>> הסעיף שלי, כאן, הוא רק הרבה של ביקורת.
ישנם כמה תרגילים כי אתם יכולים לעבוד על.
אבל על פי רוב, אנחנו באמת רוצה להגיע לדווין עם קוד אלה
על ידי תרגילי יד.
>> אז אני הולך לעוף בזה.
אם יש לך שאלות, לעצור אותי.
הרם את ידך.
אני מבטיח שאני בטח אראה אותך.
אם לא, פשוט לנפנף אותו.
אני הולך לדבר מהר.
אני מקווה שכולם בסדר עם זה.
>> אישור, מילה מיוחדת, דווין ברור שכחתי לדפדף שקופיות אלה.
[צוחק] אתה בצרות, גבר.
אז טיפים לחידון אפס, לתרגל קידוד על נייר.
אתם הולכים לקבל קצת להתאמן עם זה עכשיו עם דיווין,
כדי שלא להיות לגמרי בעצמך.
אני חושב שאנחנו עומדים באמצעות שתי הפונקציות הללו.
אז אתה תהיה מוכן לשם גם.
>> להיות מוכר עם סטי הבעיה שלך.
נשאלו שאלות בחידונים קודמים
שישאל אותך, למשל, לקוד משהו דומה מאוד למריו.
אז להיות מאוד מוכר עם הבעיה שלך קובעת, כמו גם
כשאלות שאנו שואלים אותך בתחילת בטופס
כי לך למלא, יהיה ישרת אותך היטב.
>> האם חידון קודם תחת אילוצי הזמן.
חידונים אלה הם ארוכים.
הזמן עובר ממש מהר.
ולעתים קרובות, אתה לא מבין עד כמה מהר זה הולך עד שאתה בעצם
לשים את עצמך תחת אילוצים אלה.
אז אם אתה יכול רק לסלול את, אתה יודע, בדקה ה -75, או ערב או מחר
לקחת את אחד השאלונים הללו תחת כי, אתה תהיה במצב הרבה יותר טוב.
>> וגם, יצירת גיליון ההתייחסות שלך.
זכור, אתה מקבל אחד העמוד ראשון ובחזרה
כהתייחסות לחידון שלך ביום רביעי.
יצירה שהיא דרך מצוינת ללמוד.
כל דבר שאתה נתקלת בבעיה עם ברצונך לכלול שם.
כל דבר שTFS שלך היה, כאילו, זה באמת חשוב.
אתה צריך לדעת את זה, הם אולי דברים שיש לך שם
אם אין לך אותם בזיכרון.
גם אם אתה מכיר אותם באמת טוב, לפעמים שיש את זה שם
הוא פשוט סוג של נחמה בשבילך, שאני יודע חידונים הם מלחיצים.
אז כל נוחות שאתה מקבל יכול לעזור.
בסדר, גם, לישון ו לאכול ואוהבים את הדברים הרגילים
שאנו אומרים לכם לחידונים.
>> אז החל בצורה קלה, סוגי נתונים וגדלים.
כפי שאמרתי, זה רק הולך להיות לי לזרוק הרבה דברים
עד כאן שאתה צריך לדעת.
אז יש לנו התווים שלנו כי אחד בתים, ints
כי הם ארבעה בתים, ארוכים ארוך, שהם שמונה בתים.
בעיקרון, זה רק אתה רוצה להחזיק את מספרים שלמים גדולים יותר.
צף, שהם ארבעה, זוגות, שהם שמונה.
שוב, רק נותן לך יותר מקום לצפת.
ולאחר מכן הקלד כוכב, כך שכל מצביע על מכונה 32 ביט,
וזה כל מה שאתם צריכים לדעת, הוא ארבעה בתים.
>> אז כל הדברים שאתה צריך יודע, אולי דברים
אתה רוצה להיות ב גיליון ההתייחסות שלך.
אישור, המרת ינארי לינארי, המרה
להקסדצימלי, הלוך ושוב, כל הדברים שכדאי לדעת.
אז בינארי לעשרוני.
אתם רוצים לקחת את דקה מהירה ולנסות להבין כל אחד מאלה
ואז תגיד לי מה הם?
>> יש לי גם סוכריות בתיק שלי, כך שכל אחד מי עונה מקבל ממתקים, דרך אגב.
ויש לי הרבה ממנו.
תן לי לתפוס את זה.
אני הולך לתת את זה לגייב.
אז אתה יכול לחלק את ממתקים ל מי שנחמד ושיתופי.
>> אישור, ראיתי שני יש בחלק האחורי.
>> תלמיד: כן, הראשון הוא 42.
>> אליסון: כן, ראשון הוא 42, נכון.
תלמיד: [לא ברור].
[שחוק]
אליסון: שני אחת, יש חזרה בצהוב?
תלמיד: 110010.
אליסון: נכון, וזה אחרון, כאן למטה בתחתית?
כמו כן, כן, אתה יודע רוצה?
פשוט לזרוק את סוכריות.
מה דעתך על ממתקים לכולם?
>> תלמיד: [לא ברור] לאחר שנסיים.
>> אליסון: ששש.
ולאחר מכן עבר אחד.
מי רוצה לענות?
בדיוק שם.
>> תלמיד: 11100.
>> אליסון: 11100, להסתכל על זה.
מזל טוב, עבודה נהדרת, כולם.
אישור, כולם סוג של הבנה התהליך לעושה את זה?
יש לך, הולך בינארי לעשרוני כפי שאני נוהג לעשות את זה, כותב את
החזקות של 2.
אז אני אומר, בסדר, 0 פעמים 2-0, כך זה 0, 1 פי 2 עד הראשון,
הוא 2 הולכים ואילך דרך.
האם מישהו רוצה שאני במפורש לעבור דוגמא לינארי?
אישור, מגניב.
>> עשרוני בינארי הוא דומה מאוד.
אני נוטה לכתוב את החזקות של 2.
התחל עם אחד שהוא הגדול ביותר, אך אינו עובר את הנקודה העשרונית
שאתה מחפש.
ולאחר מכן סוג של דרך העבודה שלך לאחור והוסיף את דברים כמו צורך.
>> ולאחר מכן עם תוספת, זה בדיוק כמו בנוסף נורמלי.
אם אי פעם יש לך את המקרה שבו אתה הוספת שני 1s, זה כמובן הופך 2.
2 בינארי כרגע הוא 1 0 כך שאתה צריך לבצע 1 שלך לטור הבא.
מגניב.
>> הקסדצימלי, זה יכול להיות משהו כי הוא מעט פחות מוכר.
אז כפי שרוב בדיוק ספר לי לפני כן, הטריק שלו לזה
רק לפצל אותה לארבעה נתחים בייט, בסדר?
ביטים, מצטער.
רואה?
תודה רוב.
זו הסיבה שאתה כאן. [רעש] אוקיי, אז אנחנו פשוט לשבור אותו
לארבעה נתחים סיביות.
אז עם קבצים בינאריים להקסדצימלי, אנחנו מסתכלים הראשונים 4,
וזה אם יש לנו ארבעה 1s ב שורה, מה מספר האם זה מסמל?
>> תלמיד: פ
>> אליסון: אז במקרה הזה, מה הוא 11111111 or-- כן?
תלמיד: FF.
אליסון: מושלם, FF.
כל כך גדול, ממתקים בשבילך.
עכשיו, איך הקסדצימלי לינארי, אנו רק תחשוב על זה סוג של בכיוון הפוך.
עבור כל מספר או אות ש יש לנו בהקסדצימלי שלנו,
רק להמיר אותו לשלה ארבעה קצת [צוחק] להמרת ארבעה קצת שלה.
אז 5, במקרה זה, מה הוא 5 אם אנחנו מייצגים אותו עם ארבע חתיכות?
>> תלמיד: 010?
ממ-הממ.
ולאחר מכן, שהוא למעשה 10, יהיה?
1010.
אז יש לנו את זה, כאן.
אז המרה בין הקסדצימלי ו בינארית היא בעצם לא כל כך רעה.
אם אתה מסתכל על זה בארבעה קצת נתחים, הולכים להיות זהב.
Everyone-- כן?
>> ROB: זה טיפשי, אבל אני תמיד זוכר
, מאז של אמור להיות 10.
ובינארי פשוט 10 10, אז--
>> אליסון: אה, יש לנו ללכת.
>> ROB: היי.
>> אליסון: היי, ממתקים לרוב.
יש דברים שאינם שוקולד שם.
אז אתה יכול לקבל קצת.
מתמטיקה אז ASCII.
להתנהג.
אז המתמטיקה ASCII, כפי שאתם כנראה זוכר היטב
p להגדיר 2 עם VISIONEER ו קיסר, שעשית הרבה זה.
זכור, הדמויות ביסודו רק מספרים.
אז אנחנו יכולים לעשות את המתמטיקה איתם, בדיוק כמו שאנחנו עושים במתמטיקה עם ints.
>> אז יש לנו רק קצת דבר פשוט כאן.
יש לנו כמה בזה אותחל ל -65.
ו- B שווה לערך ASCII של בתוספת 1, C char שווה D מינוס 1,
וD char שווה 68.
אז אנחנו הולכים להדפסה כולם, כפי שאנו רואים כאן.
ומישהו יכול להגיד לי מה זה יהיה להדפיס?
תלמיד: [לא ברור].
אליסון: בדיוק, כל כך דבר אחד שיבחין
שאנחנו מדפיסים את תווים בכל פעם, כאן.
אנו מייעדים למרות שA ו- B הם ints כאשר אנו הכריזו עליהם לעיל.
אנחנו מדפיסים אותם כדמויות על ידי C אחוזים והצהרת printf שלנו,
ולכן הם כל יודפסו בתווים.
וכמובן, רצון ערך ASCII 65 להדפיס כא ערך ASCII של פלוס 1
יהיו 66, אשר היו גאים ב 'כך שלמעשה, אנחנו
תקבל כולם א ב ג ד טוב שם?
שאלות?
מדהים.
>> אישור, היקף.
אז ההיקף הוא ללא ספק מאוד דבר חשוב להבין, כאן.
הרבה מכם, אם אתה יש שגיאות קומפילציה,
וזה אומר שאין לך גישה לחלק משתנה,
זה כנראה בגלל שאתה הגדיר אותו בתוך לולאה
ולאחר מכן ניסיתי לגשת אליו מחוץ לזה, או להיפך.
>> אז היקף בליבה שלה, זה פשוט קובע בי
אנו אומרים משתנים קיימים, שבו אנו יכול לשנות את זה, שבו אנו יכולים לגשת אליו.
זה פשוט סוג של אמירה אלה המקומות היחידים שבו יש לך גישה
למשתנה זה.
>> אז שני טווחים שאנחנו מדברים על במהלך השיעור הם גלובליים ומקומיים.
משתנים גלובליים אז אנחנו מדברים על כאשר אתם מגדירים אותם מעל עיקריים.
זה אומר שכולו שלך יש תכנית גישה אליו,
והיא קיימת לעוד כפועל תכנית, בסדר?
מקומי אומר שזה יותר מרותק לאזור.
אז בכל פעם שיש לך פונקציות ספציפיות כמו החלפה, אנחנו תמיד מדברים על.
אנחנו תמיד מדברים על החלפות עם ו ב 'ו-ב' קיימים בתוך הפונקציה ש.
הם לא קיימים בשום מקום אחר.
>> כמו גם, כאשר יש לך אם הצהרות או ללולאות.
בכל פעם שיש לנו, למשל, ב ללולאה שיש לנו int אני שווה 0.
יש לנו כמה מצב ואנחנו מעדכנים אותו.
אני קיים רק בתוך פלטה של ​​שללולאה.
אם אתה מנסה לגשת אליו במקום אחר, המהדר שלך היה צועק עליך.
זה יהיה כמו, מה אתה מנסה לעשות?
זה לא קיים.
אז זה שני סוגים שונים של היקף.
האם זה הגיוני לכולם?
>> כך למשל כאן, זה הוא רק חלק תכנית פשוטה.
מה אתם חושבים הוא הולך לקרות בכל נקודה
כי אנחנו מנסים להדפיס?
אז זה כאן, מה הולך לקרות?
תלמיד: זה יהיה להדפיס שלוש.
אליסון: נכון.
זה יהיה להדפיס שלוש.
מה לגבי כאן?
תלמיד: זה לא יעבוד.
אליסון: זה לא יעבוד.
אתה מחוץ לתחום, נכון?
משתנה מקומי לא קיימת מחוץ לסוגריים אלה, בסדר?
ואז מה כאן?
>> תלמיד: [לא ברור].
>> אליסון: מה?
רוב, ללכת.
>> ROB: אני רק אמרתי.
משתנים גלובלי צריכים להיות משתנה תחתון הגלובלי.
>> אליסון: אה, כן, מצטער.
תודה, רוב.
רוב של כמו קומפיילר התושב שלנו.
הוא פשוט לצעוק עלינו כאשר אנו צריכים את זה. [צוחק] כן, ש
צריך להיות משתנים תחתון הגלובלי.
אז בהנחה ש תחתון הגלובלי היה
משתנה, מה שהולך לקרות כאן?
תלמיד: זה יעבוד.
אליסון: זה עובד.
אז זה יהיה להדפיס, כל כך פשוט דוגמא פשוטה מאוד.
אישור, אב טיפוס.
אז ברור, שאנחנו באמת להדגיש בשבילכם
כדי להפוך את הפונקציות אם זה הגיוני בתוכניות שלך.
אבל כמובן, כאשר אתה להפוך את הפונקציות משלך,
בדרך כלל אתה מגדיר אותם לאחר עיקרי.
ואתה מנסה לקרוא להם בעיקרי.
ואם אתה לא משתמש באב טיפוס, מהדר שלך לצעוק עליך.
>> אב טיפוס הוא בעצם רק אומר לך מהדר
שיש לי פונקציה זו להלן עיקרי.
אני הולך לקרוא את זה לפני שאני מגדיר את זה.
רק יחזיק מעמד.
אני מבטיח שזה מוגדר, ואתה יהיה מה שאתה צריך.
>> אז כמו שאנחנו עושים זה רק את ההחזר סוג, שם הפונקציה שלך, הקלט שלך
רשימה.
זה בעצם השורה הראשונה של ההצהרה על הפונקציה שלך.
זה באמת כל מה שזה.
אבל זה רק סוג כללי בפורמט של.
>> לכן בדוגמא שלנו כאן, שאתם צריכים
ראיתי בסעיף בשלב מסוים, יש לנו
כמה קוביית int ש לוקח קצת int של קלט.
ויש לנו העיקרי שלנו פונקציה, הקוראת קובייה.
וקובייה מוגדרת לאחר המעשה.
>> אז אם לא היה לנו קלט קוביית int בחלק העליון, כאשר אנו נקראים קובייה
בתוך מהדר העיקרי, שלנו היה מתרגז עלינו.
זה יהיה כמו, מה אתה מדבר?
קובייה לא קיימת.
אני לא יודע מה שאתה מבקש.
ואני רק הולך להפסיק.
>> אבל בגלל שעשינו אב הטיפוס שלנו בחלק העליון, שאמרנו,
אתה יודע, כשאתה רואה קובייה, אל תדאג בקשר לזה.
אני מבטיח שזה הוגדר מאוחר יותר.
וזה ייתן לך לעשות מה שאתה רוצה.
אז אם אי פעם יש להם תפקיד שהוכרז לאחר שאתה קורא את זה
בפעם הראשונה, אתה צריך יש לו אב טיפוס בחלק העליון.
>> כן?
>> ROB: זה בריבוע, לא עִקוּב.
>> אליסון: הו אלוהים שלי.
אני לא have-- גייב, חשבתי היית מגינו.
בחורים אישור, לשאת איתי, כאן.
אני מקווה שכולם מקבל את הרעיון.
אוקיי, אז זה צריך להיות כבר בריבוע, לא חתוך לקוביות.
אבל הרעיון נשאר אותו הדבר.
כל פונקציה שאנחנו קוראים אחרי למעשה צריך להיות אב-טיפוס.
כולם טובים בזה?
כל שגיאות הקלדה אחרות?
אישור.
כל שגיאות הקלדה כאן לפני שאנחנו מתחילים, רוב?
[צוחק] אוקיי, אז structs.
בעיקרון, structs יאפשר לך כדי ליצור סוג הנתונים שלך.
כל כך הרבה כמו int או char או לצוף, זה רק סוג אחר.
אני רוצה לחשוב על זה כעל, כמו, ליצור סוג הנתונים שלך.
אז זה מאפשר לך לעשות את זה.
והיא מחזיקה סוגים שונים של נתונים.
>> אז אם אתה זוכר, במערך, אנחנו יכול להחזיק רק דברים מסוג דומה.
Structs יאפשר לנו להחזיק מספר רב של דברים מסוגים שונים.
אז במקרה הזה כאן, אנחנו יש לי struct בשם סטודנטים,
בשם כאן בתחתית.
ויש לנו כמה id int וכמה שם מחרוזת.
אז זה סתם עוד סוג הנתונים.
עכשיו יש לנו טיפוס בשם סטודנטים.
>> אז בגלל שאנחנו יכולים לחשוב על זה כעוד סוג הנתונים,
אנו יכולים להצהיר על משתנים כפי שאנו עושים מדי.
אז במקום רק שיש, כמו, תלמיד int, רק שיש לנו סטודנטים,
תלמיד 1.
אה, תראה.
זה רוב.
אז הנה אנחנו מכריזים struct, או משתנים
בשם תלמיד 1 של תלמיד סוג.
אז זה הולך לי id ושם משויך אליו.
>> והדרך בה אנו לגשת אלה גורמים בתוך struct שלנו
הוא עם מפעיל הנקודה, כאן.
אז במקרה הזה, אנחנו הכריז איזה סטודנט 1.
אנחנו מוקצים ID להיות 1.
ואנחנו מוקצים שם להיות רוב.
אישור, כולם טובים בזה?
השתמש בו רק like-- כן?
>> תלמיד: כן, typedef-- כאשר אנחנו צריכים להשתמש בtypedef?
>> אליסון: אז typedef רק אומר that-- רוב, אתה
יכול לתקן אותי על זה אם אני wrong-- אבל typedef הוא רק בעצם הכרזה
את זה כסוג שאתה יכול להשתמש, נכון?
>> ROB: כן, זה בעצם, כך שזה רק יצירת
כינוי, או כינוי לסוג.
אז אתה יכול להקליד ש[ לא ברור].
אז [לא ברור] קיים, ועכשיו רק שיש לנו
[לא ברור] אמצעים בדיוק אותו הדבר.
אז הנה, אנחנו הקלדה, אני חושב, כמה struct מסוג 2 [לא ברור].
כך שזה רק כינוי עבור סוג נתון.
>> תלמיד: מחרוזת ספרייה [לא ברור] הוקלד כמו כוכב char.
>> אליסון: למטרות שלנו כאן, אם אתה מכריז struct,
פשוט לעשות typedef struct.
אוקיי, אז מראש, זה הוא רק משתנה רגיל כאן.
אנו לגשת אליו עם נקודה.
אם יש לנו מצביע ל struct, אנחנו יכולים למעשה
להשתמש חץ, וזה די מגניב.
>> אז במקרה הזה, יש לנו מצביע ל תלמיד 1 שהוא תלמיד של סוג.
זכור, עם שלך בניית מצביע,
אתה רוצה לא משנה מה סוג המצביע מצביע על להיות בתחילת.
אז יש לנו איזה סטודנט 1, כאן.
ומכיוון שתלמיד זה 1 הוא עכשיו מחודד,
אנחנו באמת יכולים ללכת שם חץ 1 תלמיד במקום נקודה, כי זה מצביע,
ולהקצות רוב.
ועכשיו אם אנחנו רוצים לשנות רוב לדווין,
זה רק מראה לך דרך אחרת לעשות את זה.
>> אז במקום להשתמש בחץ, לך יכול also-- אני אסיים את זה ואז
לקחת את זה question-- אתה יכול גם לעשות תלמיד התייחסות 1.
זה אומר כמו ללכת ל כל מה שעל תלמיד 1, ש
יהיה struct הסטודנטים שלנו.
לגשת אליו עם נקודה והאלמנט שאתה רוצה, ולאחר מכן להקצות מחדש אותו.
הייתה שאלה.
סטודנט: כן, אז איך קורה שיש לך להשתמש [לא ברור] כשאתה
עושה כוכב סטודנט ללא [לא ברור] תלמיד?
אליסון: כי זה יוצר מצביע.
ROB: אנחנו הולכים לדבר על זה.
אליסון: אנחנו הולכים לדבר על כך בהמשך בסקירה.
אז פשוט להחזיק את המחשבה הזאת.
אם זה עדיין מפריע לך ב הסוף, לבוא לדבר עם אחד מאיתנו.
>> אז אלה לעשות בדיוק את אותו הדבר.
אנחנו רק מראים לך שני דרכים שונות לעשות את זה.
סטודנט 1 הוא החברה מצביע, כך אתה יכול לגשת לרכיב שם
בתוך struct עם חץ.
או שאתה יכול dereference המצביע, ו אז לגשת אליו כמו שאתה עושה בדרך כלל.
האם זה הגיוני לכל אחד?
אם כל הדברים המצביע הם קצת מבלבל, גייב יהיה לדבר על זה,
ואז אולי זה יהיה הגיוני יותר.
כן?
>> סטודנט: כן, אז איך הוא זה שונה מ?
אליסון: הקודם?
אז התלמיד 1 בזה המקרה הוא לא מצביע.
זה פשוט struct שלך בפועל.
>> תלמיד: אישור.
>> אליסון: בעוד שזה אחד הוא מצביע למבנה.
>> תלמיד: בסדר, אבל עושה את זה סוג של בסופו של עובד באותו [לא ברור].
>> אליסון: זה למעשה עובד אותו הדבר.
התחביר שלך הוא פשוט שונה.
תלמיד: אישור.
>> אליסון: כן, הם יעילות זהה.
זה פשוט תלוי בהקשר, ייתכן שתרצה אחד על פנים השני.
כן?
>> תלמיד: כאשר אתה עושה אזכור של 1--
אליסון: ממ-הממ?
תלמיד: למה אתה יש לי הסוגריים?
אליסון: כי תלמיד 1 הוא המצביע.
אז אתה צריך לוודא שאתה רק ביטול הפניה למבנה המצביע.
>> תלמיד: אישור.
>> אליסון: אז במקרה הזה כאן, הסוגריים סביבו
משמעות הדבר היא שאתה ביטול התייחסות תלמיד 1.
אז אתה הולך למקום שבי תלמיד 1 נקודות, שהוא struct שלך.
אז עכשיו אתה יכול לחשוב על זה כעל struct ש,
כדי שנוכל להשתמש בפעולת הנקודה הרגילה שלנו.
יש עוד שאלות?
מגניב, מדהים.
>> אז הדבר אחרון, אני חושב ש היא השקופית האחרונה שלי, וו!
אוקיי, אז צף חוסר דיוק נקודה.
דברנו בקצרה על זה במהלך הרצאה.
בעיקרון, יש לנו רבים לאין שיעור אמיתי מספרים.
ואם מישהו מכם אוהב מתמטיקה, יש
כל מיני דברים מגניבים איתנו.
>> אבל יש אינסוף רבים אמיתיים מספרים.
אבל הם רק בנים-תמותה פיסות רבות שיש לנו.
אז אתה תמיד הולך יש חוסר דיוק, הוא כל.
וזהו זה פשוט סוג של כמו משהו שאתה צריך לדעת.
כי כמו שאנחנו יכולים לשאול אותך מדוע נקודה צפה חוסר דיוק קיימת?
אז רק משהו שאתם צריכים לדעת.
ועם זה, אני פונה זה מעל למצביעים.
>> בינקי: שלום, חבר 'ה.
קוראים לי בינקי.
אני הולך לדבר על מצביעים.
כן, כך מצביעים הוא למעשה החלק האהוב עליי בקורס זה.
אז רק כדי להבהיר במה אליסון מדבר כאן, כך הסיבה
why-- ההבדל היחיד כאן, ההבדל הגדול היה בדרך
אנו מצהירים דברים.
אז כוכב סטודנט פירוש זה הוא מצביע לתלמיד.
בעוד השקופיות לפני, תלמיד struct בפועל, כמו תלמיד בפועל,
המכיל את כל הדברים האלה.
>> והסיבה ש רוצה to-- כן, דווין?
>> דווין: מה החץ אומר?
>> בינקי: אמצעי החץ בדיוק כמו זה.
אז אתה לא באמת צריך את החץ.
כמו, אם אתה רק תכנית ב- C, אתה יכול פשוט להשתמש בזה.
מצטער, אני לא מה ש.
אתה יכול פשוט להשתמש בתחביר זה.
>> אבל יש אנשים ש, כאשר הם עיצוב C,
הם חשבו שאנשים שימוש בתחביר שכל כך הרבה,
שהם רוצים רק לבוא עם מבנה תחביר לזה.
וזה התרחש ב הצורה של החץ הזה.
וזה ממש נחמד, כי הוא מסמל משהו
כמו שאנחנו למעשה הבאים החץ הזה, מצביע זה,
לכמה מקום בזיכרון.
וכאשר נגיע לשם, אנחנו רוצים להסתכל על שמו של תלמיד ש,
אם זה נשמע הגיוני.
בסדר?
>> אז זה בדיוק אותו הדבר.
זה בדיוק אותו דבר כמו זה.
הם מקבלים מלוקט בדיוק אותו הדבר, בסדר?
והסיבה כאן למה אנחנו malloc משהו, הוא כי במקרה זה,
המשתנה שלנו היא למעשה רק משתנה מצביע.
אז יש לנו קצת מקום רק ב זיכרון שמחזיק את מצביע.
באמת שאין לנו שום מקום שמחזיק את struct בפועל.
>> אז זה צריך להיעשות בשני שלבים.
אנחנו צריכים ליצור את זיכרון לשים struct ב.
ויש לנו כדי ליצור את זיכרון לסימון ב.
אז הם בעצם שני משתנים שונים, כאן.
אחד מהם הוא של תלמיד סוג, מלבד זה לא ממש להיות שם.
והשני הוא כוכב סטודנט סוג.
ואז נקודות 1 תלמיד יש, אם זה הגיוני.
בסדר?
>> אז הסיבה לכך שאנו משתמשים ב מצביעים הוא כי הכל
במחשב, בכל משתנה יש שני דברים במחשב.
יש לה הערך שלה.
ויש לו את הכתובת שלו.
ודרך טובה להמשיג זה הוא שיש
בעיות רבות בעת אנסה להשתמש בפונקציות.
ואנחנו הולכים לנסות להסתכל לתוך אחד מאותם.
כלומר, זה הולך לחשוב על זיכרון כקופסות.
>> אתה תמיד חשבת על משתנים כשאתה אומר na שווה 5.
אתה חושב לשים 5 לתיבה.
אז מה אם אתה רוצה לעבור int שלפונקציה?
אתה פשוט pass-- אני לא יודע-- x לפונקציה.
אבל מה שקורה הוא בדרך כלל בני אדם, אתה
היה חושב שמשהו כמו אני עובר את התיבה לאדם.
וזה לא ממש יקרה במחשבים.
מה שקורה הוא שאתה מעתיק את הערך של התיבה לתיבה של האדם.
>> אז מה שאני מנסה לומר הוא שאם יש לך function-- sorry-- כאן,
אם יש לנו פונקציה כמו לחמש עד יש, אם אתה מנסה להעביר משתנה,
זה פשוט הולך להעתיק.
אם NX לאתחל שווה 3, זה הולך כדי להעתיק ערך זה עד משתנה
שם למעלה.
אישור, וזה סוג של הסיבה לכן אנחנו רוצים להשתמש במצביעים.
כי במקום נותן רק את הערך,
במקום רק עובר רק הערך לפונקציה,
אנחנו רוצים להעביר על ידי התייחסות.
מה שאנחנו קוראים לעבור על ידי התייחסות הוא סוג לתת את התיבה לפונקציה,
כך שגם הפונקציה יכולה לשנות את הערכים בתוך התיבה ש.
>> אוקיי, אז רק חלק מצביע בסיסי דברים הוא ליצור מצביעים,
אתה פשוט להכריז עליו סוג, ו אתה שם את כוכב מייד אחרי זה.
והסוג הוא רק מה שאתה מצביע על.
אז אם זה כוכב int, אתה מצביע על int.
אם זה כוכב char, אתה מצביע על תרשים.
ואם זה כוכב סטודנט, אתה מצביע על סטודנט.
בסדר?
>> והם ארוכים כל 4 הבתים.
מכיוון שמשתנה זה זה לא באמת
צריך להחזיק char, int, או סטודנט.
זה רק צריך להחזיק את כתובת.
זו הסיבה שהם כל 4 הבתים ארוך במכונה 32 ביט רגיל.
בסדר?
אז הנה, x הוא משתנה המצביע לint. נקודות y לchar. נקודות z
למצוף.
כל שאלות כאן?
מגניב.
ויש שני סמלים שונים שיש להם
לזכור כאשר מגיע למצביע.
אז התייחסות ו ביטול התייחסות הם לגדולים.
אז האמפרסנד של שם משתנה נותן לך?
תלמיד: כתובת.
בינקי: כתובת.
אז אם אתה מצהיר על int שווה 5, אז אמפרסנד
של הוא הולך לתת לך את הכתובת.
ואתה באמת יכול לנסות כדי להדפיס את זה ולראות
מה בזיכרון כתובת יש משתנה.
ולאחר מכן dereferencing-- כך שהתייחסות,
מקבל את ביטול הפנית address-- הוא בדיוק ההפך.
אישור, ממש כמו בימים הוא ההפך מחטיבה,
כוכב הוא ההפך מהאמפרסנד.
אז אמצעי ביטול התייחסות ללכת לשם.
אז אם אתה נותן לי star-- לא יודע-- 50, זה
הולך לנסות ללכת לכתובת של מספר 50 בתוך המחשב שלך.
אישור, ולמה אנחנו רואים שהם ההפכים?
כי מה שקורה אם אתה עושה משהו כמו כוכב אמפרסנד?
ובכן, אמפרסנד נותן לך את הכתובת של משתנה, את הכתובת של.
אבל כוכב פירושו ללכת לשם.
>> אז מה קורה אם אתה גש לכתובת של?
אתה פשוט מקבל, נכון?
אז הולך לכתובת של הוא אותו הדבר כמו.
זו הסיבה שהם בדרך כלל התייחס לsame-- זה
וזה מופנים ל מפעילים הפוכים.
בסדר?
כל כך מגניב.
>> מתחת למכסה המנוע, למשל, אם אנו מצהירים x int שווה 5,
יש לנו משתנה.
וזוכר שאמרתי כל variable-- וזה דבר טוב
כדי לשמור על mind-- יש לו שני דברים שונים הקשורים ב.
יש לו וערך התייחס.
בסדר?
>> אז הערך במקרה זה הוא 5.
וכתובת is-- נניח, אני מה שהופך משהו up-- זה 0x04.
והסיבה היחידה שאנחנו בדרך כלל מייצג כתובות בהקסדצימלי
הוא אחד, כי זה כמו טוב.
זה הולך טוב עם בינארי.
זה קל להמיר אל ומאת ינארי.
וזה לא יגדל יותר מדי אם יש לך מספר גדול מאוד.
אז אנחנו רוצים להשתמש הקסדצימלי בכתובות הדפסה.
אבל אני יכול לייצג זה כמספר שלם.
זה בסדר גמור.
>> וכך יש לו את כתובת 4 וערך של 5.
ואז אמרתי מצביע כוכב int.
אז זה סוג, הודעה שונה.
מצביע כוכב Int שווה הכתובת של x.
אז מה הולך להיות הערך של PTR?
זה הולך להיות כתובת של x, כאן למטה.
אוקיי, אז הערך הוא הולך להיות זהה לכתובת.
זה המשימה לפעול אני עושה.
ולאחר מכן ptr הוא הולך להיות כתובת שלה, שמתבררת,
במקרה זה, 8, בסדר?
>> ולאחר מכן אני יוצר עותק שלם חדש.
ואני אומר עותק int שווה ללכת לשם.
אז לך למה PTR מצביע.
ובכן, מה יש לי PTR זה?
יש PTR 0x04.
מה קורה אם אני מנסה ללכת לשם?
אני תמצא את הבחור שיש לי יש x כתובת ושכתובה 4.
ומי שיש לי מתייחס לארבעה הוא x.
האם זה הגיוני?
כן?
>> תלמיד: במקרה זה, הוא את המצביע בערימה?
>> בינקי: במקרה זה, it's-- שאלה טובה.
אני לא באמת חושב על זה בעת ביצוע את הכתובות הללו.
אבל אם זה, כולו, כמו אלה הם משתנים מקומיים,
אז x הולך לחיות in-- הכל הוא הולך לחיות בערימה.
אז הכל הולך להיות מצביע על מחסנית.
אתה מקבל רק לערימה כאשר אתה מתחיל להשתמש malloc, נכון?
>> אז אם אתה זוכר ערימה היא כל זמן אתה קורא לפונקציה בתכנית שלך,
כמו, עיקרי לדוגמא, או כל תפקיד אחר, כמו printf.
כל המשתנים המקומיים הולך לקבל אותו במסגרת חבילה.
והם הולכים לקבל כמו נערם בערימה.
זה מה שנקרא ערימה.
וכל משתנים מקומיים אלה הולכים להיות שם.
וheap-- ואנחנו הולכים לדבר יותר על זה later--
הערימה היא שבו כל באופן דינמי שהוקצה חיי זיכרון.
מגניב?
>> אנחנו הולכים לשקופית זו.
כן?
>> תלמיד: למה הוא לא int להעתיק חוזר 0x04?
>> בינקי: למה לא int להעתיק חוזר 0x04?
>> תלמיד: למה לא כל כך [לא ברור]?
>> בינקי: כי מה הוא ערך של PTR?
>> תלמיד: 0x04.
>> בינקי: 0x04.
מה קורה אם אתה הולך ל0x04?
מה אתה מקבל?
>> תלמיד: אה, בסדר.
בינקי: אתה רואה?
סטודנט: כן.
בינקי: אז אתה מקבל 5.
אז העותק הוא הולך להיות 5, אם זה נשמע הגיוני.
כן?
>> תלמיד: האם יש לנו gotten 5 בתיבת הערך [לא ברור]
אם אנחנו שמים int להעתיק [לא ברור].
>> בינקי: Int-- היינו, כן.
שהיה עושה פחות או יותר את אותו הדבר.
אבל בדרך זו, אנו יכולים לעבור להתייחס לפונקציות.
וזה דבר מגניב אנחנו הולכים לעשות עכשיו.
>> אז את התרגיל הזה תמיד עולה on-- מאוד בדרך כלל מגיע על חידונים.
אז זה ממש טוב כדי לנסות לעשות דברים מסוג הזה בעצמך.
אז תנסה לעקוב אחר מה כתובת הוא ורוצה את הערכים של המשתנים
הם בכל נקודה.
אז זה בדיוק מה אנחנו הולכים לעשות.
הנה, יש לנו צעדים, אחד, שתיים, שלוש, ארבעה, חמש.
אחת, שתיים, שלוש, ארבעה, חמש.
ואנחנו הולכים כדי לעקוב אחר של הערכים של x ו.
>> אז מה זה עושה, אם זה קוד מרכבה, שאנחנו מנסים לעשות עד חמש.
אז אנחנו מנסים להשיג ב משתנה ולשנות את הערך שלה ל -5.
וזכור האנלוגיה של בעל שלי תיבה ומסירת התיבה למישהו?
יש כל כך עיקרי התיבה הזה שנקרא x.
והוא מכיל את הערך 3.
ואני מנסה להעביר תיבה זו לחמש.
>> ואני רוצה חמישה לשינוי הערך של תיבה זו כדי 5.
ואז אני פשוט להדפיס את הערך של x.
זה מה שfunction-- שלי זה מה שאני מנסה לעשות.
אני רק מנסה לעדכן הערך של x עד 5.
האם זה ברור מה הפונקציה עושה?
>> אוקיי, אז מה הולך להיות ערכים של x וממש כאן,
את השורה הראשונה, ממש לפני הראשון line-- הייתי say-- של התכנית?
>> תלמיד: כנראה אשפה.
>> בינקי: רק דברים אשפה.
אז אני פשוט לשים N /. אז אנחנו לא באמת יודעים.
כמו, אפילו לא קיימת עדיין, כי אנחנו לא נקראים לחמש.
Int לא הצהיר.
וx הולך להתקיים כאן, אבל יש לנו לא ממש
הוקצה כל ערך לזה, כל כך בסדר?
>> ואז, מה שהולך להיות ערכים של x ובמספר שתיים?
>> תלמיד: [לא ברור].
>> בינקי: אז x הולך להיות 3.
זה קל, כי אנחנו מקצים לו 3.
ועדיין לא קיימת כי רק מתגורר בחמישה.
אז אני הולך יש לי 3 ושום דבר.
או כמו זבל, מה, לא מוגדר באמת.
ועכשיו, זה הקו החשוב.
הנה, אנחנו הולכים למעשה קורא לחמש.
ונזכור מה שאמרתי.
אנחנו אף פעם לא עוברים בתיבה.
אנחנו פשוט להעתיק את הערך של התיבה לתיבה אחרת.
זה כל מה שהמחשבים עושים, להעתיק דברים ממקום אחד למשנהו.
>> אז עד חמש, מה זה בעצם עושה זה מעתיק את הערך של x ל.
אז מה הולך להיות כאן?
הערכים של x ו.
3 ו -3, אנחנו פשוט להעתיק על זה מx ל.
מגניב.
>> עכשיו אנחנו כאן.
ועכשיו אנחנו הולכים לעדכן שווה 5.
מה הולך לקרות בקו ארבעה?
>> תלמיד: [לא ברור].
>> בינקי: מתעדכן, אבל x לא עודכן.
בגלל x עדיין מתגורר במרכזי, זה בלוק שונה לגמרי מזיכרון.
זה משתנה שונה.
משתנה אחר.
הם במקרה יש לי אותו ערך, כי אני
מועתק על הערך של x ל.
אבל עכשיו כשאני עושה שווה 5, זה לא ממש משפיע על x בכל דרך.
זה החלק המסובך.
האם זה הגיוני לכולם?
כן?
תלמיד: עוד שאלה אחת, יש לך 3.
מדוע already-- הו, לא, זה 3.
מצטער, לא חשוב.
אני קורא 5.
>> בינקי: כן, 3, 3.
>> תלמיד: [לא ברור], כן.
בינקי: ואז אנו מקצים 5 ל , אבל לא ממש לשנות את x.
טוב?
סטודנט: כן.
בינקי: כן?
האם אתה יכול להסביר שוב איך מועתק [לא ברור]?
>> בינקי: בסדר, אז כאשר אתה קורא לחמש של x, כך הקו הזה של קוד כאן.
חמש של x, מה הוא X?
x הוא 3 בדיוק בנקודה זו, נכון?
אז אתה יכול פשוט לחשוב על לשים 3 בכאן ושוכחים על x.
פשוט לשים 3 כאן.
כמו, שאנחנו הולכים להעתיק את ערך של x לint זה שם למעלה.
בסדר?
>> אז הערך של x הוא 3.
אנחנו הולכים להעתיק 3 מעל ל.
וכל בלוק של אחר זה זיכרון, משתנה אחר זה
בשם יהיה לי 3, כמו גם.
האם זה הגיוני?
כן?
>> תלמיד: אם אתה נותן לחמישה כמו יש לו כמספר שלם x במקום,
היה שמתקנת את הכל?
>> בינקי: אם זה integer-- לא, שלא לתקן את הכל.
כך שזו שאלה טובה מאוד.
זה לא ממש משנה מה אתה קורא כל המשתנים הללו.
שוב, זה יהיה נושא של היקף, בגלל שהם לא אותו הדבר x.
הם לחלוטין חללים שונים בזיכרון.
תלמיד: [לא ברור].
בינקי: אז זה לא ממש משנה מה אתה קורא להם.
זה לא לתקן את הדברים, בסדר?
עוד שאלות?
כן?
>> תלמיד: איך זה לחזור ל מספר חמש [לא ברור]?
בינקי: בסדר, אנחנו לא עשינו את זה עדיין.
בואו נלך למספר חמש, ולאחר מכן.
>> תלמיד: [לא ברור]?
>> בינקי: מה?
>> תלמיד: האם יש לך תמורה בכלל?
בינקי: אין לנו תמורה, לא של עיקרי.
אך חוזר ראשי 0 באופן אוטומטי אם אתה לא מחזיר שום דבר.
כן?
>> תלמיד: האם אתה יכול לעשות main-- או אתה יכול לעשות עד חמש תמורה?
>> יש לנו יכול: בינקי חמש לחזור, כן.
אבל אז היינו x צריך להקצות שווה ערך ההחזרה של עד חמש,
אשר יהיה מעט תכנית אחרת.
זה יעבוד.
אבל מה שאנחנו רוצים לעשות הוא מה שהוא נקרא לשנות משהו במקום.
אז אנחנו רוצים בעצם לשנות תיבה ושלא לדאוג
על זה שצריך לחזור ערכים או כל דבר.
בסדר?
>> זה בדיוק כמו פונקצית swap דוד הראה בהרצאה, רק שאני
התמודדות עם משתנה אחד בלבד.
והוא השתמש בשני, כך int A ו- B ו אז משתנה זמני ומה לא.
בסדר?
אז מה השורה האחרונה?
לאחר חמש חזרות, זה פשוט הולך להיעלם.
לא תהיה לנו יותר, ו רק x עדיין ימשיך להתקיים.
>> ונחש מה? x לא לשנות את הערך שלו,
אחרי הכל, בגלל שאנחנו רק שינוי ערכו של.
זו הסיבה שx היה 3 בכל.
בסדר?
טוב.
אז התכנית הזאת לא להשיג את מה שרצינו.
עכשיו בואו נתקן את זה.
>> ותכנית התיקון היא שימוש במצביעים.
מה שאנחנו עושים הוא שיש לנו שלוש קווים שהם שונים.
הראשונים הוא שאנחנו לא עוברים x.
אנחנו עוברים את הכתובת של x.
אז במקום העתקה של הערך של התיבה,
אני עדיין הולך להעתיק משהו.
אבל אני מעתיק מעל הכתובת של התיבה.
>> אז אם אני עובר את הכתובת של שלה תיבת חמש, אז עד חמש
תוכל למצוא את זה ב זיכרון ולשנות את הערך שלו.
>> אז ולאחר מכן שם למעלה, יש לי זה לא int יותר.
הוא כוכב int.
זה מצביע למספר שלם.
ואז, מכיוון שאני עובר תעסוק כאן, ולאחר מכן מה שאני עושה
לא שווה 5, משום ש מחזיק את כתובת.
אז מה שאני רוצה לעשות הוא ללכת לשם ו לעדכן את התוכן של כתובת זו
עם 5.
>> אוקיי, אז בואו נעבור כל קווים בזה אחר זה.
לכן, כאשר אני מתחיל כאן, אני עדיין יש לי N /, N / A, N /
לכל דבר בראשון קו, כי יש לי לא ממש
הכריז דברים עדיין.
ולאחר מכן בשורה שתיים, יש לי x שווה 3.
כוכב int לא קיימת, אותו דבר כמו קודם.
>> עכשיו זה נהיה מעניין.
אז אני הולך לעבור.
ונניח שאת הכתובת של x הוא 12 בהקסדצימלי.
בואו פשוט מניחים שזה.
אני המצאתי את זה.
אז מה אני עובר כאן הוא עד חמש.
אני מעביר 12.
>> אז מה ערך יש ל?
>> תלמיד: [לא ברור].
>> בינקי: מצטער?
>> תלמיד: [לא ברור].
בינקי: כן, כמו, לבואו תניח שאנו נמצאים כאן, עכשיו.
אני מבקש.
>> תלמיד: [לא ברור].
>> בינקי: זה כבר יזם.
>> תלמיד: [לא ברור].
בינקי: מפני שהעברנו משהו לפונקציה.
כן?
>> תלמיד: כתובת של x.
בינקי: זה הולך ל יש את הכתובת של x.
ואת הכתובת של x היא 12, טובה.
אז x הולך להיות 3, כי אנו לא באמת השתנו x עדיין.
ואז הוא הולך להיות 0x12, כך הכתובת של x, כי זה
מה שעברנו לחמש.
>> ואז מה קורה אם תנסו ללכת לשם?
מה אנחנו הולכים למצוא?
אז אם אתה מנסה להדפיס לככב, אנחנו הולכים למעקב כתובת זו
ולקבל את הערך בתוך.
והערך הוא רק אותו הערך שx
יש כי זה כתובת של x, שתהיה 3.
האם אנחנו טובים?
>> אישור, ולאחר מכן עכשיו, אנחנו באמת הולכים לשם.
ואנו מעדכנים את כל מה ש הוא בכתובת זו 12.
אנחנו עושים את זה 5.
אז עכשיו הן X וכוכב הן 5.
>> מדוע זה כך?
מכיוון שהכתובת של x היא 12.
ויש גם 12 כערך שלו.
אז אם אנו עוקבים אחר 12, אנחנו רק הולך למצוא x.
אז מה אנחנו עושים עם כוכב הולך לקרות
לx, כי מכיל הכתובת של x.
בסדר?
>> ואת זה הוא כמו גופו של התיקון.
אז עכשיו אנחנו יכולים, מחמישה, בעצם
זיכרון גישה שחי בעיקרי.
אז הזיכרון הזה אינו מתגורר ל חמש, כמו לפני, כתובת זו 12.
ואנחנו היינו יכולים ללכת לשם ולשנות את הערך שלה ל -5.
>> ואז כשנחזור, אנחנו שוכחים.
אנחנו שוכחים את הכוכב.
וx הוא עדיין חמש.
אז אם אתם רוצים ליישם פונקצית swap,
היית עושה בדיוק את אותו הדבר רק, מלבד אתה צריך int כוכבים כאן,
וכן הלאה וכן הלאה.
בסדר?
האם אנחנו טובים?
מגניב.
>> אז מצביע חשבון.
זהו נושא מעט מסובך.
אז מתברר ש מצביעים הם רק מספרים שלמים.
אתה יכול לחשוב עליהם כמספרים שלמים.
כי בזיכרון, יש לך כמו זיכרון כתובת אפס, אחת, שתיים, שלוש,
ארבעה, חמש.
אז אנחנו יכולים לסכם כתובות זיכרון.
>> וזה בדרך כלל מה שאתה עושה כש אתה ובמערך, למשל.
מערך הוא בדיוק כמו רציף בלוק של זיכרון, של המון תווים,
לדוגמא, הרבה ints.
אז אם אתה רוצה ללכת ל שני int או int השלישי,
רק אתה יכול לסכם משהו לראשון כתובת, ואתה הולך להגיע לשם.
אז זה ממש שימושי בשביל זה.
>> והדבר כדי לשמור על בראש, אם כי, הוא
כי זה לא רק אוהב חשבון נורמלי במובן
כי אם אתה עם התמודדות, אומר, כוכב int, ואתה מוסיף 1 לזה,
אז אתה לא הולך להוסיף 1 לכתובת,
אתה הולך להוסיף 4 לכתובת.
בגלל int הוא 4 בתים.
>> אז זה בדיוק כמו הליכה על מערך.
אם יש לנו מערך של הרבה ints ו אז אנחנו מנסים ללכת לשנייה אחת,
זה בעצם רק סיכום כתובת של הראשון בתוספת 1.
אבל זה לא be-- רק נניח כי הכתובת של הראשונה היא 4.
כאן, במקרה זה.
ואם נסכם, אז זה זה מה שקורה.
יש לנו int.
Int x שווה 5.
יש X ערך 5.
ונאתחל את מצביע זה, int y כוכב int y שווה לכתובת של x.
>> הבה נניח את הכתובת של x היא 4.
מה הולך לקרות עכשיו, אם אני מסכם להוסיף 1 לy?
זה הולך בעצם סכום 4 ולא רק 1.
אז אני מוסיף 1, אבל זה בעצם הוסיף 4, משום שהמחשב של חכם.
אז זה הולך להוסיף בפועל על ידי i פעמים גודלו של הסוג של המצביע.
בסדר?
>> אז אם זה היה char, למשל, אם זה היה y כוכב char,
ואם הוסיפו 1 אז היית זה להיות 5, כי char הוא ארוך בייט 1.
טוב?
>> ולבסוף, הגענו ל מצביעים ומערכים.
מתברר שבכל פעם יש לך עסק עם מערך,
אתה בעצם מתמודד עם מצביע.
הסיבה הרעיונית נחמדה מאוד ל זה הוא שמערכים הם גדולים מאוד.
אז זוכר שאמרתי ש בכל פעם שאתה עובר דברים מסביב,
אתה מעתיק הכל.
אז אם יש לך מערך זה ממש, ממש גדול,
אתה לא באמת רוצה להעתיק הכל בכל פעם
אתה עובר אותו סביב למשנהו פונקציה, כי זה פשוט
כמויות עצומות של עבודה.
אז מה שאתה עושה הוא רק האחרון את הכתובת של הבית הראשון.
ואז הפונקציה תהיה גישה לכל האלמנטים במערך ש.
אז עבר את המערך על ידי הכתובת שלו, כך את הכתובת של הבית הראשון.
>> אז אם אנו מצהירים int מערך 3, כאן, אנחנו יודעים
כיצד לגשת לאלמנט הראשון באמצעות סימון הסוגר.
אם אתה זוכר את התושבת סימון, תושבת מערך 0 שווה 1.
ובכן, זה יהיה בדיוק אותו דבר כמו פשוט ללכת לשם ולשים 1.
אישור, זה בדיוק אותו הדבר.
אז סימון הסוגר כאן יהיה זהה לקו הזה.
>> ונחש מה סימון הסוגר לתושבת מערך 1 יהיה?
זה פשוט יהיה אותו הדבר כמו זה.
אז להוסיף אחד למערך.
מהלך אחד לאורך בזיכרון.
ללכת לשם, ולשים 2.
בסדר?
והקו הזה אותו דבר.
אנחנו רוצים ללכת לשלישיים תיבה, כך מערך בתוספת 2.
ללכת לשם, ולשים 3.
אז בזיכרון, מה ש הולך לקרות הוא שאנחנו
הולך להיות 1, 2, ו -3 כ שלושה אלמנטים של מערך זה.
>> היינו יכול לעשות את זה באמצעות סימון התושבת המוכר שלנו.
אני רק רוצה שבחורים לדעת שהם אותו הדבר.
אישור, שאלות על זה?
נחמד.
עכשיו, אני הולך למסור זה מעל לחנה,
>> חנה: יש, איי-האו.
>> בינקי: מדבר על זיכרון ודברים מאמר.
[מחיאות כפות]
>> חנה: היי, מגניב, כך שאנחנו הולך לדבר קצת יותר
על זיכרון, שאנחנו פשוט התייחס שימוש במצביעים.
אז יש שני חלקים עיקריים של זיכרון שבה אנו עוסקים.
יש לנו הערימה, שבו גדל בתחתית, והערימה, ש
יורד מלמעלה.
והערימה הולכת להחזיק כל המשתנים שלנו.
אז כל שיחות לפונקציה מקבלת מסגרת משלה קטנה בערימה.
אז כפי שגייב שהוזכר קודם לכן, אם לקרוא את הפונקציה שוב ושוב,
אנחנו הולכים למחסנית דברים על הערימה.
>> ובאופן דומה, הערימה, אשר מתחילה בראש
הוא הולך להחזיק בכל הזיכרון שאנחנו דינמי להקצות.
וכן, ככל שבאופן דינמי להקצות זיכרון,
זה יבוא לכיוון החלק התחתון.
דברים בני זוג להיות מודעים כאשר אנחנו משתמשים במחסנית והערימה,
עם הערימה, אם יש לנו יותר מדי many-- בואו say-- שיחות רקורסיבית,
ואנחנו קוראים לפונקציה שוב, ושוב, ושוב, ושוב,
וזה לערום את, לערום את, לערום את.
וזה הולך לקרוס לתוך הערימה.
אנחנו הולכים נגמרים של זיכרון.
זה הולך לגרום ל בעיה למחשב.
וזה נקרא הצפת המחסנית.
אז זה בהחלט משהו שאתה צריך להיות מודע ומנסה להימנע.
והערימה, צריכה לזכור לא להדליף בטעות זיכרון.
כל פעם שאתה משתמש malloc, לא תשכח לשחרר זיכרון ש.
אחרת, זה יהיה רק להיות על הערימה מבוזבזת,
והמחשב לא יודע ש זה חופשי לשימוש זיכרון ש.
אז אלה הם כמה דברים להיות זהיר מאוד עם כש
עם יש לך עסק המחסנית והערימה.
שאלות עם זה?
מדהים.
>> אישור, מגניב.
אז מסוג זה יש את אותו רעיון כהצפת מחסנית, שבו
אנחנו הולכים מעבר ל גבולות של מה זיכרון
הוא שאנחנו אמורים להיות מסוגלים להשתמש.
אז קח, למשל, חיץ, או שאתה רק יכל לחשוב על זה כעל מערך.
ואנחנו אמרו, בסדר, אנחנו הולכים ליצור מערך קטן ונחמד.
זה הולך להיות מחרוזת.
או שזה הולך לאחסון תווים.
וזה רק הולך להגיד שלום.
וזה לא מוגדר.
זֶה הַכֹּל.
>> אבל אם היינו מישהו רע ורציתי לעשות משהו רע עם המערך הזה, מה ש
אני יכול לעשות הוא לנסות לכתוב עבר את קצה החוט.
וכפי שתראה, אם אני כותב מספיק רחוק,
אני ממש יכול להשפיע כתובת השולח.
ואם אני מתחיל להשפיע כתובת השולח,
אני משפיע על איך התוכנה פועלת למעשה.
ובמקום לחזור, אתה יודע, מחרוזת שמחה כמו שלום, אני
יכול לעשות משהו רע, כמו ללכת ל במקום אחר במחשב שלך, עדיין
זיכרון, לשנות אותו, כל מה שאני רוצה לעשות.
אז זה מה שזה היה נראה כמו הוא אם אני פשוט סוג של מילאתי ​​אותה
עם ערך אקראי אשפה, במקרה זה, רק.
ואז כשאני באמת הגעתי לכתובת בזיכרון,
התחלתי למלא אותו במשהו שעשה מה שרציתי לעשות את זה.
שאלות עם הצפת מאגר?
נכון מדהים, עף מתחת לזה.
>> אוקיי, אז דברנו הרבה על מצביע עם גייב.
איך אנחנו באמת מקבלים מצביע?
איך אנחנו מקבלים את הכתובת בזיכרון?
ובכן, אנחנו יכולים להשתמש בזה נחמד malloc קריאה לפונקציה, ש
הוא הולך לקבל חתיכה קטנה של זיכרון,
במיוחד ב ערימה, כפי שדנו,
וזה הולך להחזיר לך מצביע לכתובת שבזיכרון.
ואת הטענה שאנו צריך לתת לmalloc
הוא כמה מקום בזיכרון שאנחנו רוצים.
>> אז אתה יכול לראות את הגודל בבתים.
נניח, לדוגמא, או למעשה, בדוגמא זו,
אנו מקצים מספיק חלל במשך 10 מספרים שלמים.
אז כנראה מה שאנחנו הולכים רוצים לשים כאן הוא מערך של 10 מספרים שלמים.
אז אנחנו נותנים לו גודל של ints, ש מה שלמדנו היה בתים כמה?
תלמיד: 4.
חנה: 4, יפה, ואנחנו רוצה 10 של אלה בשורה,
כך שיש לנו מספיק מקום ל לאחסן את כל 10 המספרים השלמים, במקרה זה.
משהו סופר חשוב, כל פעם שאתה קורא malloc,
אתה צריך לבדוק לnull.
אם אתה לא לבדוק null, גם, malloc אם הוא פועל מתוך שטח
וכבר לא יכול לתת לך כל יותר זיכרון, זה יחזיר null.
אז אם אתה לא בודק, malloc עשוי להחזיר null.
ואז אם אנחנו מנסים dereference מצביע null,
אנחנו הולכים לקבל באשמת פילוח, שנדברנו עליו כרגע.
מדהים.
>> אישור, שאלות עם malloc?
כן?
>> תלמיד: האם בדיקת null [לא ברור] לא עושה את זה בחידון?
>> חנה: בטח, השאלה הייתה האם זה עניין בחידון,
אתה מקבל נקודות מאם אתה לא לבדוק null?
כן, אתה תקבל נקודות מ אם אתה לא לבדוק null.
כל פעם שאתה קורא malloc, הן ב חידון וpsets שלך ובחיים אמיתיים,
אתה צריך לבדוק לnull.
שאלה טובה.
>> גייב: מה אם אני לא חופשי?
חנה: גייב רוצה לדעת מה אם אנחנו לא חופשיים.
אז תהיה לנו דליפת זיכרון בערימה שלנו.
יש עוד שאלות?
כן?
>> תלמיד: האם you-- לעבור על הצפת מאגר אמיתי מהיר שוב?
>> חנה: בטח.
השאלה הייתה שאנחנו יכולים לעבור על הצפת מאגר באמת מהירה.
בואו נחזור לשקופיות אלה.
אז חיץ, אתה יכול פשוט חושב על זה כעל מערך, נכון?
יש לך קצת מקום בזיכרון.
וכאשר אנו יוצרים המערך ראשון שלנו, אנחנו יודעים מערכים תיקנו גודל,
או שיש החיץ שלנו בגודל קבוע.
>> אז בואו נגיד שבמקרה זה, יש לנו רק מספיק מקום כדי לכתוב את מחרוזת שלום.
אם נלך האחרון שקשר, אם אנחנו הולכים האחרונים מה המערך שלנו אמר שזה יכול להחזיק,
אנחנו באמת יכולים להתחיל כתיבה לזיכרון
שהמחשב אינו רוצה לכתוב ל.
ובאופן ספציפי, אם פגעו משהו כמו חזרה
כתובת של הפונקציה, אשר, כמו כל פיסת זיכרון אחרת,
רק אי שם בך מחשב, אתה באמת יכול
לשנות את זה ולהתחיל לעשות דברים רעים.
לענות על השאלה שלך?
מדהים, כל דבר אחר?
כן?
>> תלמיד: אז מחסנית [לא ברור], ש אמר ללכת מלמטה הולך למעלה.
בטווח מחסנית, עושה הזיכרון הולך מ, כמו,
הראש מטה הנוגע לכל הפסקה?
>> חנה: איך לעשות you-- לדחות את רוב על זה.
>> ROB: זה יגדל באותו כיוון כמו הערימה גדל.
חנה: אישור.
רוב: אז אני מתבלבל.
זה הולך להיות הפשטה.
חנה: אישור.
ROB: זה נכון.
אז אם הערימה גדלה עד, אז generally-- זה
לא חייב להיות כך. אבל אתה יכול להכריז x int.
אז אתה מצהיר y int.
אז int x בדרך כלל להיות נמוך יותר במחסנית מאשר y int.
אבל זה פשוט עובדה.
שלא כמו דבר זרע חשוב.
>> רוב: אז השאלה שוב רק הייתה מה קורה כל מסגרת מצטברת.
אז כל פונקציה מקבלת חתיכה קטנה של הערימה.
וכמו שאתה הולך למעלה, בתוך ש חתיכה קטנה, בתוך מסגרת ש,
אנחנו אומרים שמשתנים בתוך המסגרת שגם לעלות.
שאלה?
>> ROB: רק כדי להיות על מיקרופון.
חנה: הו, כן.
ROB: אני אדבר אליך.
חנה: הו, כן, בסדר.
ROB: היוצא מן הכלל הוא עבור מערכים וstructs,
שבו מערכים, נמוכים מדד במערך,
ובstructs ב גבוה שדה בstructs
מובטחים להיות נמוכות בכתובות מ ערך מאוחר יותר במערך.
אז אלה הם מובטח.
אבל כל משתנים מסוימים בתוך, כמו x int וint y בתוך פונקציה,
אין קשר הכרחי בין הכתובות שלהם.
חנה: שאלה נוספת לכאן?
תלמיד: אז במאגר זרימה, רק גלישת חוצץ
קרה רק כשאתה יש, כמו, שהוקצה
סכום של מערך כי אז הוא גדול יותר?
כמו, אתה יכול?
אז אם אתה שואל ל משהו מuser--
>> חנה: ממ-הממ.
תלמיד: הם יכולים בכוח לתת לך משהו בחזרה
זה גדול יותר מכל מה ש שהוקצית להם?
חנה: בטח, כל כך השאלה הייתה בעצם,
יכול המשתמש לתת לך יותר ממה שאתה מבקש?
סטודנט: כן.
חנה: ובכן, אתה יכול למנוע המשתמש מלעשות את זה.
אפשר לומר באופן ספציפי לא תן לי יותר ממספר x על ידי בתים
נתתי לכם רק מקום למספר x בתים, x מספר התווים.
אז זה משהו שאתה רוצה למנוע.
כן?
מה ההבדל בין הצפת מחסנית וגלישת חוצץ?
>> חנה: בסדר, אז הערימה overflow-- הו, מה
ההבדל בין הערימה גלישה וגלישת מאגר?
אז אנחנו רוצים לחשוב על הצפת מחסנית קורה כאשר אנחנו בעצם
לערום את הקריאות לפונקציות אלה.
בואו נגיד שיש לך פונקציה רקורסיבית, כי אנחנו יודעים שכל פעם שאתה
לקרוא לפונקציה, זה מקבל מסגרת משלה בערימה.
>> אז אנחנו מחסנית גבוהה מדי, ו אז אנחנו מתחילים לעלות על גדותיו.
ואנו משתמשים בזיכרון רב מדי, ו אנחנו לא השאירו שום מקום.
אנחנו מקבלים שגיאה ש.
>> הצפת המאגר נמצאת בתכנית.
אנחנו רוצים אולי לא בהכרח נגמר זיכרון באותה הדרך
שאולי אם אנחנו לערום עד קריאות לפונקציות רבות כל כך,
אבל אנחנו כותבים עבר הזיכרון כי אנחנו יודעים שאנחנו יכולים להשתמש.
וזה מאפשר לנו לעשות דברים רעים.
כן?
>> ROB: כן, ייתכן שתרצה רק כדי לחזור על זה,
אבל אתה גם יכול לחשוב של הצפת מחסנית
כמו כמו סוג מסוים של הצפת מאגר.
או שאתה רק חושב עליך מחסנית כחיץ גדול באמת.
ואז כשאתה עולה על גדותיו אתה ערימה, זה כמו סוג של הצפת מאגר.
אבל הצפת מחסנית היא רק מונח מסוים משמש בעת הערימה
עצמו עולה על גדותיו.
>> חנה: ימין, כך ל לחזור לוידאו,
זה שאתה יכול לחשוב על הצפת מחסנית כ סוג מסוים של הצפת מאגר.
מגניב?
עוד שאלות לפני שאנחנו הולכים על?
מדהים.
>> אישור, מגניב, אז בואו נדבר על כמה הודעות שגיאה נפוצות.
זה משהו שיש הופיע בבחנים מרובים,
כך משהו ששווה לוקח מבט שני על.
אני בטוח שכבר נתקלתי ב לפחות חלק מאלה
כמו שאתה עושה את הבעיה שלך קובעת.
כדי לוודא שאתה יכול לדבר עליהם בחידון.
>> אז הראשון הוא אשמת פילוח.
וזה כולנו זמן מנסה לגשת לזיכרון
כי לנו לא מרשימים לגישה.
אז אתם מוזמנים ראיתם את זה, לדוגמא, בפריצה.
אם לזהות התנגשות אחזיר null, ואז אתה
ניסיתי לעשות משהו עם שהערך ריק,
המחשב ייתן לי אתה אשמת פילוח.
אז אחת, דבר חשוב ל לעשות כדי לנסות למנוע את זה
תמיד לבדוק null.
>> כמו כן, ייתכן שראה הצהרה מפורשת של פונקציה.
אז זה מה שקורה כאשר אליסון הראה לך
איך אנחנו עושים את אב טיפוס, נכון?
אז בואו נגיד שיש לנו כמה פונקציה שאנו מגדירים.
נניח קובייה.
וזה הולך בתחתית של הפונקציה שלנו, תחת עיקרי.
>> אם אנחנו שוכחים לספר לי המחשב על קובייה, כאשר עיקרי מנסה להתקשר קובייה,
המחשב יהיה, כמו, אוי אלוהים שלי.
אין לי מושג מה זה אומר.
אני לא יודע מה לעשות, כאן.
אז אב הטיפוס אומר אל תדאגו.
אני הולך לספר לכם.
>> זה יבוא.
לא צועק עליי.
אל תיתן לי משתמע הכרזה על הפונקציה.
אז אם אתה מקבל שגיאה זו, אחד דבר שאתה הולך רוצה לעשות
הוא לוודא שיש לך אב הטיפוס שלך.
בסדר?
>> ואחרון אחרון חביב, מזהה לא מוצהר
הוא למעשה כאשר אתה מנסה להשתמש ב משתנה שלא הוכרז.
אז פתאום אתה מתחיל אומר כמו n פלוס פלוס.
והמחשב אומר מה n?
אתה אף פעם לא אמר לי n היה דבר.
>> אז דבר אחד אתה צריך לוודא שאתה עשיתי הוא לומר למחשב מה הוא n.
כך למשל, n יכול להיות מספר שלם.
ולאחר מכן תוכל להימנע משגיאה זו.
כל שאלות על שגיאות נפוצות?
כן?
>> תלמיד: למשתמע הצהרה של פונקציה,
זה יכול גם להיות שאתה הושמט אחד של הספריות שהיית אמורים
לכולל, ולא אב-הטיפוס?
>> חנה: ימין, כך השאלה הייתה, האם הייתה יכול
גם מקבל את הודעת שגיאה אם שכח לכלול ספרייה.
>> סטודנט: כן.
>> חנה: בהחלט, כי באותו אופן
כי אנחנו רוצים לשים את אבות הטיפוס שלנו לפני תפקידו העיקרי,
אם יש לנו ספרייה, אלה הולכים בעצם לכלול את אבות הטיפוס,
כולל הגדרות של הפונקציות.
שאלה גדולה.
>> תלמיד: לפילוח פגם, היה שגם
יקרה אם, כמו, ניסיתי לגשת למשתנה,
כמו, ב[ לא ברור] שונה ממה שהוכרז ב?
חנה: בטח, כך גם אנחנו תקבל שגיאה סגמנטציה
אם ניסינו לגשת משתנה מחוץ לתחום?
היה שאלה?
סטודנט: כן.
חנה: יפה.
אז כנראה, אתה הולך לקבל שגיאה מזהה מוצהרת במקום.
אז זה רק הולך להגיד אני לא יודע מה זה.
מגניב, כל דבר אחר?
כן, בסדר, יפה.
>> כל righty, כך רקורסיה.
לכן הזכרתי כמה פעמים שאולי אנחנו מקבלים הצפת מחסנית
בגלל שאנחנו קוראים כל כך הרבה פעמים פונקציה רקורסיבית.
אנחנו מקבלים את כל ערימה אלה מסגרות, בלה, בלה, בלה.
מה גם היא פונקציה רקורסיבית?
ובכן, פונקציה רקורסיבית היא כל פונקציה שקוראת לעצמו.
>> כמה דברים שכדאי להיות מודעים כאשר אתה מיישמים פונקציה רקורסיבית,
אל תשכחו לכלול מקרה בסיס.
מקרה בסיס הוא נקודה שבה אנחנו בסופו.
כך, למשל, אם אנחנו קידוד, , אומרים, פיבונאצ'י באופן רקורסיבי,
אנחנו רוצים לוודא שכאשר אנחנו מקבלים לאו מספר פיבונאצ'י הראשון 0,
יש שני מספרים אלה מקרים אלה, כי אלה אינם תלויים
על הדברים שבאו לפני.
אלה שיש להם ערכים.
>> יתרונות מסוימים לרקורסיה, שבו הוא שאלה שראינו בחידוני העבר.
הם יכולים להוביל ליותר קוד תמציתי, אלגנטי.
והרבה פונקציות, הרבה אלגוריתמים שונים,
למעשה להשאיל את עצמם ברקורסיה.
ההגדרה שלהם עשויה להיות רקורסיבית בפני עצמו.
אז פיבונאצ'י הוא אחד.
עצרת היא אחד.
מיון מיזוג כלומר one-- כל דברים שאתה יכול להסתכל ב.
אישור, כל שאלות?
כן?
>> תלמיד: האם מקרה פינה בדומה למקרה בסיס?
או הוא כי עבור חלק אחר סוג של [לא ברור]?
>> חנה: בטח, כל כך מקרה פינה הוא any-- כך
הוא מקרה פינה זהה למקרה בסיס?
מקרה פינה הוא כל דבר ש קוד עשוי להתנהג באופן קצת שונה.
מקרה בסיס קשור סוג של, ב שהם כמו מקרים מסוימים
כי אתה רוצה להסתכל.
אבל הרעיון של מקרה בסיס הוא ש אתה רוצה פונקציה רקורסיבית שלך
להפסיק בשלב מסוים.
זה לא יכול להמשיך לקרוא את עצמו לנצח.
זה צריך להפסיק בשלב מסוים.
>> ROB: כן, לעתים קרובות, במקרי הבסיס שלך יכול להיות דוגמאות של בסיסי פינה.
>> חנה: ימין, מגניב, משהו?
>> תלמיד: האם אתה יכול להסביר מבסס קצת יותר?
אני לא ממש הבין מקרי בסיס [לא ברור].
>> חנה: במקרי בסיס?
>> תלמיד: מקרי בסיס, כן.
>> חנה: אה, כן, בטוח.
בואו נראה.
האם יש לנו גיר לכאן?
כן, אנחנו עושים.
אוקיי, אז באמת במהירות, אני יהיה אנסה לכתוב גדול מספיק
כך שאתה יכול לראות על המסך.
בואו נדבר על, באמת במהירות, פיבונאצ'י.
אז אני אתן לך את רצף פיבונאצ'י.
אתה יכול להסתכל למעלה ההגדרה.
>> בעיקרו של דבר, כל מספר ברצף הוא הסכום של שני המספרים הקודמים.
אוקיי, אז הדרך שאני רק תיארתי פיבונאצ'י,
היה אפשר לשמוע את רקורסיה, נכון?
כשאמרתי כל מספר הוא סכום של שני המספרים הקודמים,
נוכל לומר על אישור.
ובכן, פיבונאצ'י המי יודע כמה number-- אז בואו
אומר שיש לנו בפונקציה זו נקרא לבלף fib-- של n
הולך להיות שווה ללבלף של n מינוס 1 plus-- מצטער,
אנחנו נעבור לשורה הבאה על לבלף here-- של n מינוס 2.
>> אוקיי, אז זה עובד נהדר אם אתה מסתכל על, למשל, אפס, אחד,
שתיים, שלוש, ארבעה, מספר פיבונאצ'י החמישי,
שבו אתה יכול להגיד ש 5 הוא שווים ל 2 ועוד 3.
אבל מה אם אתה בהתחלה?
מה אם אתה רק פוגע שני ערכים הראשונים אלה?
>> כדי לקבל 1 זה, אתה לא יכול אומר להוסיף את שני הקודמים,
כי אפס כי and-- אני לא יודע.
אז בשלב מסוים, אנחנו צריכים להפסיק.
בשלב מסוים, אנחנו צריכים לומר כי אלה שני יש לי ההגדרות שלהם פשוט.
מספר 0 פיבונאצ'י הוא 0.
ומספר פיבונאצ'י הראשון הוא 1.
>> אז ככה אני יכול קוד זה, אני הייתי אומר שאם n הוא פחות משני,
אז פשוט לחזור n.
וזה יהיה מקרה הבסיס שלי.
ככה אני יודע להפסיק עם פונקציה רקורסיבית.
האם זה ברור?
מדהים.
כל דבר ברקורסיה אחר?
יפה.
>> בואו מהר לדבר על חיפוש ופעמים סוג לרוץ.
ואז אני אתן כמה דיווין זמן לדבר על קידוד דוגמאות.
אז הנה החיפוש העיקרי ו מיני שאתם צריכים לדעת על.
Guarantee-- אני לא יכול להבטיח, בגלל שלא ראיתי quiz--
אבל זה עולה חידון לאחר החידון התפטר לאחר.
אז בהחלט להשתמש תרשים זה.
כמו, לקחת תרשים זה.
שים את זה על-גבי הגיליון לרמות שלך.
אתה תהיה אדם מאושר.
>> זה אומר לנו לרוץ פעמים בכל אלגוריתמים מיון וחיפוש.
אז חיפוש ליניארי, אתה יכול לראות ריצה זמן, ואותו דבר עם חיפוש בינארי.
ללכת על מה שאלגוריתמים אלה לעשות, את הרעיון הכללי.
תראה כמה פסאודו קוד, אם לא קוד עצמו.
>> אתה תראה שיש לו מיון הבועות עליון כרוך במקרה הגרוע ביותר של n בריבוע.
אז אם המערך שלנו היה לגמרי לאחור לפני שאנחנו רוצים למיין את זה,
הייתי אומר שזה עומד לנקוט צעדי n בריבוע.
אבל במקרה הטוב ביותר, ולכן גבול תחתון למקרה הטוב ביותר
הולך להיות אם זה כבר מסודרים בצורה מושלמת.
ואז כל מה שאנחנו צריכים לעשות הוא לבדוק שזה מסודרים.
האם יש שאלה כאן?
>> תלמיד: מתי אתה רוצה להשתמש בסוג?
הסוג.
אני פשוט סקרן.
>> חנה: כאשר היית רוצה להשתמש במיון בחירה?
זה אחד?
אחד זה n בריבוע בשני המקרים?
>> תלמיד: [לא ברור].
>> חנה: אז זה שונה מאוד.
אם יש לך ספציפי דרישות עבור התכנית שלך,
כמו דברים כמו אם רק אמר ליישם sorry-- search--
ליישם סוג, שתצליח כנראה רוצה ללכת
לאחד מאלה ש יש מקרה הטוב ביותר של n,
או גבול תחתון במקרה הטוב של n.
אבל ייתכן שהיו דברים מסוימים כמו, למשל,
חילופים באמת יקר מסיבה כלשהי.
אז היית רוצה לעשות מיון בועות, כי אתה
צריך לעשות כל כך הרבה חילופים, דברים כאלה.
כל כן other--?
>> תלמיד: האם זה יהיה [לא ברור] לומר ש[ לא ברור]?
חנה: זה דבר אחד שאגיד לך
אם אתה מסתכל על היישום.
הדרך אני למעשה לחשוב למה זה n
בריבוע הוא שאנחנו צריכים לרוץ באמצעות המערך של n האורך שלנו,
בכל פעם שעושה ברוב, n חילופים.
ואנחנו צריכים לעשות את תהליך n פעמים זה.
>> לכן, כאשר יש לך לעשות ברוב, n עסקות החלף ועבור n עובר המערך,
יש הולך להיות בריבוע n.
אבל כן, זו תתגלה דרך כפול הזה ללולאה,
כמו השאלה או asked-- מקונן על לולאה, אני צריך לומר.
בסדר?
>> ולאחר מכן למזג סוג, ש הוא מהסוג שהמהיר ביותר כיום,
או שאנחנו כבר כיסינו בCS50, יודע שהאלגוריתם העיקרי הוא
הרעיון הזה של פריצה ל חתיכות מיון ולאחר מכן
מיזוג יחד פיסות מסודרים אלה.
ויקבל אותנו להיכנס n להתחבר n.
כל שאלות על חיפושים ו מיני לפני שאני עובר על זה?
בואו נראה.
>> אה, רשימות מקושרות.
מצטער, יש לי נושא אחד יותר.
אישור, מדהים, רשימות מקושרות.
בעיה עם המערכים, יש להם גודל קבוע.
אז אם אתה לא יודע עד כמה גדול הקלט שלך הולך להיות,
אתה לא רוצה ליצור מערך.
כי אם אנו יוצרים מערך שהוא קטן מדי,
אנו עלולים להיתקל בגלישת מאגר.
>> אז במקום, אנחנו יכולים לעשות משהו עם רשימות מקושרות, ש
מאפשר לנו יש באופן דינמי מבנה נתונים בגודל
שיאפשר לנו לאחסן סכום גמיש יותר של נתונים.
אז בתוך כל צומת בנו מקושר רשימה, יש לנו שתי חתיכות.
יש לנו את הערך האמיתי שהוא מאחסן.
אז זה בדיוק הדבר שהיית רואה במערך, לדוגמא.
ואז אנחנו גם לעקוב אחר מצביע לדבר הבא בזיכרון.
>> בניגוד למערכים, ש אנחנו יודעים את כל הולכים
לbe-- אלמנטים במערך כל אחד ברציפות בmemory-- קשורה
רשימות יכולות להיות בכל מקום בזיכרון.
הם מקומות שרירותיים.
אז אם היינו ללכת דווקא מוצא אותם, אנחנו
צריך לעקוב אחר הדבר הבא ברשימה שלנו.
>> ואז כדי לדעת שם רשימה שבכללותו היא,
כל מה שאנחנו צריכים לעקוב אחר הוא האלמנט הראשון ברשימה המקושרת שלנו.
וכי יהיה לאפשר לנו ללכת עד הסוף.
>> אז ככה אתה יכול להגדיר מצב.
זוהי הזדמנות נהדרת לנצל structs.
כי יש לך את הרעיון הזה, גם, לצומת נתון, יש לי שתי חתיכות.
יש לי את הערך האמיתי עצמו.
ואז יש לי מצביע ל האלמנט הבא ברשימה המקושרת.
אז אתה רואה, יש לנו n שלם, שהוא הולך להיות הערך הממשי,
ולאחר מכן מצביע ל צומת, בשם הבא.
אז זה הולך להיות הבא אלמנט ברשימה המקושרת שלנו.
סטודנט: כן?
האם יש לך כדי לציין ש הכוכב הוא כמו struct?
>> חנה: כן, כך זה מאז כמעט כמו סוג של,
זה נראה כמו רקורסיבית הגדרה בנו ש
צריך לדעת מה היא צומת בתוך למציאת צומת.
מאז שהיא עושה לא ממש יודע מה צומת היא לגמרי
עד שנגיע לסוף זה-- ואחרי זה אנחנו יכולים רק לקרוא לזה
node-- בתוך הגדרה זו, אנחנו צריכים לקרוא לזה צומת struct.
שאלה גדולה.
כל דבר אחר?
כן?
>> תלמיד: למה אנחנו יש לי לומר צומת פעמיים?
משום שכאשר היינו ב[ לא ברור] אנחנו פשוט צריכים לעשות את זה בנקודה-פסיק,
אבל עכשיו אנחנו צריכים למצוא ש צומת struct? [לא ברור].
חנה: אז אני מאמין בדוגמא האחרונה,
אנחנו פשוט יצירת בכל עת ש רציתי להשתמש בתלמיד לאחר ש,
הייתי צריך להשתמש struct node-- אני sorry-- תלמיד struct.
זה אפשר לנו, לאחר מעשה, רק צומת שימוש להוסיף סוג חדש, בעצם.
כי תחושה? איפור
אז היינו צריך לחזור ו מסתכל על הקוד לפני.
אבל אני מניח ש לא השתמש בtypedef.
ושאלנו את השאלה, למה אנחנו צריכים להשתמש typedef?
Typedef מאפשר לנו להימנע מ המילה struct בתחילת.
כן?
תלמיד: איזה סוג של תתחלנה שאלות
במונחים במונחים של צמתים ורשימות מקושרות?
>> חנה: אז דבר אחד שאנחנו יכולים לומר כמה ייתכן שתחפש את דרך רשימה מקושרת?
אישור, כי זה קצת יותר מסובך
מאשר אם אנחנו מחפשים באמצעות מערך.
אנחנו רק יכולים להסתכל באלמנט אפס, אלמנט אחד, אלמנט שני, בלה, בלה,
בלה.
אם ברצוננו לחפש באמצעות רשימה מקושרת,
היינו באמת צריך לעקוב המבוך הקטן הזה של מצביעים.
אז בואו באמת ללכת באמצעות זה ממש מהר.
מה אנחנו יכולים לעשות ב להזמין to-- נניח ש
רוצה רק כדי לבצע איטרציות ב הרשימה המקושרת לחלוטין שלנו.
היינו מתחיל בראש.
ולאחר מכן על מנת לעבור לפריט הבא,
במקום רק להגדיל כל על ידי אחד כמו שאולי בעובר מערך,
אנחנו באמת הולכים ל בצע את המצביע הבא,
כדי שנוכל למצוא בי ב זיכרון האלמנט הבא הוא.
אז אני יודע שזה לא מספיק ל לקחת את כל זה ברגע זה ממש,
אבל יהיה לך את השקפים האלה.
אז אתה יכול לעבור זה קצת יותר לאט.
אבל בעצם, מה שאנחנו רוצים לעשות הוא לעקוב מצביעים אלה
דרך השלמות של הרשימה המקושרת.
אז זו שאלה ייתכן שתתבקש.
>> משהו להבחין ב הכנסה, נניח
אנחנו רוצים לשים אלמנט חדש בחלק הקדמי של הרשימה המקושרת שלנו.
אנחנו צריכים להיות זהירים מאוד על הסדר שבו אנו
מחדש את המצביעים.
כי בואו נגיד שאני רק אמרתי על אישור.
להפוך את הצבע ועד ראש האלמנט חדש זה.
פשוט לעשות את זה מצביע על 1 ואז, יש לנו בעצם איבד את שאר הרשימה שלנו,
כי אני לא זוכר 2 שבו חיי.
>> אז אנחנו צריכים לעשות ב סדר מאוד ספציפי.
ראשית, אנחנו עושים חדשים נקודת אלמנט לראש.
ואז להפוך את הראש להצביע על הגורם החדש.
אז בואו נראה מה שנראה כמו עם arrows-- סתם ככה.
אז יש לך ראשון החדש נקודת אלמנט לראש הישן.
ועכשיו, יש לנו את הראש מצביע על האלמנט הראשון החדש.
שאלות עם זה?
>> אישור הנה כמה קוד שוב, משהו להסתכל על קצת מאוחר יותר.
ועכשיו אני אהפוך אותו לדווין לGDB וקצת תרגול
קידוד על נייר.
יפה.
>> ROB: ורוב.
>> חנה: אה, דווין ורוב.
אני מצטער.
>> תלמיד: וו!
>> ROB: תודה.
>> דווין: אתה רוצה לומר הכל ממש מהר?
ROB: כן, כן.
דווין: ברגע שאני מעלה.
אישור, ואילו רוב מעמיד מיקרופון ב, אז מה GDB?
כולם צריך לראות את GDB ב כיתה וגם בשעתי עבודה.
ואתה צריך להיות שימוש בו.
אז מה הוא GDB?
אף אחד?
>> תלמיד: זה הבאגים.
>> דווין: זה הבאגים.
ומה זה מאפשר לך לעשות?
כמו, למה אנחנו אוהבים GDB?
תלמיד: כדי להאט את התכנית.
דווין: ימין, כך שאתה יכול ללכת דרכו אוהב קצב אנושי.
ואז מה הם כמה פקודות שאתה יכול לעשות?
ובכן, הפסקה היא כנראה הפקודה. האהובה עליך
מכיוון שזה מאפשר לך לשבור את תכנית ולמעשה לעבור את זה
שורה אחרת שורה.
>> הפעלה מאפשרת לך להפעיל אותו.
בשלב הבא, כמו לפסוע דרך.
מה בין הבא וצעד?
חכה, אומר זאת בקול.
זה היה נכון.
>> תלמיד: [לא ברור].
>> דווין: כן, מדהים.
אז כמו, הצעד הבא, ואם you're-- נניח שיש לך פונקציה שאתה
להגדיר.
נניח שחלקם בפונקציה העיקרית שלך, ואתה רק פוגע הבא, הבא,
הבא.
אתה באמת הולך תפעיל פונקציה ש,
אבל אתה הולך לקפוץ על זה.
אם אתה מכה את הצעד, או של או מה, אתה
הולך לקפוץ למעשה לפונקציה ש,
ואז אתה יכול להכות הבא כדי לראות את השיחות השונות
בתוך פונקציה מסוימת.
כן?
>> תלמיד: האם יש דרך לקפוץ, כמו, לסגת?
דווין: סיום, כן, לסיים עם לקפוץ לך.
כך שזה הולך לסיים ש פונקציה, ואז אתה
הולך להיות שוב בעיקרי, לדוגמא.
הדפסה תהיה להדפיס את זה פעם אחת.
משהו שאני תמיד משתמש בה הוא תצוגה.
תצוגה להדפיס אותו בכל השלמות כל הזמן
התכנית שלך.
>> לדוגמא, אם אתה ללולאה, ואתה
רוצה לראות איך משהו משתנה, ואתה לא רוצה, כמו, כל הזמן
לעשות כמו הדפסה, הדפסה, הדפסה, תצוגה
יציג משתנה ש ברציפות, בכל פעם שאתה מכה הבא.
ולהמשיך.
אז GBD, זה GDB.
>> תלמיד: מה אחד שם [לא ברור] לך?
דווין: מה זה?
>> תלמיד: מה the-- המשתנים המקומיים.
רוב: יש משהו בעצם כמו המקומיים או משהו.
אני can't--
>> דווין: זה יכול להיות משהו כזה, כן.
>> חנה: בהמקומיים?
>> דווין: זהו זה.
זה אחד.
ROB: יפה.
>> דווין: כן.
>> תלמיד: מה להמשיך לעשות?
>> דווין: זה continues-- כך שזה רק הולך להמשיך את התוכניות שלך.
אז אם אתה לשבור ולהכות תמשיך, זה הולך
רק להפעיל את התכנית כי עד הוא פוגע שהפסקה שוב.
כך למשל, אם אתה פרץ בפונקציה,
ואתה הולך לעשות כמו ל לולאה או משהו כזה,
ואתה מכה תמשיך, זה הולך להמשיך ולחזור לזה הפסקה.
או שאין הפסקה, זה הולך להמשיך ולסיים את התכנית.
>> רוב: אז בדיוק כמו תחנות המנוהלות בנקודת העצירה הראשונה
אתה מכה, אם לאחר מכן פגעת להמשיך, זה יהיה לשמור
הולך עד שזה נקודת העצירה הבאה.
ולאחר מכן להמשיך ילך לנקודת העצירה הבאה.
דווין: כל שאלות אחרות על GDB?
אז אני חושב בעבר, אנחנו כבר שאלנו אותך מה
GDB הוא ולתת דוגמא של כמה דברים שאתה
יכול לעשות עם GDB, כך פשוט אמיתי, אבל כן.
הנה לך.
וצומת?
>> ROB: כן, כך שכיוון זה היה?
תלמיד: זה היה זה.
דווין: המתן.
ROB: הבחור הזה?
דווין: אחד ש.
ROB: הבחור הזה, אה, אני לא מבין.
אז לא היינו ברורים על מה the-- אני לא
יודע מי זה was-- אבל השאלה.
אנחנו לא יודעים בדיוק מה אתה שואלים אותו על זה, כל כך פשוט
להבהיר משהו.
אז קודם כל, כמו שאמרתי קודם, typedef אתה תמיד משתמש רק
ליצור כינוי לסוג.
אז כאן, הכינוי שאנחנו יצירה היא לצומת struct מסוג זה.
>> התעלמות צומת אז קודם כל, זה ב typedef, כך זה struct צומת מתולתל
לייצב עד מתולתל הבא סד הוא סוג צומת struct.
ואנחנו צריכים צומת ש שם למעלה, כי אנחנו
צריך להפנות צומת כאן.
אז עם סוג זה של struct רקורסיבית, אתה צריך לתת את זה struct שם,
או שאתה לא יכול אומר צומת struct כאן.
בעוד שבעבר עם תלמיד כאשר אנו מקלידים, אני חושב,
לא היה לנו לומר תלמיד שם למעלה, כי אנחנו
לא צריך להגיד struct סטודנט בתוך struct עצמו.
אז זה רקורסיבית ש מכריח אותנו לומר צומת שם.
>> צומת זו היא רק שם אנחנו נותן צומת לtypedef.
אז הצומת שאינה זהה לצומת.
אבל צומת struct זה אותו דבר כמו שצומת struct.
דווין: אז בכל פעם שאתה קורא, כמו, צומת בפונקציה העיקרית שלך,
אתה לא הולך ל יש לי לומר צומת struct.
אתה פשוט יכול להגיד צומת, משום ש צומת היא different-- היא בעצם
אתה אומר, בסדר.
במקום שיש לקרוא צומת struct בקוד שלי,
אני רק רוצה לשנות את זה כצומת כדי להפוך אותו קל יותר.
>> רוב: אם אתה תמיד להשתמש typedef, אז זה
הוא רק המקום שאתה הולך יש לי להכריז על משתנה עם צומת struct
כוכב, כן.
>> דווין: אוקיי, אז את החלק האחרון קשה ללמד because--
ROB: מה?
>> דווין: כי זה קידוד על נייר.
אז בכל שנה יש לנו קוד על שאלות נייר.
אז אני חושב ששנה שעברה, 12 מתוך 80 נקודות היו קוד על נייר.
שנה לפני כן, 10 מתוך 80, שנה לפני כן, 20 מתוך 100,
כך לא מעט מאלה.
אז אתה הולך צריך להיות מסוגל קוד פונקציות אלה ביד.
>> אז חשבתי שאולי כדאי ללכת דרך כמה מהם ולראות איך אנשים עושים,
סוג של ללכת דרך אותם לאט לאט עם אנשים.
אז בדרך כלל, וstrlen atoi היה מאוד פופולרי.
בשנה שעברה, אני חושב שהייתי לנו GetPositiveInt וRandomInt.
אבל pow, כך כוח, גם אחד חיובי מדי.
בואו פשוט לעבור אולי אחד או שניים מהם יחד.
מה שאנשים רוצים לראות?
>> תלמיד: atoi.
סטודנט: כן.
דווין: atoi?
תלמיד: [לא ברור].
דווין: אישור, אני הולך כדי לעשות את זה על הלוח.
האם יש לך העדפה אם אני עושה את זה פה או שם?
יש, גייב אומר שיש.
>> ROB: וזה מחשבות כלליות על שאלות אלה קידוד.
נסה לכתוב משהו.
אל תשאיר אותו ריק.
>> דווין: כן.
רוב: אם אתה יכול להשיג לחזור נכון סוג,
או אולי אנחנו יכולים לתת לזה אתה, אבל אם אתה יכול, כמו,
לכתוב את חתימת הפונקציה הכללית, אם אתה יכול להשיג נכון מקרי הבסיס,
או מקרי פינה, או לזכור המחאה על null,
כל עוד יש לך כמה דברים, אז אולי
יכול לתת לך כמה מצביע לבעיה.
רק אל תשאיר אותו ריק.
>> דווין: כן, ואם אתה רק לחלוטין
מבולבל על איך למעשה תהפוך לקוד.
אם אתה כותב פסאודו קוד, זה די טוב מדי.
אז זה כמו, זה שאלה שש נקודות, ואתה כותב פסאודו קוד הנכון,
תקבל לפחות שתי נקודות.
אז לא רק להשאיר אותם ריק.
נסה לשים משהו.
>> ROB: זה צריך להיות פסאודו קוד נכון, אם כי.
>> דווין: כן.
רוב: אז אנחנו בדרך כלל פחות להקל עם באגים בפסאודו קוד.
דווין: אוקיי, אז אתם רציתי לראות atoi.
אוקיי, אז רק אמת-- אז מה שאתה רוצה לעשות
הוא שאתה הולך להיות נתן איזה מספר.
אך מספר זה אינו הולך להיות int, נכון?
מה זה הולך להיות?
>> תלמיד: [לא ברור].
>> דווין: זה הולך להיות מחרוזת, נכון?
אז אם היו ניתן לך string-- בואו say--
>> רוב: אני צריך למשוך את עורך?
אני יכול למשוך up--
>> דווין: אה, אתה רוצה לעשות את זה on--
>> ROB: האם אתה מעדיף את הלוח?
>> דווין: מה אתה רוצה לעשות?
אני מתכוון, אתה רוצה לעשות את זה ביד?
או שאתה רוצה לעשות את זה על ידי מחשב?
>> ROB: לעשות את זה ביד.
>> דווין: [צוחק]
ROB: לעשות את זה ביד.
>> דווין: אוקיי, אז זה הולך להיות atoi.
אז מה it-- אני מתכוון, אנחנו כנראה לתת לך את זה.
אבל מה שזה הולך לחזור?
>> תלמיד: Int.
>> דווין: זה הולך לחזור int, נכון?
אז-- אני לא רוצה לעשות את זה שם.
אני אעשה את זה כאן.
>> ROB: אתה יכול למשוך אותה למטה ולאחר מכן דחף על זה.
>> דווין: כן.
[צוחק] שינוי משחק.
אוקיי, אז זה הולך להיות atoi int, ומה זה הולך לקחת?
כוכב char, כל כך פשוט מחרוזת, כוכב ים, כמו ש.
>> ROB: כוכב נחמד, נחמד.
דווין: זה לא יכול להיות שם, על אישור.
ROB: כן.
דווין: אוקיי, אז הראשון דבר שאתה רוצה do-- אני
לא יודע אם מישהו נראה בsolutions-- בפועל
אבל מה אתה הולך לרוצה לעשות הוא שאתה
הולך רוצה יש לי לולאה, כי אתה
הולך רוצה בעצם צעד דרך מחרוזת זו.
אז helpful-- אז נניח אנחנו הולכים ללולאה,
ואנחנו הולכים כדי לעבור כל אלמנט של המחרוזת.
כמה זמן זה?
כמה פעמים אנחנו הולכים ללחזר שללולאה?
תלמיד: Sterln?
דווין: Sterln, כן.
אז בואו נגיד שאורך int שווה sterln של.
וסתם סקרן, למה זה תמיד סוג של טוב יותר לעשות את זה בחוץ של לולאות?
כמו, למה זה טוב יותר לקרוא ל פונקציה זו מחוץ ללולאה?
רק שפיות מהירה לבדוק?
כן?
תלמיד: אז אתה לא צריך להמשיך לבדוק את זה.
אתה יכול פשוט [לא ברור].
>> דווין: בדיוק, אז כן, בדיוק מה שהיא אמרה.
אז אנחנו לא צריכים להמשיך לבדוק את זה.
כך למשל, אם אני מתקשר פונקציה זו בתוך לולאה,
אז אני הולך להמשיך לקרוא פונקציה זו מספר רב של פעמים.
וזה הולך להקטין היעילות של התכנית שלך.
אז זה תמיד שימושי להכריז עליה מבחוץ.
>> ROB: זה אמר, ב כל הבעיות הללו,
פחות או יותר כל עוד אתה מקבל פתרון עובד, אתה מקבל קרדיט מלא.
אז אל תדאגו אם העיצוב שלך הוא ממש זוועתי.
זה יכול לגרום לנו נסער קריאת הקוד שלך.
אבל כל עוד זה עובד, תקבל את הנקודות.
>> דווין: כן.
אוקיי, אז אחר כך אני הולך ל להכריז כמה משתנים.
זה רק הולך לקרוא לסכום int.
ואני הולך להגדיר את זה שווה לאפס, כמו ש.
וזה רק הולך להיות מציין מיקום.
אז זה הולך להיות מה שאני הולך לחזור.
אז אני הולך לסופו של דבר לחזור סכום מתוך תכנית זו.
אז יש לי שני המשתנים הללו.
יש לי אורך.
יש לי סכום.
ועכשיו בואו נקפוץ למחרוזת שלנו.
>> כך מאפשר לנו ללולאה.
אז ארבעה אני int שווה 0 w, ואילו אני הוא פחות ממה שאורך פלוס פלוס.
וnow--
ROB: נחמד.
דווין: אישור, ועכשיו כאן מגיע הבשר של הקוד שלנו.
אז אתה באמת יכול לעשות הקו הזה בעצם באחד.
אז האם יש למישהו רעיון של מה שאנחנו הולכים לעשות עכשיו?
אוקיי, אז זה בסדר.
אז אנחנו עושים לומר סכום equals-- תן לי לגרור את סכום over-- זה
שווה סכום פעמים 10 plus-- אנחנו הולך לקחת לי של מינוס אחד
ציטוט 0 אחד לעשות, כמו ש.
רוב: מאוד אינטואיטיבי.
>> דווין: מחצבתו.
אוקיי, אז someone-- לי את זה, יש לי את זה.
אוקיי, אז זה ברור עולה.
מה זה אומר?
אז האם מישהו יודע מה זה אומר?
האם כל אחד יכול לראות את זה?
לא, אף אחד לא יכול לראות את זה, OK.
אני הולך to--
>> רוב: אני הולך לכתוב נוסחה בדיוק כאן.
דווין: אישור, רוב הולך לעשות את זה במחשב, וזה כיף.
רוב: הו אלוהים שלי.
או שאני לא.
דווין: Stand by.
תלמיד: יש לי שאלה.
דווין: כן, בטוח.
תלמיד: [לא ברור]?
דווין: אוקיי, אז זה באמת, כמו, רק באופן כללי,
אם היית לשים, כמו, בint הצהרה זו
אני שווה אורך 0 פסיק שווה sterln, that--
>> תלמיד: [לא ברור].
>> דווין: זה בסדר, כי that--
תלמיד: למה אתה אפילו צריך להשתמש באורך?
למה אנחנו לא יכולים פשוט [לא ברורים] sterln של, כמו כל הזמן [לא ברור]?
>> דווין: אתה מתכוון כאן?
>> סטודנט: כן.
דווין: כי כל הפעם לריצות לולאה,
זה הולך להעריך את המצב הזה.
תלמיד: העכבר.
דווין: ואם יש לך sterln שם, אז זה
תצטרך לקרוא למעשה פונקציה שכל פעם אחת.
אז במקום רק השוואתה לint,
אתה הולך להיות קורא פונקציה ולאחר מכן השוואתה
לערך ההחזרה.
כן, אז זה רק, כן.
>> נחמד, בסדר, אז עכשיו כולם יכול לראות את זה.
מה does-- זה כמו, זה זה.
זה הריבה, ממש כאן.
מה זה אומר?
מה אני עושה?
כן, רעיון?
כן?
>> תלמיד: ובכן, ולכן כאשר אתה נכנסים מערך,
אתה הולך להיות יוצא משמאל לימין,
אז אתה הולך להיות הולך ב עשרוני מלמטה [לא ברור].
דווין: בדיוק.
תלמיד: אז כל אחד אתה צריך להכפיל
מה שראית כערך int על ידי הפעם שאתה מקבל לעבור כי למעלה מ.
>> דווין: מושלם, מושלם, כך למשל, בואו
נגיד שנתתי לי you-- אני הולך לכתוב כאן.
לא, אני לא.
אני הולך לכתוב כאן.
בואו נגיד שאני נתתי לך 76, נכון?
בואו נגיד שאני אתן לך 76.
זה מחרוזת מלכתחילה, בסדר?
>> כך שאורך הוא מה?
2, נכון?
סכום הוא 0.
אז אנחנו קופצים בנו ללולאה.
אישור, הגרסה הראשונה של זה, מה זה הולך להיות?
זה הולך להיות סכום הוא 0.
אז תסכם פעמים 10 0.
זה חסר משמעות.
אז מה זה עושה?
תלמיד: [לא ברור].
>> דווין: זה הולך להפוך את זה תו למספר שלם, נכון?
זה כמו סוג של עם שלך בעיה set-- light-- זה
זה כמו סוג של עם בעיה מוגדרת VISIONEER.
עם ערכי ASCII יש לך עסק.
אז אם אני נותן לך, כמו, שבע, אבל זה אופי,
ואתה רוצה לדעת, אישור, מה שספרה הוא ש?
כן, אתה יכול, כן.
אז מה ספרה זה?
אתה יכול להחסיר 0 ממנו, אבל אתה צריך להחסיר 0, האופי.
>> ושבו חלק מאנשים לקבל הכשילו את, הם
כמו, אישור, גם לעשות, אני צריך לדעת ערכי ASCII לחידון זה?
לא, אתה בהחלט לא צריך לדעת ASCII
ערכים של, כמו, באותיות קטנות , אותיות רישיות, אפס.
>> ROB: אין סיבה לאי לשים את זה בגיליון לרמות.
>> דווין: לעשות בהחלט לא לבזבז השטח שלך עם זה.
אתה יכול literally-- רק במקום לומר 48, כמו ימין למעלה
יש, כי הוא שווה ערך ל אומר אחד, גרש אחד,
כמו ש, בדיוק אותו הדבר.
>> ROB: אתה כמעט יכול לחשוב על זה כif-- אלוהים, אני צריך,
oops-- כמעט שאתה יכול לחשוב על זה כאילו יש לנו משהו כמו חשיש ש
להגדיר 0 48.
זה לא יעבוד.
אבל תחשוב על זה כעל ציטוט אחד 0 ציטוט אחד, ועבור כל הדמויות.
תחשוב על זה כקבוע ש מייצג שערך ASCII.
>> דווין: כן.
אוקיי, אז בפעם הראשונה דרך, כל כך עם 76-- כך בפעם הראשונה דרך,
זה רק האופי 7 מינוס האופי 0,
ואלו הם שבעה integers-- גם, אלה
הם אחד משבעה חללים אחר בתרשים ASCII או משהו כזה.
אז זה הולך לחזור int של 7.
אז עכשיו, סכום שווה 7.
>> בסדר, ובכן, בואו לקפוץ לזה ללולאה שוב.
אוקיי, עכשיו זה סכום פעמים 10.
אז אתה ביעילות נע 7 משמאל.
האם זה הגיוני?
אתה ביעילות להעביר אותו לצד השמאל.
>> ואז אתה add-- זה הולך להיות 6 מינוס 0.
זה 6.
אז זה הולך להיות 70 בתוספת 6.
76, זה המספר שלך.
אז בלי קשר למה מספר שנתתי לך, זה לאט פשוט
הולך להעביר את הערכים הגדולים יותר גורם, 1 בצד השמאל של 10
בכל פעם בלולאה, ולאחר מכן להוסיף במידת צורך.
>> בגב?
תלמיד: אנחנו לא צריכים לעשות כל בדיקה בתכנית?
>> ROB: עד כה כמו בדיקה הולך לתכנית,
היינו אומר לך די הרבה מה שאתה צריך לבדוק.
אם אנחנו לא אומרים לך שום דבר, אז בדרך כלל
תניח שאתה צריך לבדוק את רוב הדברים.
כמו שאתה יכול, רק כדי להיות בטוח, אתה כנראה צריך לבדוק היי, הוא null של?
ואז אין לי מושג מה לחזור.
אבל היינו אומר לך דברים מהסוג הזה.
0, אני לא יודע.
>> דווין: ולמה אתה רוצה לחזור ולבדוק אם זה שווה null?
תלמיד: [לא ברור].
דווין: בגלל כוכב char.
זה מצביע.
אז מקובל לחלוטין הצהרה, שאני יכול לומר, אישור,
של שווה null, כי זה יכול להיות מצביע null.
אז בכל פעם שיש לך עצות בדרך שלך בכך,
אתה כנראה צריך לבדוק.
כי אם אתה לא לבדוק את זה, ו אז אתה ואז ללכת לך ללולאה,
ואתה doing-- "זוז.
"זוז.
>> ROB: מצטער, זה הכל.
>> דווין: וכך, כמו, אם זה null, ואז אתה
לעשות את מה ששגיאה, זה אתה הולך לקבל?
תלמיד: אתה הולך לקבל באשמת קבוצה.
דווין: אתה הולך להקים פגם, תקין, בגלל שאתה
מנסה מדד לnull.
אז אתה הולך לנסות מדד לזיכרון שאינה בבעלותכם.
אז זה, אם זה הוא ריק, ו אתה עושה את זה, שתצליח מחזור.
>> ROB: אני גם חושב על הבחינה שב שאלנו את השאלה הזאת, אנו אומרים לכם
כי אתה פשוט יכול להניח זה מספר חיובי.
בגלל atoi צפוי גם כדי להתמודד עם מספרים שליליים,
כך היית צריך מקרה מיוחד.
היי, היא הדמות הראשונה מקף, ובמקרה זה, אישור,
עכשיו זה מספר שלם שלילי.
אנו אגיד לך דברים כאלה.
אנו אגיד לך מה שאתה צריך לטפל.
דווין: כן.
אז אני בטוח שיש אנשים שאולי have-- אם אתה התחיל להסתכל על מבחנים ישנים,
ראית sterln.
זה אחד פופולרי.
ואני חושב בsterln, היה לך ל לעשות בדיקה זו לnull, התמורה
0 או משהו כזה.
כלומר, את צריך לבדוק לnull.
ואם לא, ש היה מצביע את על החידון.
אז בכל מקרה, עושה כולם מרגיש בסדר עם atoi?
האם מישהו רוצה ללכת על חלקים שוב?
רוב: אה, כן, אני חושב ש אנחנו גם נגיד לך לך
ניתן להניח את כל מה שis-- ש הם למעשה הזנת מספר,
כי אתה לא צריך לדאוג, כמו, מכתבים להיות במחרוזת, כך.
דווין: כן.
כן?
תלמיד: האם אתה יכול ללכת על עוד פעם אחת כש
אתה משתמש במירכאות כפולות וציטוט אחד?
>> דווין: בטח, כל כך במרכאות כפולות, מאוד פשוט, הוא במרכאות כפולות הן מחרוזות.
אז אם אתה להכפיל ציטוט שום דבר, זה מחרוזת.
אז, כמו, אם היה לי זה 0 לכאן, ועשיתי את זה, זה חוט.
זה כבר לא אופי.
אז אני לא יכול למצוא ערך זה בASCII שלי תרשים, כי זה מחרוזת, כן.
>> אישור, כל שאלות אחרות?
כן?
>> תלמיד: אז יש לך כבר ענה על זה,
אבל כמו, כאשר אנחנו בעצם כותב את זה בחידון,
אתה רוצה אותנו לכתוב ב חתכים [לא ברור] אפסים?
דווין: מס '
השאלה הייתה צריך אותך לשים קו נטוי דרך האפסים
כדי לציין אם הם אפסים?
לא, אנחנו להבין את זה.
כן, תודה, הם טובים.
אישור, כל דבר אחר?
האם מישהו רוצה to-- אז אני חושב ש אנחנו פגשנו קצת לאורך זמן.
האם אתה רוצה לראות עוד אחד, או?
תלמיד: RandomInt.
>> דווין: RandomInt, אישור, בדיוק.
אז בואו נעשה RandomInt.
אני אעשה את זה כאן.
אז RandomInt הוא למעשה הרבה יותר פשוט.
אני חושב שatoi הוא כנראה הכי קשה אחד שאנחנו כבר ביקשנו בשנים הקודמות.
תלמיד: [לא ברור].
>> דווין: מה?
רוב: אני רואה אם ​​זה סוג לצפייה של מכאן.
דווין: האם זה?
רוב: אני לא חושב שזה going-- אני חושב ש זה הולך לרוץ בצד הימין.
דווין: אוקיי, אז אני אעשה את זה.
ואז אתה פשוט לשים את זה על המסך.
>> ROB: בסדר.
>> דווין: אתה רוצה להיות הסופר שלי?
>> ROB: כן.
>> דווין: נחמד.
אישור, אני יכול למחוק את זה?
>> סטודנט: כן.
>> דווין: זה כל כך קשה.
(שירה) אתה עושה מה שאתה עושה.
ועושה את מה שאתה עושה לא.
בְּסֵדֶר.
>> אישור, אם אני זוכר נכון, ב חידון RandomInt היה כמו,
בסדר, אני הולך לתת לך שני מספרים, כמו וb.
ואני רוצה שתיתן לי RandomInt בין המספרים האלה.
אז RandomInt הולך לקחת שני אחר מספרים
כך RandomInt-- וזה הולך להחזיר int.
>> אז מה ערך ההחזרה?
אני רק אמרתי לך.
Int, נכון?
כמו זה, ואז זה הולך לקחת שני ints.
כך שזה הולך לקחת int וint b, כמו ש.
אז מה הוא RandomInt הולך לעשות הוא שזה הולך
לחזור כמה ערך אקראי בין שני ערכים אלה.
אז זה הולך להיות גדול מ, פחות מ b.
אז אני חושב שאתה כנראה יכול להניח ש הוא קטן יותר משני הערכים.
אז עם אם יש לנו עסק אקראית, מה פונקציה
יש לנו ראינו ש נותן לנו דברים אקראיים?
תלמיד: Drand.
דווין: Drand, בדיוק.
אז אתה הולך כנראה רוצה להשתמש drand שלך.
אז אתה יכול לומר אקראי int, ואנו רק אומר את זה שווה 0 עכשיו.
והם אנחנו הולכים להגיד, אישור, שווים אקראיים drand 48.
ומה משמעות של זה יחזור?
מה פונקציה זו נותנת לך?
>> תלמיד: בין 0 ל -1.
>> דווין: כן, בין 0 ל -1.
אז זה הולך be--
>> ROB: וזה is-- אני חושב ש היינו אומר לך את זה.
כמו, אתה יכול להשתמש בdrand 48.
אתה יכול לאמת את זה בבחינה האחרונה.
אבל אנחנו כנראה היינו אומרים לך ניתן להשתמש drand 48, ש
חוזר לצוף בין 0 ל -1.
>> דווין: כן, כן, אני די בטוח בבחינה
זה אומר שכנראה לא רוצה להשתמש drand, כן.
כך שזה הולך לחזור ערך כלשהו בין 0 ל -1.
ואז מה אתה הולך רוצה לעשות?
ובכן, אתה רוצה להכפיל by-- לחכות, אני חושב שזה ככה, מצטער.
אני פשוט אעשה את זה.
אֲנִי לֹא יוֹדֵעַ.
>> אז ב מינוס.
אז למה ב מינוס?
אז בואו נגיד שdrand נותן לך בחזרה אישור int--, אני פשוט אעשה את השאר,
כך בתוספת.
אז מה does-- y הוא ב מינוס.
אז בואו נגיד שdrand שנותן לך בחזרה הערך המרבי שהוא יכול לנסוע
לתת לך.
מה שהולך להיות?
תלמיד: 1.
>> דווין: 1, נכון?
אז אם זה 1, ואתה הכפלתו ב מינוס,
טוב, זה פשוט הבדל בין א 'מינוס
ואם לאחר מכן להוסיף ש חזרה ל, זה מה?
זה בעצם b.
האם זה הגיוני?
>> סטודנט: כן.
>> דווין: אז אם זה המקסימום מעריך אולי זה יכול להיות,
זה הולך להיות 1.
ואז זה פשוט הבדל בין שתיים.
הוסף על, אז זה הולך לחזור אקראי.
ובמקרה הפינה ש drand נותן לך בחזרה 1,
אקראי פשוט תהיה ביעילות להיות ב'.
אבל זה המקסימום שהוא יכול להיות.
אז אם זה הולך להיות פחות מ ש, אז בואו נגיד ש כמו 0.9,
אז מינוס ב 0.9 פעמים הולך להיות פחות
מההפרש בין מינוס b.
>> ואז אם אתה מוסיף ש ל, אז הערך ש
הולך להיות גדול יותר מאשר, כי אתה מוסיף משהו על זה,
אבל זה הולך להיות פחות מ b.
אז אתה הולך לקבל אקראי מספר, כי את קוראת drand.
והראנד ש, שהמספר האקראי הוא הולך להיות איפשהו באמצע
וb.
האם זה הגיוני?
>> ROB: רק כדי לשים את זה מספרים קונקרטיים, כך
נניח שאנו רוצים לקחת מספר אקראי בין 7 ו -10.
אז מינוס b הוא הטווח שלנו.
אז יש מגוון של שלוש מספרים שאנחנו רוצים לבחור.
ולאחר מכן הכפלה שבין 0 ל -1 1,
אם כי אז נותן לנו some-- נניח שנותנת לנו 1.5.
>> אז 1.5, אנחנו רוצים ללכת 7-10.
אז 1.5 בתוספת 7 מביא אותנו בחזרה ל7-10 הטווח שלנו.
ואז אנחנו לאחסן אותו בתוך מספר שלם, כך שזה מקוצץ ל -8.
ואז אנחנו פשוט לחזור כי.
אז מינוס b הוא הטווח שלנו.
משמרות אותו למספרים שאנחנו רוצים בטווח ש.
אז בין 7 ו -10, ולאחר מכן אנו יכול להחזיר את מה שאנחנו בסופו של דבר עם.
>> דווין: כן, נחמד.
>> ROB: תודה לך.
>> דווין: כן, מה קורה?
>> תלמיד: האם אנחנו מפעילים אותו לכל סוג של שגיאות ASCII כאשר we're-- אם drand הוא
חוזר לצוף [לא ברור].
>> רוב: אז בדיוק כמו רוב אמר, כי אקראי הוא לא int,
כך drand יהיה לצוף.
אז ואז זה מכפיל את.
ואתה יכול לקבל איזו סוג של מספרים לצוף.
ואז זה הולך לחתוך.
>> תלמיד: אישור.
דווין: כן.
רוב: ואם מהדר היה להזהיר לך על, כמו, אובדן של דיוק,
רק זרקתי int ב שם, ואז זה טוב.
דווין: כן?
>> תלמיד: האם יש לו הסתברות זהה מקבל,
כמו, B או [לא ברור]?
>> רוב: אז is-- אני בעצם wondering-- הוא RandomInt הניח כי
להיות מספר מפחות מ b?
כמו, אם זה בין 7 ו 10, מה הן האפשרויות?
7, 8, ו -9, או 7, 8, 9, 10?
דווין: אני שוכח.
על set-- הבעיה
>> רוב: אני חושב שזה 7, 8, 9.
>> דווין: זה דווקא אומר אחד של כולל ואחד של בלעדי.
>> ROB: כן.
>> דווין: אבל אני don't-- אני not--
>> רוב: אז אני חושב שאלו הוא לא נכלל, ובמקרה זה,
יש שווה הסתברות של 7, 8, ו -9.
אין הסתברות של 10.
דווין: כן?
תלמיד: יש לי שאלה.
אנחנו רוצים להגדיר פונקציה חוזר לא ערך אחד, אבל מערך.
אז מה יהיה תחביר לחזור אחרי?
>> דווין: אוקיי, אז אז אתה would-- לאחר חזרה?
אז בואו נגיד שאתה הכריז מערך איפשהו שם למעלה.
אז היית לחזור רק שמו של המערך.
>> תלמיד: בסדר, תודה.
לאחר מכן פשוט לחזור עם a--
דווין: אה רגע, כל כך מצטער.
השאלה הייתה איך אתה להחזיר מערך.
>> ROB: למרות שזה לא יכול יוכרז מערך
על הערימה או משהו כזה.
זה היה צריך להיות משהו malloced, כי malloc
איך אתה מקבל סביב הקצאת זיכרון אוטומטית.
>> דווין: כן.
רוב: איך אתה מקבל סביב היקף מקומי.
>> דווין: אבל שהיית רק לחזור name--
>> תלמיד: זה [לא ברור] לא אחד ערך, למשל, שני מספרים, כך
[לא ברור].
>> דווין: אתה לא יכול להחזיר את המספר מרובה.
אתה לא יכול, כמו, return--
>> תלמיד: אני דיברתי על החזרת מערך או משהו כזה.
>> דווין: כן, אז השאלה היא אני יכול לחזור ערכים מרובים.
אתה לא יכול להחזיר ערכים מרובים.
אתה לא יכול, כמו, לחזור לאחר מכן לחזור ב או משהו כזה.
כי אחרי שאתה חוזר, אתה לחזור מהפונקציה.
ואז הפונקציה נעשה, ו כמו רוב אמר, הוא בערימה.
>> אז כל זיכרון שרק מקבל חזר למחשב.
שוכח מה שהיה, בעצם.
אז אם אתה רוצה לחזור מרובה ערכים, אתה צריך להחזיר מערך,
והדרך בה אתה עושה את זה היא mallocing.
ואז היית חוזר x כמו ש.
בעיקרון, אתה פשוט תחזיר את השם.
וכאשר אתה חוזר משהו כזה, אתה
לא ממש חוזר הערך.
>> אז בואו נגיד שאתה מאוחסן הערכים במערך.
אתה לא באמת חוזר את הערכים האלה.
כמו, אם אחזור int, אני באמת חוזר עותקים של הערכים.
אבל אם הייתי צריך לחזור משהו כזה,
אני מחזיר התייחסות לערכים אלו.
אז, אני חוזר בעצם, כתובת זיכרון לערכים.
האם זה הגיוני?
סטודנט: כן.
דווין: נחמד.
כן?
>> תלמיד: כשאתה באמצעות drand כאן,
אתה צריך לשים את srand לפני זה?
>> דווין: לא, לא, אני לא חושב כך.
>> ROB: כן, אז יש לך לומר משהו על srand?
ברירת המחדל שלך אף פעם לא אומר srand בכל הוא רק כדי לעשות srand של null.
אז drand על עבודת הרצון משלו.
וזה יהיה באופן אוטומטי לזרוע עם הזמן הנוכחי, הוא מה שהיא עושה שימוש.
דווין: כן?
תלמיד: האם אתה [לא ברור] עם המספרים?
דווין: כן, אתה יכול.
תלמיד: אז אתה יכול אומר, כמו, 4 פעמים 2.
העניין הוא, שאתה לא יכול להניח אז int הוא ארבעה בתים.
Only--
>> דווין: אני מתכוון, לחידון שאתה יכול.
[צוחק]
>> ROB: ממ, לא.
דווין: כן, כן אתה יכול.
אם אשאל אותך כמה גדול int הוא, אתה לא יכול להיות, כמו, ארבע או שמונה.
רוב: אה, אז אם שאלה היא באופן ספציפי,
כמו, אם מדוברים בבעיה הקידוד, אתה צריך להגיד גודל של int.
אם זה שולחן, או זה אומר כמה בתים,
אתה לא צריך למלא בגודל של ints.
>> סטודנטים: [צוחק]
>> דווין: נכון, אז למה הוא גודל של int החשוב כאן?
אז כמו, אם אנחנו הולכים ל32-bit מעבד או משהו כזה,
אז זה הולך להיות ארבעה בתים.
אבל בחלק מחדש יותר דברים, זה יכול להיות מה?
זה יכול להיות שמונה, נכון?
אז זה-- אם אתה רק קוד קשה ארבעה, אז על כמה מכונות, זה יעבוד.
כמה מכונות, זה לא יעבוד.
אבל אם על החידון אנחנו כמו עד כמה גדול הוא int?
שים ארבעה.
ROB: נכון.
דווין: כן?
תלמיד: אז בגלל שאנחנו מכריזים [לא ברור] בתוך פונקציה,
אנחנו צריכים לשים 3 בתוך הפונקציה ש?
או שאנחנו יכולים להשתמש בו בחוץ?
דווין: אתה יכול להשתמש בו מחוץ לתפקיד ש.
אז הוא שואל את בחינם.
>> תלמיד: לרדת במסלול היכן [לא ברור].
>> רוב: אה, החופשי אינו happen-- זה חלק מהקסם של malloc
הוא שאתה לא מוגבל להיקף מקומי.
יש לך שליטה מלאה על כמה זמן המשתנים שלך לחיות.
אז אנחנו קוראים malloc כאן, אולי זה להיות פונקציה נפרדת לחלוטין.
זה יכול להיות 10 שעות מאוחר יותר שסוף סוף להתקשר חינם.
>> דווין: כך למשל, כמו, כמה שבועות מהיום כאשר אתה סוף סוף
לעשות איות המילון שלך psets, אתה הולך
יש כמה פונקציה ש יוצר טונות של בלוטות.
אז אתה mallocing טון צמתים בפונקציה זו.
ואחר-כך ב פונקציה נפרדת, אתה
הולך רוצה לשחרר את כל אותם צמתים.
כך שאתה יכול, פשוטו כמשמעו, רק לעבור ל לשחרר את מצביע, ולכן כתובת זיכרון
למה שאתה malloced.
ושיהיה בסדר.
אתה לא חייב לשחרר, כמו, באותו התפקיד.
כן?
>> תלמיד: אז malloc משתנה [לא ברור] בחוץ?
האם זה מה שאתה אומר?
דווין: המתן, אומר את זה?
מצטער.
>> תלמיד: אם משתנה malloc יכול להיות חופשי בכל מקום בקוד,
אז הם יכולים לגשת בכל מקום בקוד?
אתה יכול לשמור אותם מקומי?
>> דווין: אה, היא שאלה, כמו, משתנה, like--
>> רוב: אז אתה עדיין צריך יש סוג מסוים של התייחסות
לבלוק של malloc של זיכרון.
אז הנה, אנחנו חוזרים x.
תלמיד: אה.
ROB: אם אנחנו לא חזרנו x כאן, וזה היו פשוט חלל,
אז לא תהיה לנו גישה ל המצביע שmalloced,
וזה דלף זיכרון.
>> תלמיד: אישור.
>> דווין: אז כמו, נניח שאתה יש לי זה, כמו, ממש כאן.
רוב: מס '
דווין: בפונקציה העיקרית שלי, אני לא יכול פשוט להתקשר x זה ולהיות, כמו, אישור,
בפונקציה זו, שעשיתי את זה.
>> ROB: נכון.
>> דווין: אז אני הולך להתקשר x ב, כמו, עיקרי או משהו כזה.
אתה לא יכול לעשות את זה.
אתה הולך להחזיר משהו.
אבל מה אתה הולך לחזור?
אתה הולך לחזור כתובת זיכרון.
ומכיוון שאתה חוזר זיכרון כתובת, שניתן לגשת אל מקום אחר.
עוד שאלות?
כן?
>> תלמיד: האם הפונקציה הנ"ל להיות צ'ק על [לא ברור]?
>> דווין: למה אני לא צריך לעשות את זה?
תלמיד: [לא ברור].
דווין: בגלל שאתה לא mallocing כל דבר.
אז זה not-- כן, זה לא אוהב מחרוזת s.
זה מצביע במקום כלשהו.
אלה הם רק ערכים.
תלמיד: אישור.
דווין: כן.
כל דבר אחר?
ROB: כן?
תלמיד: אבל כאשר אתה [לא ברור]?
>> רוב: אז על מנת לשחרר זיכרון, היינו אומר כאן.
אז x הוא המצביע שלנו הבלוק של זיכרון.
אנו משחררים מצביע ש.
ולא היינו בהכרח לעשות את זה כאן.
אנחנו יכולים לעשות את זה בכל מקום.
אבל אתה קורא רק בחינם ב משהו שmalloc מחזירה.
אז malloc, כאן חזר, מה שמאוחסן בx.
כדי שנוכל להתקשר חינם על x.
כל שאלות האחרונות?
>> דווין: כל שאלות שעברה?
כן?
>> תלמיד: מצטער, אתה יכול מחדש להסביר למה אתה תשחרר את שם?
למה [לא ברור]?
>> דווין: לכאן?
>> תלמיד: כן, כמו מייד אחרי.
דווין: אתה כנראה לא רוצה בחינם כאן.
ROB: אתה כנראה לא היית.
דווין: כן, כי זה לא יעשה דבר.
זה היה, כמו, ליצור זיכרון, לעשות את הדברים אליו,
ולאחר מכן באופן מיידי תשכח מזה, כן.
>> ROB: אבל אנחנו יכולים לעשות, כמו, כאן מסיבה כלשהי.
אפשר לומר כוכב int y שווה מערך תמורה.
לעשות כמה דברים עם Y, אולי להדפיס את התוכן.
ואז, סוף סוף, שנסיים.
אנחנו יכולים לשחרר את y.
תלמיד: [לא ברור].
דווין: אני צריך לגלול למטה?
תודה.
ROB: נחמד.
>> דווין: אישור, זה הכל.
ROB: בסדר, טוב.
מזל טוב.
>> דווין: אם יש לך שאלות, שלח לנו דוא"ל.
מזל טוב.