[Powered by Google Translate] הדוד י Malan: בסדר.
זה CS50, וזה סוף השבוע השני.
אם אתה מצפה שיהיה רעב בזמן הזה מחר, יודע שאנחנו הולכים
לכנס כקבוצה קטנה מחר, יום חמישי, 1:15 PM.
יש URL זה כאן אם אתה רוצה לאשר השתתפות.
מספר המקומות מוגבל, אז אנא סלח אם הטופס מתמלא בזמן שאתה
מלא את הפרטים.
אתר אחר למרות שהיה בו עניין זה.
>> אז רק על הזמן של חודש, כמובן הולך להיות זמין
כל באופן רחב יותר באמצעות edx, דרך שאנשים באינטרנט יהיו
תוכל לבצע יחד, לעסוק באופן פעיל למדי כמובן, למעשה.
הם ישתמשו CS50 Appliance וCS50 לדון ורוב
כלי תוכנה שונים שאנו כבר משתמשים בסמסטר הזה.
ואחת מהיוזמות שהיינו רוצה לקחת עליו כניסוי בשנה זו
הוא לראות עד כמה תוכן שאנו יכולים לתרגם אחרים דברנו ו
שפות כתובות.
אז אם אתה יכול להיות עניין בהשתתפות בפרויקט זה, לפיו
אנו נספק תמלילים וכתוביות באנגלית לקורס של
הרצאות וסמינרים ומכנסיים קצרים וחתכים וכדומה -
אם אתה מדבר באופן שוטף או לכתוב ברהיטות שפה אחרת, הייתי עושה זאת
אוהב לשתף אותך בפרויקט זה, לפיו אתה לוקח על אחד או יותר מ
קטעי וידאו, ולתרגם אותם לשפה שאתה יודע היטב.
כדי לתת לך תחושה של הממשק, יש ממשק משתמש מבוסס אינטרנט זה
כי יהיה לנו באמצעות שייצור ממשק משתמש כזה במהות.
זה היה לי מלמד איזה ליל כל קדושים לפני.
ובצד הימני יש בשחור ליד חותמות זמן אלו,
אתה תראה את הדברים השונים שיצאו מהפה שלי באותו היום.
ואז, מתחתיה, תוכל לתרגם לשפה קצת אחרת.
בדיוק מה הוא המיפוי בין, במקרה זה, באנגלית
ו, אומרים, ספרדית.
אז זה בעצם כלי מאוד ידידותי למשתמש.
אתה יכול להריץ אחורה וקדימה במהירות מאוד בקלות עם קיצורי מקלדת.
אז אם אתם רוצים לקחת חלק בניסוי זה ויש לך מילים
ראה וקראו על פוטנציאל אלף של אנשים בחוץ, אל תרגיש
חופשי להשתתף.
>> עכשיו מילה אחת על החתלתול מיום השנייה, שמא יש לנו נשלחנו מדי
הודעה מפחידה.
האם מבין שכשעתי משרד מציעות וישמשו כחלקים מציעים,
העיצוב של הקורס הוא מאוד לתלמידים ומשתפים פעולה
מדבר לעבוד דרך סטים בעייתיים ובעיות יחד.
ובאמת קו פשוט מסתכם, שוב, את העבודה שאתה סופו של דבר
צריך להגיש צריכה להיות שלך.
ואז זה, די ביושר - בשעתי עבודה, זה לגמרי נורמלי -
זה לגמרי צפוי, אפילו - שמשוחח עם חלק
חברים הקרובים אליך.
אם הוא או היא מתמודדת עם נושא מסוים, ואתה, כאילו, אה, ובכן תן
לנותני לכם צצה לכמה משורת הקוד שכתבתי.
זה בסדר גמור.
זה קורה.
וזה מאוד מעודד, אני חושב, בתהליך של למידה.
איפה הקו, שוב, מקבל חצה הוא כאשר הראש מוטה הוא סוג של מעל
כאן לשניות או דקות רבות מדי לכי באמת יש רק
היה הזדמנות לביטול חסימה של החבר שלך.
ובוודאי, כאשר דברים מקבלים החליפו באמצעות דוא"ל וDropbox ו
כמו, גם שם הוא הקו.
אז בכל האמצעים, להרגיש בנוח ותרגיש עודד כדי לשוחח עם חברים
וחבריו לכיתה על psets ועוד.
ובדיוק את מה שאתה מבין שסופו של דבר להגיש באמת צריך להיות
תוצר של יצירה ולא שלך למישהו אחר.
>> אז באותה הרוח של יצורי cuddly, אתה עלול
מכיר את הבחור הזה כאן.
אז זה סרט איום זול משנים הקודמות.
מישהו כאן ראה Spaceballs?
בסדר.
אז מספר טוב כאן.
אז זו הדרך נפלאה האקדמית שלנו בסופו של החדרה היום
הרעיון של הצפנה.
וכך, אחת הבעיות הספציפיות לתחום pset 2, שיבוא
מחר בשעת הלילה מאוחר, הוא לצלול לתוך העולם של הצפנה, אשר
היא האמנות של הצפנה או ערבול מידע.
וזה סופו של דבר מתייחס לעולם של ביטחון.
>> עכשיו אבטחה עבור רובנו מגיע בצורה של מנגנונים די שיגרתי.
לכולנו יש שמות משתמש וסיסמות.
ולכולנו יש שמות משתמש וסיסמות רעים מאוד, סביר להניח.
אם הסיסמה שלך היא זהה במספר אתרי אינטרנט, זה כנראה לא
הרעיון הטוב ביותר, כפי שנדונו לקראת סופו של הסמסטר.
אם הסיסמה שלך כתובה על פתק דביק - לא בדיחה - עליך
צג, שגם היא לא בהכרח הכי הטוב, אבל העיצוב די נפוץ
תופעה.
ואם אתה לא משתמש בהצפנה כדי להצפין את הסיסמות שלך, הם
פגיע במיוחד.
אז אם אתה חושב שאתה סופר חכם על ידי בעל Word נסתר
לתעד את המקום על הכונן הקשיח שלך, כי יש את כל הסיסמות שלך, אבל
שהוא בתיקייה שאף אחד לא הולך להיראות ב, שגם היא לא מאוד
מנגנון מאובטח.
ואז מה יהיה להכניס 2 pset הוא זו אמנות של קריפטוגרפיה
ערבול מידע, כך שדברים כמו סיסמות
כל מאובטח יותר.
כדי להניע את הבעיה האמיתית בעולם הזה עם לא בעולם אמיתי מאוד
תרחיש, הרשה לי להציג אותך לאחד הקטעים האהובים עלינו כאן מזה
סרט, Spaceballs.
>> [השמעת וידאו]
קסדה, אתה מכור, מה קורה?
מה אתה עושה לבת שלי?
-הרשה לי להציג את המנתח המבריק, הצעיר הפלסטי, ד"ר פיליפ
Schlotkin, איש עבודת האף הכי הגדול בכל רחבי
היקום ובוורלי הילס.
-הוד המעלה.
'אף עבודה?
אני לא מבין.
היא כבר היה ניתוח אף.
זה היה 16 הווה מתוק.
לא, זה לא מה שאתה חושב.
זה הרבה, הרבה יותר גרוע.
אם אתה לא נותן לי את שילוב למגן האוויר, ד"ר Schlotkin יהיה
לתת לבת שלך בחזרה אפה הישן.
-לא!
מאיפה הבאת את זה?
-בסדר.
אני אגיד.
לא, אבא, לא.
אתה לא חייב.
-אתה צודק, יקירתי.
אני אתגעגע אל האף החדש שלך.
אבל אני לא אומר להם את השילוב לא משנה מה.
-טוב מאוד.
ד"ר Schlotkin, יעשה הגרוע ביותר שלך.
-הנאה.
-לא!
חכה, חכה.
אני אגיד.
-ידעתי שזה יעבוד.
בסדר, תן לי את זה.
-שילוב הוא אחד.
-One.
ושתיים.
ושלוש
ושלוש.
וארבעה.
וחמש
וחמש.
-אז שילוב הוא אחד, שתיים, שלוש, ארבעה, חמש.
זה השילוב הכי המטומטם ששמעתי בחיים שלי.
זה מסוג הדברים שאידיוט היה על המטען שלו.
-תודה לך, הוד מעלתך.
-מה עשה?
-כיביתי את הקיר.
לא, אתה לא.
אתה כיבית את הסרט כולו.
-כנראה לחצתי על הכפתור הלא הנכון.
-ובכן, לשים אותו שוב.
שים את הסרט שוב.
-כן, אדונים.
כן, אדונים.
-בואו נלך, ארנה.
בואו, גרטשן.
כמובן שאתה יודע שאני עדיין אצטרך לחייב אותך על זה.
-ובכן, זה עבד?
איפה השער?
-זה עבד, אדונים.
יש לנו את שילוב.
Great-.
עכשיו אנחנו יכולים לקחת כל נשימה אחרונה של אוויר צח מהכוכב Druidia.
מה שילוב?
-אחת, שתיים, שלוש, ארבעה, חמש.
-אחת, שתיים, שלוש, ארבעה, חמש?
-כן.
-זה מדהים.
יש לי את אותו שילוב במטען שלי.
הכן 1 spaceball ליציאה מיידית.
-כן, אדונים.
-ולשנות את שילוב במטען שלי.
-אווה!
[וידאו השמעת END]
>> הדוד י Malan: סרט מדהים שעכשיו כולם צריך לראות.
אז ההקשר כאן הוא שעם נתונים מאובטחים מגיעה הזדמנות
להצפין אותו וכדי לטרוף אותו.
וכך זה, למשל, הוא דוגמה להודעה מוצפנת.
זה בעצם אומר משהו באנגלית.
אבל ברור שזה לא לגמרי ברור.
ואנחנו סגרנו מעגל היום להקניט בנפרד מה זה סוד
מסר כאן הוא.
אבל בעולם האמיתי של מחשבים, דברים אפילו לא נראים כמו שהם עשויים
להיות משפטים באנגלית.
לדוגמה, זה מה שאפשר למצוא על תקן לינוקס או מק או
מחשב יוניקס בקובץ שהיה פעם שם קובץ הסיסמות.
כיום, זה כבר עבר למקומות אחרים.
אבל אם אתה מסתכל במקום הנכון במערכת, תוכל לראות לא רק שלך
שם משתמש או של אנשים אחרים במערכת, אבל תראה
גרסה מוצפנת של הסיסמה שלהם.
ואכן, המילה קריפטה יש טוענת כי הדברים שלהלן הם מוצפנים.
וזו סדרה של אותיות אקראיות לכאורה ותווים ומספרים ו
כן הלאה יכול להיות מפוענח רק על ידי ידיעת סוד כלשהו בדרך כלל -
מילה סודית, מספר סודי.
וכך אכן, האמנות של הצפנה בסופו של דבר מסתכם במורד לאמונם של כמה
מיון ולדעת משהו שמישהו אחר לא.
נחקור את זה בפירוט קצת יותר היום ובpset לבוא.
>> ועכשיו מילה על עובר / נכשל.
אז במיוחד, כפי שחלקכם צלל לתוך 1 pset, המכשיר, ו
עולם חדש מאוד בעצמך, והבין שתסכולים
בלבול וקשיים טכניים פשוט יש לצפות.
במיוחד עם pset הראשון, שבו יש פשוט כל כך הרבה דברים חדשים, רק מתחיל
מכיר את LS וcd וכל הפקודות המסתוריות אלה בסביבה חדשה.
וזה נפרד מהחומר בפועל ותכנות עצמו.
אז הבין גם שיש בהחלט שעתי עבודה שבנמצא
מבנה התמיכה.
סעיפים מתחילים ביום ראשון הקרוב.
אבל הכי חשוב, אם אתם מרגישים שזה לא
העולם בשבילך, להבין שזה באמת פשוט ייקח זמן.
ואם לא היה ההזדמנות הזאת לפני שנים בשבילי לקחת כיתה
עובר / נכשל, בכנות, לא הייתי אפילו כף רגלם בכיתה.
ואתה יכול לשנות את זה עד, יניח, יום שני 5 של הקורס.
אז אם אתה בקצה עכשיו, מבין שלא בראש לחלק שני
מים בכלל, אין ספק שרואים שינוי רק לעוברים / נכשל.
שוב, אין באמת זו תרבות כאן ברווארד של לקיחת דברים
עובר / נכשל מאחר שכולם באמת רוצה להשיג או overachieve.
אבל בכנות, זו היא דרך נפלאה של ניסה משהו שאולי לא
להיות מוכר לך.
ותקבל בסופו של דבר עושה ברוב המקרים די בסדר, אולי
להפתעתו הרבה שלך.
ובמונחים קונקרטיים יותר, מה שאני חושב עובר / נכשלתי בדרך כלל עושה,
במיוחד כפי שאולי חווה עם pset 0, אם שמת
ב 10 שעות, 15 שעות, 25 שעות לתוך pset חלק - ואתה פשוט דופקים
הראש שלך בקיר,
וזה מתחיל להיות סופר מאוחר בלילה,
אבל אתה כבר לקחת pset כמו 90% מהדרך,
אתה יודע שאתה פשוט לא יכול להבין דבר אחד -
עובר / נכשל באמת לוקח את עוקצו של מעמד כזה, שבו אתה יכול למיין
של שמחה אומרים בסדר, אני יודע שזה לא מושלם.
אבל עבדתי לי את התחת על זה.
אני די מרוצה מזה שבו בסופו.
ושיעמוד בציפיות לעוברים / נכשל.
אז אל תשמור את זה בחשבון.
>> בסדר.
אז אלו מכם שנאבקו להשתמש אוניברסיטת הרווארד Wi-Fi יודעים
שיש SSID CS50, חיבור Wi-Fi מרחפת שאתה
אולי יהיה לך מזל טוב ל.
זה קצת אירוני שהסיסמה לזה - אם אתה רוצה לנסות
התחברות לזו למהירויות טובות יותר ולהודיע ​​לנו אם זה לא יותר טוב -
אחת, שתיים, שלוש, ארבעה, חמש, כל הדרך עד לשמונה, כי שמונה הם
מאובטח יותר מחמישה.
אז אם אתה צריך את הסיסמה לאינטרנט האלחוטי, חיבור לCS50 אלחוטי כאן.
אחת, שתיים, שלוש, ארבעה, חמש, שישה, שבע, שמונה.
והודעה על CS50 דיון אם עדיין יש לך בעיות קישוריות לסירוגין,
ואנחנו ניידע את הכוחות שיהיה מכירים למרחב הזה.
>> בסדר.
אז טיזר מהיר, במיוחד עבור אלה מכם שהם בנים או בנות מאוורר
מכל הדברים של אפל.
מה שחפרתי מלפני כמה שנים היה זה קובץ כאן, ilock.c, רק כדי
סוג של להפוך למוחשי יותר ויותר מורכב חלק מC הבסיסי יותר
תוכניות שעסקנו בכתיבה.
אז פתחתי את הקובץ הזה, ilock.c.
זה זמין בדף ההרצאות להיום.
בצד השמאלי, אתם תראו רשימה ארוכה של פונקציות.
אז הבחור שכתב את הטקסט הזה כתב למעלה הרבה פונקציות,
יותר מסתם ראשי.
הוא השתמש בכל חבורה של ספריות כאן.
ואם אנחנו מתחילים לרפרף, מה שזה באמת הוא מאוד
הראשון, אני מאמין, לפיצוח ה-iPhone המקורי.
כאשר אתה רוצה jailbreak iPhone המקורי, מה שאומר untether
זה מ-AT & T ובאמת להתקין תוכנה מיוחדת על זה ולעשות דברים
Apple לא רוצה שאנשים יעשו -
כן, מישהו לקח את הזמן כדי להבין בדיוק איך הם יכולים לנצל
פגמי תוכנה, טעויות, באגים בתוכנה של אפל.
וכך נולד ilock.c.
שאם חברת אותו במחשב והתקנת אותו על האייפון כי
הייתה מחובר למחשב באמצעות, למשל, כבל USB, זה היה נותן לך
הרשאות ניהול או שורש ב-iPhone שלך ​​וייתן לך לעשות פחות או יותר
מה שאתה רוצה.
>> ואז היה חתול זה מרתק ומשחק עכבר בין אפל ו
שאר העולם בפרט כפי שהם, כמו חברות רבות, נסה לנעול
החומר לתוכם, כך שאתה יכול לעשות רק עם זה מה שהם מתכוונים.
אבל הודות לאנשים כמו זה וההבנה שלהם ברמה נמוכה
פרטים ו, ​​במקרה זה, תכנות C והרבה המבנים המוכרים
שאנחנו כבר התחלנו לשחק איתו, אתה יכול באמת למנף
חומרה באופן שאתה רואה לנכון ולא בהכרח חלק התאגיד.
כך למשל, אין לי מושג מה כל זה עושה.
אבל GetVersion נשמע די פשוט.
וזה נראה כאילו זה הוא פונקציה שהאדם הזה כתב.
קח איזה שלם כויכוח, לא מחזיר שום דבר, אבל
נראה לולאה עם לולאה לכאן ואם מצב, אם מצב,
לשבור, ואיכשהו מתייחס למספרי גרסות.
אם אנחנו לגלול למטה -
למרות שהרבה מילות מפתח אלו הולכים להיות חדשים, ויש
המון פונקציות בכאן שמעולם לא ראינו ואי אפשר שלא יראה על
במהלך הסמסטר -
בסופו של היום, זה כפוף לאותם חוקים והיגיון שאנחנו כבר
לשחק עם עד כה.
אז זה זקן מכדי לפצח -3 iPhone 4s או או מייד 5s, בימים אלה,
אבל יודע שזה נובע במידה רבה מכל העולם הזה שיש לנו
צלל לתוכו.
>> אז בואו נסתכל על דוגמה קטנה ופשוטה יותר.
זה אחד, רק כדי להתחמם קצת עם תחביר וגם כמה נתונים אחרים
סוג שדברנו עליו אבל לא באמת ראיתי ב C. אז זה
קובץ שנקרא positive1.c.
ולפי דבריו בראש, זה רק דורש שמשתמש מספק
מספר חיובי.
אז זה דוגמה לעשה תוך לולאה, וזה נחמד למשתמש אינטרקטיווי
תוכניות שבו אתה צריך להגיד למשתמש לעשות משהו.
ואם הם לא ישתפו פעולה, אתה צועק עליהם או לדחות את הקלט שלהם.
מקרה לדוגמה, אני הולך לעשות את הקווים 19 עד 24, כל עוד יש למשתמש
לא נתן לי מספר חיובי.
עכשיו פרט זה כאן בקו 18, למה אני מצהיר n מעל כל זה
מבנה לולאה בניגוד לימין ליד קו 22 שבו אני
ממש אכפת לקבל n?
כן?
[לא ברור]
>> הדוד י Malan: כן, אז זה עניין של היקף.
ובטווח של הדיוט, מה ההיקף מתייחס?
כן?
[לא ברור]
הדוד י Malan: האם אתה יכול לדבר קצת יותר חזק?
רמקולים 1: איפה אתה יכול לגשת למשתנה מסוימת.
הדוד י Malan: מושלם.
איפה אתה יכול לגשת למשתנה מסוימת.
ובאופן כללי, כלל האצבע עד כה היה כי ההיקף כלשהו
משתנה שהוגדר על ידי הסוגריים המסולסלים האחרונים שראיתם.
ולכן במקרה זה, אם אני עשיתי את הטעות של הכרזת n ב 22 לקו,
קו זה יעבוד.
הייתי מקבל int, ואני היה מנסח את זה n משתנה בקו 22.
אבל ששורת הקוד שכרגע אין לי מושג על מה אני מדבר?
אז 25, ומתברר 24, וכן, כי במקרה זה, הוא נופל מחוץ
בסוגריים המסולסלים.
אז פשוט קצת מפריע, אבל פתר בקלות פשוט על ידי הכרזה
מחוץ המשתנה של הפונקציה עצם.
>> עכשיו נראה מאוחר יותר היום, אתה יכול ללכת צעד אחד קדימה.
וגם אתה יכול לקבל קצת עצלן -
וזה לא כדי להיות מומלץ, באופן כללי -
אבל אתה יכול גם לעצלנים ולשים משתנה ברחבי העולם, אם אפשר לומר כך, לא
בתוך פונקציה, לא בתוך לולאה, אבל בקובץ עצמו, מחוץ
של כל הפונקציות שכתבת, כפי שעשיתי כאן ב 15 לקו.
אבל זה כלל בעין יפה.
אבל מבין שזה פתרון לפעמים לבעיות אחרות, שכן אנו
סופו של דבר לראות.
אז לעת עתה, תשאיר את זה ככה.
אבל בואו נראה אם ​​אנחנו יכולים לכתוב את זה מחדש, רק כדי להתחיל לבטא את עצמנו
קצת אחר.
>> אז התכנית הזאת, רק שיהיה ברור, היא positive1.
תן לי ללכת קדימה כאן ובחלון מסופי לעשות positive1, Enter.
הידור, בסדר.
אני הולך לרוץ positive1, על Enter.
אני דורש ממך לתת לי מספר חיובי.
אני אגיד -1.
זה לא עבד.
0, 99, שנראה שזה עובד.
אולי לא במבחן הקפדני ביותר.
אבל לפחות זה צק של שפיות נחמדה שאנחנו על המסלול הנכון.
אז עכשיו תן לי ללכת קדימה ולפתוח את הגרסה 2 של זה.
ומה הוא כבר שונה?
היא מיישמת את אותו דבר.
אבל מה שקופץ החוצה ברגע בבירור שונים הפעם?
כן, אז זה bool בירוק.
Gedit הדגיש בירוק מילת מפתח זו המכונית bool,
שהוא סוג נתונים.
זה לא באו מובנה לכל הגרסות של ג אתה צריך לכלול
ספרייה ספציפית.
במקרה שלנו, אני כלל CS50 ספרייה כדי ש
יש גישה לbool.
אבל בקו 18, שנראה שיש ערך בוליאני כאן נקרא אסיר תודה.
אז יכולתי לקרוא לכל הדבר הזה.
אבל אני קורא לזה אסירי תודה רק כדי להעביר כמה סוג של משמעות סמנטית.
אז בהתחלה בקו 18, אני כנראה לא מודה כי
הערך מודה וליאני מאותחל לכוזב בקו 18.
ואז זה נראה מה שעשיתי כאן בקווים 21 עד 23 היא שאני פשוט
סוג של שוכתב ההיגיון שלי.
אז לא פונקציונלי שונה.
אבל בקו 22 כיום, אני בודק אם int המשתמש ספק גדול מ
0, אז אני פשוט לשנות את ערכו של אסיר תודה לאמיתית.
ולמה אני עושה את זה?
כי בקו 25, ככל הנראה, אני הולך לבדוק את מצבו.
האם זה לולאה בזמן אסירי תודה הם שקרי.
>> אז אני מציע זאת כאלטרנטיבה לגרסה אחת, כי זה לפחות
קצת יותר אינטואיטיבי, אולי.
זה קצת יותר מעוגן באנגלית.
אז בצע את הפעולות הבאות בזמן שאתה לא מודה או בעת אסירי תודה הוא שקרי.
וגם הפעם, כנראה שאני לא רוצה לזכור את מה שמשתמש הקליד
בהודעה כי אין n משתנה.
כך שלמעשה, אני -
שקר לבן קטן שם.
מבחינה פונקציונלית, התכנית היא קצת שונה הרגע שנגיע לתחתית
זה כי אני לא זוכר מה הוא n.
אבל רציתי להדגים גם כאן שלמרות שאנחנו ראינו וGetInt
GetString בשימוש בצד הימני של סימן שוויון עד כה, כך ש
אנו זוכרים את הערך, מבחינה הטכנית, זה לא הכרחי.
אם מסיבה כלשהי אתם פשוט לא אכפת לך לשמור את הערך, אתה רק רוצה
כדי לבדוק את הערך, שים לב שאנחנו יכולים פשוט לכתוב את זה כGetInt פתוח
סוגר, סוגר קרוב.
פונקציה שהוא הולך להחזיר ערך, כפי שאנו טוענים.
זה הולך לתת לך בחזרה int.
ולכן אם אתם חושבים נפשיים שזה יקרה, כשאני מקליד ב99, GetInt
מחזיר את המספר 99.
וכך מושגית, זה כאילו הקוד שלי היה למעשה זה.
אז אם 99 הן אכן גדול מ 0, אז תודה שתתגשם.
ואז קו 25 מבין אווה, סיים כי אני עכשיו אגיד תודה.
ובקו 26, פשוט אומרים אנחנו מודים למספר החיובי, מה שזה
במקרה.
>> עכשיו בואו נעשה סוכר תחבירי קל כאן, כביכול.
בואו נראה אם ​​אנחנו יכולים לנקות את קו 25 זה עם שונות שלישיות ואחרונות זה
בpositive3.
אז תבחין בהבדל היחיד כרגע הוא מה שורת הקוד?
כן, אז 25.
ואנחנו כבר לא ממש ראינו את הטריק הזה עדיין.
אבל אנחנו לא רואים את סימן הקריאה ביום שני, אשר מציין מה?
אז לא, או שלילה.
אז קח את הערך בוליאני ולהעיף את הערך שלו.
האמת הופכת להיות שקר.
השקר הופך לאמיתי.
אז כך, אני הייתי מציע, הוא אפילו קצת יותר אינטואיטיבית של דרך
כתיבת הקוד, כי אני עדיין לאתחל מודה לכוזב.
אני עדיין עושה את הדברים הבאים.
אני מודה לנכון לקבוע בבוא העת.
אבל עכשיו אתה יכול באמת רק לתרגם את הקוד הזה השאיר מילולי לימין,
ואילו לא אסיר תודה.
בגלל מפץ, או סימן קריא, מציין את הרעיון של לא, אז בזמן
לא תודה.
>> אז שוב, אנו לא הצגנו כל מושגים חדשים כשלעצמה.
דברנו על Booleans אחורי כששחקנו עם גרד.
אבל עכשיו אני מבין שאנחנו פשוט יכולים להתחיל לכתוב את הקוד שלנו ב
דרכים רבות ושונות.
אז במיוחד בpset1, אם אתה סוג של נאבק כדי למצוא את הדרך ל
לכתוב איזה תכנית, סיכויים יש לך מזל, כי עומדים להיות כל
מספר הפתרונים שיכולים לקרות בעת.
לדוגמה, זה רק 3 לאפילו הפשוט ביותר של תוכניות.
בסדר.
ועכשיו נזכר ביום שני, שיצאנו בפתק הזה עם ערכים לחזור.
אז בפעם הראשונה, שכתבנו תכנית שלא רק צריכה ראשי,
יש לו גם פונקציה מותאמת אישית משלה שכתבתי כאן.
אז בקו 31 דרך 34, שהתקנתי את פונקצית קובייה.
זה לא מורכב.
זה רק פעמים בפעמים, במקרה זה.
אבל מה חשוב בזה הוא שאני לוקח את הקלט בצורה ו
אני מחזיר פלט בצורה של פי פי א.
>> אז עכשיו יש לי את היכולת, הרבה כמו שהייתי עם printf לבד, לקרוא
פונקציה זו על ידי קריאה לפונקצית הקובייה.
ופונקצית הקובייה לוקחת קצת קלט.
ופונקצית הקובייה מחזירה חלק פלט.
וכך לעומת זאת, printf פשוט עשה משהו.
זה לא החזיר דבר שחשובים ל-- אף כי, כפי
בצד, זה עושה להחזיר ערך.
אתה פשוט בדרך כלל מתעלם ממנו.
Printf פשוט עשה משהו.
זה היה תופעת לוואי של הדפסה על גבי המסך.
לעומת זאת כאן, יש לנו את פונקצית הקובייה, אשר
למעשה מחזיר משהו.
>> אז זה בדרך כלל -
עבור מי שמכיר את זה, שזה רעיון פשוט למדי.
אבל עבור אלה פחות מכירים את הרעיון הזה של העברה בתשומות ומקבלים
יציאות אחוריות, בואו ננסה פשוט פשוט סופר משהו.
האם מישהו בנוח לבוא לבמה לזמן קצר?
אתה צריך להיות נוח עם מצלמה עליך, גם כן.
כן.
אוקיי, מה השם שלך?
KEN: קן.
הדוד י Malan: קן.
הטוב, קן.
בואו נעלה.
אז קן הולך להיות פונקציה של מיני סוגים.
ובואו נלך ותעשה את זה.
בואו תחביב קטן.
נע מאוד.
ברוכים באים למרכז במה.
בסדר.
בואו נכנסתי ללחצן זה כאן.
בסדר.
אז הנה יש לך לוח מודרני.
ומה שאני הוא הפונקציה העיקרית, למשל.
ואין לי אייפד ביד שלי.
אני לא ממש זוכר איך - טוב, למעשה, לא יכול להגיד את זה.
אני לא באמת צריך את כתב יד טוב.
וכך אפוא, אני רוצה שלהדפיס משהו על המסך שלי.
>> אז אני מתנהג בתכנית הראשית.
ואני הולך יש לך להגיד את זה על ידי כתיבתו בשריטה שלי והעוף
אז עובר לך קלט.
אז כאווילי ככל שהתרגיל הזה הוא, הרעיון של פונקציות וקוראים
פונקציה וחזרה למטה פונקציה באמת מסתכם לזה.
אני ראשי.
יש לי רק בכתב printf ("משהו") על המסך.
אני מפעיל תכנית זו.
וברגע שמקבל בשם printf, זה לוקח טיעון אחד - או פרמטר אחד,
לפעמים -
בין מרכאות כפולות.
הנה הטיעון הזה.
אני מעביר אותו לקן.
כעת הוא קופסה שחורה כתבה חלק לפני מספר שנים, שכנראה
רק יודע כיצד להדפיס דברים על המסך.
>> אז, לבצע.
זה לא רע.
לכן, טוב מאוד.
אז עכשיו קן נעשה ביצוע.
האם הוא צריך למסור לי משהו בחזרה?
אז לא שאנחנו ראינו עד כה.
שוב, printf אין בעצם להחזיר מספר.
אבל אנחנו הולכים להתעלם כי לעת עתה, כי אנחנו אף פעם לא השתמשנו בו.
אז זהו זה לקן.
ואז עכשיו עיקרי חוזר לביצוע -
ראשי לוקח על שליטה בתכנית שוב משום ששורת הקוד,
printf, נעשה ביצוע.
ואנחנו הולכים על הדרך שלנו ביצוע כל קווים אחרים נמצאים שם.
>> בסדר.
אז עכשיו בואו ננסה דוגמה קצת שונה.
והפעם כאן, בואו לנקות את המסך הראשון כאן.
והפעם, אנחנו נעשה את הפונקציה עקוב.
אבל הפעם, אני מצפה ערך תפוקה.
אז בואו נלך ותעשה את זה.
אז עכשיו יש לי שורת הקוד שאומרת x = קובייה (x).
אז בעצם - בואי
שורת הקוד, כזכור, נראית כך.
x = הקובייה (x).
אז איך זה הולך לעבוד?
אז בואו נלך קדימה ולתת לך מסך לבן שוב.
ואני הולך לכתוב עכשיו את הערך של x, אשר ברגע זה ב
זמן קורה להיות, יניח, 2, כדי לשמור את זה פשוט.
אז כתבתי על פיסת נייר ערך 2
אשר הוא x הערך שלי.
אני מעביר אותו לקן.
KEN: ואני רק כותב את התשובה?
הדוד י Malan: כן, בואו פשוט נכתוב את התשובה.
אוקיי.
ועכשיו הוא צריך להחזיר לי משהו.
אז -
מושלם.
נחמד רצף.
>> אז עכשיו הוא מחזיר לי את הערך של 8, במקרה זה.
ומה עליי לעשות עם זה?
טוב, בעצם, בואו נראים.
קבל את הזכות הזו.
מה אני הולך לעשות עם זה?
עכשיו אני הולך לקחת את הערך הזה ובעצם לאחסן אותו באלה
אותם ביטים בזיכרון.
אבל שים לב, אני די נאבק כאן.
אני קצת מבולבל כי לאן אני בעצם לכתוב את הערך של x?
כי מה בדיוק עשיתי הוא יד פיזית קן פיסת נייר
שהיה לו הערך 2, שהיה x.
ואכן, זה בדיוק מה שקורה.
אז מתברר שכשאתה קורא לפונקציה, ואתה עובר בויכוח
אוהבים "שלום עולם", או שאתה עובר בטיעון כמו 2, בדרך כלל, אתה
עובר בעותק של ויכוח.
וכך בדיוק כפי שכתבתי את המספר 2 כאן ומסרתי אותו לקן; שחייב
אומר שעדיין יש לי עותק של 2 ערך כלשהו.
כי אכן, עכשיו אחרי שקבלתי בחזרה את הערך 8, אני צריך לחזור ב
זכרון RAM ובעצם לכתוב ירידה של 8 שבו היה לי פעם המספר 2.
>> אז חזותי זוכר את הרעיון הזה של העברה באופן מילולי
עותק של הערך.
קן עושה את הדבר שלו, מחזיר לי משהו - במקרה זה,
ערך כמו 8.
ואז אני חייב לעשות משהו עם זה ערך אם
רוצה לשמור על הסביבה.
אז כל זה יהיה מוכר מדי לפני זמן רב.
תודה רבה לך על זה הדגמה כאן, קן.
בסדר.
עשה טוב מאוד.
אז בואו לראות איך שסופו של דבר מתייחס לחלק מהפונקציה
קורא שאנחנו עושים כאן.
אז תן לי ללכת קדימה ולהחזיר אותנו לדוגמא עקוב כאן.
ושים לב שאם אנחנו רוצים באמת להתחיל לקחת את זה עוד יותר, אנחנו הולכים
יש להיות מודע לעובדה שהמספר x המועבר ב
כאן הוא שונה ממה באמת מועבר לפונקציה.
אז שוב, זה חלף עותק הולך להיות די
מקורן ברגע.
>> אז בואו נסתכל על משהו שלא ממש עובד נכון עדיין.
אני הולך קדימה, לפתוח למשל מרכבה 3, אשר
פגום על ידי הטבע.
וזה נקרא buggy3, והיא מיישמת את פונקצית החלפה.
אז הנה יש לנו פונקציה עיקרית שx ו-y מאותחל באופן שרירותי
1 ו 2, בהתאמה.
אנחנו יכולים להשתמש בGetInt, אבל אנחנו פשוט צריכים תרגיל פשוט.
אז זה קידוד קשיח כמו 1 ו 2.
בקווי 21 ו 22, אנחנו כנראה להדפיס את X ו-Y, אחד בכל שורה.
ואז, בקו 23, אני טוען שאני מחליף את הערכים הללו, נקודה, נקודה, נקודה.
כנראה שאני קורא לפונקציה בקו 24 בשם החלפה
שלוקח את שני טיעונים.
זה לגמרי לגיטימי לפונקציות לקחת שני טיעונים.
ראינו printf לעשות את זה כבר.
אז ההחלפה כנראה לוקחת x ו-y.
וכפי שהשם מרמז, אני מקווה שזה הולך
להחליף שני ערכים אלה.
אז אני טוען ביום 25 בקו, החליף.
ואני להדפיס מחדש את X ו-Y תחת ההנחה כי
הם אכן כבר החליפו.
אבל אם אני באמת להפעיל תכנית זו -
תן לי לפתוח את חלון מסוף.
תן לי לעשות buggy3.
כפי שהשם מרמז, זה לא הולך להסתיים בטוב.
כי כשאני על Enter, תבחין כי x הוא 1.
y הוא 2.
ובכל זאת, בסוף התכנית, הם עדיין, למעשה, את אותו הדבר.
>> זאת בהתבסס על ההפגנה רק עכשיו עם קן, מה בעצם קורה?
ובכן, בואו לצלול לתוך פונקצית עסקה זו.
זה סופר קצר.
זה רק כמה שורות של קוד ארוך.
אבל מה הבעיה הבסיסית המבוססת על הסיפור פשוט ספרה
עד כאן עם קן?
למה החלפה שבורה?
[לא ברור]
בדיוק.
אז אנחנו אחסון להעתקה, לא משתנים עצמו.
במילים אחרות, העסקה כנראה לוקחת שני ארגומנטים, int.
וקוראים לזה באופן שרירותי וb.
וכאן למעלה, אני כבר עברתי בX ו-Y, שהם בהתאמה 1 ו 2.
אבל אני לא ממש עובר בx.
אני לא ממש אני עובר בy.
אני מעביר עותק של x ו עותק של Y.
זה כמו כמעט כאילו אתה להעתיק ולהדביק לתוך להחליף את הערכים ש
אתה רוצה שזה בעצם מניפולציה.
אז אם זה מצב, כש, התכנית, תתחיל להוציא להורג
קו 35, אז 36 -
כשאני מגיע לקו 37, בנקודה זו בסיפור, מהו הערך של a?
בנקודה זו בסיפור, קו 37, מהו הערך של בנקודה זו?
אז זה פשוט צריך להיות 1.
נכון?
בגלל x היה מועבר כטענה הראשונה.
ופונקציה זו רק באופן שרירותי קוראה הטיעון הראשון שלה,.
כמו כן הוא y, הארגומנט השני.
וזה רק באופן שרירותי לקרוא ב הטענה השנייה.
>> עכשיו דיכוטומיה זו היא למעשה די פשוט הסבירה.
תחשוב על זה.
אף אחד מאתנו לא פגש האדם שכתב printf.
אז בוודאי, שהוא או שאין לה מושג מה משתנינו 30 שנים מאוחר יותר הולכים
שייקרא.
אז צריך להיות הבחנה בין מה שאתם קוראים במשתנים
פונקציות אתה כותב ומה שאתה קורא משתנים בפונקציות שאתה
התקשרות או שימוש.
אז במילים אחרות, שכתבתי משתנים שלי בתור X ו-Y.
אבל אם מישהו אחר כתב את פונקצית ההחלפה, הוא או היא בהחלט
לא היה יודע מה המשתנים שלי הולכים להיות בשם.
אז מבין שזו הסיבה שיש לך דואליות זו של שמות.
מבחינה טכנית, אני יכול לעשות את זה במקרה.
אבל הם עדיין יהיו מועברים כהעתקים.
זו תהיה סתם צירוף מקרים טהור מבחינה אסתטית, אם כי מי שכתב
החלפה השתמשה באותם שמות.
>> בסדר.
לכן בשלב זה בסיפור, קו 37, הוא 1.
b הוא 2.
ועכשיו אני ממשיך להחליף אותם.
ובכן, קודם כל, תן לי לעשות את זה דווקא הרבה יותר פשוט.
אני לא יודע מה שלוש השורות האלה של קוד עושות.
תן לי רק לעשות את זה.
ב מקבל.
מקבל ב.
עשה.
למה זה שבור, באופן הגיוני?
זה סוג של דבר אינטואיטיבי, נכון?
אז הופך ב.
והופך ב.
אבל הבעיה היא שברגע שמבצע קו 37, מה
ערך של A ו-B?
אותו הדבר, 1.
בגלל שיש לך דפוק, אם אפשר לומר כך, ששינית ב שווה.
אז ברגע קו 37 הוא להורג, זה נהדר.
כעת יש לך שני עותקים של חלק הפנימי מספר 1 של פונקציה זו.
אז כשאתה אומר בקו 38, מקבל ב, ובכן, אתה סוג של נדפק.
מכיוון שאתה רק הקצאת 1 על 1.
סוג שלך אבד את הערך שאכפת לך.
>> אז בגרסה המקורית של זה, שים לב למה שעשיתי.
במקום זאת נאלצה שורה שלישית של קוד שנראית כמו זה.
אני מצהיר משתנה זמני - tmp הוא שם נפוץ מאוד
למשתנה זמנית.
זה int כי יש לו להשתוות למה שאני רוצה לעשות עותק של.
אני לאחסן עותק של חלק פנימי של tmp. אז ברגע קו 37 בצע,
הערך שלו -
שפיות מהירה לבדוק -
1.
הערך של b הוא 2.
והערך של tmp הוא גם 1.
אז עכשיו אני מבצע את הקו 38.
אז ברגע קו 38 מבצע, מקבל את הערך של b.
והייתה ב 2.
אז עכשיו הוא 2.
לכן בשלב זה בסיפור, הם 2, b הוא 2,
וtmp הוא 1.
אז עכשיו מבחינה לוגית, אנחנו יכולים רק הערך של tmp פלופ לב.
ואנחנו נעשינו.
>> אז ככה פתר את הבעיה.
למרבה הצער, כאשר אני מפעיל את התכנית בצורה זו, זה לא ממש להחליף
כל ערכים.
אבל שיהיו ברור, למה?
אני תקנתי את הבעיה הלוגית מרק לפני רגע.
אבל שוב, אם אני מפעיל תכנית זו, x ו-y יישארו ללא שינוי עד סוף
הביצוע של התכנית.
[לא ברור]
הדוד י Malan: אז לא חזרתי שום דבר.
אז זה נכון.
אבל מתברר שיש קצת בעיה כאן כי עד כה,
דבר היחיד שהצלחנו לחזור זה דבר אחד.
וזו היא הגבלה של ג תוכל לחזור באמת ערך אחד בלבד,
ובמקרה זה, אני די תקוע כאן
כי אני יכול להחזיר את הערך החדש של X או שאני יכול לחזור
ערך חדש של Y.
אבל אני רוצה גם לחזור.
אז חזר לא פתרון פשוט כאן.
אבל הבעיה מהותית היא למה?
מה אנחנו בעצם להתחלף?
ב.
אבל וb הם עותקים של X ו-Y, מה שאומר שאנחנו פשוט עשינו את כל זה
עובדים - אנחנו פשוט בילינו כשלוש דקות לדבר על ההחלפה
פונקציה וכל שלושת המשתנים הללו.
וזה נהדר, נכון לגמרי בבידוד.
אבל ההיקף של b ורק בשורות אלה כאן.
אז בדיוק כמו ללולאה, אם תכריז שלמה אני בפנים ל
לולאה - באופן דומה, אם אתה מצהיר וb בתוך פונקציה ש
אתה כתבת, שהם בתוך תקפים רק שבפונקציה.
כלומר ברגע שההחלפה נעשית ביצוע ואנחנו הולכים מקו 24 עד
הקו 25, x ו-y לא השתנו בכלל.
אתה פשוט בזבזת המון זמן בחילופי עותקים של משתנים.
>> אז מתברר שהפתרון לזה הוא למעשה אינו ברור.
זה לא ממש מספיק כדי להחזיר ערכים משום שאנו יכולים
להחזיר ערך אחד בלבד.
ואני באמת רוצה להחליף גם x ו-y באותו הזמן.
אז אנחנו הולכים לחזור לזה.
אבל לעת עתה, מבין שהבעיה יסודית נובעת מהעובדה
ושb הם עותקים.
והם בהיקפם.
ובכן, בואו ננסה לפתור את זה בדרך כלשהי.
תן לי לחזור לכאן בעצם לגלול ולפתוח, יניח, גרסה 4
זאת, buggy4.
ומה לגבי זה?
זו בעיה דומה אך פשוטה יותר להסתכל לפני שאנחנו לוקחים בדקירה
לפתור אותה.
תכנית זו נקראת תוספת.
וזה כנראה מאתחל שלם x עד 1 בקו 18.
אז אני טוען x הוא 1.
אז אני טוען הגדלה, נקודה, נקודה, נקודה.
אז אני קורא לתוספת.
אבל אז בקווי 22 ו 23, אני טוען את זה כבר בהפרש קבוע.
אני טוען x הוא עכשיו מה שזה לא, 2 מן הסתם.
>> אבל תכנית זו היא כרכרה.
מה הבעיה?
כן?
[לא ברור]
הדוד י Malan: בדיוק.
אז x הוכרז כמובן בקו 18.
כלומר בתוך סוגריים המסולסלים של העיקרית.
אז התשובה הפשוטה היא ש, טוב, x קיים כאן.
זה לא קיים בקו 32.
אז התכנית הזאת בעצם אפילו לא לקמפל.
המהדר, כשאני מנסה להרכיב את הקוד הזה, הוא הולך לצעוק עליי
על איזה מזהה או משהו דומה לזה לא מוצהר.
למעשה, בואו ננסה.
זה עושה buggy4.
זה מה שיש.
השתמש של x מזהים המוצהר בקו 32.
ובעצם, בואו אהיה יותר מפורש כאן היום כדי שזה מועיל ב
שעתי עבודה ובבית.
שים לב שזה קצת כתוב ולא פרש.
אבל העובדה שיש קלאנג צעקה עלינו ואומר
buggy4.c: 32:5, הוא באמת שימושי.
זה אומר שהטעות היא בקו 32 בעמדת הדמות חמש.
אז אחת, שתיים, שלוש, ארבעה, חמש.
זה, למעשה, שבו הבעיה היא.
וגם לזכור בשעתי עבודה ובבית, יש לי מזל כאן.
יש לי טעות אחת.
זה הולך להיות קל יחסית לתיקון.
אבל אם אתה מקבל את כל מסך מלא בהודעות שגיאה מכריעות, שוב,
להבין שאחד התחתון יכול להיות רק סימפטום של
אלה עליונים.
אז תמיד לרדוף אחריך באגים מלמטה למעלה.
מכיוון שיש יכול להיות רק השפעת דייזי שרשרת שמציעה לך
יש דרך לבעיות יותר מאשר אתה באמת כן.
>> אז איך אפשר לתקן את זה אם המטרה שלי היא להגדיל x?
מה זה?
אוקיי.
אז אנחנו יכולים לעשות את x הגלובלי.
בואו ניקח את קיצור הדרך שהזהרתי עליו קודם לכן.
אבל לעזאזל, אנחנו רק צריכים פתרון מהיר.
אז בואו רק תגיד x int עד כאן.
זה הופך את x הגלובלי.
אז עכשיו ראשי יש גישה אליו.
ותוספת יש גישה אליו.
ואז תן לי להמשיך ולעבד את זה עכשיו.
הפוך buggy4, Enter.
נראה לקמפל עכשיו.
בואו לרוץ buggy4, ונראה ממש לעבוד.
עכשיו זה אחד מהדברים האלה -
תעשה מה שאני אומר, לא כמוני, כמו שאני עשיתי רק כאן.
כי באופן כללי, התוכניות שלנו הולכות לקבל הרבה יותר מעניין ו
הרבה יותר מזה.
ואם הפתרון שלך לבעיות החיים הוא פשוט אה, לשים את כל
משתנה בחלק העליון של הקובץ שלך, לעשות מהר מאוד תוכניות להגיע
בעתה קשה לניהול.
זה נהיה קשה יותר לחשוב על שמות משתנים חדשים.
זה נהיה קשה יותר להבין מה משתנה עושה מה.
>> וכך באופן כללי, זה לא פתרון טוב.
אז בואו נעשה את זה טוב יותר.
אנחנו לא רוצים להשתמש במשתנה גלובלית כאן.
אני רוצה להגדיל x.
אז ברור שאני יכול -
בסופו של היום, זה סוג של סיפור טיפשי כי אנחנו פשוט עושים את זה.
אבל אם אני לא ידעתי על שהמפעיל, או שאני לא נתתי לי
לשנות אותו בראשי עצמו, איך עוד יכולתי ליישם קן לכאן, זה
זמן לא קובייה אבל כדי להגדיל?
איך אני משנה את זה כאן?
כן.
[לא ברור]
הדוד י Malan: אוקיי, טוב.
אז למה שאני לא אעבור בx?
ואז, במקום להחזיר אותו, למה לא פשוט לעשות תשואת x + 1?
עכשיו, עוד כמה דברים צריכים להשתנות פה.
אני על המסלול הנכון.
מה עוד אני צריך לצבוט?
מישהו אחר.
כן?
[לא ברור]
הדוד י Malan: אני צריך לשנות את סוג ההחזרה של תוספת
כי זה לא לבטל.
חלל פירוש דבר לא הוחזר.
אבל ברור, עכשיו זה.
אז זה צריך לשנות לint להיות עקבי עם מה
בעצם אני חוזר.
>> עכשיו משהו אחר עדיין כרכרה כאן.
כן?
[לא ברור]
הדוד י Malan: אז אני צריך להגדיל x?
[לא ברור]
הדוד י Malan: אה, אז אני צריך לעבור x.
אז אני צריך לעשות את זה כאן.
אז אב הטיפוס, אני צריך לשנות את זה כאן.
אז זה צריך להיות int.
זה צריך להיות -
הממ.
למעשה יש לי באג כאן למטה.
בואו לתקן את זה ראשון.
מה זה צריך להיות למעשה?
אז זה חייב להיות משהו int.
זה יכול להיות x.
אבל בכנות, אם אתה מתחיל לקרוא את כל המשתנים x שלך, זה הולך להגיע
פחות ופחות ברור מי הוא מי.
אז בואו רק באופן שרירותי לבחור יום אמנה שונה עבורי
פונקציות עזר, פונקציות שאני כותב.
אנחנו קוראים לזה.
או שאנחנו יכולים לקרוא לו - בואו נקראים לזה even_number להיות אפילו יותר מפורש.
אז יש לי לחזור מה הוא המספר 1 ועוד.
ועכשיו אני צריך לשנות את דבר אחד כאן ואחד
דבר השני כאן.
מה יש לי לשינוי בקו 21 בפעם הראשונה?
אני צריך להקצות אותו x.
אז אני לא יכול פשוט לקרוא x תוספת.
אני צריך לזכור את התשובה על ידי שינוי הערך של x על
בצד השמאל.
ואף על פי x הוא עכשיו על ימין ועל שמאל, זה בסדר גמור, כי
בצד ימין מקבל להורג ראשון ואז מקבל צנח לשמאל
דבר יד, x במקרה זה.
ואז לבסוף, זה קל לתקן עכשיו.
זה פשוט צריך להתאים את מה שנמצא שם למטה.
מספר int.
>> בסדר.
אז כל חבורה של שינויים לתפקוד ממש טיפשי.
אבל נציג שלנו יותר ויותר דברים שאתה רוצה לעשות.
אז להפוך buggy4.
כבר פשלתי איפשהו.
אוי, אלוהים.
חמש טעויות ב, כמו, תכנית בת שש שורות.
אז מה רע בקו 18, דמות 5?
בסדר.
אז אני צריך להצהיר על זה int.
בסדר.
אז בואו נראה, חבורה שלמה של טעויות אחרות.
אוי אלוהים.
19, 18, 21.
אבל שוב, בואו פשוט לנקות את המסך -
L בקרה כאן - וקלאנג מחדש ריצה.
אז חמש בעיות שהן למעשה רק אחת.
אז עכשיו בואו תרוצו buggy4, Enter.
ואווה.
x כבר מוגדל בצורה נכונה.
>> בסדר.
כל שאלות על איך להגדיל מספרים?
כן?
רמקולים 2: איך זה שאתה פשוט יכול לשנות את x למספר במשתנה
שם ותדע למה אתה מתכוון?
הדוד י Malan: שאלה טובה.
איך זה שאני יכול פשוט לשנות את x למספר ואת התכנית יודעת
מייד?
אז שוב, תחשוב על זה כעל הפשטה זו.
אז אם אני ראשי וקן הוא הדרגתי, בכנות, לא אכפת לי
מה קן קורא iPad שלו.
לא אכפת לי מה שהוא מכנה כל דבר שיש לעשות עם יישומו
בפונקציונליות זו.
אז זה פירוט יישום ש, עיקרי, לא
צריך שיהיה אכפת.
וכך פשוט לשנות אותו בעקביות פנימית של הפונקציה, מספר כאן
ומספר כאן, הוא כל מה שנדרש כל כך הרבה זמן כמו שההידור מחדש.
זה קצת כמו שאם אתה חושב על - רבים מאיתנו, אלה מכם עם הנהג של
רישיונות שכבר מונעים, או אפילו אם אתה כבר עם מכונית -
רובנו אין לי מושג איך עובדת מכונית מתחת למכסת המנוע.
ופשוטו כמשמעו, אם אתה פותח את מכסה מנוע, רובנו - כולל אותי -
לא הולך באמת יודע מה אנחנו מסתכלים.
כמו סוג של אתה עלול להרגיש דברים כאלה עם זה עכשיו.
אבל אנחנו לא באמת צריכים לדאוג איך המכונית עובדת.
אין לנו לשים לב למה כל המוטות ובוכנות והכבלים בתוך של
המכונית עושה למעשה.
>> אז משהו כמו מה שאתם קוראים את הבוכנה לא משנה
כאן במקרה זה.
אותו הרעיון.
כן?
[לא ברור]
הדוד י Malan: אם היו יותר שימושים של רגע xa משתנה לפני,
אתה, המתכנת, הייתי צריכה לשנות אותם בכל מקום.
או שאתה ממש יכול לעשות את הקובץ, תפריט ולאחר מכן חיפוש / החלפה,
משהו כזה.
אבל אתה תצטרך לבצע שינויים אלה בעצמך.
אתה צריך להיות עקבי.
[לא ברור]
הדוד י Malan: סדר מסוים כמו כאן?
אם זה היה int מספר אחר?
כן.
אז על מנת שחשוב כאשר אתה קורא את הפונקציה.
אז אם אני היה קורא תוספת כאן עם משהו פסיק משהו,
יש מיפוי ישיר.
המשתנה הראשון, איך שלא קוראים, הוא עשה עותק של המהדורה הראשונה
ויכוח כאן.
מצטער, זה לא צריך להיות מוסגר.
בשורות השניות הטיעון עם עד השנייה אחת.
>> אז בסדר, כן, עניינים.
בסדר.
מצטער שלקחתי את הדרך ארוכה כדי להגיע לשם.
שאלות אחרות?
בסדר.
אז בואו נראה אם ​​אנחנו לא יכולים לצייר תמונה של מה שקורה בפועל על
כאן מתחת למכסת המנוע, אם אפשר לומר כך.
אז זה הוא מלבן שעשוי לייצג את הזיכרון של המחשב.
אז גם אם אין לך מושג איך עובד זיכרון או איך עובד הזיכרון RAM, לפחות
תניח שיש לך צרורות שלו בימים אלה.
יש לך מגה בייט שלו.
יש לך ג'יגה בייט שלו.
ואנחנו יודעים מאפס שבוע שבתים הם רק מה?
8 סיביים.
בסדר, אז 8 אפסים ואחדים.
אז אם המחשב שלך יש חלטורה של RAM, שתי הופעות של זכרון RAM בימים אלה, יש לך
מליארד או 2 מליארד בתים של זיכרון, או בערך 8000000000 או 16000000000
ביטים, בתוך המחשב שלך.
עכשיו בניגוד לדוגמא וילי הצמרית הקטנה, זה לא חלקיקים מגנטיים
בדרך כלל יותר.
יותר ויותר, במחשבים ניידים בכל המקום, זה כונני מצב מוצק, כונני SSD, כי
פשוט אין לי חלקים נעים.
הכל האלקטרוני.
הכל החשמל המבוסס.
כן, למרות שחושב, של מלבן זה כפשוט מייצג את אחד או שניים
ג'יגה בייט של זיכרון שיש לך.
>> אז זה נתח של זיכרון.
עכשיו העולם של מדעי מחשב יש סוג של גושים של מחיצה כדי
זיכרון כדי לעשות דברים שונים.
כך למשל, אם מדובר בזכרון RAM של המחשב שלך - כפי שהוצע על ידי
מלבן שם - מתברר כי למוסכמות, בחלק העליון של זכרון RAM שלך, ולכן
לדבר, הוא בדרך כלל מה שנקרא קטע טקסט.
אלה הם אפסים והאחדים שיש לך ערך.
לכן, כאשר אנחנו בדקנו מתחת למכסת המנוע במה a.out הוא, כל
את האפסים והאחדים -
כשאתה מפעיל את תכנית, האפסים והאחדים הללו נטענים משלך קשה
כונן למשהו שנקרא הזיכרון RAM.
ובזכרון RAM, הם שמו בראש.
עכשיו בינתיים, יש לך דברים אחרים.
נתונים אותחלו, נתונים שלא אותחל.
אלה שתי אגודות של זיכרון מתייחסות למשתנים הגלובליים, אשר
אתה לא משתמש לעתים קרובות.
אבל לפעמים אם אתה עושה, הם בסוף לשם גם כן.
אז יש כמה דברים אחרים.
משתני סביבה, שאנחנו לא מבלים הרבה זמן על.
אבל אז שני דברים חשובים שיחזרו בכל זה
סמסטר, מחסנית וערימה.
>> אז רוב זכרון המחשב שלך שמורה בעת הפעלת תכנית עבור
משהו שנקרא המחסנית ומשהו שנקרא ערימה.
ואנחנו לא מתכוונים לדבר על הערימה היום, אבל אנחנו
לדבר על הערימה.
והמחסנית נועדה להעלות באוב החזותי של כמו חדר האוכל
מגשי ארוחה בבית מאת'ר, או בכל המקום אתה במקרה, שבו
חדר אוכל צוות לנקות אותם כל יום.
הם עורמים אותם מהקומה למעלה.
וכך גם בזיכרון, אין זה רעיון של לשים משהו על
לערום, לשים משהו במחסנית, לשים משהו במחסנית.
ומה אנחנו מתכוונים בזה?
ובכן, בואו פשוט להתמקד על החצי התחתון של התמונה הזאת, המחשב שלך
זכרון RAM, להציע את הפעולות הבאות.
מתברר כי בעת הפעלת תכנית כמו a.out או שלום, מה
התכנית היא שאתה כתבת,
שוב, האפסים והאחדים הללו נטענים מהכונן הקשיח שלך - שהוא
אחסון ארוך טווח, נשאר שם גם כשאתה מושך את התקע -
נטען לזכרון RAM.
זכרון RAM הוא מהיר יותר מכוננים קשיחים.
הוא קטן יותר מכוננים קשיחים.
אבל זה מקום שבו תוכניות לחיות בזמן שאתה מפעיל אותם.
>> אז תלחץ פעמים על תכנית במקינטוש או PC - שהוא מתמלא מ
כונן קשיח לזכרון RAM.
ברגע שזה טעון לזכרון RAM, את האפסים והאחדים ללכת בראש הדרך,
מה שנקרא קטע טקסט.
אבל אז ברגע שהתכנית שלך בעצם מתחילה לרוץ, העיקרי
פונקציה נקראת.
ועיקרי, כפי שראינו, לעתים קרובות יש משתנים מקומיים.
ויש לה ints ומחרוזות ותווים וכדומה.
אז אם התכנית שלך שאתה כתבת או של התכנית שיש לך
כפול לחץ השתמש כמה משתנים בתוך ראשי, הם בסוף ב
תחתית הערימה של זיכרון שלך, אם אפשר לומר כך.
כעת מוחשי יותר, מה זה בעצם אומר?
זה רק אומר שאם אנחנו הולכים למספר הדברים -
אם אנחנו הולכים למספר הבתים בזיכרון RAM במחשב שלך, תבחין כי
זה יכול להיות מספר אפס בתים.
זה יכול להיות מספר ייט אחד, שתיים, שלוש, ארבעה, חמש, שישה, כל
הדרך עד ירצה -
2000000000 יהיו כל הדרך עד לשם בראש.
אז במילים אחרות, כאשר אנו מדברים על זכרון RAM או זיכרון במונחים של בתים, זה
רק אומר שמישהו החליט מה למספר כל אחד
הגושים האלה של זיכרון.
>> לכן, כאשר אתה צריך 32 ביטים לint, או שאתה צריך 8 ביטים לchar, שבי
הם בסופו של זיכרון?
ובכן מושגית, הם רק בסוף בתחתית זה
דבר הזה שנקרא מחסנית.
אבל מה שמעניין עכשיו הוא כאשר עיקרי קורא לפונקציה.
תניח שפונקציה בשם foo, רק שם שרירותי.
מה שקורה הוא עיקרי הוא בתחתית ערימה זו של זיכרון.
Foo עכשיו הוא לשים על גבי עיקרי בזיכרון.
אז כל משתנים מקומיים שהפך בסופו של foo סוג של מושגית לעיל
אלה עיקריים.
אם foo קורא פונקציה אחרת בשם בר, המשתנים האלה הגיעו לכאן.
אם בר קורא משהו אחר, כאן, כאן, כאן.
אז מה שמעניין בהפעלת תכנית הוא שככל שאתה קורא פונקציות,
כפונקציות אלה לקרוא לפונקציות, והפונקציות האלה לקרוא לפונקציות ו,
אתה בונה את ערימה זו של פונקציות בזיכרון.
ורק פעם בתשואות פונקציה אתה מתחיל לקבל זיכרון שיחזור.
לכן אחת הדרכים הקלות ביותר להפעלה מתוך זיכרון בתכנית מחשב הוא
לכתוב פונקציות שלא לחזור לעולם.
>> כך למשל, בואו להפגין באותה המידה עם
תכנית מכוונת כרכרה.
תן לי ללכת קדימה ואל # כוללים , int main (void).
ואני הולך לעשות בזמן (2> 1), שכנראה לא יהיה אי פעם
שינוי עלינו.
ותן לי ללכת קדימה עכשיו ולעשות printf.
למעשה, זה הולך להיות פחות מעניין מבחינה ויזואלית.
בואו נעשה את זה.
לint (i = 0; i> 0).
בואו נעשה את הטעות הזאת, אני + +.
ובואו לא printf כאן.
בואו להתאמן על מה שאני מטיף.
בואו שיטה כאן.
מקהלת החלל, ואנחנו נגיד אני int.
ואז אני הולך להגיד, printf -
הו, בואו נעשינו את זה יותר מעניין.
בואו ממש לא להדפיס כל דבר.
בואו פשוט נעשה את זה.
פזמון (אני).
>> בסדר.
אז זה עגלה כי למה?
אני עושה את זה כמו שאני הולך, כי התכנית לא תעשה דבר של ממש
של עניין.
אבל זה לא המטרה.
המטרה היא לכתוב תכנית שתפקידה העיקרי עושה מה, כנראה?
שיחה עוצמה.
ובעצם, אנחנו לא צריכים את הלולאה.
בואו אפילו לפשט זאת רק כדי לא לאבד את הראייה של ממש
באג בסיסי.
שיחות עיקריות מקהלה תשיר מקהלה.
ואז עשיתי משהו טיפשי, והיה לי שיחת מקהלת מקהלה משום שהנחתי
מישהו אחר היה הולך ליישם אותו אולי.
ועכשיו זה לא הולך לקמפל עדיין.
אני צריך לעשות את מה?
אני צריך את אב טיפוס, לזכור.
אז אני צריך להיות כאן מקהלת הריק (int i);.
>> אז עכשיו, אם אני יורד כאן -
בעצם, בואו להשתמש בחלון הגדול יותר.
בואו נלך קדימה ולהפוך את המקהלה.
שימוש בכרוז לא מזוהה אני.
אה, זה היה טיפשי.
אנחנו לא צריכים את הוויכוח.
בואו פשוט נעשה את זה.
חבל שלא התחיל בדרך זו.
זה היה יכול להיות תכנית הרבה יותר קלה לכתוב.
אז יש.
עכשיו בואו ניגשנו לחלון מסופי, קלאנג מחדש ריצה.
והנה זה בא.
זה היה ממש מהר.
מה בעצם פשוט אבל קרה?
ובכן, עכשיו אני אוסיף את קו ההדפסה, כך שאנו יכולים לראות.
אז הרשה לי לומר printf, תניח, אני כאן.
אוקיי, לא משתנה, אנחנו נשאיר את זה ככה.
תן לי להפעיל מחדש לעשות.
תן לי פזמון חוזר ריצה.
ותבואו.
תמשיך.
במאמר מוסגר, מדוע הוא עדיין לא התרסק?
אשמת הפילוח קרתה לפני סופר מהיר.
[לא ברור]
הדוד י Malan: בדיוק.
אז זה לוקח זמן כדי להדפיס.
זה פשוט לוקח יותר עבודה על החלק של המחשב.
וזה מה שיש.
אשמת פילוח.
>> אז שם לב עד כמה תוכניות לרוץ מהר.
אם אתם לא מדפיסים כל דבר, סופר מהיר.
אבל יש לנו עדיין אשמת פילוח זה בגלל מה שקורה?
ובכן, אם אתה חושב על איך הזיכרון של המחשב שלך הוא לפריסתו, זה
קורה להיות ראשי.
אבל כאן -
בואו פשוט נקרא הפזמון הזה, ובואו נקראים לפזמון הזה.
ועכשיו אם אני עושה את האסתטיקה שלי נכון, זה היה רק ​​זה שאומר מקהלה,
מקהלה, מקהלה, מקהלה, מקהלה, מקהלה, מקהלת, עד זרא.
וסופו של דבר, מה יקרה?
אם התמונה הגדולה, פשוטו כמשמעו, היא זו, מה בדיוק קורית רעיוני?
את צפות ערימת הערימה.
או גרוע מכך, אתה פשוט מוצף הכל, כולל קטע הטקסט, שהוא
את האפסים והאחדים שמייצגים את התכנית שלך.
בקיצור, זה פשוט סופר, סופר רע.
נכון?
התכנית שלך יצאה מכלל שליטה.
אתה משתמש בדרך יותר זיכרון ממה שהתכוונת והכל בגלל טיפשה
טעות, במקרה זה.
או במקרה הזה, פונקציה מאוד נעשה במכוון מכנה עצמו.
עכשיו זה לא כל כך נורא.
פונקציות קוראות לעצמם דווקא יש לו כוח גדול
כשאתה משתמש בו בצורה נכונה.
אני לא השתמשתי בו בצורה נכונה כאן.
>> אז זה לא כל כך נורא.
אבל העובדה שאני לא באמת אפסיק לקרוא לעצמי היא יסוד
חולשה כאן של תכנית זו.
אז לאן אנחנו הולכים עם כל זה?
ובכן, מה באמת קורה?
כשאני קורא את פונקצית תוספת, כמו שאנחנו עושים בדוגמות הללו,
יש לי ערך כמו 1 שאני עובר פנימה
אני עובר בעותק של מספר אחד.
אז הבא שקורה.
אז בואו נלך לדוגמא תוספת.
והבחור הזה, ממש כאן.
אז הנה מה שבאמת קורה.
כשהתקשרתי תוספת, ואני עובר בx, ציורי מה
קורה כאן הוא זה -
אם יש לי ערך של 1 נשמר כאן, ואני באמת קורא לתוספת, אשר
עכשיו נקרא מקהלה -
כן, זה זורק אותי מכאן.
אז בואו נקראים לתוספת זו.
ואנחנו לא יודעים מה הפונקציה הבאה זה הולך להיות.
אז מה בעצם קורה כאן הוא אי שם בעיקרי, יש לי נתח של
זיכרון, שאחסון המספר 1.
כאשר אני קורא את תוספת, אני משתמש בנתח נוסף של זיכרון, אבל עכשיו אני
יש עותק של 1.
כשאני להגדיל את הערך, זה הופך להיות 2 - כתוב בצורה איומה
מסך כאן.
אבל אז, מה יקרה ברגע שחוזר תוספת?
זיכרון זה פשוט מקבל להחזיר למערכת ההפעלה, מה שאומר שכל
עשית שום דבר מועיל.
האחד שהיה כלול במקור בשינה העיקרית הוא עדיין שם באמת.
>> אז לאן אנחנו הולכים עם זה?
ובכן, מתברר כי בזיכרון יש לך את זה, כדי לגבות רצף
בתים שאתה יכול לשים דברים פנימה
ומתברר שכבר ראו משהו שכרוך בהצבה
דברי גב אל גב אל הגב אל גב.
מה היא מחרוזת, המבוססת על שבוע אחד ועכשיו שבועות?
אז זה רק אוסף של תווים.
כך מתברר, בדיוק כפי שאתה יכול לשים את המספרים בזיכרון, באופן דומה אתה יכול
לשים את התווים בזיכרון.
וברגע שאנחנו מתחילים לשים תווים בזכרון גב אל גב אל גב אל
חזרה, מתברר ששימוש הפשוט ביותר של דברים כמו ללולאה או
לולאה בזמן, אנחנו יכולים לחזר -
משמאל לימין על התווים במחרוזת -
ולהתחיל לעסות אותם לדמויות שונות לגמרי.
יכול להיות ב-B יכול להיות C. אז שסופו של דבר, אנחנו יכולים לקחת
המשפט באנגלית שממש הגיונית ולהמיר כל אחד מאלה
מכתבים אחד בכל פעם על ידי הליכה דרך הזיכרון של המחשב שלנו נותרו
זכות למעשה להצפין.
>> אז בואו לקחת ההפסקה של חמש הדקות שלנו כאן, וכשנחזור, אהיה
להתחיל את התהליך הזה של ערבול מידע.
>> בסדר.
אז לפני שאנחנו צוללים לחלק האנוסים והדברים האלה נקראים מערכים, תן לי
להשהות לשאלות כי אני מרגיש שאני באמת סוג של מבולבל חלק
לנושאים אלו.
אז בואו נתקן עכשיו אם אנחנו יכולים.
אז אנחנו פשוט דברנו על ערכים לחזור.
דברנו על טיעונים.
ודברנו על הרעיון הזה, שאנחנו נחזור לשבועות
לבוא, של צפייה בזיכרון כחבורה שלמה של מוערם אלה
מגשים, אם אפשר לומר כך.
מלמטה למעלה, כך שכל מגש שמקבל לשים על הערימה מייצג
פונקציה הנקראת כיום.
יש שאלות?
אז מה דעתך - תן לי לנסות לשאול את השאלה.
אני שומר מקלקל את זה, אבל עכשיו - זהו כאלה כבר ראה את כל פניו של הילד.
אז אנחנו נחזור לזה.
>> אז הרשה לי לשאול שאלה כאן.
בואו תפשטו אותי בחזרה זה למה שהוא היה לפני כמה ש הקודם שלנו & A.
והעובדה שיש תוספת סוגריים פתוחים, מספר int, נסגרה
סוגריים.
מה מספר int מייצג?
[לא ברור]
הדוד י Malan: ויכוח.
אוקיי, אבל מה ויכוח?
[לא ברור]
הדוד י Malan: הסליחה, מה זה?
רמקולים 3: משהו שאתה עובר פנימה
הדוד י Malan: אוקיי.
אז משהו שאתה עובר פנימה
ואופן כללי יותר, זה רק הקלט.
אם אתה כותב את פונקציה ומטרה של אותו לתפקד בחיים הוא לעשות
משהו קצת שונה בכל פעם שאתה משתמש בו, אז הדרך היחידה עבור
כדי שזה יקרה באמת היה נראה לספק לו הזנה, כך שהוא
יכול לעשות משהו אחר עם שקלט בכל פעם.
>> אז אתה צריך לציין שני דברים כאשר הפונקציה לוקחת תשומות.
אתה צריך לציין את השם שאתה רוצה לתת לזה קלט, רק לשם
הנוחות שלך, כך שאתה יכול להתייחס אליו בפונקציה ש
את עצמך כותב, כפי שעשיתי כאן בקו 32.
אבל אתה גם צריך לציין את הסוג שלו, כי C היא שפת תכנות
זה פשוט דורש
שאם אתה רוצה משתנה, יש לך לומר למחשב מה
הקלידו נתונים זה,
בחלק גדול, כך שהוא יודע כמה ביטים ל
להקצות לאותו משתנה.
כי זה יכול להיות 6 -
מצטער, זה לא יהיה שש.
זה יכול להיות 16.
זה יכול להיות 8.
זה יכול להיות 32, אפילו 64.
אבל המחשב צריך לדעת.
עכשיו int בצד השמאלי מייצג את מה, לעומת זאת?
[לא ברור]
הדוד י Malan: מה זה?
[לא ברור]
דוד י Malan: הסוג של הפונקציה, ולייתר דיוק,
סוג הפלט שלה.
נכון.
אז אילו דבר בסוגריים מייצג את הקלט שלה, אם בכלל,
דבר לשמאל מייצג את התפוקה שלה.
ובמקרה הזה, כנראה תוספת מחזירה int.
וכך int הוא סוג ההחזרה של פונקציה זו.
>> מה זה אומר לחזור?
פשוטו כמשמעו, אתה משתמש במילת מפתח שיבה.
ואז, אם מה שאתה חוזר לימין של מילת המפתח הוא
מספר שלם, אז זה אכן עולה בקנה אחד עם מה שהבטחנו.
אתה לא יכול לעשות משהו כזה -
שלום, עולם -
כי זה מחרוזת.
ברור שזה אינו מספר שלם.
אז בקיצור, הניטל הוא באמת עלינו, המתכנת, להיות ספציפית כמו
למה שאנחנו חוזרים ואז באמת ללכת על החזרתו.
ולאחר מכן לעשות קצת יותר ברור ההקשר -
הנה הוא שוב.
ההקשר -
הפתעה גדולה מגיעה ברגע.
ההקשר כאן עכשיו הוא שהזיכרון של המחשב שלך הוא, שוב,
ג'יגה, 2 ג'יגה, לא משנה מה.
אולי זה יותר.
אולי זה פחות.
אבל מחשב רואה אותו כבעל מקטעים שונים.
משהו הולך שם למטה.
משהו אחר הולך שם למעלה.
חומר אחר הולך באמצע.
והיום, אנחנו רק מתחילים לספר את הסיפור הזה.
>> אבל אנחנו נחזור לזמן על זה.
לעת עתה, פיסת הזיכרון היחידה שבאמת אכפת לי היא קטע הטקסט
משום שרק מייצג את האפסים והאחדים
שיש outputted קלאנג.
אז כשאתה מפעיל את פקודה במקלדת כמו a.out, או שכפול
לחץ על סמל ב-Mac OS או Windows, התכנית שלך היא טעונה משלך קשה
נוסע לזכרון RAM.
ומטיל אותה בחלק העליון של זכרון RAM של המחשב שלך, אם אפשר לומר כך.
עכשיו בינתיים, כפי שהתכנית שלך מתחילה לרוץ ועיקרי מקבל נקרא ב
תכנית שכתבת או התכנית של Microsoft או Apple כתב, כולה
משתנים מקומיים בסופו שם למטה בחלק התחתון של זכרון המחשב שלך.
אבל אם קורא עיקרי פונקציה אחרת שעצמו יש משתנים או
טענות, הם בסופו מעליו.
ואם הפונקציה שקוראה משהו, הם בסופו מעליו,
מעליו, מעליו.
ורק פעם אחת פונקציה נעשתה ביצוע עושה את ערימת המגשים, כך
לדבר, תתחיל להיות נמוך יותר ויותר.
וזה מה שאז, בקליפת האגוז, מסביר, מדוע כאשר אתה קורא קובייה -
או שאתה קורא לתוספת -
אתה עובר בעותק של הערך.
ומה זה אומר ציורי הוא שאתה ממש אתה כותב
מספר 1 בחלק אחר של זיכרון, שינוי כי 1 ל 2, במקרה של
תוספת -
או 8, במקרה של קובייה -
ואז לזרוק את זיכרון זה בהקדם תוספת או הקובייה
חוזר פונקציות.
>> שאלה.
[לא ברור]
הדוד י Malan: איפה - משתנים הגלובליים מאוחסנים במה
קרא כרגע את הנתונים אותחלו או נתונים מאותחלים.
ההבדל הוא, אם יש לך משתנה גלובלי, ואתה מקצה אותו
מייד ערך עם סימן השוויון, זה בסופו בראש שם.
ואם אתה רק אומר x פסיק int ללא ערך, זה בסופו מעט
נמוך יותר בזכרון RAM, פשוט על ידי ועידה.
שאלות אחרות.
בסדר.
>> אז התמונה הזאת תחזור כפי שאנו מקבלים יותר חזקים ממה שאנחנו יכולים לעשות
עם המחשב.
אבל לעת עתה, בואו יש מבוא קצר לקריפטוגרפיה, סוג מסוים של
הצפנה שאינה פותר את כל בעיות העולם, אבל אין לפתור
כמה מהם.
במקרה זה לכאן, יש לנו משהו שנקרא הצפנה במפתח סודית.
והצפנה במפתח סודי, כפי שהשם מרמז, נובעת ביטחונה
מסוד.
כך למשל, אם אתה בחזרה בבית הספר יסודי ואתה עובר
מכתב קטן סוד אהבה לילד או הילדה את מוחץ על - אם אתה
רציתי להעביר את זה דרך הקהל, סביר להניח שלא היית כותב
שטר כזה באנגלית או כל השפה האם שלך הוא, אלא אתם
אולי להצפין אותו.
או שאולי פשוט לשלוח להם הודעת טקסט בימים אלה.
אבל אולי בעצם אתה מעביר להם פתק בכל הכיתה.
וכדי לעשות זאת היטב, באופן כזה שהחברים שלך והמורה
לא יודע מה שאתה כותב, אתה יכול לבוא עם פשוט למדי
אלגוריתם -
צעיר למרות שאתה יכול להיות -
רק כדי לטרוף את המילים.
אז במקום לכתוב, אתה יכול לכתוב ב 'במקום B, אתה יכול לכתוב
ג במקום C, שאפשר לכתוב D, וכן הלאה.
או שאתה יכול לבוא עם תרגום מתוחכם יותר של אותיות
לאותיות שונות.
אבל המלכוד הוא ילד או ילדה למי אתה שולח את המכתב הזה צריך
יודע משהו.
וזה מה ש, ברור?
כאילו, מה הסוד שלך.
כאילו, על מה הוא מיפוי שבין וכארוחת בוקר וCs וDs?
האם זה רק מוסיף אחד, כביכול, לכל אחד מהמכתבים ללכת מ
A ל-B, B ל-C?
האם זה מורכב יותר מזה?
אז אתה ומושא אהבתך צריך להיות מידע הסודי הזה.
אבל יש סוג של מלכוד-22 כאן.
אם זו הפעם הראשונה שאתה שולח מכתב אהבה זו דרך
כיתה, איך נער או הנערה שהולך לדעת מה הסוד גם הוא?
אז סוד מפתח אנוסים לא פותרים את כל בעיות העולם.
ויש בעצם מערכת יחסים שאנחנו נחזור לכיוון
סופו של הסמסטר.
>> בדומה לכך, אף אחד מאתנו יש כנראה אי פעם שלח -
באופן דומה, רובנו לא מכירים מישהו שעובד, למשל, ב
Amazon.com.
ובכל זאת, רבים מאיתנו כנראה קנו את הדברים ב-Amazon.com.
ולמד אותנו להניח כי אלה מסחר אלקטרוני
עסקות מאובטחות.
נכון?
כתובת האתר כנראה אומרת https.
יש אולי סמל של מנעול קטן וטיפשי במקום.
יש סוג כלשהו של הצפנת אבטחת פרטי כרטיס האשראי שלך
בינך וAmazon.com.
ועדיין, אם קריפטוגרפיה כרוכה לדעת איזה סוד, ובכל זאת אני לא
מכיר מישהו באמזון, ואני בהחלט לא סדרתי כל סוג של
סוד עם מישהו באמזון, איך המחשב שלי או הדפדפן שלי עושה את זה?
ובכן, מסתבר שיש סוגים אחרים של הצפנה לגמרי כי לפתור
שהבעיה.
אבל להיום, אנו נתמקד באחד פשוט, שבו אתה יכול לארגן ב
להתקדם ליודע איזה סוד, כמו 1 פלוס או מיפוי בין וכארוחת בוקר.
>> והתהליך של הצפנה בדרך כלל כרוך זה.
יש לך קצת טקסט רגיל, מתואר כאן בצד שמאל.
אתה מפעיל את זה דרך איזה אלגוריתם או הליך
להצפנתו.
אולי זה רק הופך B, B יהפוך ג ואז אתה בסופו של דבר עם
צופן טקסט.
בינתיים, לאחר שהמושא אהבתך מקבל את הפתק הסודי, הוא או היא צריכה אז
לפענח אותו על ידי ההיפוך בדרך כלל אלגוריתם שכדי לקבל
לגבות טקסט הרגיל.
עכשיו יש גלגולים פיסיים של זה.
לדוגמה, זה טבעת מפענח סוד קטנה.
וזו היא טבעת במובן זה שיש כאן שתי חוגות.
בפריפריה מחוץ לדבר הזה, יש אותיות A עד Z,
על אף שהן בסדר אקראיות.
ומבפנים, יש בעצם כמה מספרים, כך שעם זה
טבעת, אתה יכול להפוך את הסוג שלו מבחוץ, אבל לא מבפנים כדי ליישר קו
מספרים עם אותיות.
ובסרטון שאתה עומד לראות - שחלקם אולי ראה 24/7
סביב עונת חג המולד מסרט שנקרא סיפור חג המולד.
אתה תראה שראלפי הקטן היה כל כך להוט להבין מה יתומה קטנה
המסר הסודי של אנני היה לו שהיה מתקשר, אני חושב, ב
צורה של הודעות מספריות בתיבת סדרתי.
והיה לך לצבור את כל הקלפים הקטנים שהגיעו
בקופסא דגני הבוקר.
הייתה לך לשלוח אותם פנימה
היה לך כדי לקבל בחזרה את טבעת מפענח הסוד, כך שאתה יכול סוף סוף להבין
מה הוא המיפוי בין אותיות ומספרים,
או אותיות וספרות.
אז אני נותן לכם קליפ קצר זה מסיפור חג המולד להניע pset 2 ו
הדיון שלנו, ברגע של מערכים.
אז הנה יש לנו ראלפי.
>> [השמעת וידאו]
-זה היה ידוע לכל ומשונים שראלף פרקר מתמנה בזאת
חבר בחוג היתומה הקטן אנני הסוד והוא זכאי לכל
את הכיבודים והטבות המתרחשים אליהם.
בחתימה, יתומה הקטנה אנני.
תשובה, הפיר אנדרה!
בדיו!
כיבודים והטבות, שכבר בגיל תשע.
יאללה, בואו נגמור עם זה.
אני לא צריך את כל הג'אז שעל מבריחים ופירטים.
תקשיב, מחר בערב להרפתקה המסכמת של השחור
ספינת פירטים.
עכשיו זה זמן למסר הסודי של אנני לחבריך
של המעגל הסודי.
זכרו, ילדים, רק חברי המעגל הסודי של אנני יכולים לפענח
המסר הסודי של אנני.
זכור, אנני היא תלויה בך.
הגדר את הפינים לB2.
כאן הוא המסר.
12, 11 -
-אני בפגישה החשאית הראשונה שלי.
-14, 11, 18, 16 -
הפיר היה בקול גדול הלילה.
אני יכול לומר שההודעה של הערב הייתה באמת חשובה.
-3, 25.
זה מסר מאנני את עוצמה.
זכור, לא לספר לאף אחד.
כעבור -90 שניות, אני בחדר היחיד בבית שבו ילד בן תשע
יכל לשבת בפרטיות ולפענח.
אהה, הלכתי ב 'הבא.
א 'המילה הראשונה היא להיות.
ס 'זה היה בא יותר בקלות עכשיו.
U.
-נו, באמת, ראלפי.
אני חייב ללכת.
-אני אהיה ישר, MA.
גי-גאון.
-T, O. מקפיד.
הקפד מה?
מה הייתה יתומה הקטנה אנני מנסה לומר?
הקפד מה?
-ראלפי!
רנדי חייב ללכת.
אתה מוכן בבקשה לצאת?
-בסדר, אמא.
אני מייד החוצה.
-שאני מתקרב עכשיו.
המתח היה נורא.
מה זה היה?
גורלו של כדור הארץ עשוי להיות תלוי ועומד.
-ראלפי!
רנדי צריך ללכת.
-אני אהיה ישר, לכל הרוחות.
-וואו, כבר כמעט שם.
האצבעות שלי עפו.
המוח שלי היה מלכודת פלדה.
כל נקבובי רטט.
זה היה כמעט ברור.
כן, כן, כן, כן.
-הקפד לשתות השוקו שלך.
שוקו?
מסחרי עלוב?
בן זונה.
[וידאו השמעת END]
>> הדוד י Malan: אז יש לנו את הצפנה.
אז איך במחשב שאנחנו יכולים ללכת על יישום או
מייצג דברים כאלה?
ובכן, אנחנו צריכים דרך להביע את עצם קצת יותר גמישים מאשר
המשתנים שלנו עד כה מותרים.
היו לנו ints.
היו לנו תווים.
היו לנו צפתי וזוגות ועוד כמה.
אבל אלה הם פיסות בודדות של זיכרון שלא באמת מאפשרות לנו
לבטא את דברים כמו מילים ומשפטים וביטויים.
ואכן, יש לנו בשם מחרוזות דברים כאלה.
אבל הבטיח שזה באמת רק בפישוט CS50
ספרייה שאנחנו מתכוונים לקלף.
>> ואז הבה תתחיל לעשות את זה כאן.
תן לי ללכת קדימה, לפתוח את קובץ -
כל הקבצים הללו זמינים גם באינטרנט רגיל -
קרא array.c לפתור בעיה שאינם קשורה למייתרים אבל שמצייר
תמונה כאן של איך אנחנו יכולים להשתמש במשהו שנקראת מערך.
מערך הוא סוג נתונים.
זה סוג של משתנה, מסוג כלשהו, ​​שיש סוגי נתונים קטנים יותר מרובים
בתוכו גב אל גב אל הגב אל גב.
כך למשל, אם ברצוננו לכתוב תכנית קטנה שינתנו לך שלך
חידון ממוצע לקורס כמו 50 שיש שני בחנים, אתה יכול מאוד בקלות
לכתוב תכנית זו - המבוסס גם על חלק מהחומר של השבוע האחרון -
באמצעות GetInt וזוג של משתנים.
Int quiz1, quiz2 int, וזה די פשוט.
זה אולי 10, 20 שורות של קוד, מקסימום, כדי ליישם תכנית ששואלת
משתמש לשני ציוני בחנים ואז מחשב הממוצע שלהם על ידי הוספתם
יחד, חלוקה ידי שתיים, ואז להדפיס את התוצאות.
אנחנו ודאי יכולים לעשות את זה די בקלות עכשיו אחרי
חלק מספר דקות.
>> אבל הבעיה היא שמניח כי 50 היו שלושה או ארבעה בחנים.
תניח שאתה רוצה להשתמש באותה התכנית לכיתה שהייתה
חידונים שבועיים.
תחשוב על כיתה שיש חידונים שבועיים.
אם יש כמו 16 או כך שבועות בסמסטר, עכשיו יש לך 16 משתנים -
int quiz1, int quiz2, int quiz3, quiz4 int.
ברגע שאתה מתחיל לראות יתירות זה, זה העתקה והדבקה
של קוד, זה צריך להתחיל לעשות רצונך הייתה דרך טובה יותר.
ותודה לאל, כי מערכים, שיש.
אז בואו לעשות את זה.
ראשית, הרשה לי להציג את דבר פשוט מאוד שאנחנו כבר לא בשימוש עד כה,
אבל אתה רואה אותו מדי פעם בקוד.
זה מה שנקרא באופן כללי קבועה.
אז זה קבוע במובן זה שערך זה לא משנה.
הכנס האנושי בעת יצירה מתמדת הוא להשתמש בכל ההון
מכתבים, רק כדי שזה באמת בולט בקוד שלך.
ומילת מפתח המיוחדת שאתה משתמש ב-C # היא להגדיר.
אז אם אתה אומר # להגדיר, לאחר מכן רווח, ואז את המילה שברצונך להשתמש עבור
שמו של הקבוע, ולאחר מכן הערך של הקבוע.
אז הודעה, זה שונה מהקצאת משהו משתנה.
אין שום סימן שוויון.
אין שום פסיק.
זה מה שידוע בדרך כלל כהוראת preprocessor, אלא יותר על
בהזדמנות אחרת.
>> לעת עתה, זה יוצר ערך בלתי משתנה נקרא חידונים שבפועל
ערך מספרי הוא 2.
אז בכל מקום שאתה רואה חידונים, שעשועונים, חידונים לאורך קובץ זה, זה
רק המספר 2.
עכשיו, אם אני מסתכל עיקרי עכשיו, בואו נראה איך זה עובד.
בהתחלה, זה נראה קצת תמוה.
אבל זה כל הדברים משבוע אחד.
בקש מהמשתמש לכיתות.
איך עושים את זה?
ובכן, בקו 22 -
זה באמת חלק העסיסי -
אני מצהיר לצוף, אבל לא רק לצוף אחת.
הריני מצהיר, אלא מערך ערכי נקודה צפו.
זה משתנה הולך להיקרא ציונים, כפי שנרמז כאן.
אבל רק לקטע של תחביר חדש אז הם הסוגריים מרובעים האלה, העובדה
לאחר שאמרתי את ציונים לצוף ואז סוגריים פתוחים ואז מספר.
שימו לב, אם זה קבוע, זה בדיוק כמו שעשינו את זה.
פירושו של דבר מחשב, ייתן לי שני מצופים, ובואו ביחד קורא
ציוניהם.
זאת בניגוד להרבה יותר משעמם תהליך כזה.
לצוף grade1, לצוף grade2, וכן הלאה.
אז מערך מאפשר לנו ליישם את הרעיון הזה, אבל הרבה פחות מבולגן, ב
כך שאנו יכולים לכתוב שורה אחת של קוד במקום, יניח, 16 ל16
סמסטר שבוע.
אז אני לא רוצה קוד קשיח-2 משום שאם אתה חושב על זה עכשיו
לוגי - תניח בשנה הבאה CS50 שינויי 3 בחנים במקום.
והיה לי את המספר 2 כאן.
היה לי מספר 2 כאן.
זה הופך להיות מאוד משעמם וקל מאוד לפשל ולשנות בטעות
ערך אחד עד 3 ומתגעגעים ערך אחר של 2.
אז אני הולך לשם במקום מופשט זה ולהשתמש בזה קבוע, כי כשלה
השם מרמז, לא משתנה לעולם.
ועכשיו, לא משנה אם יש לנו אחר בחני השנה או הבאה, אני
רק צריכים לשנות אותו במקום אחד, עד כאן למעלה.
>> אז זה כל מה שקבוע הוא.
בינתיים, התכונה הרעיונית החדשה היא זה של מערך.
אז הסוגריים המרובעים ינתנו לי הרבה זה צף ומאפשר לי באופן קולקטיבי
קורא להם ציונים כאן.
אז עכשיו בואו נראה מה אני הולך לעשות.
כאן, בקו 24 היא תחילתו של ללולאה.
זה באמת שום דבר מהודר.
זה פשוט באמצעות חידונים במקום מספר קבוע בקוד.
אבל אין שום דבר שונה מבחינה אינטלקטואלית לשם בשבוע שעבר.
זה רק printf.
אז printf ("מספר% d החידון של% d"), כי אני פשוט רוצה להדפיס לתת לי חידות
מספר אחד משתיים, ואז שניים משתיים.
אז זה הוא אך ורק עניין אסתטי.
אבל חלק המעניין כרגע הוא בקו 27.
כדי למלא באחת משני המציינים עם נקודה צפה
ערך, אתה שוב להשתמש בסוגריים מרובעים.
במקרה זה, אני משתמש בזה בשבילי, כי לולאה החל עם אני שווה
איזה ערך, כנראה?
0.
>> אז באיטרציה הראשונה של לולאה זה, כאילו
כתב את זה בקוד.
אבל באיטרציה השנייה של לולאה זה, כאילו
כתב את זה בקוד שלי.
אבל העובדה שאני משתמש במשתנה היא מושלמת, כי, כפי שהשם
מרמז, זה משתנה שוויו בכל איטרציה.
אז אני ממלא מערך זה נקודה אחת בכל פעם.
מה מערך זה נראה לך?
ובכן, הסיבה שאני ציירתי מלבן זה סופר פשוט על המסך כאן
לפני היה מסיבה זו.
מערך הוא פשוט גוש של זיכרון ואחריו עוד חתיכה מזיכרון,
אחריו עוד חתיכה מזיכרון, וכן הלאה.
אז אם המערך שלי הוא בגודל 2, במקרה הזה כאן, כל מה שאני היה עושה על ידי
הקלדת ציוני הבחנים שלי, כמו כאן.
יש לי 100 על זה.
ואז יש לי 99 על זה.
אז הזיכרון הזה לא יכול גם לשמש משום שרק בקש
מחשב למערך בגודל 2.
הריבועים האלה עדיין נמצאים שם.
נכון?
עדיין יש לך שתי ג'יגה בייט של RAM, גם אם אתה רק
שואל לשני מצופים.
אז הרעיון מאחורי מערכים הוא שהמחשב פשוט לוקח נתח של זיכרון
ולאחר מכן מקצה בחתיכות קטנות יותר גב אל גב אל הגב אל גב.
ואז זה כל מערך הוא.
זה נתח רציף של זיכרון, אשר לתוך אתה יכול לשים את הדברים.
>> עכשיו זה קורה אז לעשות בדיוק כמה חישובים משעממים.
אם אני לגלול למטה כאן, זה מקום שבי אז לחזר על המערך.
אני בא עם הסיכום של כל הערכים במערך.
ואז אני משתמש בפונקציית הסיבוב כאן למעשה לעשות
הסיכום מחולק בחידונים.
אבל תן לי להניף את היד שלי שבכל סוג של חשבון מספיק לעת עתה.
אבל כל מה שהוא עושה עבורי בסופו החישוב ממוצע.
חידון אז קודם תוספת חידון שני, מחולק לפי 2, ולאחר מכן הדפסה
זה כמו int.
>> אבל בואו עכשיו מעבר לדוגמה אחרת הנקראת string1,
אשר מצייר תמונה דומה אבל מייתרי שימוש.
תן לי ללכת קדימה ולפשט את זה לרגע.
ותסלח כניסה לעת עתה.
הודעה בקו 19 של דוגמה זו, אני מקבל מחרוזת מהמשתמש.
אבל שים לב למה שאני עושה בא בשורות 22 ואילך.
בעצם אני iterating מעד - וזה טריק חדש -
strlen, אורך מחרוזת.
זוהי פונקציה שמגיעה עם C שאם אתה עובר אותו חוט, זה אומר לי
כמה דמויות הם שבמחרוזת.
זה הכל.
העובדה שזה strlen במקום אורך מחרוזת היא רק בגלל שזה
יותר תמציתי.
לפני 30 שנים, אנשים שאוהבים לכתוב דברים באופן תמציתי ככל האפשר.
אז אנחנו כבר המשכנו את כנס זה כאן.
אני + + רק אומר להגדיל i בכל איטרציה.
ועכשיו שם לב זה, וזה באמת מעניין.
אז בקו 24, אני אומר מחשב, תן לי אופי, 8
ביטים, וקורא לו ג.
אבל מה זה בצד ימין אומר?
באנגלית, מה זה מייצג?
[לא ברור]
הדוד י Malan: בדיוק.
תן לי את התו הראשון במערך.
או באופן כללי יותר, תן לי את דמות i-th במערך.
ומבין שזה חשוב עכשיו שכמדעני מחשב, אנחנו בעצם
לספור מ 0.
אין לך שיקול דעת עכשיו להתחיל לעשות את זה.
עכשיו אתה צריך להתנהג בהתאם לציפיות של המחשב ו
לספור מאפס כי [0] הוא הולך להיות ראשון
תו במחרוזת.
[1] הוא הולך להיות שני.
[2] הוא הולך להיות שלישי, וכך הלאה.
אז התכנית הזאת, אם אני אהדר אותו - זה הוא, שוב, string1.
>> אז להפוך string1.
ועכשיו אני רץ string1 בחלון המסוף שלי.
הוא מחכה לקלט, אז אני הולך להקליד, אומר דוד.
Enter.
ועכשיו הוא מדפיס את כל דוד על קווים שונים בגלל
שים לב למה שאני עושה.
אני מדפיס תו אחד בכל פעם.
עכשיו אנחנו לא נכנסנו לפרטים היום על זה.
אבל אני מחקתי לפני רגע סימון זו כאן.
מסתבר שאם המשתמש אינו מתנהג כשורה, יריבות, או סתם
מבולבל, אתה ממש יכול להיכשל לתת מחרוזת באורך מסוים.
אם אתה מכה על המקש הלא הנכון במקלדת, שאולי תנתנו לי
אין מחרוזת בכלל.
או אם אתה זדוני, ייתכן שתנסה להדביק בשווי של ג'יגה של
מאמר כדי למלא את המחרוזת.
ואם במחשב פועל מתוך זיכרון, מתברר שאנחנו הולכים
לחזור הערך המיוחד הזה שנקרא אפס.
אז לעת עתה, רק יודע שיש הערך המיוחד הזה שנקרא שnull
יאפשר לנו לבדוק כאשר אנחנו יוצאים מזיכרון, בין השאר.
>> אבל אם אני פותח עכשיו string2, תבחין בהבדל אחד כאן.
שים לב הבדל אחד כאן עם string2.
עם string2, זה ללולאה הוא קצת שונה.
תן לי למחוק את ערכי null כדי שנוכל לדבר על הדברים האלה בפעם אחרת.
אבל מה ששונה לגבי ללולאת הזמן הזה?
ואני יכול לחזור לדוגמה הקודמת.
אז זה גרסה 2.
זו גרסה אחת.
אחת, שתיים, אחת שתיים.
אז strlen השיחה היא איפה?
זה בחלקו הראשון של ללולאה.
כל מחשבות, מדוע אני עושה את זה?
כן.
[לא ברור]
הדוד י Malan: אז אנחנו לא קוראים לפונקציה בכל פעם אחת.
בדיוק.
היזכר ללולאות שהם סופר פשוט ברגע שאתה די
להבין שזה האתחול,
תנאי והעדכון.
הבעיה היא שהמצב שקורה בכל
איטרציה של הלולאה.
וכך בדוגמה זו כאן, מה רע בכך
שזה המצב שלי?
אתה קורא strlen שוב ושוב ושוב.
אבל ברגע שהקלדתי בדוד, שאורך המחרוזת הוא חמש.
וזה לא הולך להשתנות בכל איטרציה של הלולאה כי
מחרוזת היא עדיין D--V-I-D. אז זה רמז למה שהולך להיות
רעיון חשוב יותר וידוע כהחלטת עיצוב, שם - פשוט לא
להפוך את המחשב לעשות עבודה מיותרת.
>> עכשיו, בדיוק כמו צצה מקדימה של pset 2, pset 2 במהדורה הסטנדרטית הוא
הולך לאתגר אותך למעשה ליישם חלק מספר של צופן, חלק
מספר אלגוריתמי הצפנה, כך שאתה יכול גם להצפין ולפענח
מסרים סודיים, בדומה לראלפי אחד יש פוענחו.
במהדורה של האקר pset 2, אנחנו הולכים להיכנס קצת יותר.
אנחנו הולכים למסור לך קובץ ממערכת מחשב המכילה בפועל
חבורה שלמה של שמות משתמש וסיסמות מוצפנות בפועל, והאתגר
למהדורת ההאקר הולכת להיות לפיצוח הסיסמות והגזרה האלה
מה קריפטוגרפיה או מה הסוד שמש למעשה
ליצור הסיסמות האלה.
ואנחנו הולכים לעשות את זה על ידי שימוש בתכונה חדשה של C כאן שאני אתן לי
אתה רק הדגמה של, הידוע כטיעוני שורת פקודה.
>> אז מתברר, כחלק מכם אולי ראה בסעיף או בספרי לימוד,
עיקרי לא תמיד צריך להיות מבוטל בסוגריים.
מתברר שראשי יכול גם להיות כתוב ככה, בשני טיעונים,
argc וargv, שם argc הוא מספר המילים שהקלדת לאחר
שמה של התכנית בשורת הפקודה שלך.
וargv הוא את המילים עצמן.
וכמו הסוגריים המרובעים שם מציעים, argv הוא כנראה מערך.
זה הולך להיות מחרוזת אחרי מחרוזת אחרי מחרוזת בזיכרון.
אז מה אנחנו הולכים להיות מסוגלים לעשות, החל מpset 2,
משהו כזה.
אם אני עושה argv1, שהוא דוגמה תוכל לחזור אליו ביום שני, ולהפעיל
זה, שים לב שזה לא מצליח לעשות שום דבר עדיין.
זה פשוט מדפיס את שמו שלו.
אבל אם אומר שמעמד פרידה, שימו לב שתכנית זו כנראה סובב
על כל אחת מהמילים שהוקלדו בשורת הפקודה.
ואת האמצעי שבעזרתו אנו מקבלים גישה למילים שהמשתמש
הקליד בשורת הפקודה היא על ידי השינוי העיקרי, החל בסוף השבוע הזה, מint
ראשי (חלל) לint ראשי (argc, argv).
וכך יהיה נולד טיעוני שורת פקודה.
וברגע שאתה מקבל באמת מתוחכם בזה, תוכל לכתוב
תוכניות ממש Trippy, כגון זה שלפנינו, שהולך מעל ומעבר
חלק מהפונקציונליות שעשינו עד כה, אבל כולם די חזק.
>> אז אשאיר את זה עם זה על המסך.
ואנו רואים אותך ביום שני.