>> [מוסיקה נושא]
>> 1 SPEAKER: היי, כולם.
ברוכים השבים לסעיף.
יום מקסים out-- ולכן, אני בטוח, יש רק ארבעה מכם כאן
ולא חבילה הרגילה שלנו.
אני הייתי חולה בסוף השבוע הזה.
אז אין לי Starburst בשבילכם.
ואני יכול להתחיל שיעול נורא לאורך כל זה.
אז פשוט תהיה סבלני איתי.
אני הולך באמת לנסות ולעבור את זה ראשון,
אם כי, לפני שאקבל התקף שיעול.
אבל רק להיות קל עליי קצת bit-- זה כל מה שאני מבקש.
>> אז סדר היום שלנו לtoday-- רק reminder-- החידון שלך הוא בשבוע הבא.
אמרתי לך בשבוע שעבר זה כל כך זה לא יתפוס אותך לא מוכן.
אז אני מזכיר לך שוב.
החידון שלך בשבוע הבא.
לשם כך, בשבוע הבא של סעיף יהיה הרבה יותר
ל-- אני אנסה ועבודה בחלק הסקירה.
אז אם אתם יכולים לעזור לי ושלחת אותי
דברים שאתה מרגיש בנוח עם, שאתה מודאג,
נושאים שאתה רוצה ל לי לכסות, זה יהיה נהדר.
אז אני יכול לנסות ולעבוד אותם לסעיף שלנו בשבוע הבא
או לשלוח לך חומר או הכנה נוספים שאתה לא יכול לקבל במקום אחר.
>> כן!
יותר אנשים באים!
חשבתי, עשיתי את זה קשה שעבר שבוע, כי אף אחד לא רוצה לחזור?
אני מפחד.
אז שלושה דברים האחרים שאנחנו הולכים לעבור על
הם ניתוב מחדש, אני קובץ / O, ו אז מצביעים וזיכרון דינמי.
אני בטוח שכולכם נרגש סופר על pointers-- הנושא האהוב על כולם,
כל כך פשוט להבנה.
אני בטוח שאתם כל יש את זה, נכון?
>> דברים אז קודם ראשון, redirection-- זה בעצם רק דרך
כדי לשלוט באופן שאתה קלט דברים בתכנית שלך,
איך אתה דברים פלט מהתכנית שלך.
הדרכים העיקריות שאתם כבר אינטראקציה עם זה
רק דרך החוצה סטנדרטיים עם מסך ההדפסה שלך כאן.
אבל יש דרכים ל pipe-- כפי שאנו רואים כאן
הוא אחד מסוג words-- צינור שהמידע
הנתונים לקובץ מקובץ או.
זה דרכים שונות רק מקבל דברים בתכנית שלך
ואת התכנית שלך, במקום רק להדפיס אותם למסך הזה
או המזינים דברים משורת הפקודה.
>> אז ראשון הוא קטן גדול מתו.
אז output-- זה פשוט מדפיס את הפלט לקובץ במקום המסך שלך.
אז אם היה לך משהו שמודפס "שלום, עולם!" למסך,
אם תשים אותו במקום לoutput.text, ש
יוצר הקובץ הזה שנקרא output.text.
וכאשר אתה פותח אותו, זה יהיה להגיד "שלום, עולם!" שם.
זה יכול להיות סופר שימושי אם יש לך טונה של שגיאות
למעשה, כפי שאנו רואים בזה.
אם אתה עושה את שני תו, זה יהיה להדפיס הודעות השגיאה.
>> אז אם אתה נתקלת בבעיה עם קומפילציה, יש לו הרבה שגיאות
ואתה מסתבך בניסיון כדי לגלול בשורת הפקודה שלך
דרך כולם, שאתה יכול פשוט להדפיס אותם לקובץ,
לפתוח את הקובץ ש, כך שאתה יכול לגלול אותם קלים יותר.
אני ממש בשימוש ש הרבה כשבאגים
181 psets שלי ללמידת מכונה.
אז זה יכול להיות סופר שימושי בהמשך.
זה גם שימושי אם יש לך תכנית שאולי הוא יצירת ספרייה
או לייצר כמה סט של מחרוזות, ואתה
צריך להיות מסוגל לראות את זה שהיא מייצרת אותם כראוי.
זו הדרך לעשות את זה.
>> אז אם אתה מדפיס אותם לקובץ, אתה בקלות רבה יותר יכול לבחון אותם, נכון?
לעומת מנסה לגלול דרך שורת הפקודה שלך.
ואז דבר אחד לציין הוא שרק עם יותר
מ תו, אם אתה כותב לקובץ שכבר exists--
כך כמו אם רצנו זה ראשון זמן, אנחנו שמים את זה לoutput.text,
ולאחר מכן הייתה לנו תכנית שנייה שהודפס זה כתכנית שתי
ועשה יותר מאשר לoutput.text, זה יחליף that-- כך
להחליף את מה שהיה אי פעם ב קובץ שמלכתחילה.
>> אז אם ברצונך לצרף לקובץ, כפי שאנו רואים כאן,
אתה פשוט עושה את שני גדול יותר מסימנים.
וזה יוסיף לזה.
זה לא להחליף אותו.
אז אם אתה צריך להפעיל מספר רב של תוכניות וסוג של לשמור
אחר מה כולם חוזר אליך בקובץ,
זו דרך לעשות את זה.
אם לא אכפת לך מה נמצא בתיק שלך וזה מותר להיות מוחלף,
אתה יכול פשוט להשתמש יותר בודד מאשר.
האם זה הגיוני לכולם?
>> קהל: כמו נקודה לקצץ שלום גדול יותר יותר מאשר טקסט נקודת תפוקה, כמו פעמיים,
זה פשוט יראו רק על פלט על מודעה נקודת time-- שנייה
>> 1 SPEAKER: נכון.
אז זה בעצם היית רק לחלוטין להחליף את מה שהיה שם מלכתחילה.
אם קובץ זה כאן, output.text כבר
קיים, בעצם כל מה שאתה קורא זה שוב עם יותר בודד
ממה שאתה יכול רק לחשוב על זה כמו כמו שהוא החליף את הקובץ.
כמו כשאתה שומר Word מסמך ואתה לשמור כ,
ואתה שומר אותו שם, ו היא מחליפה it-- לחלוטין
זה אותו הסוג של דבר.
למישהו יש שאלות על רק פלט לקובץ?
מדהים.
>> אז ברור, אם אתה להפוך את חץ כיוון, הוא יכול לעשות קלט.
לכן, כאשר יש לך חבר ' כמו קיסר או VISIONEER
והיה לך לקלט משהו, הייתה לך טענת שורת פקודה
כי בעצם קלט אותו.
זוהי דרך נוספת לעשות את זה.
אז במקום לחכות לפקודה,
כמו בעת שבקשת הודעה בקיסר או VISIONEER,
אם היה לך קובץ טקסט שההודעה שלך,
אתה יכול פשוט להקליד את זה לתוך זה.
>> אז אם זה היה כמו נקודה לקצץ קיסר 3 פחות מטקסט קלט חץ, ש
המסר שלך, ש היה רץ בסדר גמור.
כאשר תכנית הקיסר שלך למעשה ביקש קלט מהמשתמש,
זה כבר יש את זה, כי שהקלדת בקובץ זה.
זה רק בדרך אחרת.
רק הפוך של output-- רק קלט עבור הנתונים שלך.
>> ואז האחרון הוא צינור.
אז די מגניב של זה.
כי זה מאפשר לך לקחת את הפלט של אחד
תכנית והכניסה אותו כ קלט לתכנית אחרת.
אני לא יודע אם מישהו מכם שיחקתי עם אותן לפענוח
CS50 שאולי יש לי נתתי לך, אבל זה יהיה
מאפשר לך לקחת חלק מדגם קובץ, הקלד אותו להצפנה שלך,
ואז משם להקליד כי לפענוח שלך
כדי לוודא שכיבה את אותו הדבר.
אז זה כמו סוג של שלוש דרך לולאה.
לכו על זה.
>> קהל: אם תכנית יש כניסות מרובות,
האם יש דרך להגיד את זה שקלט כדי להשתמש בקובץ הטקסט או הפלט עבור?
>> 1 SPEAKER: יש לו כניסות מרובות.
לא משנה מה להגיש input-- שלך כאשר זה מבקש קלט שהפעם הראשונה, זה
הולך להניח, אני חושב, שזה הולך צינור בכל הקובץ.
אז אם יש לך כניסות מרובות, אתה הולך להיות צנרת במספר קבצים.
אז אם אתה שואל להודעות שלוש פעמים בקוד שלך,
אתה הולך לשים בשלושה קבצים שונים.
וזה הופך להיות משוגע.
ואתה לא צריך לדאוג שעכשיו.
אבל זה הרעיון.
>> אז כן, צינור הוא רק פלט של אחד תכנית משתמשת בקלט לתוך השני.
כולם טוב שם?
מגניב.
אישור.
אתה כנראה לא תהיה לי לעשות יותר מדי עם זה.
אבל אתה צריך להבין דרכים אתה יכול להשתמש בזה.
ויש מקרים מסוימים ש אולי כדאי לך להשתמש בו.
>> אז להגיש I / O-- אני יודע מה אתה saying-- אנחנו רגילים לקרוא מ
וכתב למסך שלנו יש, אשר הוא סטנדרטי ובפלט סטנדרטי.
וזה מה שאתם היו עושה מאז תחילת הכיתה כאן.
אבל אתה יכול גם לקרוא ולכתוב קבצים, וזה כל הקובץ אני / O-- כך קובץ קלט,
פלט הוא כל מה שהוא מייצג.
אז זה בעצם אומר ש אתה יכול לאחסן את הנתונים שלך עכשיו.
>> כאשר אתה פשוט להדפיס אותו ל מסך, שזה בעצם נעלם, נכון?
ברגע שאתה עושה "שלום עולם "וברח" שלום העולם "
הוא מדפיס "שלום עולם" על המסך.
אבל אתה לא באמת יכול לעשות כל דבר עם אותו משם.
אם תאחסן בטקסט קובץ, ואז פתאום
יש לך את הנתונים שאתה רשאי להשפיע או להכניס אותו לתוך קובץ,
או לשים אותו לתכנית מאוחר יותר.
אחת הסיבות למה אנחנו עושים את זה רק
כדרך לאחסון נתונים לשימוש מאוחר יותר.
>> יש לי כמה צעדים כאן רק הליכה בתקן
I / O. בשלב אחד, אתה צריך ליצור הפניה
לקובץ עם כל כובעי קובץ כוכב.
לכן נוצר מצביע לקובץ.
אז אתה רוצה לפתוח אותו.
ואתה אומר, פשוטו כמשמעו, רק קובץ שווה fopen.
וזה הולך לחזור מצביע לקובץ שרק נפתח.
ראיתי כמה מכם החבר 'ה בשעתי עבודה.
>> אבל אחד הדברים הוא מצביעי remember--
יכול להיות כמה כתובות או null, נכון?
אם אי פעם יש לנו מקרה שבו משהו יכול להחזיר null,
מה שאנחנו צריכים לעשות לפני שאנחנו משתמשים בו?
אנחנו צריכים לבדוק אם זה null או לא, נכון?
מפני שחלק מכם אולי יש לי הבעיה שבה כל מה שאובייקט
היה מוחזר בפריצה היה ריק.
ניסית לבצע כמה פונקציה עליו.
ואתר המחשב פגם.
נכון?
אני בטוח שכמה מכם ייתכן שיהיה לה בעיה.
>> אז עם fopen, fopen לא יאמין מחזירות מצביע לקובץ,
או אם משהו משתבש, זה הולך יחזיר null.
אז אתה תמיד צריך לבדוק שלא חזר null
לפני שתנסה לעשות שום דבר אחר.
זה כמו הפרדיגמה סטנדרטית שאתה הולך צריך כאן.
אם יש אי פעם סיכוי ש משהו יכול לחזור null,
לבדוק כדי לוודא שהוא לא לפני שתמשיך.
אחרת, אתה הולך כדי לקבל תקלות אתר יפות.
ואף אחד לא אוהב להתמודד עם אלה.
>> אז כפי שאנו רואים כאן, את הטענה הראשונה רק הנתיב לקובץ.
אם קובץ שאינו קיים, זה הולך ליצירת קובץ זה.
וזה רק הולך להיות ריק.
ולאחר מכן את הטענה השנייה הוא המצב שאתה רוצה.
האם אנחנו רוצים לקרוא מקובץ זה?
האם אתה רוצה לכתוב מזה?
האם אתה רוצה לצרף?
אז בעצם מה שאני רק said-- אם הקובץ לא קיימת
ואתה מנסה לקרוא מ זה, זה הולך לזרוק שגיאה.
אם הקובץ name-- אוהב אם file.text עדיין אינו קיים
ואתה רוצה לכתוב לזה, זה יהיה ליצור
קובץ ריק בשם file.text בשבילך.
ואם אתה רוצה לצרף, אתה צריך לעשות את אותו דבר.
האם זה הגיוני?
אם אתה מנסה לקרוא מ קובץ שאינו קיימים עדיין,
זה יהיה לזרוק את השגיאה.
אחרת, היא תיצור את הקובץ לך לעשות מה שאתה רוצה זה.
מגניב.
עכשיו אנחנו יכולים לקרוא מהקובץ.
וזה פשוט סוג של הולך באמצעות הפונקציות השונות
שיש לנו שלקובץ קלט / פלט. רצון זה יהיה צורך בpset השבוע,
אם אני זוכר נכון.
כן, זה בהחלט יהיה צורך בpset השבוע.
אז fgetc מחזיר את התו הבא.
fgets רק מחזיר שורת טקסט.
הוא יחזור כל דבר עד קו חדש, וזה יהיה לשבור.
אז fread קורא מסוים מספר הבתים ובמקומותיהם
למערך, ש הוא משהו שאתה יכול
רוצה לעשות עם מחדש size-- עשוי להיות שימושי.
>> כמה אנשים קראו מפרט pset, דרך אגב?
אישור.
[לא ברור]
>> 1 SPEAKER: אישור.
בְּסֵדֶר.
בהחלט לקרוא that-- זה pset כיף.
אתה מקבל כדי לשחזר זיכרון שנמחק card-- באמת מרגש כאשר זה עובד.
אבל בהחלט, להתחיל לקרוא את זה.
בואו לדבר איתי אם אתה יש לך שאלות על זה.
>> אוקיי, אז כפי שאמרתי, fread קורא מספר מסוים של בתים.
זה חלק מספר שרירותי שאתה הולך להקים.
ולאחר מכן fseek רק מהלכים לתפקיד מסוים.
אז אולי לא אכפת לך על הבאים 10 הבתים.
אתה רק רוצה לדלג קדימה.
לא אכפת לך על אלה.
אתה רוצה לקרוא החל בייט 11.
fseek מאפשר לך לעשות את זה.
אז זה מאפשר לך להיות בררן על מה שאתה קורא.
בגלל fgetc, fgets, וקריאה fread ממקום מסוים בקובץ.
>> דרך לחשוב על זה היא אם זה הוא הקובץ שלנו, כאשר אתה פותח אותו לראשונה,
יש לך עמדה זו בקובץ שמתחיל בתחילת.
בכל פעם שאתה קורא fgetc, fgetf, או fread,
זה הולך להתחיל מ סמן עמדה זו.
בואו נגיד שאתה רק רוצה לקרוא נתח זה של זיכרון לכאן.
אתה לא יכול פשוט להתקשר.
אתה צריך לחפש כאן ולאחר מכן קרא משם
או לקרוא, מקבל, או getc, תלוי מה אתה רוצה.
אז לחפש רק מאפשר לך דלג על חלקים מזיכרון.
וזה רק דרך בה אתה יכול לדלג על דברים
מבלי לקרוא אותם למאגר שלך.
האם זה הגיוני לכולם?
>> ברור, שיש הרבה here-- המקביל
הניתוב מחדש של פלט, או הקלט שלנו, יש לך לקרוא ולכתוב.
רק אז fputc כותב אופי לקובץ.
fputs כותב קו.
Fprintf מדפיסה פלט בפורמט.
אז אם יש לך כרטיסיות, או שטח, או מה שלא.
ולאחר מכן fwrite כותב כמה מערך של בתים לקובץ.
אז זה באותה הדרך fwrite וfread הם מקבילים
fgets opposites--, fputs, ו אז המון fputc וfgetc--
מטורף, דברים מהירים.
>> רק סוג של לשמור handy-- זה יהיה לך זמנים שונים
שבו אולי אתה פשוט רוצה תו אחד בכל פעם.
אולי אתה רוצה כל קו.
עם pset-- המילון שלך וזה בשתי psets,
אני מאמין, אנחנו נותנים לכם את כל מילון בפורמט טקסט
בה לכל מילה מופרד על ידי קו.
אז אם אתם רוצים לקרוא במילה אחת בכל פעם,
מה שאתה יכול להשתמש אם אתה קורא והם כולם מופרדים על קווים חדשים,
ואתה רק רוצה מילה אחת בכל פעם?
>> קהל: fgets
>> 1 SPEAKER: נכון.
Fgets-- כי חוזר כל מה שעל קו אחד.
ואם כל מילה היא קו עצמו, אנחנו יכולים להשתמש בfgets.
מגניב.
האם זה הגיוני, כולם?
מגניב?
כן, אנחנו הולכים להגיע ל החלק המהנה עם מצביעים
בקרוב מאוד, שבו אתה לקבל לעשות קצת מתמטיקה.
וזה יהיה נהדר.
>> אחרון step-- לסגור את הקובץ שלך.
עם כל כך הרבה דברים כאן, אחד מפרדיגמות שלנו
הוא אם הוא יכול לחזור null, לבדוק null.
אם אתה פותח משהו, כדאי שתסגור אותו.
אוקיי, אז אתה לא עשית עד שאתה נעשה אלא אם כן סגר אותו.
כמו סוג של זה לא נגמר עד שגברת השמנת שרה.
זה כמו לסגור את הקובץ שלך.
כפי שהוא אומר כאן, רק לחזור ולהדגיש, תמיד
לפתוח הקובץ שלך לפני שאתה קריאה או כתיבה אליו.
ותמיד לסגור אותו אם אתה שפתחת אותו.
בסדר?
מגניב.
>> אז הנה דוגמא.
אז tiny-- אני לא יודע אם אתה אתם יכולים לראות את זה טוב מאוד.
אם רק היינו יכולים להגדיל הבהירות איכשהו.
תן לי באמת לעשות את זה, אם אני יכול.
אישור, אתם לא באמת יכולים רואה שבכלל, אתה יכול?
בסדר, אנחנו הולכים לעשות את זה, אז.
[לא ברור]
>> אני מניח שזה הרבה יותר טוב לראות.
כל אחד יכול לראות בי העכבר הלך היא השאלה?
אה, הנה זה is-- מה נאבק!
>> אישור.
בעיקרון, אתם צריכים להיות סוג של מושג מה זה עושה.
זה לא מושלם.
אבל אני מעדיף להסביר את זה יותר מאשר לבלות יותר זמן בניסיון לעצב אותו כמו שצריך.
בעיקרון, כפי שאתה רואה כאן, אנחנו מתחילים עם פתיחת קובץ.
ויש לנו כמה קובץ מסד נתונים שאנחנו
פתיחה שאומרת שזה לתלמידים שלנו.
ואנחנו הולכים לכתוב את זה.
אז כמובן, תחזיר null.
אז אנחנו צריכים לבדוק null.
ואז אם זה לא null, שאנחנו עוברים.
וכמו שאתה רואה, אנחנו לולאה דרך כאן.
יש תלמידים.
סטודנטים הוא החשיש המוגדר כשלוש.
ומה שאנחנו עושים הם שאנחנו הדפסה לקובץ, נכון?
אז מה אנחנו מדפיסים לקובץ שלנו?
>> קהל: הציונים שנמצאים במערך?
>> 1 SPEAKER: כן.
הציונים שנמצאים ב array-- בדיוק.
אז אנחנו פותחים את זה קובץ מסד הנתונים, ש
אני מניח שהוא סוג מסוים של מסד נתוני ציונים.
ואנחנו רק הדפסנו את ציונים של כל תלמיד לקובץ ש.
מגניב?
טוב.
מדהים.
אישור.
בואו נחזור to--
>> קהל: יש לי שאלה מהירה.
האם printf לא ללולאה?
זה רק באם הלולאה?
1 דובר: לא, זה ללולאה.
אני לא יכול לראות את העכבר שלי טוב מאוד עד כאן.
אז אני נאבק ל פורמט שצריך.
הסוגר זה צריך להיות נעלם.
זה צריך להיות כאן למטה.
זה מה שהוא בך ללולאה.
יש.
עכשיו זה די.
אז ככה זה צריך be-- חוץ שלסוגר האחרון שפטרתי.
אישור.
האם זה הגיוני לכולם?
אישור.
אנחנו הולכים לעבור לדבר הבא then--
אשר, למעשה, שאתה הולך לצריך לראות את הקוד.
אז אני פשוט הולך להעתיק שמעל עכשיו.
אישור.
אז אני הולך להראות לכם את הקוד הזה.
ואני רוצה שתנסה ודמות את מה שהיא אמורה לעשות.
>> אז נתן that-- לקחת דקה או כך.
נסה להבין מה קורה כאן.
>> יש לך רעיונות?
>> אנחנו יודעים שיש לנו לפחות שני טיעונים בשורת הפקודה, נכון?
אני מניח שאחד מהם הולך להיות ש[ לא ברור] של התכנית שלנו היא
ואז משהו אחר.
כי אם [לא ברור] הוא פחות משני, שצועקים עליהם.
נכון?
ומן השימוש, זה נראה כמו זה הולך להיות סוג של קובץ.
כולנו מסכימים לזה?
אז עכשיו, מה הלולאה עושה?
מה זה עובר?
>> קהל: כל הקבצים.
1 SPEAKER: בדיוק.
זה עובר את כל קבצים שיש לנו קלט יש.
אז עבור כל קובץ, זה פתיחה כמה מחרוזת שם.
הוא נפתח קובץ ש.
נכון?
וזה לקרוא ממנו.
כמובן, לבדוק אם זה null.
ואז הוא מדפיס.
אם זה null, זה פשוט אומר לנו כי זה לא שקובץ קיים.
כי תזכור, עם לקרוא הקבצים שלנו צריך להתקיים.
נכון?
עם כתיבה וצרף, אתה יכול לצאת מזה.
אבל עם קריאה, הקובץ שלנו צריך להתקיים.
>> ולאחר מכן אם הוא קיים, מה אנחנו עושים כאן?
בואו נתחיל כאן.
מה זה do-- תו ראשון זה.
מה זה עושה?
הוא מקבל תו אחד, נכון?
אז מה הוא עושה את זה?
זה מתחיל להיות התו הראשון.
מישהו יודע EOF?
>> קהל: סופו של קובץ?
>> SPEAKER 1: סוף file-- בדיוק.
כך שזה הולך לעבור את הקובץ כולו, נכון?
ואז זה הולך לעדכן על ידי מקבל כל תו שלאחר מכן.
נכון?
ומה הוא עושה?
קהל: לשים שin--
>> 1 SPEAKER: הדפסי Putchar לשומר המסך שלך.
[לא ברור] האופי.
ואז כשזה [לא ברור] זה יהיה לסגור את התיק.
>> קהל: האם אתה לא צריך [? ? אחר ?]
>> 1 SPEAKER: לא בהכרח.
אני מתכוון, זה משתמע סוג של בזה.
בגלל זה אף חוזר,, כל עוד כזה לא תופס את זה, אתה בסדר.
אני מתכוון שזה כנראה טוב להתאמן כדי לעשות אחר.
אבל דבר אחר הוא לא תמיד נחוץ במיוחד
אם יש לך משהו כמו שיבה, ש
משמעות הדבר היא כי במקרה זה, אם זה תופס זה, התכנית שלך הולכת להיגמר
וזה אף פעם לא יגיע לזה.
זה יותר למקרה שבו אתה לא בהכרח חוזר משהו.
כי אם זה לא היה חוזר כל דבר,
זה אומר שאם זה היה נכון, שאר זה עדיין ירוץ.
ובמקרה כזה, אתה היה רוצה שווא.
אם זה חוזר, ו הסיום של התכנית שלך,
אחר אין צורך בכל הזמן, תלוי בהקשר.
יעקב, שיש לך שאלה?
קהל: כן.
כך גם fgetc לקבל את התו הבא?
איך האופי אין להגדיל?
1 SPEAKER: כן.
אז fgetc מקבל את התו הבא.
אתה יכול לחשוב על זה כמו C ++ במובן מסוים.
>> קהל: אז מה היה EOF?
>> 1 SPEAKER: EOF זה סופו של קובץ.
זה רק סמן שמאפשר לך לדעת כי אתה בסופו של הקובץ שלך.
אז זה הולך להדפיס לפלט הסטנדרטי שלך.
ואז זה הולך לסגור הקובץ כאשר זה נעשה.
ואז בואו נלך ל הקובץ הבא, נכון?
כך שבסך הכול, מה התכנית הזאת עושה?
>> [לא ברור]
>> 1 SPEAKER: כן.
זה פשוט מדפיס את כל מה שיש.
אז CAT אם אי פעם בחורים השתמשו ולאחר מכן את השם של חלק file--
אני לא יודע אם מישהו מכם יש לי אי פעם עשה את זה על המסוף שלך.
אבל אם אי פעם להשתמש ב פקודת CAT-- C-A-T--
ולאחר מכן כל מה שקובץ יש לך there-- זה
מדפיס את זה למסוף שלך, ש יכול להיות סופר שימושי לכמה דברים.
אני משתמש בו הרבה.
האם זה הגיוני לכולם?
מגניב?
>> אישור אז המשימה שלך now-- או על ידי בעצמך או עם האנשים סביב you--
רק כדי לכתוב תכנית פשוטה שפשוט יכתוב "שלום, עולם!"
לקובץ.
>> [לא ברור]
>> 1 SPEAKER: הייתי כמו, עשה אני עושה את זה בשבוע שקשה שעבר?
אני לא חושב שזה היה כל כך נורא.
אני שמח שאתה כאן.
זה באמת גורם לי אושר.
אני בחורה של הנאות פשוטות.
אני פשוט אוהב כאשר הסעיף שלי לומד.
אז אני פשוט מקבל את זה התחיל ל אתם כל כך שאנחנו יכולים קוד ביחד.
אני לא אוהב לשים מישהו ב המקום אלא אם כן אתה רוצה להיות.
>> קהל: לחידון, לעשות יש לנו לכתוב תכנית?
>> 1 SPEAKER: ייתכן שתתבקש ל לכתוב תוכניות פשוטות ביד.
כן.
>> קהל: החידון הוא בשבוע הבא, נכון?
>> 1 SPEAKER: החידון הוא ביום רביעי הבא.
זה אומר שיש [יפה? מנוע חיפוש מותאם אישית?] דירוג מסיבה שלאחר מכן, ש
כלומר, תקבל את הניקוד שלך בחזרה שnight-- באיזו שעה?
מי יודע?
אבל זה יהיה באותו הלילה.
>> בְּסֵדֶר.
איך אנחנו רוצים להתחיל את זה?
אני אתן לך מתחיל hint-- עם זה.
>> קהל: אתה צריך לפתוח את קובץ.
>> 1 SPEAKER: כן.
אז מה אתה רוצה לקרוא לזה?
האם אתה רק רוצה לקרוא לזה "קובץ"?
בואו נעשה את זה קל.
אז fopen-- מה מבחן תפוקה הולך להיות?
קורא לזה "שלום".
ומה המצב שלנו?
מה שאנחנו עושים בקובץ זה?
>> קהל: קרא.
כתיבה.
1 SPEAKER: אנו כותבים אליו.
יפה.
אוקיי, אז יש לנו את הקובץ עכשיו.
מה אנחנו צריכים לעשות?
קהל: בדוק אם זה null.
1 SPEAKER: בדוק אם זה null-- בדיוק.
זה מה שאני רוצה לשמוע.
זה צריך להיות אוטומטי, במיוחד פחות או יותר מנקודה זו והלאה.
אם אתה מתחיל segfaulting, אתה כנראה לא בדקתי לnull איפשהו.
תשע פעמים מתוך עשר, זה הולך להיות השגיאה שלך.
אז אם אתה יכול פשוט לקבל ב הרגל, תמיד לבדוק אם זה null,
החיים שלך הולך להיות נחמד וeasy-- או קל יותר.
>> אז לבדוק כדי לראות אם זה null.
אז אם זה לא ריק, ש מה שווה את התמורה
means-- לא null-- זה תקף.
מה אנחנו רוצים לעשות?
אנחנו רק רוצים להדפיס בקובץ זה, נכון?
אז מה אנחנו הולכים להשתמש?
>> קהל: fprintf
>> SPEAKER 1: יפה Fprintf--.
וfprintf לוקחת שתי arguments-- בי זה הולך ומה אנחנו רוצים להדפיס.
אז מה, לא?
איפה זה הולך?
>> קהל: קובץ.
>> 1 SPEAKER: זה הולך להגיש.
ומה אנחנו רוצים מודפסים?
"שלום, עולם!"
בְּסֵדֶר.
יש לנו thing-- האחרון עוד הפרדיגמה גדולה כאן.
קהל: לסגור.
SPEAKER 1: סגור.
הנה לך.
>> קהל: האם זה קורה אם הקובץ הוא null?
1 דובר: לא, זה אם זה לא ריק.
קהל: אה, אם זה not-- אישור.
לfopen ולאחר מכן שני טיעונים שייכנסו פנימה,
מה הטענה הראשונה אומרת שוב?
>> SPEAKER 1: הטענה היא בדיוק כמו השם של הקובץ
שאתה רוצה ללכת ל.
אז אחרי זה פועל, שהיית יש לי כמה קבצים בשם "שלום"
ש" שלום, עולם "בתוכו.
זה כל מה ש.
רק שם.
>> קהל: ומכיוון שזה כתיבה, קובץ לא צריך כבר קיים.
האם זה מה שאמר?
>> 1 SPEAKER: נכון.
בדיוק.
אם "שלום" כקובץ לא קיים עדיין, זה
הולך ליצור קובץ בשם שלום "ולכתוב את זה בשבילך.
>> קהל: כאשר אתה אומר לי התכנית לכתבה לקובץ,
למה אתה כותב "קובץ" במקום את שמו של הקובץ וfprintf--
>> 1 SPEAKER: כי במקרה הזה, יש לנו שFILE-- הגדול כל בכוכב caps--,
להגיש.
אז זה מצביע לקובץ על זה אתה מדבר.
זוהי הדרך ש רק אנו מתייחסים אליו.
אז במקרה הזה, אתה יכול לחשוב על אהה file--,
אנו יכולים להשתמש בזה-- קובץ כאן מתייחס לפתיחה של "שלום"
ולתת לה לכתוב.
>> קהל: האם אנו יכולים לשים את "שלום" במקום [? רק? קובץ] f?
1 דובר: לא, כי "שלום" צריך להיות פתוח וניתן לכתיבה.
קובץ כאן הוא כמו ציין שאומר בסדר, אנחנו
יש לי hello-- file-- זה שאנחנו מסתכלים.
זה כבר נפתח.
ואנחנו הולכים לכתוב את זה.
אם אתה פשוט להשתמש "שלום", שמגולם בזה.
אז זה הולך להתחרפן.
אני מתכוון, אתה יכולת לקרוא לזה.
אתה יכול לעשות את הקובץ, כוכב, "הלו", שווה לזה.
אבל כל העניין הוא שאתה צריך מצביע כוכב קובץ על מנת
כדי להיות מסוגל להשתמש בפונקציות אלה.
קהל: אתה יכול לעשות קובץ, כוכב, קובץ, "הלו"
או שאתה צריך לשים את קובץ כוכב, קובץ על-ידי אותו?
SPEAKER 1: אתה יכול לעשות קובץ, כוכב, "הלו".
אתה יכול לשנות את זה ל כל שם שאתה רוצה.
זה שרירותי לחלוטין מה השם שהוא.
אתה יכול שם זה שום דבר.
שם זה עף ספגטי, אם אתה רוצה.
>> קהל: מהו "w" בציטוטים?
>> 1 דובר: "w" הוא פשוט המצב.
אז אנחנו כותבים בקובץ זה.
כולם טובים?
ברור?
כן.
>> קהל: אז כשזה כותב את זה קובץ, שבו אנחנו לאחר מכן מוצאים את הקובץ הזה?
>> 1 SPEAKER: זה יהיה באותו ספרייה שבה אתם נמצאים.
אם אתה בpset שלוש ו אתה מפעיל את זה, בתוך pset שלך
שלוש תיקייה הוא הולכת להיות הקובץ הזה שנקרא "שלום".
מגניב?
כולם טובים?
אני מרגיש כמו כולכם מקבל את זה, וזה נהדר.
אישור.
אז בחזרה לshow-- השקופיות שלי אני אוהב כאשר דברים עובדים.
אישור, pointers-- האם אתם מתרגשים?
מצביעים הם גדולים.
הם לוקחים קצת לעטוף את הראש סביב.
זו השנה השנייה שלי מצביעי הוראה.
ואני חושב שסוף סוף יש לי את זה.
אז אם אתה במאבק, שזה בסדר.
כפי שאמרתי קודם, ציור תמונות עוזר הרבה עם דברים בCS,
כמה שאני חושב שאנשים נוטים לחשוב הו, אנחנו במחשב.
אנחנו צריכים פשוט קוד.
תמונות ציור No-- יהיה באמת לעזור לך.
ואני באמת ממליץ לך להתחבר לצד הילד בגן שלך
ולהביא את העפרונות או סמנים ותיקו.
כי זה יעזור לך.
ואם אתה רואה אותי בשעתי עבודה, אני יהיה נושא סביב ערימות של נייר
עם עטי ציור את הדברים.
>> אז במיוחד עם pointers-- לצייר תמונות.
ואני בטוח שאנחנו באמת הולכים ל להיות ציור כמה תמונות גם כאן.
>> אז אתם כל זכיתם לראות בינקי, דבר claymation מגניב.
ואנחנו חושבים שזה ממש מצחיק כש הוא מתפוצץ לתוך חבורה של חתיכות.
זה קצת אתנחתא קומית לכיתה.
[לא ברור] היכולת הגדולה הזה C להיות מסוגל לשלוט בזיכרון.
וזה אחד הדברים שבאמת עושה את זה בשפה כזו חזקה.
אבל עם כוח גדול מגיע אחריות גדולה.
ודברים מטורפים יכולים לקרות אם אתה לא זהיר.
לכן, כאשר אתה משתמש ב מצביעים, אתה רוצה לעשות
בטוח שאתה באמת מבין בדיוק מה שאתה עושה.
אני מקווה שקצת הבא של הזמן יעזור לך להבין באמת
מצביעים, כיצד להשתמש בם, וכיצד לתפעל אותם.
>> אז memory-- אני בטוח שיש לנו ראה תרשים זה לפני.
כך שזה רק תרשים פשוט של איך דברים יכולים להיות מאוחסנים בזיכרון.
אז בעצם יש לך אלה במערכים אדירים של לוקים בייט אחד
זה מה שיש לנו here-- קל תוספות שאחד בכל פעם.
זה בhex [לא ברור] כך שמונה סיביות בלוקים.
וכל בלוק קשור עם כמה כתובת הקסדצימלי.
אז אם אי פעם תראה את 0x, שפשוט notating
שזה כתובת הקסדצימלי.
אתה יכול להניח שזה אומר כמה כתובת בזיכרון.
על כתובות זיכרון אנחנו מדברים בכל פעם שאתה רואה הקסדצימלי.
>> יש לנו ints משתנה, צף הם משתנים שמאחסנים.
אז ints חנות ints.
חנות צף צף.
אז יש לנו גם מצביעים שכתובות זיכרון חנות.
זה סוג של מיפוי.
מצביעים הם באופן בלעדי לכתובות זיכרון.
אז זה כמו הסוג שלך יש.
המכשיר שלכם הוא 32 סיביות, מה שאומר ש שכתובת הזיכרון שלך היא ארבעה בתים.
אז כל מצביע שיש לך גם הוא הולך להיות ארבעה בתים.
או שמא אם זה ארבעה בתים, זיכרון הוא ארבעה בתים.
זיכרון חנות מצביעים.
לכן, הם ארבעה בתים.
Cool-- רק רוצה לחזק את זה.
>> אתה צריך לקבל קומיקס זה עכשיו.
אני לא יודע כמה מכם הם אוהדי xkcd, אבל אני אוהב את xkcd.
זה נהדר.
>> בְּסֵדֶר.
אז יצירת pointers-- כמו שאמרתי, זה פחות או יותר בדיוק כמו כל דבר אחר.
יש לך סוג.
יש לך שם.
נכון?
זה מה שיש לנו שם. [? Hex?] כוכב אומר שזה מצביע,
ואז מה שאתה רוצה לקרוא לזה.
אז הסוג מייצג מה שאתה יכול לאחסן.
בסדר?
באותו אופן שאם אנחנו עושים ints, אנחנו יודעים שאנחנו אחסון int יש.
עם מצביע, זה מחזיק כתובת זיכרון.
אבל מה זה אומר הוא that-- הנה שבי ציור הולך להיות שימושי.
אז במקרה הזה, יש לנו כמה value-- נניח ארבעה.
ארבעה הוא בכתובת אחת.
בסדר?
>> ראשון זה כאן פירושו שזה 2x מצביע.
נכון?
זה כמה x מצביע.
x יכול להיות משהו, לא משנה מה.
לא משנה מה x is-- אומר x הוא ארבעה.
זה הולך לאחסון כתובת זיכרון כאן.
אז int, כוכב, x-- זה כמה חריץ אחר בmemory--
מי יודע מה זה.
אבל זה הולך לאחסון כתובת כאן.
אז זה יהיה like-- במקרה זה, לא משנה מה,
מאוחסן ב0x1-- מה מאוחסן בכתובת שהמצביע שלנו מחזיק,
יש להתאים את עם מה שמיועד.
אז ב0x1, במקרה הזה, זה הוא x.
זה רק יכול אי פעם להיות int בזמן שאנחנו משתמשים בזה.
>> באופן דומה, אם יש לנו 1Y אחר, כל מה ש
כתובת מאוחסנת עם y יש להיות אותו דבר char-- עם z.
באותו אופן, כל פעם שאתה לנסות ולעשות intx שווה 0.4,
זה הולך לצעוק עליך ולהיות אין כמו, אתה אמר שאתה רוצה int.
זה אמור להיות int.
תפסיק לנסות להפוך אותו לצוף.
>> אז לתת לדברים להיות מה שהם רוצים להיות.
לתת לדברים להיות הם עצמם.
אז דבר גדול הוא רק כל סוג של מצביע
זה, זה רק דבר שאתה יכול לאחסן שם.
בסדר?
בעזרת תרגול, כמו ב בשבוע שעבר, כל מה ש
נראה באמת סוג של המופשט.
אנחנו הולכים לעשות קצת תרגול.
זה צריך יותר הגיוני.
>> אז התייחסות וdereferencing-- זה באמת חשוב להגיע ישר אלה.
אני עדיין צריך לרענן מדי פעם.
ואני כמו המתנה, אשר אחד אני רוצה?
אז האמפרסנד בעצם ייתן לי אתה ההתייחסות או הכתובת של.
אז זה מחזיר את הכתובת ב לזכרו של אשר משתנה מאוחסן.
אז זה הולך ממש לחזור אליכם הקסדצימלי, ואילו ביטול התייחסותו
הולך בעצם לתת לך נתונים שמאוחסנים שם.
בסדר?
אז אנחנו הולכים להסתכל על דוגמא ממש מהר, או בעצם ליד.
>> אישור.
אז אנחנו צריכים לחשוב באמת בזהירות על זה.
אז הנה יש לנו כמה x מספר שלם.
אני הולך לנסות ולצייר את זה למיטב היכולות שלי.
אז אנחנו הולכים להיות x חריץ זה.
וזה אחסון חמישה.
הכתובת שלו היא 0x4.
מגניב?
כל טוב.
>> אז עכשיו יש לנו מצביע זה.
זה נגמר כאן.
והאמפרסנד נותן לנו הכתובת של משהו.
אז, במקרה זה, זה את הכתובת של x.
מהי הכתובת של x?
04-- ומצביע זה הוא ב0x08.
מגניב?
כך שאתה יכול לחשוב על זה המצביע, 04, רק מצביע לכאן.
והם נקראים מצביעים כי כפי שאנו מקבלים יותר לתוך זה,
אתה הולך לראות מצביע על דברים.
ובלוק אחד מצביע על עוד בלוק יעשה הרבה יותר הגיוני.
אז הנה שתי.
ולאחר מכן יש לנו כמה עותק, שהוא 0x0c what--.
וזה הולך dereference המצביע שלנו.
>> אז מה זה אומר הוא קיי, אז הנה המצביע שלנו.
הערך זה מאחסן הוא 0x04, ומה זה אומר שיגיע לכתובת זו
ותגיד לי מה יש בו.
אז זה ביעילות מה הלחץ הזה עושה.
אתה יכול לחשוב על זה כמו הכוכב שלך.
אז או קיי, כאשר אנו עושים כוכב, זה אומר מעקב.
תגיע לכתובת זו.
וזה בעצם רק הבא החץ הזה לנתח זיכרון זה.
ולתת לנו מה יש בו, שהוא 5.
זה למה העותק שלנו שווה ל 5.
האם זה הגיוני?
האם מישהו צריך אותי כדי לעבור כי שוב, או לאט יותר?
אתה רוצה שאני אלך דרכו עוד פעם אחת?
אישור.
אנחנו הולכים לצייר מחדש את זה שוב.
כאשר אנחנו מתחילים, כולנו מסכימים שיש לנו כמה נתח של זיכרון זה משתנה
x שהצבנו שווה ל 5.
אין לנו שליטה בו בזיכרון.
אז במקום זה הוא פשוט באופן שרירותי שהוקצה.
טוב שיש?
אישור.
אז לאתחל מצביע לint.
זו הסיבה שמותר לו להצביע על x כי יש לנו int כאן.
יש לנו עוד נתח מ זיכרון כי מצביע זה
הוא משתנה בדיוק כמו כל דבר אחר.
זה נקבע באופן שרירותי כמה מקום בזיכרון.
ומה הוא מאחסן היא הכתובת של x.
אמפרסנד אומר כתובת של x.
אז מה היא הכתובת של x?
>> קהל: זה zero--
1 SPEAKER: 0x04.
אז then-- אחרון.
יש לנו כמה copy-- שוב רק עוד משתנה.
אז בואו להקצות מקום שרירותי.
ואנחנו dereference המצביע שלנו.
כוכב פירושו ללכת ל כתובת מאוחסנת במצביע שלי.
תגיד לי מה יש שם.
אז אחסנה את הכתובת במצביע שלנו הוא 0x04.
אז אנחנו הולכים לכתובת זו.
זה מצביע לכתובת זו.
מה יש בפנים בלוק הזיכרון הזה?
זה חמש.
אז זה מה שאנו מקצים העותק שלנו.
כולם טובים?
מגניב.
תמונות Again--.
>> אז מעקב הערכים here-- אני הולך לתת לכם לחשוב על זה.
אנחנו יכולים לצייר תמונה אחרת.
אבל אני רוצה שתנסה וסיבה דרך זה בעצמך לרגע.
>> מאז הם לא נתנו לי שלנו כתובת לדוגמה,
אני רק הולך לעשות x-- אמפרסנד שאמור לעזור להסיע אותו הביתה.
אמפרסנד משמעות כתובת.
>> אז בראשון, כולם ללכת עם הקו הראשון.
של five-- כמה סט x חלק חריץ אקראי בזיכרון.
מצביע כוכב Int שווה לכתובתו של x, נכון?
מצביע כוכב Int יוצר הבלוק הזה, קורא לזה מצביע,
ומקצה אותו לכתובת של x.
אני נורא בסימן חיבור.
>> עכשיו מה שאנחנו עושים הוא שאנחנו אומרים אישור, dereference המצביע שלנו.
אז אנחנו הולכים על אישור, מה במצביע שלנו?
זה x אמפרסנד.
עבור לx אמפרסנד ולהקצות מחדש אותו.
>> אז עכשיו, x האמפרסנד הולך להיות 35.
אז בעצם, כשאתה ביטול ההפניה למבנה, שאתה הולך על אישור.
אתה הולך להיות ציור תמונות כמו זו.
אתה הולך להיות ציור החצים שלך על איפה זה.
אז ללכת לחריץ זה בזיכרון וגם תן לי את זה בחזרה ערך, או לשנות אותו.
במקרה זה, כי אנחנו בשעה זו ערך, שאנחנו מקצים את זה כדי להיות 35.
בעוד שבעבר אחד, אם אתה שם לב, אנחנו
היו הקצאה מה היה כאן למשהו אחר.
>> אז יש להם השולחן מדהים הזה.
זה לא שרע.
אתם עובדים על זה.
אני הולך לצייר את זה על הלוח.
אנחנו הולכים למלא אותו יחד, בסדר?
אז לתפוס את נייר, לתפוס כמה שותף, להתחיל לעבוד.
אני הולך לקבל חתיכה גדולה של גיר.
כי זה הולך להיות הרבה.
אישור.
פרופסור: אישור.
בואו נתחיל עם השורה הראשונה.
נתחיל שם, אז אתם אולי יכול לעבוד דרך כמה יותר.
אישור.
שווה פעמים ב ג אז מה הוא?
זה לא שאלה מכשילה, אני מבטיח.
>> תלמיד: 4 פעמים 5.
>> פרופסור: 4 פעמים 5.
20.
אז מה ב?
תלמיד: 4.
>> פרופסור: ו- C?
תלמיד: 5.
פרופסור: 5.
ואז זה רק הולך להיות אמפרסנד, ב אמפרסנד,
אמפרסנד ג, נכון?
לא רע.
זה די פשוט.
אישור.
אז הבא.
שווה פעמים ג, במקרה אף אחד לא הכיר את זה.
האם כולם מכירים עם הזמן שווה?
אישור, כל זה means-- זה קיצור לשווה פעמים ג.
גם אתה יכול לעשות את זה עם החלוקה, עם תוספת, עם חיסור.
אתה יכול לעשות את שווים, או בתוספת שווה ג משמעות הדבר היא שווה ג תוספת, מינוס שווה
ג יהיה שווה ג מינוס.
זה רק סוכר תחבירי.
>> אז, במקרה זה, שווה ל פעמים ג ייתן לנו מה?
שוב, לא שאלה מכשילה.
>> תלמיד: 100.
>> פרופסור: 100.
האם כל דבר אחר לשנות?
מס '
אולי אני סוף סוף אקבל טוב יותר בסימן החיבור שלי.
>> תלמיד: אוקיי, מצטער, איך אתה מקבל 100?
פרופסור: אישור.
אז שווה ל פעמים ג, כה פעמים ג.
תלמיד: אה, אתה משתמש ב לprevious--
פרופסור: כן.
אז אלה הם ערכינו העדכנית ביותר.
אלה הם מה שאתה צריך להיות באמצעותה אנו מעבירים את, אישור.
אז, ב הוא שינוי הדבר היחיד, נכון?
אז בואו למלא בכל דבר אחר.
ב 'מה ב הולך להיות?
להיות או לא להיות.
אז מה הוא עושה את זה?
מה הוא כוכב הרשות הפלסטינית עושה?
>> תלמיד: קוד למיקום של הרשות הפלסטינית.
>> סטודנט: לא, לא ממש.
אז זה התייחסות ד.
>> תלמיד: אז b הוא ערך בידיים של הרשות הפלסטינית.
>> פרופסור: כן, אז רשות פלסטינית הכתובת של, נכון?
אז זה אומר ללכת למקום שבו מאוחסן ולתת לו ערך ש.
אז מה הוא ב?
תלמיד: 100.
פרופסור: 100.
מושלם.
אוקיי, אז המחשב הוא מה שמשנה.
כל השאר נשאר אותו הדבר.
מה מחשב הולך להיות?
משימה פשוטה.
המחשב שווה לרשות פלסטינית, ומה היא הרשות הפלסטינית?
>> תלמיד: אמפרסנד.
פרופסור: מושלם.
עכשיו אנחנו מתחיל להיות מעניינים.
אישור, בואו לשבור את זה למטה.
ראשית, מה פעמים ב ג, כי זה החלק קל של זה, נכון?
B פעמים ג is--
>> תלמיד: 500.
>> פרופסור: כן, כל כך מה זה עושה,
אם שלו PB הכוכב, מה משתנה?
>> תלמיד: מה בthe--
פרופסור: מה בב?
תלמיד: מה בחלל PB שמצביע.
פרופסור: וPB מצביע to--
תלמיד: ב '
פרופסור: ב 'אז רק שינוי דבר הוא ב, נכון.
ג אז ב פעמים, 500.
אז זה מה שמשנה עכשיו.
מגניב.
יפה.
אתם עושים נהדרים.
בסדר, פירוק הזה.
C משתנה, נכון?
כדי שנוכל למלא בכל דבר אחר.
בואו נראה.
אישור.
אנחנו יודעים שג הולך להיות מכפלה של שני מספרים, נכון?
מה שני מספרים, אם כי?
>> תלמיד: וג?
>> פרופסור: אז הוא נכון עבור הראשון.
אז אנחנו ד התייחסות p של, נכון?
P של נקודות ל, כך שאנחנו יודעים ש זה הולך להיות 100 פעמים מה?
פעמים מה עושה נקודת מחשב ל?
מצביע.
אז 100 פעמים 100 הוא 10,000.
האם זה הגיוני?
מגניב.
למתוח את הבית, בחורים, השורה האחרונה.
אישור.
מה השתנה כאן?
>> תלמיד: א
פרופסור: א מושלם, כל כך כל דבר אחר יכול להישאר אותו הדבר.
אישור.
ומה הוא?
אז זה פעמים מה?
זה PB כוכב.
אז PB כוכב פירושו הנה PB, נקודות PB ל b.
>> תלמיד: 500.
>> פרופסור: 500.
אז יש לנו פי 500 100.
זה 50,000.
אוף!
תראה את זה.
>> תלמיד: למה יש לנו וג לlast--
פרופסור: מצטער.
תלמיד: אה, בסדר.
פרופסור: רע שלי.
הרבה כתיבה.
כולם טובים?
לא רע, נכון?
פשוט לוקח קצת זמן לעבוד דרך.
אם אתה תשבור אותו, להבין מה כל חלק
מתייחס to-- כ עם כל מה שזה,
yes-- לפרק אותו למעט בעיות ולאחר מכן לשלב מחדש,
ואתה יכול לעשות כמה דברים מדהים.
יש תשובות, אבל עשו את זה.
פעולות אריתמטיות על מצביעים.
אה.
הידיים שלי הן כל גירי.
אז הוספה או הפחתה int מתאים את המצביע
על ידי הגודל של הסוג של מצביע.
זוכר איך כל סוג יש בגדלים שונים?
אז כמו כפול או ארוך ארוך שמונה וint הוא ארבעה אבל char הוא אחד.
>> אז מה שאתה רוצה לעשות is-- דבר אחד לזכור
כי הוא פשוט כמה ערך מצביע משנה למעשה
יהיה תלוי ב סוג של מצביע זה הוא.
כולם טובים עם זה?
האם אני יכול למחוק אותו?
אנחנו טובים?
מדהים.
>> אז אם יש לנו כמה מצביע that-- זה הולך be-- אני
הולך לעשות את זה מצביע int.
הוא מאחסן את זה.
אם היית אומר מצביע ועוד אחד, מה זה הולך לעשות
הוא זה הולך לעדכן זה על ידי הגודל של int
כי זה סוג של מצביע זה הוא.
>> עם C, כל מה שהוא מאוד קפדן ומוסדר.
מצביע int הולך לעדכן על ידי כמות השטח int היה לוקח.
Int הוא ארבעה בתים.
>> אז מה זה היה הופך ל?
אתה פשוט מוסיף ארבעה על זה.
עכשיו המצביע היה be-- אישור.
>> אז אם זה היה char ועשינו מצביע ועוד אחד, מה זה היה עכשיו?
אם זה started-- מעמיד פנים שאנחנו started-- עכשיו זה 0x08.
בואו עכשיו אומרים שזה היה char מצביע, והוספנו אחד.
מה זה משנה ל?
כמה בתים הוא char?
>> קהל: אחת.
>> 1 SPEAKER: אחת.
קהל: אז 0x09.
1 SPEAKER: אז זה יהיה תשע.
אז רק משהו לזכור.
רק כאשר אתה מוסיף אחד, זה לא הוספה אחד אלא אם כן זה char.
זה מוסיף כמה ביטי הסוג שהוא,
וזו הסיבה שיש לנו משוואה זו כאן.
אז זה הפעמים int הגודל מהסוג של מצביע.
>> אז יש לנו הדוגמא כאן.
y הוטל על שערך, 0x4, כשעשינו Y ועוד שווה לאחד.
מה יש בו, מה ש בx, לא משנה.
מה עושה שינוי הוא מה שהוא בy.
כתובת מאוחסנת בy מעודכן על ידי ארבעה כי יש ארבעה בתים בint
וזה מצביע int.
>> בְּסֵדֶר.
אז עכשיו יש לנו עוד תרגיל.
אז השאלה היא מה יהיה להדפיס.
יש לך רעיונות?
>> קהל: מספר דמויות בחתול מאושר?
1 SPEAKER: בדיוק.
אז כמו בחוט שלך.
האם כולם מקבלים את זה?
האם אנחנו רוצים ללכת בו?
>> כן, בסדר.
אז מה יש לנו here-- אני כמו זה כל כך הרבה יותר.
אין לי ל [לא ברור] עד כדי גיחוך.
>> אז יש לנו המחרוזת שלנו כאן, חתול מאושר.
יפה.
יש לנו כמה דלפק ש אנחנו עוקבים אחרי.
אז יש לנו כמה מצביע char * כי רק מוגדר שווה לStr.
מה זה עושה הוא זה הקצאת חלק מצביע
לתחילת המחרוזת שלך.
כי אני בטוח, כפי ש הוזכר בהרצאה,
אנחנו נותנים לך בחורים זה טיפוס בשם מחרוזת.
>> אבל באמת בחוטים הם רק מערך ל-- כמו char *.
זה מצביע לחבורה של דמויות כי הם רציפים בזיכרון.
אז זה רק מגדיר את זה שווה לכל מחרוזת היא
זוהה על ידי שבו התו הראשון שלה הוא.
אז זה רק הגדרת שלב מסוים שווה לתחילת המחרוזת.
כולם טוב שם?
מגניב.
>> אז זה הוא ביטול התייחסות המצביע שלנו.
אז זה באמת הולך תן לנו קצת ערך לכאן,
במחרוזת שלנו שאנחנו מדברים.
ואנחנו אומרים כל זמן ש זה לא שליחות קטלנית null.
אז להמשיך עד שאתה מקבל לסוף המחרוזת.
עדכון המצביע שלך על ידי אחד.
אז r, זה יהיה ממש לעדכן על ידי אחד בכל פעם, כי זה char,
* char.
>> כך שזה הולך לעבור.
זה הולך לעדכן.
אז בפעם הראשונה זה פועל, זה הולך להיות כאן בשעות.
זה הולך לעדכן.
>> זה יהיה.
זה יהיה p, y, וכן הלאה וכן הלאה.
אנו נעדכן את הדלפק.
כאשר הוא מגיע לסוף, זה רק מדפיס כמה רחוק זה הגיע.
כן.
>> קהל: אז הוא מביא בחשבון החלל כאחד, נכון?
אישור.
>> 1 SPEAKER: חושב כך.
האם זה question--
>> קהל: [לא ברור].
>> 1 SPEAKER: אין בעיה.
אני זה לעשות את זה.
טוב, אז הדבר אחד ש להבין שעם מערך הוא,
גם אתה יכול להתייחס אליו כ מצביע כי מערכים הם רק
נקודות רצופות של זיכרון.
>> כך שאתה יכול להתייחס אליו באותה הצורה.
אתה יכול לתפעל אותם עם מצביעים, מדי.
כך, במקום, בזה מקרה, הדבר מקביל
יהיה מערך 0 שווה 1.
>> אבל באותו אופן שבי מחרוזת נקבעה
עד תחילת שבי התו הראשון שלו הוא,
מערך נקבע על ידי שבו האלמנט הראשון שלה הוא.
בגלל שאנחנו יודעים, אנחנו ביותר, כי אלה
הולכים להיות רציף בלוקים של זיכרון.
זה מה שמאפשר לנו לעשות את זה.
אנחנו יודעים שהם רציפים בלוקים של זיכרון.
>> אז במקרה הזה, על ידי ביטול התייחסות רק מערך, שאומר לנו,
אישור, ללכת לתחילת המערך שלך, שהוא כאן.
אז אתה יכול להגדיר את זה שווה לאחד.
ובמקרה הזה, כל מה שהמערך שלך הסוג הוא, כאשר אתה מעדכן אותו על ידי אחד,
זה בדיוק כמו עדכון שלו לאינדקס הבא.
אתה יכול לעשות את זה בגלל שאתה יודע מה יש במערך שלך.
אז הוא יודע כמה ל לעדכן את המצביע שלך על ידי,
מה כתובת כדי לעדכן אותו לכך כי אתה בחריץ הבא.
>> כך שזה רק צורה שונה כתיבת מערך 0 שווה 1,
מערך 1 שווה 2, מערך תושבת 2 שווה 3.
זאת פשוט דרך נוספת לחשוב על זה.
כי הם רציפים בלוקים בזיכרון,
אתה יכול להתייחס אליהם או על ידי המערך notation--
שאני באופן אישי למצוא easier-- אבל אולי
אתה צריך לתפעל אותו בקפדנות על ידי כתובות זיכרון.
וזו הדרך שאתה הייתי עושה את זה.
סוג של יותר כמו דבר מגניב שאתה יכול לעשות
לעומת אולי לא משהו שאתה הולך לממש בפועל.
>> אני משתמש בו ב -61.
אתם כנראה לא צריכים לדאוג בקשר לזה יותר מדי.
אבל אם אתה מעוניין, לקחת 61 בשנה הבאה.
אנחנו בבחורים למתוח את הבית.
אני יודע, זה ארוך.
הזיכרון דינמי Allocation-- כך אנו יודעים כי אחד
דברים כאשר דברנו ב הסעיף הראשון שלנו יחד,
הסתכלנו החלפה פונקציה שבה היה
מחוץ להיקף תפקידו העיקרי שלנו.
ואנחנו עוברים בערכים אלה שהיו יעיל עותקים.
>> וברגע שההחלפה סיים ביצוע, זה פשוט השאיר את ערימה.
זכרו, יש לנו מחסנית מסגרת להחלפה.
זה משאיר את ואלה ערכים לעזוב איתו.
והם נעלמו.
אנחנו לא יכולים לעשות שום דבר איתם ואנחנו היינו עצובים
כי אנחנו לא יכולים להחליף את הערכים שלנו.
>> אבל עם C, כפי שציינתי, אתה יש להם הרבה כוח על זיכרון.
אז מה שאתה יכול לעשות הוא שאתה יכול להקצות דברים על הערימה כאן
שיישאר שם עד אתה אומר להם אחרת.
>> הם כמו ילדים טובים.
הם שוהים שם.
הם לא משאירים.
הם יישארו שם עד שאתה כמו, בסדר, אתה יכול ללכת משם.
>> ואילו דברים על הערימה, who-- הם כמו ילדים שובבים.
הם פשוט יברחו כאשר אתה רוצה להיות שם ואז הם נעלמים.
אתה לא יכול לקבל אותם בחזרה.
>> אז הערימה is-- אנחנו הולכים לדבר על malloc וחופשי, ש
אני בטוח שאתם שמע על בהרצאה.
וזה בעצם דרך יש נתונים מאוד עקשנים.
אז אתה יכול לשמור את הנתונים בסביבה כמה שאתה רוצה.
מהמ.
>> קהל: אתה יכול להגדיר ערימה ומחסנית?
האם הם אוהבים מקומות לשים את הדברים?
>> 1 SPEAKER: אז הם בעצם פשוט- הם
הדרך בה אנו מתייחסים רק לזיכרון.
אז ערימה היא רק מקומות שבם זיכרון מוקצה באופן דינמי,
בעוד ערימה מתייחסת יותר לערום מסגרות
כי הם יותר מרכזיים ל פונקציות שבעצם פועלות.
באמת שאין לך שליטה.
>> ההבדל הגדול, יש לך שליטה מעל הערימה, אם אתה רוצה.
יש לך פחות שליטה על הערימה.
הערימה תלויה ב פונקציות הפועלות,
והסדר שבו הם נמצאים לרוץ, ואיך הם חזרו דברים.
ואילו עם הערימה, כ אנו רואים, שאתה יכול להגיד,
בסדר, אני רוצה ערך זה להיות בסביבה עד שאני אומר לך אחרת.
אין באפשרותך להיפטר מזה.
אתה לא רשאי לבטל אותה.
אתה הולך לשמור אותו סביב כל עוד אני אומר לך.
אתה מקבל להיות הבוס בערימה, בעוד stack-- אולי אם
כמו להתברג בדרך שלך אתה יכול להיות הבוס.
אבל לא ממש.
וזה באמת רק זיכרון.
זה דרכים שונות רק הפניה לזיכרון.
>> מגניב.
אז עם זה, איך לשלוט בזיכרון שלך.
זה עם malloc, ש אתה הולך לקבל לשימוש.
אז זה קצר רק להקצאת זיכרון.
זה כל מה שזה.
יש חבורה של מגניב אחרים פונקציות שיש לי alloc בסוף,
והם עומדים לדברים שונים.
>> כך שכאשר אתה צריך אחסון צריך לשרוד יותר הפונקציה הנוכחית שלך כל כך
שכאשר הנוכחי שלך פונקציה בורחת,
עדיין יש לך את הנתונים שב קיבלתי ממנה, אתה רוצה להשתמש malloc.
זה יהיה לאתחל אותו בערמה.
וכמו שאמרתי ולשמור אומר, תוכל לשמור אותו שם
עד שאתה אומר את זה בדרך אחרת, וזה הדבר החשוב כאן.
>> אז דבר אחד שם לב, ו זה בדרך כלל באמת חשוב,
הוא שזה sizeof הוא סופר שימושי לשימוש
כי בהתאם לסוג של מכונה שלך פועל,
ייתכן שיש לו כמויות משתנות זיכרון שזה לוקח.
אז אתה תמיד רוצה גודל של כל כך להשתמש שאתה לא מכונה תלויה,
כדי שהקוד שלך לרוץ על כל מכונה.
>> וזה רק חלק כתיבת קוד טוב.
אם זה עובד במחשב אחד, אבל לא כל האחרים,
כמה שימושי הייתה התכנית שלך?
אז אתה תמיד רוצה לוודא ולהשתמש sizeof.
>> קהל: אז זה כמו גודל של 10 אינץ '[לא ברור]?
>> 1 דובר: זה הוא בגודל של 10 ints.
כן.
אז גודל של ints יחזור כמה זה int אחד לקחת.
או גודל של char, כיצד הרבה לוקח char אחד.
ואז כמה בלוקים של שאתה רוצה?
>> אז במקרה הזה, אנחנו רוצים משהו שאנחנו יכולים לאחסן 10 ints ל.
וזה יעבוד ללא קשר של מכונה, וזה מגניב.
אז כמה בתים יהיו שבעצם נותן לך?
מתמטיקה מהירה.
>> קהל: 40.
1 SPEAKER: 40.
בדיוק.
אז אחר דבר גדול.
מצביע או malloc יכול לחזור null.
>> אז שוב, תמיד לבדוק ל לראות אם הוא חזר null
לפני שאתה מנסה לעשות עם זה כלום.
אם תנסה וdereference מצביע זה עכשיו,
זה פשוט הולך segfault כי אתה הלך וניסה
לגעת null כאשר אתה לא צריך.
אז תמיד לבדוק null.
שוב, כל מה שאתה יכול לעשות.
>> אולי זה יחזיר null.
זה יחזור null אם אתה או מתוך שטח, או מכל סיבה
זה נתקל בכמה באגים זיכרון.
לפעמים זה פשוט מחזיר null.
אז אתה פשוט צריך לבדוק את זה.
זה כל מה ששקופית שזה אומרת.
ואז מה שיש לנו כאן היא קריאה לשחרור.
אז באותה הצורה שאם אתה לפתוח קובץ, עליך לסגור את קובץ,
אם אתה זיכרון malloc, עליך לשחרר זיכרון ש.
ואתם תקבלו לעשות דברים ממש מגניבים.
>> ויש תכנית שאתה יכול לרוץ ל לראות אם אתה אי פעם דולף זיכרון.
אבל אתה לא רוצה דליפת זיכרון.
זה ממש רע.
רק דברים לבלגן.
>> זה רע לעשות בדיוק כמו תכנות חכם לחיסכון בעיצוב.
אבל זה פשוט סוג גם רע עבור המחשב שלך.
דברים כל כך פשוט חופשיים כאשר אתה Malloc.
>> אתם רואים את הסימטריות כאן.
סופר פשוט.
רק חינם ולאחר מכן כל מה שהמצביע שלך,
מה שמו של המצביע שלך הוא, וזה
ידאג לשחרר אותו עבורך.
מגניב.
>> אז יש לנו את זה.
אז אנחנו פשוט הולכים ל ללכת דרך תכנית זו.
ואז אתם נעשים.
>> אז פשוט עיקרי [לא ברור].
אז יש לנו כמה * int מצביע.
אז יש לנו מצביע זה הולך להחזיק ints.
וכמה ints זה הולך להחזיק?
רק אחד.
גודל של int.
>> אנחנו בודקים כדי לראות אם המצביע הוא null כי זה
הוא, שאנחנו רוצים לומר לא עושים שום דבר.
זה רע.
אז אנחנו להדפיס איזו שגיאה מ זיכרון, לרוב לחזור 1,
כאתם משמשים ל.
>> ואז יש לנו כאן, אנחנו dereference המצביע שלנו.
אז זה אומר שאנחנו הולכים לחנות משהו במיקום שניתן לנו.
Int * מצביע, או malloc, מחזיר את כתובת שבו מניח בצד זה
זיכרון בשבילך.
אז זה בעצם נותן לך like-- אם אתה
חושב על חבורה של בתים בשכונה
שאתה רוצה לשים ברהיטים, malloc שלך
זה כמו אישור, אתה מקבל ללכת לבית שלוש.
וזה נותן לך כתובת של בית בן שלוש.
>> אז את זה עכשיו, זה חנויות מצביע כתובת,
מאחסן את הכתובת של הבית שלך.
* אמצעי PTR, על אישור, אני בבית שלי.
מגניב.
אני צריך לקבל קצת מספרים שלמים.
>> אז אתה שואל על מישהו כדי לתת לך רהיטים עכשיו.
אז אתה מקבל כמה int.
וזה מכניס את המצביע זה איפה זה מצביע על.
>> ואז זה פשוט מדפיס את, אתה נכנס לכל מקום.
ושוב, ההתייחסות.
אז זה כמו שאתה נכנס לזה לטפל וראית מה היה שם.
מגניב?
>> ואז כמובן אנו משחררים המצביע שלנו.
אל תשכח לשחרר את המצביע שלך.
אל תשכח לבדוק null.
אל תשכח לשחרר את המצביע שלך.
יש לך שני דברים שאתה זוכר מ זה, או שאתה צריך לזכור.
כן.
קהל: [לא ברור] דברים כמו ש, char * s.
איך אנחנו אף פעם לא באים בחינם אלה?
>> 1 SPEAKER: Hm?
>> קהל: הם אלה כמו מחרוזות?
אתה אמר מייתרים בדיוק כמו char * s, נכון?
אז למה אנחנו לא לשחרר את המיתרים?
>> SPEAKER 1: אתה רק ל בחינם אם אתה mallocing.
קהל: אה, אם אתה mallocing.
SPEAKER 1: אז malloc וחופשי הם שני דברים
כי אתה צריך תמיד יש ביחד.
ו פתוח קרוב ו,, שני דברים צריך להיות לך ביחד.
בשני המקרים האלה, לבדוק null.
כן.
>> קהל: אז חופשי הוא רק מאפשר משהו אחר
להיות מאוחסן שם אחרי תכנית זו השתמשה בו?
>> 1 SPEAKER: זה רק אומר, אישור, אני גמרתי עם זה.
אתה לא צריך לשמור את זה בסביבה.
אחרת המחשב שלך בדיוק כמו לנסות ולשמור אותו שם.
ואז אתה can't-- הוא פועל לבעיות זיכרון בהמשך.
אתה תמיד רוצה לשחרר אותו כי זה אומר לי המחשב, על אישור, אני
לעשות עם המקום הזה של זיכרון.
אתה יכול לקבל אותו בחזרה עבורי לשימוש מאוחר יותר.
מגניב?
כן.
>> קהל: אז השתמשנו ב% d רק בגלל כפול שחוזר,
או למה [לא ברור] is--.
>> קהל: אתה יכול להשתמש ב% i?
>> 1 SPEAKER: ניתן להשתמש% i.
כל שאלות רגע האחרונות?
קדימה.
קהל: יש לי רק שאלה מהירה.
אז משתנה PTR, that's-- כמו, עם ptr = malloc * int,
זה פשוט אומר שזה מצביע על מקום בmemory--
SPEAKER 1: האם אתה רוצה [לא ברור]?
קהל: --that זה גודל ל-- לא, זה בסדר.
אבל זה רק מצביע על מקום ב זיכרון זה בדיוק כמו ארבעה בתים.
1 SPEAKER: נכון.
אז malloc הגודל של int אומר, בסדר, אני הולך לברוח,
למצוא ארבעה בתים של זיכרון בשבילך.
כאשר היא מגלה כי ארבעה בתים של זיכרון, זה
נותן לך בחזרה את הכתובת היכן זה מתחיל,
וזה מה שמאוחסן במצביע, או PTR.
טוב.
אתם נראים פחות מבולבלים ממה שרוב אנשים כשאני מדבר על מצביע,
אז אני מרגיש די טוב עכשיו.
>> בְּסֵדֶר.
כמו תמיד, אתם צריכים את כל להוציא ציוני pset2 שלך עד עכשיו.
אני יודע שיש כבר כמה רופף דברים שבו כתוב, נוסחה לא תקפה
או משהו.
אם אתה מקבל את זה, כל הציונים שלך הם חוקיים בצד שלי.
אז אני יכול לשלוח לך צילומי מסך של הציונים שלך.
רק תודיע לי גם אם אתה חסר כל ציונים או משהו
לא נראה הגיוני.
בואו אליי.
>> אני כבר סופר גאה בך בחורים כבר, אז לשמור את זה.
ולנוח טוב של השבוע שלך.
אני בטוח שאני תראה את חלק שלך בשעתי עבודה.