[Powered by Google Translate] [שבוע 2, המשך]
[דוד י מלאן, אוניברסיטת הרווארד]
[זה CS50. - CS50.TV]
בסדר. זה CS50, וזה הסוף של שבוע 2.
אם אתה מצפה שיהיה רעב בזמן הזה מחר,
ידעתי שאנחנו הולכים לכינוס כקבוצה קטנה מחר, יום חמישי, 1:15 pm.
יש URL זה כאן אם אתה רוצה לאשר השתתפות.
מספר המקומות מוגבל, אז אנא סלח אם הטופס מתמלא עד שאתה למלא את הטופס.
אתר אחר, לעומת זאת, שהיה בו עניין זה.
כמעט בזמן של חודש, כמובן הולך להיות זמין
כל באופן רחב יותר באמצעות edx, דרך שאנשים באינטרנט יוכלו לבצע יחד,
לעסוק בקורס די פעיל, למעשה.
הם ישתמשו CS50 Appliance וCS50 דיון
ורוב כלי תוכנה השונים שאנו כבר משתמשים בסמסטר הזה.
ואחת מהיוזמות שהיינו רוצה לקחת עליו כניסוי בשנה זו
הוא לראות עד כמה תוכן שאנו יכולים לתרגם
לשפות מדוברות וכתובה אחרות.
אז אם אתה יכול להיות עניין בהשתתפות בפרויקט זה
לפיו אנו נספק תמלילים וכתוביות באנגלית להרצאות של הקורס
ומכנסיים קצרים ובסמינרים וחתכים וכדומה,
אם אתה מדבר באופן שוטף או לכתוב ברהיטות שפה אחרת,
נשמח לשתף אותך בפרויקט זה לפיו אתה לוקח על אחד או יותר מהסרטונים,
לתרגם אותם לשפה שאתה יודע היטב.
>> כדי לתת לך תחושה של הממשק, יש ממשק משתמש מבוסס אינטרנט זה
כי יהיה לנו באמצעות שייצור ממשק משתמש כזה במהות.
זה היה לי מלמד איזה ליל כל קדושים לפני
ובצד הימני יש בשחור ליד חותמות זמן אלו,
אתה תראה את הדברים השונים שיצאו מהפה שלי באותו היום,
ואז מתחתיה תוכל לתרגם לשפה אחרת
בדיוק מה הוא המיפוי בין, במקרה זה, באנגלית, ואומרת, ספרדית.
אז זה בעצם כלי מאוד ידידותי למשתמש.
אתה יכול להריץ אחורה וקדימה במהירות מאוד בקלות עם קיצורי מקלדת.
אז אם אתם רוצים לקחת חלק בניסוי הזה ויש את המילים שלך ראו וקראו
על ידי פוטנציאל אלף של אנשים בחוץ, אנא אל תהסס להשתתף.
מילה אחת על החתלתול מיום השנייה.
פן שלחנו הודעה מדי מפחידה, הבין ש, כשעתי משרד מציעות
וכפי שמציעים חלקים, העיצוב של הקורס הוא מאוד
לתלמידים משתפים פעולה ומדבר לעבוד דרך סטי בעיה
ובעיות ביחד, ובאמת הקו פשוט מסתכם,
שוב, העבודה שסופו של דבר להגיש צריכה להיות שלך.
וכך בכנות, בשעתי עבודה במשרד זה נורמלי לחלוטין,
זה לחלוטין צפוי גם, שמשוחח איתו כמה חבר לידך.
>> אם הוא או היא מתמודד עם נושא מסוים ואתה כמו,
"נו, טוב, בוא וניתן לך מבט חטוף על כמה משורת הקוד שכתבתי," זה בסדר,
זה קורה, וזה מאוד מעודד, אני חושב, בתהליך של למידה.
איפה הקו מקבל חצה הוא כאשר הראש מוטה הוא סוג של כאן לשניות רבות מדי
או דקות שבאמת היו בדיוק הזדמנות הסבירה איך לחבר שלך,
ובוודאי כאשר דברים מקבלים החליפו באמצעות דוא"ל וDropbox וכדומה,
שם יש גם את הקו.
אז בכל האמצעים להרגיש בנוח וחשים עידוד כדי לשוחח עם חברים
וחבריו לכיתה על psets ועוד ופשוט מבינים שסופו של דבר מה שאתה להגיש
באמת צריך להיות התוצר של יצירה ולא שלך למישהו אחר.
וכך, אחת בעיות תחום הספציפיות לpset2,
שיצא מחר בלילה מאוחר, הוא לצלול לתוך העולם של קריפטוגרפיה,
שהוא האמנות של הצפנה או ערבול מידע,
וזה סופו של דבר מתייחס לעולם של ביטחון.
עכשיו, בטחון עבור רובנו מגיע בצורה של מנגנונים די שיגרתי.
לכולנו יש שמות משתמש וסיסמות,
ולכולנו יש שמות משתמש וסיסמות רעים מאוד, סביר להניח.
>> אם הסיסמה שלך היא זהה במספר אתרי אינטרנט, זה כנראה לא הרעיון הטוב ביותר,
כנדברנו לקראת סוף הסמסטר.
אם הסיסמה שלך כתובה על פתק דביק - לא בדיחה - על הצג שלך,
שגם הוא לא בהכרח הכי הטוב, אבל העיצוב די תופעה נפוצה.
ואם אתה לא משתמש בהצפנה כדי להצפין את הסיסמות שלך,
הם פגיעים במיוחד.
אז אם אתה חושב שאתה סופר חכם על ידי בעל מסמך Word נסתר
מקום בכונן הקשיח שלך, כי יש את כל הסיסמות שלך
אבל זה בתיקייה שאף אחד לא הולך להיראות ב, שגם הוא לא מנגנון מאובטח מאוד.
ואז מה יהיה להכניס pset2 הוא זו אמנות של קריפטוגרפיה
וערבול מידע, כך שדברים כמו סיסמות הם כל מאובטחים יותר.
ההקשר כאן הוא שעם נתונים מאובטחים
מגיע הזדמנות להצפין אותו וכדי לטרוף אותו.
וכך זה, למשל, הוא דוגמה להודעה מוצפנת.
זה בעצם אומר משהו באנגלית, אבל ברור שזה לא לגמרי ברור.
ואנחנו סגרנו מעגל היום להקניט בנפרד מה המסר הסודי הזה כאן הוא.
אבל בעולם האמיתי של מחשבים, דברים אפילו לא נראים כמו שהם יכולים להיות משפטים באנגלית.
לדוגמה, זה מה שאפשר למצוא על תקן לינוקס או מק או UNIX מחשב
בקובץ שהיה פעם שם קובץ הסיסמות.
>> בימינו זה כבר עבר למקומות אחרים.
אבל אם אתה מסתכל במקום הנכון במערכת, תוכל לראות לא רק את שם המשתמש שלך
או שאנשים אחרים במערכת, אבל תראה גרסה מוצפנת של הסיסמה שלהם.
ואכן, המילה קריפטה יש טוענת כי הדברים שלהלן הם מוצפנים,
וזו סדרה של אותיות אקראיות לכאורה ותווים ומספרים וכן הלאה
יכול להיות מפוענח רק על ידי ידיעת סוד כלשהו בדרך כלל -
מילה סודית, מספר סודי -
וכך אכן, האמנות של הצפנה בסופו של דבר מסתכם במורד לסמוך כלשהי
ולדעת משהו שמישהו אחר לא.
כך יהיה לנו לחקור את זה בפירוט קצת יותר היום ובpset לבוא.
ועכשיו מילה על עובר / נכשל.
במיוחד כפי שחלקכם צלל לתוך pset1, Appliance,
ועולם חדש מאוד לעצמך, להבין שתסכולים ובלבול
ורק קשיים טכניים הם די צפויים,
במיוחד עם pset הראשון, שבו יש פשוט כל כך הרבה דברים חדשים,
פשוט מקבל את מכיר את LS וcd וכל הפקודות המסתוריות האלה
וסביבה חדשה, וזה נפרד מהחומר בפועל ותכנות עצמו.
אז הבין גם שיש בהחלט שעתי עבודה שקיימת כמבנה תמיכה.
>> סעיפים מתחילים ביום ראשון הקרוב.
אבל הכי חשוב, אם אתם מרגישים שזה לא העולם בשבילך,
להבין שזה באמת פשוט ייקח זמן.
ואם לא היה ההזדמנות הזאת לפני שנים בשבילי לקחת לעבור כיתה / נכשל,
בכנות, לא הייתי אפילו כף רגלם בכיתה.
ואתה יכול לשנות את זה עד, יניח, 5 היום השני של הקורס,
כך שאם אתה בקצה עכשיו, מבין שלא בראש לכמה מים אחרים לגמרי,
בהחלט תשקלו רק משנה לעובר / נכשל.
שוב, אין באמת זו תרבות כאן ברווארד של לקיחת דברים עוברים / נכשל
מאז כולם באמת רוצה להשיג או overachieve,
אבל בכנות, זו היא דרך נפלאה של ניסה משהו
כי לא יכול להיות מוכר לך, ותקבל בסופו של דבר לעשות, ברוב המקרים, אפילו בסדר גמור,
אולי להפתעתך.
ובמונחים קונקרטיים יותר, מה שאני חושב עובר / נכשלתי בדרך כלל עושה,
במיוחד כפי שאולי חווה עם pset0,
אם אתה מכניס 10 שעות, 15 שעות, 25 שעות לתוך pset חלק
ואתה פשוט לדפוק את הראש בקיר וזה מתחיל להיות סופר מאוחר בלילה
אבל אתה כבר לקחת 90% pset של הדרך ואתה פשוט לא יכול להבין דבר אחד,
עובר / נכשל באמת לוקח את עוקצו של מעמד כזה,
שבו אתה יכול למיין של שמחה אומר, "בסדר, אני יודע שזה לא מושלם,
אבל עבדתי לי את התחת על זה, אני די מרוצה מזה שבו בסופו, "
ושיעמוד בציפיות לעוברים / נכשל.
אז אל תשמור את זה בחשבון. בסדר.
>> אז אלו מכם שנאבקו להשתמש אוניברסיטת הרווארד Wi-Fi,
יודע שיש CS50 SSID, חיבור Wi-Fi, מרחף
שייתכן שתהיה לך מזל טוב ל.
זה קצת אירוני שהסיסמה לזה, אם ברצונך לנסות להתחבר לזה
למהירויות טובות יותר - ולהודיע ​​לנו אם זה לא היה טוב יותר - היא עד 8 12345, כל הדרך
כי 8 הם בטוחים יותר מאשר 5.
אז אם אתה צריך את הסיסמה לאינטרנט האלחוטי, חיבור לCS50 אלחוטי כאן, 12345678,
והודעה על CS50 דיון אם עדיין יש לך בעיות קישוריות לסירוגין,
ואנחנו ניידע את הכוחות שיהיה מכירים למרחב הזה. בסדר.
אז טיזר מהיר, במיוחד עבור אלה מכם שהם בנים או בנות מאוורר של אפל כל הדברים.
מה שחפרתי מלפני כמה שנים היה זה קובץ כאן, iUnlock.c,
רק לסוג של להפוך למוחשי יותר ויותר מורכבים
חלק מהתוכניות הבסיסיות יותר C אנחנו כבר כותבים.
אז פתחתי את הקובץ הזה, iUnlock.c. זה זמין בדף ההרצאות להיום.
בצד השמאל אתה רואה רשימה ארוכה של פונקציות.
אז הבחור שכתב את הטקסט הזה כתב למעלה הרבה פונקציות, יותר מאשר רק ראשי.
הוא השתמש בכל חבורה של ספריות לכאן, ואם אנחנו מתחילים לרפרף,
מה שזה באמת הוא, אני מאמין, את הסדק הראשון לאייפון המקורי.
>> כאשר אתה רוצה jailbreak iPhone המקורי, מה שאומר untether מ-AT & T
ובאמת להתקין תוכנה מיוחדת עליו ולעשות דברים שאפל לא רוצה שאנשים יעשו,
מישהו לקח את הזמן כדי להבין בדיוק איך הם יכולים לנצל פגמים בתוכנה,
טעויות, באגים בתוכנה של אפל, וכך נולדו iUnlock.c--
שאם חברת אותו במחשב שלך ולהתקין אותו על ה-iPhone
שהיה מחובר למחשב באמצעות, למשל, כבל USB,
זה ייתן לך הרשאות ניהול או שורש על iPhone
וניתן לך לעשות פחות או יותר מה שאתה רוצה.
ואז היה חתול זה מרתק ומשחק עכבר
בין אפל ושאר העולם בפרט כפי שהם, כמו חברות רבות,
תנסה לנעול את החומר שלהם כלפי מטה, כך שאתה יכול לעשות רק עם זה מה שהם מתכוונים.
אבל הודות לאנשים כמו זה וההבנה של פרטים ברמה נמוכה -
ובמקרה זה תכנות C - והרבה מהמבנים המוכרים
שאנחנו כבר התחלנו לשחק איתו, אתה יכול באמת למנף את החומרה
באופן שאתה רואה לנכון ולא בהכרח חלק התאגיד.
כך למשל, אין לי מושג מה כל זה עושה,
אבל GetVersion נשמע די פשוט,
וזה נראה כאילו זה הוא פונקציה שהאדם הזה כתב.
זה לוקח קצת סוג של מספר שלם כויכוח, לא מחזיר שום דבר,
אבל נראה שלולאה בלולאה לכאן ואם מצב, אם מצב הפסקה,
ואיכשהו מתייחס למספרי גרסות אם לגלול למטה,
למרות שהרבה מילות מפתח אלו הולכים להיות חדשים.
ויש המון פונקציות בכאן שלא ראו ואי אפשר שלא נראה
במהלך הסמסטר.
>> בסופו של היום, זה כפוף לאותם חוקים והיגיון שאנחנו כבר משחקים עם עד כה.
אז זה זקן מכדי לפצח -3 iPhone או 4s או מייד 5s בימים אלה,
אבל יודע שזה נובע במידה רבה מכל העולם הזה שאנחנו כבר צללנו לתוך.
בואו נסתכל על דוגמה קטנה ופשוטה יותר:
את זה, רק כדי להתחמם קצת עם תחביר וגם איזה סוג נתונים אחרים
שדברנו עליו אבל לא באמת ראינו בג
זה קובץ שנקרא positive1.c, ולפי תגובות בראש,
זה פשוט דורש שמשתמש לספק מספר חיובי.
אז זה דוגמה לעשה תוך לולאה, וזה נחמד לתוכניות משתמש אינטראקטיביות
שבו אתה צריך להגיד למשתמש לעשות משהו,
ואם הם לא ישתפו פעולה אתה צועק עליהם או לדחות את הקלט שלהם.
מקרה לדוגמה: אני הולך לעשות קווים 19 עד 24
כל עוד המשתמש לא נתן לי מספר חיובי.
פרט זה כאן בקו 18, למה אני מצהיר מעל כל n looping זה לבנות
בניגוד לימין ליד קו 22 שבו אני ממש אכפת לקבל n? כן.
[תלמיד] סקופ. >> כן, אז בעיה זו של היקף.
ובמונחים של הדיוטות, מה היקף מתייחס?
כן. >> [תגובת תלמיד לא נשמעה] >> אתה יכול לדבר קצת יותר חזק?
[תלמיד] איפה אתה יכול לגשת למשתנה זה. >> מושלם.
איפה אתה יכול לגשת למשתנה מסוימת.
ובאופן כללי, כלל האצבע עד כה היה כי ההיקף משתנה כלשהו
מוגדר על ידי הסוגריים המסולסלים האחרונים שראיתם.
>> ולכן במקרה זה, אם אני עשיתי את הטעות של הכרזת n ב 22 לקו, קו שיעבוד.
הייתי מקבל int, ואני היה מנסח את זה n משתנה בקו 22,
אך שורת הקוד יהיה עכשיו אין לי מושג על מה אני מדבר? >> [תלמיד] 25.
[מלאן] 25, ומתברר גם כי 24 במקרה זה נופל מחוץ לסוגריים המסולסלים.
אז פשוט קצת מפריע, אבל פתר בקלות פשוט על ידי הכרזה על משתנה
מחוץ לתפקיד עצמו.
נראים בהמשך היום אתה יכול ללכת צעד אחד קדימה
ואפילו אתה יכול לקבל קצת עצלן.
וזה לא כדי להיות מומלץ באופן כללי, אבל אתה יכול גם לעצלנים
והכניס את משתנה גלובלית, אם אפשר לומר כך, לא פנימי של פונקציה, לא בתוך לולאה,
אבל בקובץ עצמו, מחוץ לכל הפונקציות שכתבת, כפי שעשיתי כאן ב 15 לקו.
זה בדרך כלל זה בעין יפה, אבל מבין שזה פתרון לפעמים לבעיות אחרות,
כפי שסופו של דבר יראה.
אז לעת עתה נשאיר את זה ככה, אבל בואו נראה אם ​​אנחנו יכולים לכתוב את זה מחדש
רק כדי להתחיל לבטא את עצמנו באופן מעט שונה.
תכנית זו, רק שיהיה ברור, היא positive1.
תן לי ללכת קדימה כאן ובחלון מסופי לעשות positive1, Enter.
הידור בסדר. אני הולך לרוץ positive1, על Enter.
אני דורש ממך לתת לי מספר חיובי. אני אגיד -1. זה לא עבד.
0, 99. נדמה שזה עובד.
אולי לא במבחן הקפדני ביותר, אבל לפחות זה צק של שפיות נחמדה
שאנחנו על המסלול הנכון.
>> אז עכשיו תן לי ללכת קדימה ולפתוח את הגרסה 2 של זה,
ומה שונה כבר?
היא מיישמת את אותו דבר, אבל מה שקופץ החוצה ברגע בבירור שונים הפעם?
זה bool בירוק. זה מסומן בירוק, מילת מפתח זו המכונית bool, שהוא סוג נתונים.
זה לא באו מובנה לכל הגרסות של ג
אתה צריך לכלול ספרייה ספציפית.
במקרה שלנו, אני כלל CS50 הספרייה, כך שיש לנו גישה לbool.
אבל בקו 18, שנראה שיש ערך בוליאני כאן נקרא אסיר תודה.
הייתי יכול בשם כל הדבר הזה, אבל אני קראתי אותו תודה
רק לסוג של להעביר כמה משמעות סמנטית.
אז בהתחלה בקו 18, אני כנראה לא תודה
מכיוון שהערך מודה וליאני מאותחל לכוזב בקו 18.
ואז זה נראה מה שעשיתי כאן בקווים 21 עד 23
אני פשוט סוג של שוכתב ההיגיון שלי.
אז לא פונקציונלי שונה, אבל בקו 22 עכשיו אני בודק אם int המשתמש ספק
גדול מ 0, אז אני פשוט לשנות את ערכו של אסיר תודה לאמיתית.
ולמה אני עושה את זה? כי בקו 25, כנראה אני הולך לבדוק מצב.
האם זה לולאה בזמן אסירי תודה הם שקרי.
אז הצעתי את זה כאלטרנטיבה לגרסת 1
כי זה לפחות קצת יותר אינטואיטיבי, אולי, זה קצת יותר מעוגן באנגלית.
אז בצע את הפעולות הבאות בזמן שאתה לא מודה או בעת אסירי תודה הוא שקרי.
וגם הפעם אני כנראה לא רוצה לזכור את מה שהמשתמש הקליד ב
בגלל הודעה שאין n משתנה, ולכן למעשה, שקר לבן קטן שם.
>> מבחינה פונקציונלית, התכנית היא קצת שונה הרגע שנגיע לתחתית שלה
כי אני לא זוכר מה הוא n.
אבל רציתי להדגים גם כאן שלמרות שאנחנו ראינו GetInt
וGetString בשימוש בצד הימני של סימן השוויון עד כה
כך שאנו זוכרים את הערך, מבחינה הטכנית, זה לא הכרחי.
אם מסיבה כלשהי אתם פשוט לא אכפת לך לשמור את הערך,
אתה רק רוצה לבדוק את הערך, שים לב שאנחנו יכולים פשוט לכתוב את זה כGetInt,
פתוח סוגריים, paren הקרוב.
פונקציה שהוא הולך להחזיר ערך, כפי שאנו טוענים.
זה הולך לתת לך בחזרה int.
ולכן אם אתם חושבים נפשיים שזה יקרה,
כשאני מקליד ב99, GetInt מחזיר את המספר 99,
ולכן רעיוני, שזה כאילו הקוד שלי היה למעשה זה.
אז אם 99 הם אכן גדול מ 0, אז תודה הופכת אמיתית,
אז קו 25 מבין אווה, סיים כי אני עכשיו אסירת תודה,
ובקו 26, אנחנו פשוט אומרים, "תודה על המספר החיובי!"
כל זה קרה להיות.
עכשיו בואו נעשה סוכר תחבירי קל כאן, כביכול.
בואו נראה אם ​​אנחנו יכולים לנקות את קו 25 זה עם גרסה שלישית ואחרונה זה בpositive3.
>> שים לב ההבדל היחיד כרגע הוא מה שורת הקוד? >> [תלמיד] 25. >> [מלאן] כן, 25.
ואנחנו כבר לא ממש ראינו את הטריק הזה עדיין, אבל אנחנו לא רואים את סימן הקריאה ביום שני,
אשר מציין מה? >> [תלמיד] לא. לא >> או שלילה.
אז קח את הערך בוליאני ולהעיף את הערך שלו.
האמת הופכת להיות שקר, שקר הופך להיות אמת.
אז כך, אני הייתי מציע, היא אפילו קצת יותר אינטואיטיבית דרך של כתיבת הקוד
כי אני עדיין לאתחל מודה לשקר, אני עדיין עושה את הדברים הבאים,
אני מודה לנכון לקבוע בבוא העת,
אבל עכשיו אתה יכול באמת רק לתרגם את הקוד הזה השאיר מילולי לימין,
בזמן (תודה!); בגלל נקודת מפץ או קריאה מציינת את הרעיון של לא,
זאת תוך לא אסיר תודה.
אז שוב, אנו לא הצגנו כל מושגים חדשים כשלעצמה.
דברנו על Booleans אחורי כששחקנו עם שריטה,
אבל עכשיו אני מבין שאנחנו פשוט יכולים להתחיל לכתוב את הקוד שלנו בדרכים רבות ושונות.
אז במיוחד בpset1 אם אתה סוג של נאבק כדי להבין את הדרך לכתוב איזה תכנית,
סיכויים הם לך מזל, כי לא יכול להיות כל מספר של פתרונות
שיכול לקרות בעת.
לדוגמה, זה רק 3 לאפילו הפשוט ביותר של תוכניות. בסדר.
ועכשיו נזכר ביום שני יצאנו בנימה זו עם ערכים לחזור.
אז בפעם הראשונה שכתבנו תכנית שלא רק לי עיקרי;
יש לו גם פונקציה מותאמת אישית משלה שכתבתי כאן.
אז בקו 31 דרך 34 שהתקנתי את פונקצית קובייה.
זה לא מורכב. זה פשוט * * במקרה זה.
אבל מה חשוב בזה הוא שאני לוקח את הקלט בצורה של
ואני מחזיר פלט בצורה של * *.
אז עכשיו יש לי את היכולת, הרבה כמו שהייתי עם prinf לבד,
לקרוא לפונקציה זו על ידי קריאה לפונקצית הקובייה.
>> ופונקצית הקובייה לוקחת קצת קלט, ופונקצית הקובייה מחזירה חלק פלט.
לעומת זאת, printf פשוט עשה משהו.
זה לא החזיר דבר שחשובים ל, למרות שכפי שצד זה להחזיר ערך;
בדרך כלל אתה פשוט להתעלם ממנו.
Printf פשוט עשה משהו. זה היה תופעת לוואי של הדפסה על גבי המסך.
לעומת זאת כאן, יש לנו את פונקצית הקובייה, שלמעשה מחזירה משהו.
אז למי שמכיר את זה, שזה רעיון פשוט למדי.
אבל עבור אלה פחות מכירים את הרעיון הזה של העברה בתשומות ותפוקות מקבלות בחזרה,
בואו ננסה פשוט פשוט סופר משהו.
האם מישהו בנוח לבוא לבמה לזמן קצר?
אתה צריך להיות נוח עם מצלמה עליך גם. כן? אוקיי.
מה שמך? >> [תלמיד] קן. >> קן. בסדר. קן, יעלה למעלה.
קן הולך להיות פונקציה של מיני סוגים.
בואו נלך קדימה ולעשות את זה. בואו תחביב קטן.
נע מאוד. ברוכים באים למרכז במה. בסדר.
בואו נכנסתי ללחצן זה כאן. בסדר.
אז הנה יש לך לוח מודרני,
ומה שאני הוא הפונקציה העיקרית, למשל,
ואין לי אייפד ביד שלי.
>> אני לא ממש זוכר איך - ובכן, אני לא יכול להגיד את זה.
אני לא באמת צריך את כתב יד טוב,
וכל כך ולכן אני רוצה שלהדפיס משהו על המסך שלי.
אני מתנהג בתכנית הראשית, ואני הולך יש לך להגיד את זה
על ידי כתיבתו בהתחלת עופי ואז עובר לך קלט.
אז אווילי ככל שהתרגיל הזה הוא, הרעיון של פונקציות וקוראים לפונקציה
וחוזר לתפקד באמת מסתכם זו.
אני עיקרי, יש לי רק כתבתי משהו printf, במרכאות על המסך,
אני מפעיל תכנית זו, וברגע שprintf מקבל נקרא,
זה לוקח טיעון אחד או פרמטר אחד לפעמים בין מרכאות כפולות.
הנה הטיעון הזה. אני מעביר אותו לקן.
הוא קופסה שחורה כתבה חלק לפני מספר שנים
כנראה שרק יודע כיצד להדפיס דברים על המסך.
אז לבצע.
זה לא רע. טוב מאוד.
אז עכשיו קן נעשה ביצוע. האם הוא צריך למסור לי משהו בחזרה?
לא שראינו עד כה.
שוב, printf אין בעצם להחזיר מספר, אבל אנחנו הולכים להתעלם כי לעת עתה
כי אנחנו אף פעם לא השתמשנו בו. אז זהו זה לקן.
ואז עכשיו ראשי לוקח על שליטה בתכנית שוב
כי קו זה של קוד, printf, נעשה ביצוע.
ואנחנו הולכים על הדרך שלנו, ביצוע כל קווים אחרים נמצאים שם.
אז עכשיו בואו ננסה דוגמה קצת שונה.
הפעם כאן בואו לנקות את המסך ראשון, והפעם אנחנו נעשה את הפונקציה עקוב,
אבל הפעם, אני מצפה ערך תפוקה.
>> אז בואו נלך ותעשה את זה.
עכשיו יש לי שורת הקוד שאומרת x מקבל קובייה של x.
שורת הקוד, כזכור, נראית כך: x = קובייה (x);
אז איך זה הולך לעבוד? בואו נלך קדימה ולתת לך מסך לבן שוב.
אני מתכוון לכתוב עכשיו את הערך של x,
אשר ברגע זה בזמן קורה להיות, יניח, 2 לשמור את זה פשוט.
שכתבתי על פיסת נייר הערך של 2, שהוא x הערך שלי.
אני מעביר אותו לקן. >> ואני רק כותב את התשובה? >> כן, בואו פשוט נכתוב את התשובה.
אוקיי. ועכשיו הוא צריך להחזיר לי משהו. מושלם. נחמד רצף.
אז עכשיו הוא מחזיר לי את הערך של 8 במקרה זה, ומה אני עושה עם זה?
למעשה - בואו לראות, לקבל זכות זו. מה אני הולך לעשות עם זה?
עכשיו אני הולך לקחת את הערך הזה ובעצם לאחסן אותו באותם הקטעים האלה בזיכרון.
אבל תשים לב שאני סוג של נאבק כאן.
אני קצת מבולבל כי לאן אני בעצם לכתוב את הערך של x,
כי מה בדיוק עשיתי הוא קן יד פיזית פיסת נייר שהיה לו ערך 2,
שהיה x, ואכן, זה בדיוק מה שקרה.
אז מתברר שכשאתה קורא לפונקציה ואתה עובר בויכוח
כמו שלום, עולם או שאתה עובר בטיעון כמו 2,
בדרך כלל, אתה עובר בעותק של ויכוח.
וכך בדיוק כפי שכתבתי את המספר 2 כאן ומסרתי אותו לקן,
שיש אומר שעדיין יש לי עותק של הערך 2 במקום
כי אכן, עכשיו אחרי שקבלתי בחזרה את הערך 8, אני צריך לחזור בזכרון RAM
ובעצם לכתוב ירידה של 8 שבו היה לי פעם המספר 2.
אז מבחינה ויזואלית, זוכר את המושג הזה של עובר ב, פשוטו כמשמעו, עותק של הערך.
>> קן עושה את הדבר שלו, מחזיר לי משהו - במקרה זה ערך כמו 8 -
ואז אני חייב לעשות משהו עם זה ערך אם אני רוצה לשמור על הסביבה.
אז כל זה יחזור להיות מוכר מדי לפני זמן רב.
תודה רבה לך על זה הדגמה כאן, קן. [מחיאות כפות]
עשה טוב מאוד.
בואו לראות איך שסופו של דבר מתייחס לחלק מהפונקציה קוראה שאנחנו עושים כאן.
תן לי ללכת קדימה ולהחזיר אותנו לדוגמא עקוב כאן.
שים לב שאם אנחנו רוצים באמת להתחיל לקחת את זה עוד יותר,
אנחנו הולכים צריכים להיות מודעים לעובדה שהמספר x המועבר כאן
שונה ממה באמת מועבר לפונקציה.
אז שוב, זה לעבור על עותק הוא הולך להיות די שייך ברגע.
בואו נסתכל על משהו שלא ממש עובד נכון עדיין.
אני הולך קדימה, לפתוח למשל מרכבה שלישית, שלוקה בטבע,
וזה נקרא buggy3 והוא מיישם פונקצית החלפה.
כאן יש לנו פונקציה עיקרית שx ו-y מאותחלים באופן שרירותי 1 ו 2, בהתאמה.
אנחנו יכולים להשתמש בGetInt, אבל אנחנו פשוט צריכים תרגיל פשוט,
אז זה קידוד קשיח כמו 1 ו 2.
בקווי 21 ו 22, אנחנו כנראה להדפיס את X ו-Y, 1 בכל שורה.
ואז ב 23 לקו, אני טוען שאני מחליף את הערכים הללו, נקודה, נקודה, נקודה.
כנראה שאני קורא לפונקציה בקו 24 שנקראה החלפה לוקחת 2 טענות.
זה חוקי לחלוטין לפונקציות לקחת 2 טיעונים. ראינו printf לעשות את זה כבר.
>> אז ההחלפה כנראה לוקחת X ו-Y, וכפי שהשם מרמז,
אני מקווה שזה הולך להחליף 2 ערכים אלה.
אז אני טוען שעל קו 25 "החליפו!" ואני להדפיס מחדש את x ו-y
בהנחה שהם אכן הוחלפו.
אבל אם אני באמת להפעיל תכנית זו - תן לי לפתוח את חלון מסוף,
תנו לי לעשות buggy3 - כפי שהשם מרמז, זה לא הולך להסתיים בטוב
כי כשאני על Enter, תבחין כי x הוא 1, y הוא 2,
ובכל זאת בסוף התכנית, הם עדיין, למעשה, את אותו הדבר.
זאת בהתבסס על ההפגנה רק עכשיו עם קן, מה בעצם קורה?
בואו לצלול לתוך פונקצית עסקה זו. זה סופר קצר. זה רק כמה שורות של קוד ארוך.
אבל מה הבעיה הבסיסית המבוססת על הסיפור פשוט ספר כאן עם קן?
למה החלפה שבורה?
[תלמיד] אתה אחסון להעתקה, לא משתנה.
בדיוק. אנחנו אחסון להעתקה, לא משתנים עצמו.
במילים אחרות, ככל הנראה ההחלפה לוקחת 2 טענות, int,
וזה נקרא באופן שרירותי וב,
וכאן אני כבר עברתי בX ו-Y, שהם 1 ו 2 בהתאמה,
אבל אני לא ממש עובר בx, אני לא ממש עובר בy,
אני מעביר עותק של x ו עותק של Y.
זה כמעט כאילו אתה להעתיק ולהדביק לתוך ההחלפה
את הערכים שאתה רוצה שזה בעצם מניפולציה.
אז אם זה מצב, אז כאשר אני תחילת תכנית ביצוע קו 35 36,
כשאני מגיע לקו 37, בנקודה זו בסיפור, מהו הערך של a?
בנקודה זו בסיפור, קו 37, מהו הערך של בנקודה זו? >> [תלמיד] 1.
[מלאן] זה פשוט צריך להיות 1, נכון, כי x היה מועבר כטענה הראשונה,
ופונקציה זו רק באופן שרירותי קוראה הטיעון הראשון שלה.
כמו כן הוא y הטענה השנייה, וזה רק באופן שרירותי מתקשר ב הטענה השנייה.
>> דיכוטומיה זו היא למעשה די פשוט הסבירה. תחשוב על זה.
אף אחד מאתנו לא פגש האדם שכתב printf,
כך בוודאי, הוא או שאין לה מושג מה משתנינו 30 שנים מאוחר יותר הם הולכים להיות שם.
אז צריך להיות הבחנה בין מה שאתם קוראים משתנים בפונקציות שאתה כותב
ומה שאתה מכנה משתנים בפונקציות שקוראים או משתמשים.
אז במילים אחרות, שכתבתי משתנים שלי בתור X ו-Y,
אבל אם מישהו אחר כתב את פונקצית ההחלפה, הוא או היא בהחלט לא הייתי יודע
מה המשתנים שלי הולכים להיקרא,
כל כך מבין שזו הסיבה שיש לך דואליות זו של שמות.
מבחינה טכנית, אני יכול לעשות את זה במקרה,
אבל הם עדיין יהיו מועברים כהעתקים.
זו תהיה סתם צירוף מקרים טהור מבחינה אסתטית, אם כי מי שכתב החלפה
השתמש באותם שמות.
לכן בשלב זה בסיפור, קו 37, הוא 1, b הוא 2, ועכשיו אני ממשיך להחליף אותם.
קודם כל, תן לי לעשות את זה דווקא הרבה יותר פשוט.
אני לא יודע מה 3 הקווים האלה של קוד עושים.
תן לי רק לעשות את זה: ב =; = b; עשה.
למה זה שבור, באופן הגיוני?
זה סוג של דבר אינטואיטיבי, נכון?
אז הופך b ו b הופך,
אבל הבעיה היא שברגע שמבצע קו 37, מה הערך של A ו-B?
אותו הדבר, 1, בגלל שיש לך דפוק, אם אפשר לומר כך, ששינית ב שווה.
אז ברגע הקו 37 בצע, זה נהדר, עכשיו יש לך 2 עותקים של המספר 1
בתוך פונקציה זו, אז כשאתה אומר בקו 38 = b,
סוג של אתה נדפק בגלל שאתה רק הקצאת 1 על 1.
סוג שלך אבד את הערך שאכפת לך.
אז בגרסה המקורית של זה, שים לב למה שעשיתי.
במקום זאת נאלצה שורה שלישית של קוד שנראית כמו זה.
אני מצהיר משתנה זמני.
>> Tmp הוא שם נפוצים מאוד למשתנה זמנית, וזה int
כי יש לו להשתוות למה שאני רוצה לעשות עותק של.
אני לאחסן עותק של חלק פנימי של tmp, לכן ברגע קו 37 בצע,
הערך שלו - סימון שפיות מהירה - 1, את הערך של b הוא 2,
והערך של tmp הוא גם 1.
אז עכשיו אני מבצע את הקו 38.
ברגע קו 38 מבצע, מקבל את הערך של b. והייתה ב 2, אז עכשיו הוא 2.
לכן בשלב זה בסיפור, הם 2, b הוא 2, וtmp הוא 1,
אז עכשיו מבחינה לוגית, אנחנו יכולים רק הערך של tmp פלופ לb ואנחנו נעשינו.
אז ככה פתר את הבעיה.
למרבה הצער, כאשר אני מפעיל את התכנית בצורה הזאת, זה לא ממש להחליף את כל ערכים.
אבל שיהיו ברור, למה?
אני תקנתי את הבעיה הלוגית מרק לפני רגע,
אבל שוב, אם אני מפעיל תכנית זו, x ו-y יישארו ללא שינוי
בסוף הביצוע של התכנית.
[הערת תלמיד לא נשמעה] >> יש לנו לא חזרתי שום דבר, אז זה נכון.
אבל מתברר שיש קצת בעיה כאן כי עד כה,
הדבר היחיד שהצלחנו לחזור זה דבר אחד, וזה הוא הגבלה של ג
אתה יכול לחזור רק באמת ערך אחד, ובמקרה זה אני די תקוע כאן
כי אני יכול להחזיר את הערך החדש של X או שאני יכול להחזיר את הערך החדש של Y,
אבל אני רוצה את שניהם בחזרה.
אז חזר לא פתרון פשוט כאן.
אבל הבעיה מהותית היא למה? מה אנחנו בעצם להתחלף?
[תלמיד] וכן ב. >> ב.
אבל וb הם עותקים של X ו-Y, מה שאומר שאנחנו רק עשינו את כל העבודה הזו,
אנחנו פשוט בילינו 3 דקות מדברים על הפונקציה וההחלפה כל 3 מהמשתנים הללו,
וזה נהדר, תקין לגמרי בבידוד,
אבל ההיקף של b ורק בשורות אלה כאן.
>> אז בדיוק כמו ללולאה, אם תכריז שלם אני בתוך ללולאה,
באופן דומה, אם אתה מצהיר וב פנימי של פונקציה שכתבת,
הם כבר בפנים תקפים רק שבתפקיד, מה שאומר ברגע שההחלפה נעשית ביצוע
ואנחנו הולכים מקו 24-25 קו, x ו-y לא השתנו בכלל.
אתה פשוט בזבזת המון זמן בחילופי עותקים של משתנים.
אז מתברר שהפתרון לזה הוא למעשה אינו ברור.
זה לא ממש מספיק כדי להחזיר ערכים כי אנחנו יכולים להחזיר ערך 1 בלבד,
ואני באמת רוצה להחליף גם x ו-y באותו הזמן,
אז אנחנו הולכים לעשות כדי לחזור לזה.
אבל לעת עתה, מבין שהבעיה נובעת ביסודו מהעובדה ושb הם עותקים
והם בהיקפם.
בואו ננסה לפתור את זה בדרך כלשהי.
תן לי לחזור לכאן בעצם לגלול ולפתוח, יניח, גרסה רביעית של זה, buggy4.
מה עם זה?
זו בעיה דומה אך פשוטה יותר להסתכל לפני שאנחנו לוקחים דקירה בפתרונו.
תכנית זו נקראת תוספת, וכנראה שזה מאתחל שלם x עד 1 בקו 18.
אז אני טוען x הוא 1, אז אני טוען "הגדלה ..."
אז אני קורא לתוספת, אבל אז בקווי 22 ו 23, אני טוען את זה כבר בהפרש קבוע,
אני טוען x הוא עכשיו מה שזה - 2, ככל הנראה - אך תכנית זו היא כרכרה.
מה הבעיה?
כן. >> [תגובת תלמיד לא נשמעה] >> בדיוק.
אז x הוכרז, כמובן, בקו 18.
כלומר בתוך סוגריים המסולסלים של העיקרית.
אז התשובה הפשוטה היא, שכל עוד x קיים כאן,
זה לא קיים בקו 32, ולכן תכנית זו תהיה למעשה אפילו לא לקמפל.
המהדר כשאני מנסה הידור קוד זה הולך לצעוק עליי
על איזה מזהה או משהו דומה לזה לא מוצהר. למעשה, בואו ננסה.
זה עושה buggy4. זה מה שיש.
שימוש ב" x "מזהה לא מוצהר בקו 32.
ובעצם, בואו אהיה יותר מפורש כאן היום כדי שזה שימושי
בשעתי עבודה ובבית.
>> שים לב שזה קצת כתוב ולא פרש.
אבל העובדה שיש קלאנג צעקה עלינו ואומר buggy4.c: 32:5, היא באמת שימושי.
זה אומר שהטעות היא בקו 32 בעמדת הדמות 5.
אז 1, 2, 3, 4, 5. זה, למעשה, שבו הבעיה היא.
וגם, מדי, יש לזכור בשעתי עבודה ובבית, יש לי מזל כאן.
יש לי טעות אחת. זה הולך להיות קל יחסית לתיקון.
אבל אם אתה מקבל את כל מסך מלא בהודעות שגיאה מכריעות,
שוב להבין שאחד התחתון יכול להיות רק סימפטום לאחד העליון ביותר.
אז תמיד לרדוף אחרי הבאגים שלכם מלמעלה למטה
משום שיש יכול להיות רק השפעת שרשרת דייזי
כי הוא טוען שיש לך את הדרך לבעיות יותר מאשר אתה באמת כן.
אז איך אפשר לתקן את זה אם המטרה שלי היא להגדיל x? >> [תלמיד] הפוך x הגלובלי.
אוקיי, אז אנחנו יכולים לעשות את x הגלובלי.
בואו ניקח את קיצור הדרך שעליו קודם לכן הזהיר, אבל לעזאזל, אנחנו רק צריכים פתרון מהיר,
אז בואו רק נאמר x int עד כאן. זה הופך את x הגלובלי.
אז עכשיו ראשי יש גישה אליו ויש תוספת גישה אליו,
ואז תן לי להמשיך ולעבד את זה עכשיו.
הפוך buggy4, Enter. נראה לקמפל עכשיו.
בואו לרוץ buggy4. ונראה ממש לעבוד.
זה אחד מהדברים האלה שיעשו כמו שאני אומר, לא כמוני,
כמו שרק שעשיתי כאן, כי באופן כללי,
התוכניות שלנו הולכות לקבל הרבה יותר מעניין והרבה יותר מזה,
אם הפתרון שלך לבעיות של החיים הוא פשוט לשים את כל המשתנים בחלק העליון של הקובץ שלך ו,
מהר מאוד תוכניות מקבלות איום קשות לניהול.
זה נהיה קשה יותר לחשוב על שמות משתנים חדשים,
זה נהיה קשה יותר להבין מה משתנה עושה מה,
וכך באופן כללי, זה לא פתרון טוב.
אז בואו נעשה את זה טוב יותר.
אנחנו לא רוצים להשתמש במשתנה גלובלית כאן.
>> אני רוצה להגדיל x, כך שיכולתי כמובן -
בסופו של היום, זה סוג של סיפור טיפשי כי אנחנו פשוט לעשות את זה -
אבל אם אני לא ידעתי על שהמפעיל או שאני לא נתתי לי לשנות אותו בראשי עצמו,
איך עוד אני יכול ליישם קן לכאן הפעם לא קובייה אבל כדי להגדיל?
איך אני משנה את זה כאן? כן.
[תלמיד] Pass בx ואז לחזור [לא ברור] >> אוקיי, טוב.
אז למה שאני לא אעבור בx ולאחר מכן ולא להחזיר אותו,
למה שאני לא פשוט לחזור X + 1.
עוד כמה דברים צריכים להשתנות פה. אני על המסלול הנכון.
מה עוד אני צריך לצבוט? מישהו אחר. כן.
[תגובת תלמיד לא נשמעה]
אני צריך לשנות את סוג ההחזרה של תוספת, כי זה לא לבטל.
אין לה כל החלל מוחזר, אבל ברור שעכשיו זה הוא,
כך זה צריך לשנות ל-- >> [תלמיד] int.
int להיות בקנה אחד עם מה שאני מחזיר למעשה.
עכשיו משהו אחר עדיין כרכרה כאן. כן.
[תגובת תלמיד לא נשמעה] >> [מלאן] אז אני צריך להגדיל x?
[תגובת תלמיד לא נשמעה] >> [מלאן] אה, אז אני צריך לעבור x.
אז אני צריך לעשות את זה כאן. >> [הערת תלמיד לא נשמעה]
[מלאן] אז אב הטיפוס, אני צריך לשנות את זה כאן.
אז זה צריך להיות int, זה חייב להיות -
הממ, יש לי בעצם באג כאן למטה. בואו לתקן את זה ראשון.
מה זה צריך להיות למעשה? זה חייב להיות משהו int.
זה יכול להיות x, אבל בכנות, אם אתה מתחיל לקרוא את כל המשתנים x שלך,
זה הולך לקבל פחות ופחות ברור מי הוא מי.
>> אז בואו רק באופן שרירותי לבחור יום אמנה שונה עבור פונקציות העוזר שלי,
את הפונקציות שאני כותב. אנחנו קוראים לזה, או שאנו יכולים לקרוא לזה -
בואו נקרא לזה מספר להיות אפילו יותר מפורש.
אז יש לי לחזור מה הוא המספר 1 ובנוסף,
ועכשיו אני צריך לשנות שום דבר אחר 1 עד כאן ועוד דבר אחד כאן.
מה יש לי לשינוי בקו 21 בפעם הראשונה? >> [תגובת תלמיד לא נשמעה]
[מלאן] אני צריך להקצות אותו x. אני לא יכול פשוט לקרוא תוספת (x).
אני צריך לזכור את התשובה על ידי שינוי הערך של x בצד השמאלי.
ואף על פי x הוא עכשיו על ימין ועל שמאל, זה לגמרי בסדר
משום שצד ימין מקבל להורג ראשון ואז מקבל נשר לתוך הדבר השמאלי -
x במקרה זה.
ואז לבסוף, זה קל לתקן עכשיו.
זה פשוט צריך להתאים את מה שנמצא שם למטה, מספר int.
אז כל חבורה של שינויים לתפקוד ממש טיפש
אבל נציג שלנו יותר ויותר דברים שאתה רוצה לעשות.
אז להפוך buggy4. כבר פשלתי איפשהו.
הו, אלוהים שלי. חמש טעויות בתכנית 6-קו.
אז מה רע בקו 18, דמות 5?
אז יש לי להצהיר, int זה.
בואו נראים. יש קבוצה שלמה של טעויות אחרות.
הו, אלוהים שלי - 19, 18, 21 - אך שוב, בוא פשוט לנקות את המסך, L בקרה כאן,
ושידור חוזר קלאנג.
אז 5 בעיות הן שלמעשה רק 1.
אז עכשיו בואו תרוצו buggy4, Enter. אוף, X כבר מוגדל בצורה נכונה.
בסדר. כל שאלות על איך להגדיל מספרים? כן.
[שאלת תלמיד לא נשמעה] >> שאלה טובה.
איך זה שאני יכול פשוט לשנות את x למספר ואת התכנית תהיה לדעת באופן מיידי?
>> שוב, לחשוב על זה כהפשטה זו.
אז אם אני ראשי וקן הוא תוספת, בכנות, לא אכפת לי מה שקורא קן iPad שלו.
לא אכפת לי מה שהוא מכנה כל דבר שיש לעשות עם יישומו של פונקציונליות זו.
זה פירוט יישום שאני, ראשי, לא צריך אכפת.
וכך פשוט לשנות אותו בעקביות הפנימית של הפונקציה - מספר כאן ומספר כאן -
כל זה לוקח כל כך הרבה זמן כמו שההידור מחדש.
זה קצת כמו שאם אתה חושב על רבים מאיתנו, אלה מכם עם רישיונות הנהיגה
שמונע או אם אפילו שהוסעת במכונית,
רובנו אין לי מושג איך עובדת מכונית מתחת למכסת המנוע.
ופשוטו כמשמעו, אם אתה פותח את מכסה מנוע, רובנו - כולל אותי -
לא הולך באמת לדעת מה אנחנו מסתכלים,
כמו סוג של אתה עלול להרגיש דברים כאלה עם זה עכשיו.
אבל אנחנו לא באמת צריכים לדאוג איך המכונית עובדת,
אין לנו לשים לב למה כל המוטות ובוכנות והכבלים הפנימיים של המכונית
למעשה הם עושים.
אז משהו כמו מה שאתם קוראים את הבוכנה לא משנה כאן, במקרה זה. אותו הרעיון.
כן. >> [שאלת תלמיד לא נשמעה]
אם יש יותר שימושים של רגע xa משתנה לפני,
אתה, המתכנת, הייתי צריכה לשנות אותם בכל מקום.
או שאתה ממש יכול לעשות את הקובץ, תפריט ולאחר מכן מצא, חלף - משהו כזה -
אבל אתה תצטרך לבצע שינויים אלה בעצמך.
אתה צריך להיות עקבי. >> [תלמיד] אם יש משתנים רבים [לא ברור]
סדר מסוים כמו כאן, אם זה היה int מספר אחר? >> [תלמיד] נכון.
[מלאן] כן. סדר חשוב כאשר אתה קורא את הפונקציה.
>> אז אם אני היה קורא תוספת כאן עם משהו פסיק משהו,
יש מיפוי ישיר.
המשתנה הראשון, איך שלא קוראים, הוא עשה עותק של הטיעון הראשון כאן.
סליחה. זה לא אמור להיות מוסגר.
בשורות השניות הטיעון עם עד השנייה אחת. אז בסדר, כן, עניינים. בסדר.
סליחה. לקחתי את הדרך הארוכה כדי להגיע לשם. שאלות אחרות? בסדר.
אז בואו נראה אם ​​אנחנו לא יכולים לצייר תמונה של מה שבאמת מתרחש כאן
מתחת למכסת המנוע, אם אפשר לומר כך.
זה מלבן שעשוי לייצג את הזיכרון של המחשב.
גם אם אין לך מושג איך עובד זיכרון RAM או איך עובד,
לפחות להניח שיש לך צרורות שלו בימים אלה.
יש לך מגה בייט שלו, יש לך ג'יגה בייט שלו,
ואנחנו יודעים משבוע 0 שבתים הם רק מה? >> [תלמיד] 8 סיביים.
8 סיביים, נכון? כן 8 אפסים ו1.
אז אם המחשב שלך יש חלטורה של RAM, 2 GB של זכרון RAM בימים אלה,
יש לך מיליארדים או 2 מליארד בתים של זיכרון או בערך 8000000000 או 16 מליארד ביטים
הפנימי של המחשב שלך.
בניגוד לדוגמא הקטנה Wooly וילי, זה לא חלקיקים מגנטיים בדרך כלל יותר.
יותר ויותר - במחשבים ניידים לפחות - זה כונני מצב מוצק, כונני SSD,
כי פשוט אין להם חלקים נעים. הכל האלקטרוני. הכול מבוסס חשמל.
אז תחשוב על זה כמלבן פשוט מייצג את 1 או 2 ג'יגה בייט של זיכרון שיש לך.
>> אז זה נתח של זיכרון.
סוג של עולם מדע מחשב המחיצות
נתחי הזיכרון לעשות דברים שונים.
לדוגמה, אם זה זכרון RAM של המחשב שלך, כפי שהוצע על ידי המלבן שם,
מתברר שלפי אמנה, בחלק העליון של זכרון RAM שלך, אם אפשר לומר כך,
בדרך כלל מה שנקרא קטע טקסט.
אלה הם 0s ו 1s שיש לך הידור.
לכן, כאשר אנחנו בדקנו מתחת למכסת המנוע במה a.out הוא,
כל אלה 0s ו 1s, כשאתה מפעיל את תכנית,
אלה 0s ו 1s נטענים מהכונן הקשיח למשהו שנקרא הזיכרון RAM,
ובזכרון RAM הם שמו בראש.
בינתיים, יש לך דברים אחרים: לאתחל נתונים, לבטל את אתחול נתונים.
אלה 2 אגודות של זיכרון מתייחסות למשתנים הגלובליים, שאתה לא משתמש לעתים קרובות
אבל לפעמים אם אתה עושה, הם בסוף לשם גם כן.
אז יש כמה דברים אחרים: משתני סביבה, שאנחנו לא מבלים זמן רב ב,
אבל אז 2 דברים חשובים שיחזרו לאורך כל הסמסטר,
מחסנית וערימה.
אז רוב זכרון המחשב שלך שמורה בעת הפעלת תכנית
למשהו שנקרא המחסנית ומשהו שנקרא ערימה.
אנחנו לא הולכים לדבר על הערימה היום, אבל אנחנו מדברים על המחסנית.
המחסנית נועדה להעלות באוב חזותי ממגשי הארוחות בחדר האוכל בבית מאת'ר
או כל מקום שלא יהיה בה צוות חדר האוכל לנקות אותם כל יום,
הם עורמים אותם מרצפה ומעלה,
ובאופן דומה, בזיכרון, יש את הרעיון הזה של לשים משהו במחסנית,
לשים משהו במחסנית, לשים משהו במחסנית.
ומה אנחנו מתכוונים בזה?
>> בואו זום על רק על החצי התחתון של התמונה הזאת, זכרון RAM של המחשב שלך,
להציע את הפעולות הבאות.
מתברר כי בעת הפעלת תכנית כמו a.out או שלום -
כל התכנית היא שאתה כתבת -
שוב, אלה 0s ו 1s נטענים מהכונן הקשיח שלך, שהוא אחסון לטווח ארוך,
נשאר שם גם כשאתה מושך את התקע, נטען לזכרון RAM.
זכרון RAM הוא מהיר יותר מכוננים קשיחים - זה קטן יותר מאשר כוננים קשיחים -
אבל זה מקום שבו תוכניות לחיות בזמן שאתה מפעיל אותם.
אז תלחץ פעמים על תכנית במקינטוש או PC, זה נטען מכונן קשיח לזכרון RAM.
ברגע שזה טעון לזכרון RAM, ללכת 0s ו 1s בראש הדרך,
קטע הטקסט שנקרא, אבל אז ברגע שהתכנית שלך בעצם מתחילה לרוץ,
הפונקציה העיקרית נקראת, ועיקרי, כפי שראינו, לעתים קרובות יש משתנים מקומיים,
ויש לה ints ומחרוזות ותווים וכדומה.
אז אם התכנית שלך שאתה כתבת או את התכנית שיש לך לחיצה כפולה
השתמשתי כמה משתנים בתוך מראשי,
הם בסופו בתחתית הערימה של זיכרון שלך, אם אפשר לומר כך.
באופן קונקרטי יותר, מה זה בעצם אומר?
זה רק אומר שאם אנחנו הולכים למספר הבתים בזיכרון RAM במחשב שלך,
שם לב שזה יכול להיות מספר בתי 0, זה עשוי להיות מספר בתי 1, 2, 3, 4, 5, 6,
כל הדרך עד 2 מליארד תהיה כל הדרך עד לשם בראש.
אז במילים אחרות, כאשר אנו מדברים על זכרון RAM או זיכרון במונחים של בתים,
זה רק אומר שמישהו החליט מה למספר כל אחד מהגושים האלה של זיכרון.
לכן, כאשר אתה צריך 32 ביטים עבור int או שאתה צריך 8 ביטים לchar,
שם הם בסופו של זיכרון?
>> מבחינה מושגית, הם פשוט בסופו בחלק התחתון של הדבר הזה שנקרא המחסנית.
אבל מה שמעניין עכשיו הוא כאשר עיקרי קורא לפונקציה -
מניח פונקציה בשם foo, רק שם שרירותיים -
מה שקורה הוא עיקרי הוא בתחתית ערימה זו של זיכרון;
foo עכשיו הוא לשים על גבי עיקרי בזיכרון.
אז כל משתנים מקומיים שהפך בסופו של foo סוג של מושגית מעל אלה בראשיים.
אם foo קורא פונקציה אחרת בשם בר, המשתנים האלה הגיעו לכאן.
אם בר קורא משהו אחר, כאן, כאן, כאן.
אז מה שמעניין בהפעלת תכנית הוא שככל שאתה קורא פונקציות
כפונקציות אלה לקרוא לפונקציות ופונקציות אלה לקרוא לפונקציות ו,
אתה בונה את ערימה זו של פונקציות בזיכרון.
ורק פעם בתשואות פונקציה אתה מתחיל לקבל זיכרון שיחזור.
לכן אחת הדרכים הקלות ביותר להפעלה מתוך זיכרון בתכנית מחשב
הוא לכתוב פונקציות שלא לחזור לעולם.
כך למשל, בואו להפגין כמה שיותר בתכנית במכוון כרכרה.
תן לי ללכת קדימה ואל # כוללים ,
int הראשי (ריק),
ואני הולך לעשות בזמן (2> 1), שכנראה לא ישתנו לעולם עלינו,
ותנו לי ללכת קדימה עכשיו ולעשות printf.
למעשה, זה הולך להיות פחות מעניין מבחינה ויזואלית. בואו נעשה את זה.
לint i = 0; i> 0 - בואו נעשה את הטעות הזאת - אני + +.
ובואו לא printf כאן. בואו להתאמן על מה שאני מטיף.
בואו שיטה כאן, מקהלת חלל, ואנחנו נגיד אני int,
ואז אני הולך לומר printf - לא, בואו נעשה את זה יותר מעניין.
בואו ממש לא להדפיס כל דבר. בואו פשוט נעשה את זה פזמון: (i).
בסדר. אז זה עגלה כי למה?
אני עושה את זה כמו שאני הולך, כי התכנית לא ממש עושה משהו מעניין.
>> אבל זה לא המטרה.
המטרה היא לכתוב תכנית שתפקידה העיקרי עושה מה, כנראה?
שיחה עוצמה. ובעצם, אנחנו לא צריכים את הלולאה.
בואו אפילו לפשט זאת רק כדי לא לאבד את הראייה של ממש באג הבסיסי.
שיחות עיקריות מקהלה תשיר במקהלה,
אז עשיתי משהו טיפשי ולא היה לי שיחת מקהלת מקהלה
משום שהנחית שמישהו אחר היה הולך ליישם את זה אולי,
ועכשיו זה לא הולך לקמפל עדיין. אני צריך לעשות את מה?
אני צריך את אב טיפוס, לזכור.
אז אני צריך להיות כאן מקהלת הריק (int i);
אז עכשיו אם אני יורד כאן - בעצם, בואו להשתמש בחלון הגדול יותר.
בואו נלך קדימה ולהפוך את המקהלה.
שימוש במזהה לא המוצהרת.
אה, זה היה טיפשי. אנחנו לא צריכים את הוויכוח. בואו פשוט נעשה את זה.
חבל שלא התחילו בדרך הזאת. זה היה יכול להיות תכנית הרבה יותר קלה לכתוב.
יש. עכשיו בואו ניגשנו לחלון מסופי, שידור חוזר קלאנג, והנה זה בא.
זה היה ממש מהר.
מה בעצם פשוט אבל קרה?
ובכן, עכשיו אני אוסיף שורת ההדפסה כדי שנוכל לראות.
הרשה לי לומר printf ("אני פה") - לא משתנה. אנחנו נשאיר את זה ככה.
תן לי לעשות שידור חוזר. תן לי שידור חוזר מקהלה.
ו ... בחייך. תמשיך.
במאמר מוסגר, מדוע הוא עדיין לא התרסק?
אשמת הפילוח קרתה לפני סופר מהיר.
[תגובת תלמיד לא נשמעה] >> בדיוק. אז זה לוקח זמן כדי להדפיס, נכון?
זה פשוט לוקח יותר עבודה על החלק של המחשב.
וזה מה שיש: אשמת פילוח.
>> אז שם לב עד כמה תוכניות לרוץ מהר.
אם אתם לא מדפיסים כל דבר, סופר מהיר.
אבל יש לנו עדיין אשמת פילוח זה בגלל מה שקורה?
אם אתה חושב על איך הזיכרון של המחשב שלך הוא לפריסתו,
זה קורה להיות ראשי, אבל כאן בוא פשוט נקרא הפזמון הזה, ובואו נקראים לפזמון הזה.
ועכשיו אם אני עושה את האסתטיקה שלי נכון, זה היה רק ​​זה שאומר מקהלה, מקהלה, מקהלת,
מקהלה, מקהלה, מקהלה, מקהלת, עד זרא, וסופו של דבר, מה יקרה?
אם התמונה הגדולה, תר משמע, היא זו, מה בדיוק קורית רעיוני?
את צפות ערימת הערימה.
או, גרוע מכך, אתה פשוט מוצף הכל, כולל קטע הטקסט,
אשר 0s ו 1s שמייצג את התכנית שלך.
בקיצור, זה פשוט סופר, סופר רע.
התכנית שלך יצאה מכלל שליטה.
אתה משתמש בדרך יותר זיכרון ממה שהתכוונת
והכל בגלל טעות טיפשית במקרה הזה,
או במקרה זה פונקציה נעשתה במכוון מאוד מכנה עצמו.
עכשיו, זה לא רע כל כך.
פונקציות קוראות לעצמם דווקא יש לו כוח גדול כאשר אתה משתמש בו בצורה נכונה.
אני לא השתמשתי בו בצורה נכונה כאן.
אז זה לא רע בכלל, אבל העובדה שאני אף פעם לא באמת להפסיק לקרוא את עצמי
היא חולשה בסיסית כאן של תכנית זו.
אז לאן אנחנו הולכים עם כל זה? מה באמת קורה?
כשאני קורא את פונקצית תוספת כמו שאנחנו עושים בדוגמות הללו,
יש לי ערך כמו 1 שאני עובר פנימה
אני עובר בעותק של המספר 1, אז הבא שקורה.
בואו נלך לדוגמא תוספת, הבחור הזה ממש כאן.
הנה מה שבאמת קורה.
כאשר אני קורא את התוספת ואני עובר בx, ציורי, מה שקורה כאן הוא זה.
>> אם יש לי ערך של 1 מאוחסן כאן ואני באמת קורא לתוספת,
כיום שמתי מקהלה - iPad הוא לזרוק אותי מכאן.
בואו לקרוא תוספת זו, ואנחנו לא יודעים מה הפונקציה הבאה זה הולכת להיות.
אז מה בעצם קורה כאן הוא אי שם בעיקרי שיש לי נתח של זיכרון
האחסון המספר 1.
כאשר אני קורא את תוספת, אני משתמש בנתח נוסף של זיכרון,
אבל עכשיו יש לי עותק של 1.
כשאני להגדיל את הערך, זה הופך להיות 2,
אבל אז מה שקורה ברגע שחוזר תוספת?
זיכרון זה פשוט מקבל להחזיר למערכת ההפעלה,
מה שאומר שכל מה שעשית הוא שום דבר מועיל.
1 שהיה כלול במקור בשינה העיקרית הוא עדיין שם באמת.
אז לאן אנחנו הולכים עם זה?
מתברר כי בזיכרון יש לך רצף גב אל גב זה של בתים
כי אתה יכול לשים את דברים ב, ומתברר שכבר ראו משהו
שכרוך מחזיר את הדברים לגב אל הגב אל גב.
מהו המבוסס על מחרוזת 1 שבוע ועכשיו שבוע 2?
זה פשוט אוסף של תווים.
אז מתברר שבדיוק כמו שאתה יכול לשים את המספרים בזיכרון,
באופן דומה אתה יכול לשים את תווים בזיכרון.
וברגע שאנחנו מתחילים לשים תווים בזכרון גב אל גב אל גב אל גב,
מתברר ששימוש הפשוט ביותר של דברים כמו ללולאה או לולאה בזמן,
אנחנו יכולים לחזר משמאל לימין על התווים במחרוזת
ולהתחיל לעסות אותם לדמויות שונות לגמרי -
יכול להיות B, B יכול להיות ג -
כך שסופו של דבר, אנחנו יכולים לקחת את המשפט באנגלית שממש הגיונית
ולהמיר כל אחד מהמכתבים האלה 1 בכל פעם
הליכה בתוך הזיכרון של המחשב שלנו משמאל לימין דווקא כדי להצפין.
אז בואו לקחת ההפסקה של חמש הדקות שלנו כאן,
וכשנחזור, נתחיל את התהליך הזה של ערבול מידע.
>> בסדר.
לפני שנצלול לתוך כמה אנוסים והדברים האלה נקראים מערכים,
תן לי לעצור לשאלות כי אני מרגיש שאני באמת סוג של מבולבל
חלק מנושאים אלו. אז בואו נתקן עכשיו אם אנחנו יכולים.
רק דברנו על ערכים לחזור, דברו על ויכוחים,
ודברנו על הרעיון הזה, שאנחנו נחזור לשבועות הקרובים,
לצפייה בזיכרון כחבורה שלמה של המגשים העמוסים האלה, אם אפשר לומר כך,
מלמטה למעלה, כך שכל מגש שמקבל לשים על הערימה
מייצג פונקציה שכרגע זה נקרא.
יש שאלות?
תן לי לשאול שאלה כאן.
בואו תפשטו אותי בחזרה זה למה שהוא היה לפני כמה ש הקודם שלנו & A.
העובדה שיש תוספת סוגריים פתוחים, מספר int, סגורה סוגריים -
מה מספר int מייצג?
[תלמיד] ויכוח. >> ויכוח. אוקיי. אבל מה ויכוח?
[תגובת תלמיד לא נשמע] >> מה זה? >> [תלמיד] משהו שתוכל לעבור פנימה
אוקיי, אז משהו שתוכל לעבור בו ואופן כללי יותר, זה רק הקלט.
אם היית כותב את הפונקציה ומטרה של אותו תפקיד בחיים
הוא לעשות משהו קצת שונה בכל פעם שאתה משתמש בו,
אז הדרך היחידה שזה יקרה באמת הייתה נראית לספק לו הזנה
כך שהוא יכול לעשות משהו אחר עם שקלט בכל פעם.
>> אז אתה צריך לציין שני דברים כאשר הפונקציה מקבלת קלט.
אתה צריך לציין את השם שאתה רוצה לתת לזה קלט
אך ורק לנוחות שלך, כך שאתה יכול להתייחס אליו
בפונקציה שאתה עצמך כותב, כפי שעשיתי כאן בקו 32.
אבל אתה גם צריך לציין את הסוג שלו, כי C היא שפת תכנות
זה פשוט דורש שאם אתה רוצה משתנה, יש לך לומר למחשב מה סוג נתונים שהוא,
בחלק גדול, כך שהוא יודע כמה ביטים שיוקצו לאותו משתנה
כי זה יכול להיות 6 - מצטער, זה לא יהיה 6.
זה יכול להיות 16, זה יכול להיות 8, זה יכול להיות 32, אפילו 64,
אבל המחשב צריך לדעת.
עכשיו, int בצד השמאלי מייצג את מה, לעומת זאת?
[תגובת תלמיד לא נשמע] >> מה זה? >> [תלמיד] סוג של פונקציה.
הסוג של פונקציה, ולייתר דיוק, בסוג הפלט שלה. נכון.
אז אילו דבר בסוגריים מייצג את הקלט שלה, אם בכלל,
הדבר לשמאל מייצג את התפוקה שלה.
ובמקרה הזה, כנראה תוספת מחזירה int,
וכך int הוא סוג ההחזרה של פונקציה זו.
מה זה אומר לחזור?
פשוטו כמשמעו, אתה משתמש במילת מפתח שיבה ואז אם מה שאתה חוזר
מימין למילת המפתח הוא מספר שלם,
אז זה אכן עולה בקנה אחד עם מה שהבטחנו.
אתה לא יכול לעשות משהו כזה - שלום, עולם - כי זה מחרוזת.
>> ברור, זה לא שלם.
אז בקיצור, הניטל הוא באמת עלינו, המתכנת, להיות ספציפית
על מה שאנחנו חוזרים ואז באמת ללכת על החזרתו.
ההקשר כאן עכשיו הוא שהזיכרון של המחשב שלך הוא ג'יגה, 2 ג'יגה -
מה - אולי זה יותר, אולי זה פחות,
אבל מחשב רואה אותו כבעל מקטעים שונים.
משהו הולך שם למטה, משהו אחר הולך לשם,
חומר אחר הולך באמצע, והיום אנחנו רק מתחילים לספר את הסיפור,
אבל אנחנו נחזור לזמן על זה.
לעת עתה, פיסת הזיכרון היחידה שבאמת אכפת לי היא קטע הטקסט
משום שרק מייצג שקלאנג 0s ו 1s יש outputted.
אז כשאתה מפעיל את פקודה במקלדת כמו a.out
או הלחיצה כפולה על סמל ב-Mac OS או Windows,
התכנית שלך היא טעונה מהכונן הקשיח לזכרון RAM
ומטיל אותה בחלק העליון של זכרון RAM של המחשב שלך, אם אפשר לומר כך.
בינתיים, כפי שהתכנית שלך מתחילה לרוץ ועיקרי מקבל נקרא
בתכנית שכתבת או התכנית של Microsoft או Apple כתב,
כל אחד מהמשתנים המקומיים שלה בסופו שם למטה בחלק התחתון של זכרון המחשב שלך.
אבל אם שיחות עיקריות פונקציה אחרת שעצמו יש משתנים או ויכוחים, הם בסופו מעליו.
ואם הפונקציה שקוראה משהו, הם בסופו מעליו, מעליו, מעליו.
>> ורק פעם אחת פונקציה נעשתה ביצוע אין את ערימת המגשים, כביכול,
מתחיל לקבל יותר ויותר.
וזה מה שאז, בקליפת האגוז, מסביר מדוע כאשר אתה קורא קובייה
או שאתה קורא לתוספת, אתה עובר בעותק של הערך.
ומה זה אומר ציורי הוא שאתה ממש כותב את המספר 1
בחלק אחר של זיכרון, שינוי ש1-2 במקרה של תוספת
או 8 במקרה של קובייה, ואז לזרוק זיכרון זה
ברגע שהתוספת או את תשואות פונקציית הקובייה. שאלה.
[תלמיד] איפה מאוחסנים משתנים גלובליים?
משתנים גלובליים מאוחסנים במה שנקרא כעת את הנתונים אותחלו או הנתונים מאותחלים,
ההבדל הוא שאם יש לך משתנה גלובלי ותקצה אותה מייד ערך
בסימן שוויון, זה בסופו בראש שם,
ואם אתה רק אומר x int; ללא ערך, זה בסופו מעט נמוך יותר בזכרון RAM
פשוט על ידי ועידה.
שאלות אחרות? בסדר.
אז התמונה הזאת תחזור כפי שאנו מקבלים יותר חזקים
עם מה אנחנו יכולים לעשות עם המחשב,
אך לעת עתה, בואו יש מבוא קצר לקריפטוגרפיה,
סוג מסוים של הצפנה שלא יפתור את כל הבעיות בעולם
אבל פותר חלק מהם.
במקרה זה כאן, יש לנו משהו שנקרא הצפנת סוד מפתח.
קריפטוגרפיה סוד מפתח, כפי שהשם מרמז, נובעת מהביטחון שלה בסוד.
>> לדוגמה, אם היית בבית הספר יסודי ועברתם מכתב אהבת סוד קטן
לילד או הילדה שהיית מוחץ, אם אתה רוצה לעבור את הלב שעבר בקהל,
אתה כנראה לא לכתוב פתק כזה באנגלית או כל השפה האם שלך היא.
במקום זאת, אתה יכול להצפין אותו או שאתה יכול פשוט לשלוח להם הודעת טקסט בימים אלה.
אבל אולי בעצם אתה מעביר להם פתק בכל הכיתה.
וכדי לעשות את זה באופן מאובטח בצורה כזו שהחברים שלך והמורה
לא יודע מה שאתה כותב, אתה יכול לבוא עם אלגוריתם פשוט למדי,
צעיר למרות שאתה יכול להיות, רק כדי לטרוף את המילים.
אז במקום לכתוב אתה יכול לכתוב ב,
במקום שאפשר לכתוב ב ג,
במקום שאפשר לכתוב ג ד, וכן הלאה.
או שאתה יכול לבוא עם תרגום מתוחכם יותר
מכתבים לאותיות שונות.
אבל המלכוד הוא ילד או ילדה למי אתה שולח את המכתב הזה
צריכים לדעת משהו, וזה מה ש, ברור? >> [תלמיד] מה אתה שולח.
מה הסוד שלך, כמו מה שהמיפוי בין של וציונים הטובים ושל ושל ד '.
האם זה רק מוסיף 1 לכל אחד מהמכתבים ללכת מנקודת א ', ב' לג'?
האם זה מורכב יותר מזה?
>> אז אתה ומושא אהבתך צריך להיות מידע הסודי הזה,
אבל יש סוג של מלכוד-22 כאן.
אם זו הפעם הראשונה שאתה שולח מכתב אהבה זה באמצעות הכיתה,
איך נער או הנערה שהולך יודע מה הסוד גם הוא?
אנוסים כך סודי מפתח לא יפתרו את כל הבעיות בעולם,
ויש בעצם כאן מערכת יחסים שאנחנו נחזור ללקראת סופו של הסמסטר.
כמו כן אין רובנו לא מכירים מישהו שעובד, למשל, בAmazon.com,
ובכל זאת רבים מאיתנו כנראה קנו את הדברים ב-Amazon.com,
ולמד אותנו להניח שעסקות אלו מסחר אלקטרוני מאובטחות.
כתובת האתר כנראה אומרת https, יש אולי סמל של מנעול קטן וטיפשי במקום כלשהו,
יש איזה סוג של הצפנת אבטחת פרטי כרטיס האשראי שלך
בינך וAmazon.com.
ובכל זאת, אם קריפטוגרפיה הכרוכה לדעת איזה סוד
ובכל זאת אני לא מכיר אף אחד באמזון ואני בהחלט לא סדרתי כל סוג של הסוד
עם מישהו באמזון, איך המחשב שלי או הדפדפן שלי עושה את זה?
מסתבר שיש סוגים אחרים של הצפנה לגמרי שיפתרו את הבעיה.
אבל להיום, אנו נתמקד באחת הפשוט
שבו אתה יכול לארגן מראש לדעת איזה סוד
כמו +1 או מיפוי בין חלק של ושל ב.
והתהליך של הצפנה בדרך כלל כרוך זה.
יש לך קצת טקסט רגיל, מתואר כאן בצד שמאל,
אתה מפעיל את זה דרך איזה אלגוריתם או הליך להצפנתו -
אולי זה רק הופך B, B יהפוך ג -
ואז אתה בסופו של טקסט מוצפן.
בינתיים, לאחר שהמושא אהבתך מקבל הפתק הסודי הזה,
הוא או היא צריכה לפענח ואז זה בדרך כלל על ידי היפוך האלגוריתם ה
כדי לקבל בחזרה את הטקסט הרגיל.
יש גלגולים פיסיים של זה.
>> לדוגמה, זה טבעת מפענח סוד קטנה,
וזו היא טבעת במובן זה שיש כאן שתי חוגות.
בפריפריה מחוץ לדבר הזה, יש אותיות A עד Z,
על אף שהן בסדר אקראיות,
ומבפנים, יש בעצם כמה מספרים
כזה שבטבעת זו תוכלי סוג של להפוך מבחוץ אבל לא מבפנים
כדי ליישר קו עם מספרי אותיות.
מסרט שנקרא סיפור חג המולד, אתה תראה שראלפי הקטן
היה כל כך להוט להבין מה המסר הסודי של היתומה הקטנה אנני היה לו
שתקשר, אני חושב, בצורה של מסרים מספריים בקופסא דגנים
והיה לך לצבור את כל הקלפים הקטנים שבאו בקופסא דגני הבוקר,
היה לך לשלוח אותם, היה לך כדי לקבל בחזרה את טבעת מפענח הסוד
כך שאתה יכול סוף סוף להבין מה הוא המיפוי בין אותיות ומספרים
או אותיות וספרות.
איך במחשב שאנחנו יכולים ללכת על יישום או מייצגים דברים כאלה?
אנחנו צריכים דרך להביע את עצם קצת יותר גמישות
מהמשתנים שלנו עד כה מותרים.
היו לנו ints, היה לנו תווים, היה לנו צפתי וזוגות ועוד כמה,
אבל אלה הם יצירות בודדות של זיכרון שלא באמת מאפשרות לנו לבטא את הדברים
כמו מילים ומשפטים וביטויים.
ואכן, יש לנו בשם מחרוזות דברים כאלה,
אבל אנחנו מבטיחים שזה באמת רק בפישוט CS50 הספרייה
שאנחנו מתכוונים לקלף.
ואז הבה תתחיל לעשות את זה כאן.
תן לי ללכת קדימה, לפתוח את קובץ -
כל הקבצים הללו זמינים, כרגיל, באינטרנט - שנקרא array.c
כדי לפתור בעיה שאינם קשורה למייתרים אבל זה מצייר תמונה כאן
של איך אנחנו יכולים להשתמש במשהו שנקרא מערך.
>> מערך הוא סוג נתונים.
זה סוג משתנה של מיני שיש סוגי נתונים קטנים מרובים שבתוכה
גב אל גב אל הגב אל גב.
כך למשל, אם הייתי רוצה לכתוב תוכנה קטנה שנותנת לך ממוצעת החידון שלך
לקורס כמו 50 שיש לה 2 חידונים,
מאוד בקלות אתה יכול לכתוב תכנית זו מתבססת גם על חלק מהחומר של השבוע שעבר
באמצעות GetInt וכמה משתנה: int quiz1, int quiz2.
וזה די פשוט.
זה אולי 10, 20 שורות קוד מקסימום כדי ליישם תכנית
ששואל את המשתמש עבור 2 ציוני בחנים ואז מחשב הממוצע שלהם
על ידי הוספה אותם יחד, חלוקה ידי 2, ולאחר מכן להדפיס את התוצאות.
אנחנו ודאי יכולים לעשות את זה די בקלות עכשיו אחרי מספר מסוים של דקות.
אבל הבעיה היא שמניח כי 50 היו 3 בחנים או 4.
תניח שאתה רוצה להשתמש באותה התכנית לכיתה שהייתה שבועי חידונים.
תחשוב על כיתה שיש חידונים שבועיים.
אם יש 16 או כך שבועות בסמסטר, עכשיו יש לך 16 משתנים:
int quiz1, int quiz2, int quiz3, quiz4 int.
ברגע שאתה מתחיל לראות יתירות זה, זה העתקה והדבקה של קוד,
זה צריך להתחיל לעשות רצונך הייתה דרך טובה יותר.
ותודה לאל, כי מערכים שיש. אז בואו לעשות את זה.
ראשית, הרשה לי להציג את דבר פשוט מאוד שאנחנו כבר לא בשימוש עד כה,
אבל אתה רואה אותו מדי פעם בקוד.
>> זה מה שנקרא באופן כללי קבועה.
אז זה קבוע במובן זה שערך זה לא משנה.
הכנס האנושי בעת יצירה מתמדת
הוא להשתמש בכל האותיות, רק כדי שזה באמת בולט בקוד שלך,
ומילת מפתח המיוחדת שאתה משתמש ב-C # היא להגדיר.
אז אנחנו אומרים # להגדיר, לאחר מכן רווח, ואז את המילה שברצונך להשתמש לשם של הקבוע
ואז הערך של הקבוע.
שים לב זה שונה מהקצאת משהו משתנה.
אין שום סימן שוויון, אין פסיק.
זה מה שידוע בדרך כלל כהוראת preprocessor,
אבל עוד על כך בפעם אחרת.
לעת עתה, זה יוצר ערך בלתי משתנה נקרא חידונים
הערך המספרי שבפועל הוא 2.
אז בכל מקום שאתה רואה חידונים, שעשועונים, חידונים לאורך קובץ זה,
זה רק המספר 2.
אם אני מסתכל עיקרי עכשיו, בואו נראה איך זה עובד.
בהתחלה זה נראה לא ברור מספיק, אבל זה כל הדברים משבוע 1.
בקש מהמשתמש לכיתות. איך עושים את זה?
בקו 22 - זה באמת החלק העסיסי - אני מצהיר לצוף
אבל לא רק לצוף אחת. הריני מצהיר, אלא מערך ערכי נקודה צפה.
זה משתנה הולך להיקרא ציונים, כפי שנרמז כאן,
אבל רק לקטע של תחביר חדש אז הם הסוגריים מרובעים האלה.
העובדה שאני כבר אמרתי את ציונים לצוף ואז סוגריים פתוחים ולאחר מכן מספר -
תבחין אם זה קבוע זה בדיוק כמו שעשינו את זה -
זה אומר, "היי מחשב, תן לי 2 צף ובואו ביחד קוראים להם ציונים".
>> זאת בניגוד להרבה יותר משעמם תהליך כזה: מצוף grade1;
לצוף grade2, וכך הלאה.
אז מערך מאפשר לנו ליישם את הרעיון הזה, אבל הרבה פחות מבולגן,
באופן כזה שאנחנו יכולים לכתוב קו 1 של קוד במקום, תניח, 16 לסמסטר 16-שבוע.
אני לא רוצה קוד קשיח-2 משום שאם אתה חושב על זה עכשיו באופן הגיוני,
מניח בשנה הבאה CS50 שינויי 3 בחנים במקום
והיה לי את המספר 2 כאן, היה לי המספר 2 כאן,
היה לי את המספר 2 לכאן, המספר 2 כאן.
זה הופך להיות מאוד משעמם וקל מאוד לפשל
ולשנות בטעות הערך 1-3 ומתגעגע ערך אחר של 2.
אז אני הולך לשם במקום מופשט זה ולהשתמש בזה קבוע ש,
כפי שהשם מרמז, לא משתנה לעולם.
ועכשיו, לא משנה אם יש לנו אחר בחנים או השנה הבאה,
אני רק צריך לשנות אותו במקום אחד כאן בראש.
אז זה כל מה שקבוע הוא.
בינתיים, התכונה הרעיונית החדשה היא זה של מערך.
אז הסוגריים המרובעים ינתנו לי הרבה זה צף ומאפשר לי לקרוא להם ציונים קולקטיביים כאן.
אז עכשיו בואו נראה מה אני הולך לעשות.
כאן, בקו 24 היא תחילתו של ללולאה.
>> זה באמת שום דבר מהודר. זה פשוט באמצעות חידונים במקום מספר קבוע בקוד.
אבל אין שום דבר שונה מבחינה אינטלקטואלית לשם בשבוע שעבר.
זה רק printf, אז printf ("החידון ד #% מ% ד:")
כי אני פשוט רוצה להדפיס לי חידון מספר 1 מתוך 2 ולאחר מכן 2 מתוך 2.
אז זה דבר אסתטי.
אבל חלק המעניין כרגע הוא בקו 27.
כדי למלא באחת משני מצייני המיקום עם ערך נקודה צפה,
שוב להשתמש בסוגריים מרובעים.
במקרה זה, אני משתמש בזה בשבילי, כי לולאה החל עם אני שווה איזה ערך, כנראה?
[תלמיד] 0. >> [מלאן] 0.
אז באיטרציה הראשונה של לולאה זה, זה כאילו אני כתבתי את זה בקוד,
אבל באיטרציה השנייה של הלולאה הזו, זה כאילו אני כתבתי את זה בקוד שלי.
אבל העובדה שאני משתמש במשתנה היא מושלמת, כי, כפי שהשם מרמז,
זה משתנה את הערך שלו בכל איטרציה,
אז אני ממלא מערך זה נקודה אחת בכל פעם.
מה מערך זה נראה לך?
הסיבה ציירתי מלבן פשוט סופר על המסך כאן לפני הייתה מסיבה זו.
מערך הוא פשוט גוש של זיכרון ואחריו עוד נתח של זיכרון
אחריו עוד נתח של זיכרון וכן הלאה.
אז אם המערך שלי הוא בגודל 2 במקרה זה כאן, כל מה שאני היה עושה
על ידי הקלדת ציוני הבחנים שלי כמו כאן - יש לי 100 על זה ואז יש לי 99 על זה -
אז הזיכרון הזה לא יכול גם לשמש כי אני כבר שאלתי את המחשב רק
עבור מערך בגודל 2.
הריבועים האלה עדיין נמצאים שם, נכון?
עדיין יש לך 2 ג'יגה זכרון RAM גם אם אתה רק מבקש 2 מצופים.
אז הרעיון מאחורי מערכים הוא שהמחשב פשוט לוקח נתח של זיכרון
ולאחר מכן מקצה בחתיכות קטנות יותר גב אל גב אל הגב אל גב.
ואז זה כל מערך הוא.
>> זה נתח רציף בתוך זיכרון שלו אתה יכול לשים את הדברים.
זה קורה אז לעשות בדיוק כמה חישובים משעממים.
אם אני לגלול למטה כאן, זה מקום שבי אז לחזר על המערך.
אני בא עם הסיכום של כל הערכים במערך,
ואז להשתמש בפונקצית הסיבוב כאן למעשה לעשות סכום מחולק בחידונים.
אבל תן לי להניף את היד שלי שבכל סוג של חשבון מספיק לעת עתה.
אבל כל מה שהוא עושה עבורי בסופו החישוב ממוצע.
אז חידון 1 חידון בתוספת 2 חלקי 2 ולאחר מכן להדפיס את זה כמו int.
אבל בואו עכשיו מעבר לדוגמה אחרת הנקראת string1,
אשר מצייר תמונה דומה אבל מייתרי שימוש.
תן לי ללכת קדימה ולפשט את זה לרגע.
סלח לי על הכניסה לעת עתה.
הודעה בקו 19 של דוגמה זו, אני מקבל מחרוזת מהמשתמש.
אבל שים לב למה שאני עושה בא בשורות 22 ואילך.
בעצם אני iterating מעד - וזה טריק חדש - strlen, אורך מחרוזת.
זוהי פונקציה שמגיעה עם C שאם אתה עובר אותו חוט,
זה אומר לך כמה תווים שבמחרוזת. זה הכל.
והעובדה שזה strlen במקום אורך מחרוזת היא רק בגלל שזה תמציתי יותר.
לפני שלושים שנה, אנשים אוהבים לכתוב דברים באופן תמציתי ככל האפשר,
אז אנחנו כבר המשכנו את כנס זה כאן.
אני + + רק אומר להגדיל i בכל איטרציה.
ועכשיו שם לב זה, וזה באמת מעניין.
בקו 24, אני אומר, "מחשב, תן לי אופי, 8 ביטים, וקורא לו ג."
אבל מה זה בצד ימין אומר?
באנגלית, מה זה מייצג?
[תלמיד] התו הראשון במערך.
בדיוק. תן לי את התו הראשון במערך.
או, באופן כללי יותר, תן לי את תו ה-i במערך.
ומבין שזה חשוב עכשיו שכמדעני מחשב,
אנחנו למעשה לספור מ 0.
>> אין לך שיקול דעת עכשיו להתחיל לעשות את זה.
עכשיו אתה צריך להתנהג בהתאם לציפיות של המחשב ולספור מ 0
כי [0] הולך להיות התו הראשון במחרוזת,
[1] הוא הולך להיות שני, [2] הולך להיות שלישי, וכך הלאה.
אז התכנית הזאת, אם אני לקמפל את זה, זה שוב string1, אז לעשות את string1,
ועכשיו נגמרתי לי string1 בחלון המסוף שלי.
הוא מחכה לקלט, אז אני הולך להקלדה בדוד, זן,
ועכשיו הוא מדפיס את כל דוד על קווים שונים, בגלל הודעה מה שאני עושה.
אני מדפיס תו אחד בכל פעם.
אנחנו לא נכנסנו לפרטי פרטים היום על זה, אבל אני מחקתי לפני רגע סימון זו כאן.
מסתבר שאם המשתמש אינו מתנהג כשורה, יריבות, או סתם מבולבל,
אתה בעצם יכול להיכשל לתת מחרוזת באורך מסוים.
אם אתה מכה על המקש הלא הנכון במקלדת, ייתכן שלא לתת מחרוזת בכלל,
או אם אתה זדוני, ייתכן שתנסה להדביק בשווי של ג'יגה של מאמר
כדי למלא את הערך הזה, ואם המחשב פועל מתוך זיכרון,
מתבררים שאנחנו הולכים לקבל בחזרה הערך המיוחד הזה שנקרא NULL.
אז לעת עתה, רק יודע שיש הערך המיוחד הזה שנקרא NULL
שיאפשר לנו לבדוק כאשר אנחנו יוצאים מזיכרון, בין השאר.
אבל אם אני פותח עכשיו string2, תבחין בהבדל אחד כאן.
שים לב הבדל אחד כאן עם string2.
עם string2, זה ללולאה הוא קצת שונה.
>> תן לי למחוק את ערכי null כדי שנוכל לדבר על הדברים האלה בפעם אחרת.
מה שונה ללולאת הזמן הזה?
אני יכול לחזור לדוגמה הקודמת.
אז זה גרסה 2, זו היא גרסה 1. 1, 2.
1, 2.
Strlen השיחה היא איפה?
זה בחלקו הראשון של ללולאה.
כל מחשבות, מדוע אני עושה את זה? כן.
[תלמיד] אז אתה לא קורא לפונקציה בכל פעם אחת.
[מלאן] אז אנחנו לא קוראים לפונקציה בכל פעם אחת. בדיוק.
היזכר ללולאות שהם פשוט סופר
ברגע שאתה סוג של להבין שזה אתחול, התנאי והעדכון.
הבעיה היא שהמצב שקורה בכל איטרציה של הלולאה.
וכך בדוגמה זו כאן, מה רע בעובדה שמדובר במצב שלי?
[תלמיד] אתה קורא strlen.
[מלאן] אתה קורא strlen שוב ושוב ושוב.
אבל ברגע שהקלדתי בדוד, שאורך המחרוזת הוא 5,
וזה לא הולך להשתנות בכל איטרציה של הלולאה
כי המחרוזת היא עדיין D--V-i-ד.
אז זה רמז למה שהולך להיות יותר ויותר חשוב רעיון
מכונה עיצוב החלטה בי פשוט לא להפוך את המחשב לעשות עבודה מיותרת.
>> בדיוק כמו צצה מקדימה של pset2, pset2 במהדורה הסטנדרטית
הוא הולך לאתגר אותך למעשה ליישם חלק המספר של צופן,
חלק מספר אלגוריתמי הצפנה, כך שאתה יכול גם להצפין
ומסרים סודיים לפענח הרבה כמו ראלפי אחד יש פוענח.
במהדורה של האקר pset2, אנחנו הולכים ללכת עוד קצת.
אנחנו הולכים למסור לך קובץ ממערכת מחשב בפועל
המכיל כל חבורה של שמות משתמש וסיסמות מוצפנות בפועל,
והאתגר עבור מהדורת ההאקר הולך להיות לפיצוח הסיסמות האלה
ולהבין מה קריפטוגרפיה או מה הסוד שמש בפועל ליצירת הסיסמות האלה.
ואנחנו הולכים לעשות את זה על ידי שימוש בתכונה חדשה של C כאן
שאני אתן לך רק הדגמה של המכונית טיעוני שורת פקודה.
מתברר, כפי שחלקכם אולי ראה בסעיף או בספרי לימוד,
עיקרי לא תמיד צריך להיות מבוטל בסוגריים.
מתברר שראשי יכול גם להיות כתוב ככה, בשני טיעונים,
argc וargv, שם argc הוא מספר המילים
לאחר שהקלדת את שמה של התכנית בשורת הפקודה שלך
וargv הוא את המילים עצמן.
וכמו הסוגריים המרובעים שם מציעים, argv הוא כנראה מערך.
זה הולך להיות מחרוזת אחרי מחרוזת אחרי מחרוזת בזיכרון.
>> אז מה אנחנו הולכים להיות מסוגלים לעשות את החלנו בpset 2 הוא משהו כזה.
אם אני עושה argv1, שהוא דוגמה תוכל לחזור אליו ביום שני, ולהפעיל אותו,
שם לב שהוא לא מצליח לעשות שום דבר עדיין.
זה פשוט מדפיס את שמו שלו.
אבל אם אומר שמעמד פרידה, שימו לב שתכנית זו כנראה סובב
על כל אחת מהמילים שהוקלדו בשורת הפקודה.
ואת האמצעי שבעזרתו אנו מקבלים גישה למילים שהמשתמש הקליד בשורת הפקודה
היא על ידי השינוי העיקרי החל מסוף השבוע הזה int הראשי (ריק) לint ראשי (argc, argv)
וכך יהיה נולד טיעוני שורת פקודה.
וברגע שאתה מקבל באמת מתוחכם בזה, תוכל לכתוב תוכניות ממש trippy
כמו זו כאן, שהולכת מעל ומעבר
חלק מהפונקציונליות שעשינו עד כה, אבל כולם די חזק.
>> אז אשאיר את זה עם זה על המסך, ואנו רואים אותך ביום שני.
>> [CS50.TV]