>> [השמעת מוסיקה]
דוד י מלאן: בסדר.
זה CS50, וזה הוא סוף השבוע 2.
אז היום, אנחנו הולכים להמשיך המבט שלנו
באופן בו אנו מייצגים דברים מתחת hood-- מתרחק
ממספרים כמו מספרים שלמים וערכי נקודה צפה
והתמקדות במחרוזות ו תוכניות סופו של דבר יותר מעניינות.
אבל אנחנו גם נסתכל על כמה problems-- תחום ספציפי
הראשון שבם יהיה להיות מעורב קריפטוגרפיה,
האמנות של ערבול מידע, שבו אתה רואה לעיל כאן
תמונה של רדיו אנני היתומה של טבעת מפענח סוד מפעם.
>> זהו למעשה צורה מאוד פרימיטיבית וצורה ידידותית לילדים של cryptopgraphy
לפי יש טבעת זו שתי disks-- בתוך אחד ואחד בחוץ.
ועל ידי החלפה אחד מאותם, אתה יכול בעצם בשורה אותיות כמו
עד Z עם אותיות אחרות כמו ב 'עד א' במילים אחרות,
אתה ממש יכול לסובב את האלפבית, ובכך מגיע עם מיפוי מ
מכתבים למכתבים כך ש, אם אתה רציתי לשלוח מסר סודי
למישהו כמו אנני, אתה יכול לכתוב את ההודעה שלך ולאחר מכן לסובב
המכתבים, לפיה, אם אתה מתכוון לומר "," לך במקום לומר "B,"
אתה מתכוון לומר "B," אתה במקום לומר "C" -
או משהו קצת יותר חכם מ that-- ולאחר מכן, בסופו,
כל עוד אנני יש מפענח זה טבעת, היא יכולה לפענח את ההודעה.
עכשיו, שאתם אולי זוכרים, למעשה, כי זה היה בשימוש בסרט מפורסם מאוד ש
nauseum מודעה משחק במהלך עונת חג המולד.
בואו נסתכל כאן.
ראלפי PARKER: "זה היה ידוע לכל בסיכום
שראלף פארקר מתמנה בזאת חבר הקטן אנני הסוד יתום
מעגל, והיא זכאי לכל כיבודים והטבות המתרחשים לו. "
>> ראלפי פארקר (מספרת): חתמה היתומה הקטנה אנני.
בתשובה, פייר אנדרה!
בדיו.
כיבודים והטבות, כבר בגיל תשע.
>> [השמעת מוסיקה]
>> [ברבורים ברדיו]
יאללה: ראלפי פרקר.
בואו נגמור עם זה.
אני לא צריך את כל הג'אז הזה על מבריחים ופירטים.
שדרן רדיו: תקשיב מחר לילה להרפתקה המסכמת
של שחור ספינת פיראטים.
עכשיו, הגיע זמן לאנני של מסר סודי בשבילך חברים
של המעגל הסודי.
זכור את הילדים, רק חברים של המעגל הסודי של אנני
יכול לפענח המסר הסודי של אנני.
>> זכרו, אנני תלויה בך.
הגדר הסיכות שלך לB-2.
הנה 12 message--, 11, 2--
ראלפי פארקר (מספרת): אני אני בפגישה החשאית הראשונה שלי.
שדרן רדיו: --25, 14, 11, 18, 16--
ראלפי פארקר (מספרת): הו, פייר היה בערב קול גדול.
אני יכול לספר לי הלילה של ש ההודעה הייתה באמת חשובה.
>> שדרן רדיו: --3, 25.
זה מסר מאנני את עצמה.
זכור, לא לספר לאף אחד.
>> [מתנשף]
ראלפי פארקר (מספרת): תשעים שניות מאוחר יותר, אני
בחדר היחיד ב בית שבו ילד בן תשע
יכל לשבת בפרטיות ולפענח.
אה.
"ב '"
>> [מגחך]
>> ראלפי פארקר (מספרת): הלכתי למקום הבא.
"א '"
המילה הראשונה היא "להיות".
כן!
זה היה הקרוב יותר קל עכשיו.
"ע '"
>> [מגחך]
>> רנדי PARKER: אוי, בחיים, ראלפי.
אני חייב ללכת!
>> ראלפי PARKER: אני אהיה מימין למטה, מא.
גאון גי.
"ט" "א '" "תהיה בטוח ל. "" הקפד "מה?
מה הייתה היתומה הקטנה אנני מנסה לומר? "הקפד" מה?
אמא: ראלפי, רנדי חייב ללכת.
אתה מוכן בבקשה לצאת?
>> ראלפי PARKER: בסדר, אמא!
אני אהיה מחוץ נכון!
ראלפי פארקר (מספרת): אני מתקרב עכשיו.
המתח היה נורא.
מה זה היה?
גורלו של כדור הארץ עלול להיתקע במאזן.
>> אמא: ראלפי, רנדי חייב ללכת!
>> ראלפי PARKER: אני אהיה תקין את, בוכה בקול רם!
ראלפי PARKER (מספרת): כמעט שם!
האצבעות שלי טסו!
המוח שלי היה מלכודת פלדה.
כל נקבובית רטט.
זה היה כמעט ברור!
כן!
>> ראלפי PARKER: "תהיה בטוח לשתות השוקו שלך. "
שוקו?
מסחרי עלוב?
>> [השמעת מוסיקה]
>> ראלפי PARKER: יא בן זונה.
>> [צוחק]
>> דוד י מלאן: אז שלאחר מכן הוא הצצה אל מה קריפטוגרפיה
יכול להיות לזה- לשתות מפעם.
אז הודעה מהירה.
אם אתה חופשי זה יום שישי בשעה 1:15 והיית
רוצה להצטרף אלינו לCS50 ארוחת צהריים, בראש לכתובת אתר זו כאן.
במקום ראשון, ישמש ראשון כרגיל.
אבל לאורך זמן, נדאג ש רוב מי שרוצה להשתתף
עשוי לקבוע חכם.
>> אז מיתרים.
יש לנו Zamyla-- עכשיו אתה כבר פגשת סביר ביותר
בבעיה סט 1-- ש שם מאוית כך.
ונניח שהקלדת את שמה לתוך תוכנת מחשב זה
באמצעות משהו כמו getString.
כדי לאחזר הקשות האלה, איך
אנחנו הולכים על ייצוג מחרוזת, מילה, פיסקה,
או מכתבים מרובים כמו כאן אלה?
>> דברנו בפעם האחרונה על מספרים שלמים ובעיות
שעולה עם מעבר שלם וערכי נקודה צפה
ובעיות ש להתעורר בתוך דיוק.
עם מחרוזות, אנחנו לפחות יש קצת יותר גמישות
בגלל המייתרים: רק בworld-- האמיתי
יכול להיות באורך די שרירותי.
די קצר, ארוך למדי.
אבל גם אז, אנחנו הולכים יגלה שלפעמים מחשבים יכולים
נגמרים של זיכרון ואפילו לא לאחסן מספיק מחרוזת גדולה.
>> אבל לעת עתה, בואו נתחיל לדמיין מחרוזת כמו משהו בקופסות אלה
כאן.
אז שש קופסות כאלה, כל אחד מהם מייצג דמות או "char".
אז תזכור, כי "char" - c-h--r-- הוא אחד מסוגי הנתונים מובנים בג
ומה נחמד הוא שאתה יכול להשתמש כי סוג של כאבן בניין,
פיסת הפאזל, אם תרצה, כדי ליצור סוג גדול יותר של נתונים שאנחנו נמשיך
לקרוא "מחרוזת".
>> עכשיו, מה שימושי על חשיבה על דברים כמו מחרוזות בדרך זו?
ובכן, מתברר שאנחנו יכולים למעשה למנף את המבנה הזה
כדי לגשת למעשה תווים בודדים בדרך די פשוטה.
אני הולך קדימה וליצור קובץ בשם "stringzero.c,"
אבל אתה יכול לקרוא לזה איך שאתה רוצה.
ובאתר האינטרנט של הקורס הוא כבר דוגמא זו מראש,
אז אתה לא צריך הקלד את הכל.
>> ואני הולך קדימה ולעשות void main int הראשון.
ותוך כמה ימים, נתחיל להקניט בנפרד
מה חלל הוא כאן, מדוע זה int ליד ראשי, וכן הלאה.
אבל לעת עתה, בואו נמשיך ללהעתיק ולהדביק את זה.
>> אני הולך להכריז על מחרוזת בשם ש.
ואני הולך לחזור מ GetString מה שהמשתמש ב.
זה הולך להיות פשוט תכנית, אין הוראות,
אני רק הולך לעיוור מצפה שהמשתמש יודע
מה לעשות כדי לשמור את זה פשוט.
>> ועכשיו אני הולך להיות ללולאה.
ובתוך לולאת for שלי אני הולך להיות int i מקבלת אפס.
ואני הוא, שוב, רק אמנה, משתנה מדד לספירה,
אבל אני יכול לקרוא לזה מה שאני רוצה.
אני הולך לעשות הוא אני פחות than-- גם שמו של Zamyla הוא באורך של שש אותיות.
אז אני הולך לקשה כי קוד שם לעת עתה.
>> ולאחר מכן אני ++.
ועכשיו בתוך מתולתל אלה פלטה אני הולך לעשות printf,
ואני רוצה להדפיס אחד אופי בכל פעם.
אז אני הולך להשתמש% ג ל אולי בפעם הראשונה.
ולאחר מכן אני רוצה להדפיס כל דמות בשורה הנפרדת.
אז אני הולך לשים קו נטוי מעט n יש.
ציטוט לסגור.
>> ועכשיו אני רוצה לעשות משהו כאן.
אני רוצה להדפיס מכתב ספציפי במחרוזת,
ים, כמו שאני iterating מאפס על עד שש.
במילים אחרות, אני רוצה להדפיס את אופי i'th של ים.
עכשיו איך אני יכול לעשות את זה?
>> ובכן הרבה כמו התיבות ב ייצוג זה כאן,
סוג של, להעלות את הרעיון של אגרוף אותיות ב, אתה יכול לעשות את זה באופן דומה
מבחינה תחבירית בC פשוט על ידי ציון, אני רוצה להדפיס של של i'th אופי.
שימוש בסוגריים מרובעים על המקלדת של המחשב שלך
שעל מקלדת ארה"ב בדרך כלל מעל מפתח ההחזר.
>> אז זה לא לגמרי בסדר עדיין, כפי שאתה אולי שמת לב.
אבל אני הולך לסוג של באופן עיוור להתקדם כאן.
ואני הולך לעשות לעשות מחרוזת 0.
אבל לפני שאני עושה את זה, בואו תראו אם אנחנו לא יכול לצפות כמה טעויות נפוצות.
האם זה הולך לקמפל?
לא, אני חסר חבורה שלמה של דברים.
ספריות שמעתי.
>> אז איזה כותרת קבצים אולי אני רוצה להוסיף כאן?
כן.
>> קהל: אתה צריך אני סטנדרטי / פלט [לא ברור]
>> דוד י מלאן: מצוין.
אז אני צריך קלט / פלט סטנדרטי. למה מטרה לעשות אני רוצה I / O סטנדרטי?
לprintf.
אז להכליל את stdio.h.
ואתה גם מציע שאני כולל ספריית CS50 למה סיבה?
יש מחרוזות.
כך תוכל לראות מה הספרייה של CS50 עושה
כדי ליצור את הרעיון הזה של מחרוזת.
אבל לעת עתה, אתה יכול פשוט חושב על זה כעל סוג הנתונים בפועל.
>> כך שנראה שניקה קצת.
ועכשיו אני הולך קדימה ואכן לעשות להפוך את המחרוזת 0.
הידור.
אז זה טוב.
אז ./string0 תן לי להתקרב כל כך שאנחנו יכולים לראות יותר מקרוב מה קורה.
הזן.
Z--M-Y-L-להיכנס.
ואנחנו כבר הדפסנו לשמו של Zamyla.
>> אז זה די טוב.
אז עכשיו בואו נלך קדימה ו להפעיל את התכנית שוב,
ולהקליד את השם המלא של דייבן.
הפתעה, הפתעה.
הזן.
הממ.
לא הדפסנו ךייבן של ראשון שמו מלא בצורה נכונה.
עכשיו זה צריך להיות ברור ב בדיעבד, בגלל מה,
סוג של, החלטת עיצוב טפשה?
>> כן, אני קשה מקודד שש בתוכי ללולאה.
עכשיו אני עשיתי את זה רק בגלל ש ידעתי את שמו של Zamyla
הולך להיות שש אותיות.
אבל אין ספק שזה לא פתרון כללי.
אז מתברר שאנחנו יכולים דינמי להבין את האורך של מחרוזת
על ידי קריאת פונקציה שנקראת strlen.
>> שוב, בכוונה בשם בתמציתיות רק
כדי לעשות את זה יותר נוח להקלדה.
אבל זה שם נרדף ל מקבל את האורך של מחרוזת.
אני הולך לחזור למסוף שלי חלון מחדש להפעיל את המהדר.
אבל זה לצעוק עליי.
במרומז הכרזת פונקצית ספרייה strlen עם סוג שאינו חתום int const--
אני אבוד.
לחלוטין.
>> אז, במיוחד כמו שלך עיניים מתחילות מזדגגות
עם הודעות שגיאה כמו זו, מוקד בכנות על כמה המילים הראשונות.
אנחנו יודעים שהבעיה היא ב קו 8, כפי שצוין כאן.
וזה במחרוזת-0.c.
במרומז הכרזה פונקצית ספריית strlen.
כך שבדרך כלל הולכים להיות דפוס של הודעות שגיאה.
במובלע שהכריז משהו.
>> אז בקיצור, מה שיש לי נראה ש עשה ביחס לקו 8, כאן.
מה יכול להיות הפתרון להיות אפילו אם מעולם לא השתמשו strlen את עצמך?
>> קהל: חלק מספרייה אחרת?
דוד י מלאן: חלק של ספרייה שונה.
אז הוא הצהיר, כביכול.
היא מוזכרת בכמה קובץ מלבד stdio.h וCS50.h.
עכשיו שבו הוא מוגדר?
אם להיות כנה, אתה גם צריך רק יודע שזה את החלק העליון של הראש שלך,
או שאתה בגוגל ולגלות.
או יודע את זה, אני כבר פתחתי בCS50 מכשיר תכנית המסוף, ש
רק הגרסה של גדולה, מסך מלא מה שבתחתית החלון של gedit.
>> ומתברר שיש הפקודה דומה תמציתית, הנקראת
אדם לידני, שבו אם אתה מקליד ב השם של פונקציה וקש Enter,
אתה תחזרי למדי תיעוד מסתורי.
זה פשוט טקסט שבדרך כלל נראה קצת משהו כזה.
זה קצת מוחץ במבט ראשון.
אבל בכנות, אני הולך הניח לעיניי לזגג מעל
ולהתמקד רק בחלק אכפת לי לרגע.
>> איזו היא זו.
שנראה מבחינה מבנית כמו משהו שאני מכיר.
אכן דף האדם, כך לדבר, יגיד לך
במה שכותרת להגיש פונקציה כמו strlen מוגדר.
אז אני הולך לחזור עכשיו לgedit.
ואני הולך קדימה, להוסיף בכאן #include
ולשמור את הקובץ.
>> אני הולך לנקות את המסך עם L שליטה אם אתה כבר תוהה.
ואני הולך להפעיל מחדש איפור string.0, הידור זה זמן.
./string.0 Zamyla.
זה נראה לעבוד תן לי ללכת קדימה ולהפעיל מחדש את זה עם דבנפורט.
הזן.
וזה, יותר מדי, נראה לעבוד.
>> אז אנחנו יכולים לעשות קצת יותר טוב מזה, אם כי, אנחנו יכולים להתחיל לדברים מסודרים
עד קצת.
ואני הולך בעצם להציג דבר אחד אחר עכשיו.
אני הולך קדימה, להציל את זה בקובץ אחר.
ואני הולך לקרוא string1.c קובץ זה פשוט
להיות עקבי עם הקוד תוכל למצוא באינטרנט.
>> ובואו נתמקד ב בדיוק באותו הקוד.
מתברר שיש לי היה סוג של לקיחה
כמובן מאליו את העובדה שהמחשב הנייד שלי, בתורו, את מכשיר CS50
יש לו הרבה זיכרון, הרבה זיכרון RAM, הרבה בתים של שטח
שבו אני יכול לאחסן מחרוזות.
>> אבל המציאות אם הקלדתי ארוכה מספיק, ומספיק הקשות,
אני יכול בסוג התאוריה בתווים נוספים
מהמחשב שלי יש פיזי זיכרון ל.
וזה בעייתי.
בדומה int יכול רק לספור כל כך גבוה, בתאוריה,
אתה יכול רק לדחוס כל כך הרבה דמויות לזכרון RAM של המחשב שלך או אקראי
גישה לזיכרון.
>> לכן כדאי שצופה בעיה, זה אפילו
למרות שזה יכול להיות נדיר מקרה פינה, אם אפשר לומר כך.
לא קורה, כי לעתים קרובות, יכול לקרות.
ואם זה קורה ואני לא צופה ותכנית לזה,
התכנית שלי יכולה לעשות מי יודע מה.
להקפיא, לתלות, אתחול מחדש, לא משנה מה.
משהו צפוי שעלולים לקרות.
>> אז מה שאני הולך לעשות עכשיו, מכאן ואילך באמת,
הוא לפני שאי פעם באופן עיוור להשתמש משתנה כמו של ש
הוקצה ערך ההחזרה של תפקיד אחר כמו getstring,
אני הולך לוודא שהערך שלה הוא בתוקף.
אז אני יודע רק שמקראתי התיעוד של CS50 לgetstring,
שסופו של דבר אנחנו נצביע עליך, getstring שחוזר סמל מיוחד
נקרא, N-U-L-L NULL בכל כובעים, אם משהו משתבש.
>> אז בדרך כלל, זה מחזיר מחרוזת.
אבל חוץ מזה, אם הוא חוזר N-U-L-L-- אנו סופו של דבר תראו מה שבאמת
means-- שרק אמצעי קרה משהו רע.
עכשיו זה אומר, ממש כמו בגרד, אני יכול לבדוק את מצב כאן בC,
אם ים לא NULL שווה.
אז אם כבר אתה לא ראית את זה קודם, זה רק אומר שאינו שווה.
>> אז זה ההפך של שווה שווה, אשר, כזכור,
שונה מאחד שווה, אשר היא משימה.
אז אם של אינו שווה NULL, רק אז
אני רוצה לבצע שורות הקוד הללו.
אז במילים אחרות, לפני שאני צולל באופן עיוור
ולהתחיל iterating מעל ים, וטיפול בו
כאילו זה הוא רצף של דמויות, אני הולך קודם לבדוק,
חכה רגע, הוא בהחלט לא שווה לערך מיוחד זה, NULL?
>> כי אם כן, דברים רעים יכולים לקרות.
ועכשיו, תניח דברים שרעים קורים פירושו קריסות התכנית שלך,
ואתה לא יכול לשחזר בהכרח.
אז בכנות, זה נראה מכוער.
זה סוג של מבלבל עכשיו במבט חטוף ב.
אבל זה יהיה יותר מוכר לפני זמן רב.
>> אבל אני הולך להציע עכשיו שיפור אחד אחר.
זה שיפור לתקינות.
התכנית שלי היא עכשיו נכונה יותר, משום ש במקרה הנדיר שאין מספיק זיכרון
קיים, אני אטפל בזה, ואני רק לא לעשות כלום.
אני לפחות לא לקרוס.
>> אבל בואו נעשה את הגרסה סופית כאן.
וקובץ שנקרא string2.c.
אני הולך להדביק ש אותו קוד רק לרגע,
ואני הולך כדי להדגיש את זה קו, 11, כאן, רק לרגע.
עכשיו המציאות היא שמהדרים חכמים כמו קלאנג יכול לתקן את זה בשבילנו
מאחורי הקלעים מבלי שלנו בידיעה.
אבל בואו נחשוב על זה ביסודו כעיצוב בעייתי.
>> קו זה של קוד הוא, כמובן, אומר, לאתחל כמה משתנה i ל0.
זה די פשוט.
ומה הוא שוב זה אמירה, כאן, אני ++, עושה?
אנחנו ראינו את זה לפני, אבל אנחנו לא ממש מדבר על זה.
>> קהל: להגדיל כל i.
>> דוד י מלאן: i להגדיל כל.
אז בכל איטרציה דרך לולאה זו, בכל מחזור,
אתה להגדיל כל i על ידי אחד.
אז זה נעשה גדול יותר, וגדול יותר, ו גדול עד הלולאה מסתיימת.
איך זה לסיים?
ובכן יש אמצע זה מצב שבו אנו כבר השתמשנו בעבר.
ראית וב ערוצים בסט P.
>> אבל מה זה אומר?
האם הלולאה הבאה כך עוד הוא אני פחות ממה?
קהל: האורך של המחרוזת.
דוד י מלאן: אורך של המחרוזת.
אז זה מתרגם די נקי לאנגלית במובן זה.
עכשיו הבעיה היא שכל זמן אני לחזר דרך לולאה זה בתאוריה,
אני שואל את השאלה הזאת.
האם אני פחות מאורך המחרוזת של ים?
>> עכשיו הוא שאני משתנה בכל איטרציה?
זה.
בגלל ++.
אז כל איטרציה אני נעשה גדול יותר.
אבל האם זה נעשה גדול יותר, או קטן יותר, או שינוי בכלל?
מס '
אז במונחים של עיצוב, אחד מהצירים שלאורכו אנו מנסים להעריך קוד
בכיתה, זה מרגיש סוג של טיפשים.
>> כמוך, פשוטו כמשמעו, בכל איטרציה
של לולאה זה שואל אותה שאלה ארורה שוב,
ושוב, ושוב, ופשוטו כמשמעו זה לא הולך להשתנות.
לפחות אם אני לא נוגע בים ו מנסה לשנות את תוכנו של ים.
אז אני יכול לעשות קצת יותר טוב מזה.
>> ומה שאני הולך לעשות הוא לא להכריז רק אחד אני משתנה,
אבל משתנה שני אני באופן שרירותי ימצא, אבל כמקובל, קורא לזה n.
הקצאת n שווה ל אורך מחרוזת של s.
ולאחר מכן לכאן, אני הולך לעשות אופטימיזציה קטנה וחכמה, כל כך
לדבר, כי בסופו של היום הוא לא יותר נכון או לא פחות נכון
יותר מאשר בעבר.
אבל זה עיצוב טוב יותר.
בעובדה שאני משתמש פחות זמן, מחזורי CPU פחות, כך
לדבר, לענות אותו שאלה, אבל רק פעם אחת.
>> כל שאלות באופן כללי ש עיקרון של שיפור,
אומר, היעילות של תכנית?
כן?
קהל: למה אתה להשתמש ב[ לא ברור]?
דוד י מלאן: שאלה טובה.
אז למה אנחנו שמים את ++ על הקצה אני במקום תחילת i?
במקרה זה, יש לו אין השפעה תפקודית.
ובאופן כללי, אני נוטה להשתמש במפעיל postfix
כך שזה קצת יותר ברור כאשר הפעולה שקורה.
>> עבור לא מוכר אלו, יש עוד הצהרות שבו אתה יכול לעשות ++ i.
אלה הם פונקציונלי שווה ערך במקרה זה
כי אין שום דבר אחר סביב incrementation ש.
אבל אתה יכול לבוא עם מקרים ושורות קוד
שבו שעושה את הבדל.
אז בדרך כלל, אנחנו עושים לא אפילו לדבר על זה.
כי למען האמת, זה גורם לך סקסי קוד, וסוג של מעיל גשם,
ומספר קטן של תווים.
אבל המציאות היא שזה הרבה יותר קשה, אני חושב, אפילו בשבילי לעטוף את דעתי
סביבו לפעמים, את סדר פעולות.
אז כמו בצד, אם אתה ממש לא אוהב את זה,
למרות שזה סוג של סקסי מחפש, אתה יכול גם לעשות i + = 1,
המהווה את הגרסה מכוערת יותר של אותו רעיון לincrementation postfix.
>> אני אומר את זה ואתה צריך לצחוק על זה,
אבל אתה תבוא לראות את הקוד כ משהו יפה לפני זמן רב.
>> [שחוק]
>> דוד י מלאן: מימין?
כן.
שאלה באמצע.
>> קהל: האם אתה צריך להגיד n int?
דוד י מלאן: אתה עושה לא צריך להגיד n int.
אז בגלל שכבר אמרו int, אתה לא צריך להגיד את זה שוב.
המלכוד הוא שn יש להיות אותו סוג נתונים כפי שאני.
אז זה רק נוחות כאן.
כן.
>> קהל: אתה יכול לעבור על אופי של הדפסת סוגר אני שוב?
דוד י מלאן: בהחלט.
אז% ג, זוכר מאחרון הזמן, הוא רק מציין.
זה אומר לשים char כאן.
n הקו הנטוי, כמובן, רק אמצעים לשים מעבר שורה כאן.
אז זה משאיר רק, עכשיו, זה חתיכת התחביר חדש.
וזה, פשוטו כמשמעו, ואמר, לתפוס נקראת את המחרוזת של וללכת לקבלו
אופי i'th, אם אפשר לומר כך.
>> ואני חוזר ואומר אופי i'th כי בכל איטרציה של לולאה זה
זה כאילו שאנחנו מדפיסים את, סוגר של ראשון 0,
כמתכנת יכולה להגיד.
אז זה סוגר 1, ולאחר מכן s סוגר 2, ואז 3, ולאחר מכן 4.
אבל כמובן שזה משתנה, אז אני פשוט לבטא את זה עם i.
>> מפתח, אם כי, הוא להבין, במיוחד אם יש לך לא
כבר הסתגלות לעולם הזה של תכנות, שבו כולנו
נראה לספור מאפס, צריך מתחיל לספור מאפס עכשיו.
בגלל מיתרים, תו ראשון, z בZamyla הוא לטוב או לרע
הולך לחיות במספר מיקום אפס.
>> בסדר, אז תנו לי להביא אותנו בחזרה לכאן כדי Zamyla
ולראות מה באמת קורה על מתחת למכסת המנוע.
אז יש את הרעיון הזה של יציקת סוג.
ייתכן שבאמת יש להם שיחקתי עם זה כבר,
אולי להאקר מהדורה של P להגדיר אחד.
אבל ליהוק סוג פשוט מתייחס ל היכולת בC וכמה שפות אחרות
להמיר סוג נתונים אחד למשנהו.
>> עכשיו איך אנחנו יכולים לראות את זה די בצורה ישירה?
אז זה, כזכור, היא תחילתו של האלפבית האנגלי.
וההקשר, כזכור, מ כמו לפני שבוע הוא ASCII.
התקן האמריקאי הקוד למידע מחלף.
וזה רק באמת דרך ארוכה לומר מיפוי מאותיות
למספרים, וממספרים לאותיות.
>> אז דרך M כאן, נקודת נקודה נקודה, שורות עם, כזכור,
המספר העשרוני 65 בעד.
ואנחנו לא מדברים על זה באופן מפורש,
אבל אין ספק שיש דומה מספרים לאותיות קטנות.
ואכן, יש.
העולם החליט כמה שנים לפני שקטן, אותיות קטנות,
הולך להיות 97.
וb הקטנה הולכת להיות 98, וכן הלאה.
>> ועבור כל מקש אחר על המקלדת שלך, יש
הולך להיות דפוס דומה של ביטים.
או באופן שקול, מספר עשרוני.
אז השאלה שעל פרק, לאחר מכן, יכולים הוא איך אנחנו
למעשה רואה את זה מתחת למכסת המנוע?
אז אני הולך לעבור לgedit שוב.
ולא סוג זה אחד מהתחלה,
אני הולך קדימה, רק לפתוח משהו
מהקוד של היום נקרא ASCII אפס.
>> וASCII אפס נראה כך.
אז בואו לעטוף את דעתנו לעקוף את זה.
אז קודם כל, אני כבר הגיב הקוד, וזה נחמד.
כי זה ממש אומר לי למה לצפות,
להציג מיפוי לאותיות רישיות.
עכשיו אני לא ממש יודע למה אני מתכוון, אז בואו להסיק.
>> באנגלית, אולי אנגלית טכנאי במידה מסוימת,
מה עושה שורת 18 מופיעים להיות עושה לנו?
רק שורת 18.
מה זה ישכנע?
מה זה הולך לבעוט את כאן?
>> קהל: לולאה.
>> דוד י מלאן: לולאה.
וכמה פעמים היא שהולך לחזר?
קהל: [חציצת קולות] שש פעמים.
דוד י מלאן: לא שש פעמים.
קהל: 26 פעמים.
דוד י מלאן: 26 פעמים.
כן, מצטער.
26 פעמים.
למה?
ובכן, זה קצת מוזר, אבל אני כבר התחלתי לספור מ65.
וזה מוזר, אבל לא רע.
זה לא רע לכל אומר.
ואני עושה את זה רק כי, לדוגמא זו,
אני די מצפה הון שהיה 65.
עכשיו זה לא אלגנטי ביותר דרך לעשות זאת, לסוג של קוד קשה
ערכים אזוטריים שאף אחד לא אי פעם צפוי זוכר.
>> אבל לעת עתה, שם לב שאני עושה את זה דרך 65 תוספת 26.
כי כנראה אני אפילו לא רוצה לעשות חשבון בראש שלי.
אז אני אתן לי מהדר לעשות את זה.
אבל אז בכל לולאה, כל איטרציה של הלולאה, אני להגדיל כל i.
>> אז עכשיו זה נראה קצת לא ברור מאליהם.
אבל אנחנו צריכים את הבניין הבסיסי לוקים בה להבין את זה.
% C הוא רק מציין לchar.
אני% הוא מציין מיקום עבור int.
ומתברר כי באמצעות זה תחביר חדש, בסוגריים זה, כל כך
לדבר, כך סוג הנתונים בתוך סוגריים,
אני יכול להכריח את המהדר לטיפול אני לא הוא מספר שלם, אלא כתווים.
>> ובכך מראה לי את האופי מקבילה של המספר הזה.
עכשיו כאן למטה, את הקוד הזה הוא זהה למדי.
אני רק רציתי לעשות סופר מפורש העובדה
כי אני מתחיל ב97, שאותיות קטנות.
על דרך 26 מכתבים יותר.
ואני doing-- שוב, ליהוק i, אם אפשר לומר כך.
או ליהוק סוג i, אם אפשר לומר כך.
>> מint לchar.
אז התוצאה הסופית תהיה, בכנות, מידע שאנו כבר יודעים.
אני הולך לעשות ascii-0 dot-- לא מנקדים ג.
שים לב, אתה כנראה עשית את זה טעות כמו שאני פשוט עשיתי טעות.
הפוך ascii-0.
עכשיו אני הולך לעשות ./ascii-0.
אני להתקרב, ולמרבה הצער, זה הולך כדי לגלול את המסך.
אבל אנחנו רואים תרשים כולו שבו מפות ל97, מפות ב 98,
ואם אנחנו לגלול מעלה נוספים , כמובן, מפות ל65.
אז זה רק אומר ש מה שאנחנו כבר הטפה,
יש שקילות זו, היא למעשה המקרה במציאות.
אז שינוי מהיר של זה.
תן לי לפתוח את ascii-1.c.
ושים לב זה חכם, סוג של, בירור זה.
זה ascii-1.c, ו שם לב הדבר המטורף הזה.
>> וזה באמת מגיע ללב ממה שמחשבים עושים.
למרות שאנחנו בני אדם היית לא לספור במונחים של letters--
אני לא מתחיל לחשוב, בסדר אז ב,
ולהשתמש בם כדי לספור עצמים פיזיים.
אתה בהחלט יכול לומר שאני רוצה לאתחל כמה משתנים בשם c--
אבל אני יכול היה נקרא anything-- זה כך ג מאותחל לא הון
>> כי בסופו של היום, המחשב לא אכפת לי מה אתה אחסון,
זה רק אכפת איך אתה רוצה להציג את המידע הזה.
איך אתה רוצה שמחשב לפרש דפוס זה של ביטים?
אז זה לא שאני משהו בדרך כלל ממליץ לעשות.
זה באמת רק דוגמה ל להעביר את המסר שאתה בהחלט יכול
לאתחל שלם לתווים.
מפני שמתחת מכסה המנוע של char, כמובן,
רק מספר בין 0 ל 255.
>> אז אתה בהחלט יכול לשים אותו בתוך int.
ומה זה גם מדגים הוא שאנחנו
יכול להמיר מאחד הקלד למשנהו, כאן,
סופו של דבר הדפסה את אותו הדבר.
ואכן, זו אני אסדר online-- היה אמור להגיד את זה, שוב, כאן.
תן לי לנקות את זה באינטרנט, ואנו לראות בהדרכה מקוונת לפי צורך,
מה נועד לשם.
>> אישור.
דוגמא כל כך שעברה עכשיו מעורבת של וb של ואז
לקחת את הדברים צעד אחד קדימה.
אז עם של וb של ו ג של בהיוון
ושקילותיהם, בואו תסתכל בדוגמה זו, כאן.
דוגמא נוספת קוד.
אנחנו תפתחו אחד זה כבר עשה, ולכן אנחנו
לא יצטרך להקליד אותה כל את מאפס.
>> ושים לב בציפייה אנחנו משתמשים בכותרת מספר
קבצים, בין שהוא החבר החדש שלנו, string.h.
עכשיו זה נראה, בהתחלה מבט חטוף, קצת לא ברור מאליהם.
אבל בואו נראה אם ​​אנחנו לא יכולים לדבר בהיגיון דרך מה שקורה כאן.
ראשית אני מקבל מחרוזת מהמשתמש, ואני שם את המחרוזת שבמשתנה
שנקרא.
העתק דבק מלפני.
בשורה 22, אני כנראה עושה בדיוק את מה
אני עשיתי לפני רגע, אני iterating על הדמויות בים.
>> והטריקים החדשים כאן משתמשים אורך מחרוזת, אופטימיזציה הקטין
אחסון אורך המחרוזת בn, במקום לקרוא strlen שוב,
ושוב, ושוב.
ורק בודק שהוא אני פחות מ n.
עכשיו כאן, דברים מקבלים קצת מעניין.
אבל זה רק יישום של אותו הרעיון החדש הזה.
מה באנגלית עושה סוגר של אני מייצג?
>> קהל: ספירה כל אופי [לא ברור].
>> דוד י מלאן: ספירת כל דמות.
ואפילו באופן תמציתי יותר, הסוגר של i מייצגת את מה?
היית אומר.
לא לשים אותך במקום כאן.
>> קהל: Well--
דוד י מלאן: אז אם המילה is-- אם המחרוזת היא Zamyla, שstarts--
קהל: --you להתמודד עם דמויות separately--
דוד י מלאן: טוב.
בדיוק.
סימון הסוגר המרובע מאפשר כדי לגשת לכל תו בנפרד,
כך הסוגר של 0 הולך להיות התו ראשון במחרוזת.
של הסוגר 1 הולך להיות השני, וכן הלאה.
אז השאלה שאני שואל, כאן, במצב הזה הוא מה?
האם אופי i'th של יותר של או שווה לאותיות קטנות?
ומה זה אומר, כאן, עם סימן החיבור הכפול?
קהל (ביחד): ו.
דוד י מלאן: ו.
זה פשוט שווה ערך לזה.
ולא מילת מפתח בC, יש לך ל שימוש, מעצבן, אמפרסנד אמפרסנד.
וזה, לעומת זאת, מבקש הוא ים של i'th אופי פחות או שווה
לאותיות קטנות z?
ושוב, הנה שבו הבנה הבסיסית
יישום מחשב הגיוני.
שים לב ש, אף על פי שיש לי נקודת נקודת נקודה שם,
נראה כמו דרך z באותיות קטנות ה כל הערכים רציפים מ97 בעד.
>> ואותו הדבר עבורו באותיות גדולות מתחיל ב65.
אז האוכל המוכן, אז, היא שבאנגלית,
איך היית מתאר את מה קו 24 עושים?
כן?
>> קהל: ביום 24 בזה בודק אם כל תו הוא באותיות קטנות.
דוד י מלאן: זה לבדוק אם כל דמות היא אות קטנה.
אז גם באופן תמציתי יותר, הוא אופי i'th של אותיות קטנות של?
זה כל מה שאתה להביע כאן באופן הגיוני,
קצת מסתוריות, אבל סופו של דבר די בצורה ישירה.
האם ים של i'th אותיות קטנות אופי?
>> אם כך, והנה שבו דברים לקבל קצת מוח כיפוף
רק לרגע, אם כן, ללכת קדימה ולהדפיס את דמות.
אז זה רק מציין, אבל מה אופי?
למה אני עושה את של הסוגר אני מינוס בביטוי זה כאן?
>> ובכן שים לב לדפוס כאן.
המספרים בפועל לא משנה כל כך הרבה.
אבל שים לב ש97 הוא כמה רחוק מ65?
>> קהל: 32.
>> דוד י מלאן: 32.
כמה רחוק הוא 98 מ66?
>> קהל: 32.
>> דוד י מלאן: c הקטן מC הגדול?
32.
אז יש 32 כשות מ אות אחת למשנהו.
אז בכנות אני, יכול לפשט את זה של.
אבל אז אני סוג של קידוד קשה הבנה ברמה נמוכה זה
שאף קורא הוא אי פעם הולך להבין.
אז אני הולך להכליל אותו כ, אני יודעים האותיות קטנות הן גדולות יותר.
אני יודע האותיות הגדולות הן ערכים קטנים יותר, באופן אירוני.
>> אבל זה הוא, למעשה, שווה ערך ל אומר להחסיר 32 משל סוגר אני.
אז בהקשר של אלה מכתבים, אם המכתב
קורה להיות, באותיות קטנות , ואני לחסר 32,
מה השפעה שיש ל, מבחינה מתמטית, באותיות קטנות?
קהל: Capitalizes--
דוד י מלאן: מנצל את זה.
ואכן, זו הסיבה שלנו תכנית נקראת לנצל אפס.
תכנית זו או מהוון מכתב,
לאחר הבדיקה אם הוא אכן אות קטנה.
אחרת, בשורה 30, מה עליי לעשות אם זה לא אות קטנה שאני
מסתכל על במסוים איטרציה בלולאה.
רק להדפיס אותו.
>> אז לא לשנות דברים זה אפילו לא באותיות קטנות.
הגבל את עצמך ל קצת דרך z הקטן.
עכשיו זה די מסתורי.
אבל בסופו של היום, זה הוא כיצד אנו, פעם,
הייתי צריך ליישם את הדברים.
אם אני במקום פתוחים לנצל אחד, הו תודה לאל.
יש פונקציה שיכול נקרא לעליון
לעשות הכל רק שעשינו ברמה נמוכה למדי.
>> עכשיו לעליון הוא מעניין משום שהוא הצהיר בקובץ,
ואתה רק היה יודע את זה על ידי בדיקת התיעוד,
או שאומר לי, למשל, בכיתה, שבו הוא קיים, בctype.h קובץ שנקרא.
אז זה עוד חבר חדש שלנו.
ועליון לעושה בדיוק מה ששם מרמז.
>> אתה יכול לעבור ב, כטיעון, בין סוגריים אלה, איזו דמות.
אני הולך לעבור באופי i'th של s באמצעות הסימון החדש והמפואר שלנו
מעורב בסוגריים מרובעים.
ולקחת את ניחוש, מה היא התשואה ערך של לעליון הולך כנראה
להיות?
מכתב הון.
>> אז אם אני עובר באותיות קטנות, אני מקווה, על ידי הגדרה של לעליון,
זה הולך לחזור באותיות גדולות א 'אחרת,
אם זה לא אות קטנה ב מלכתחילה, אני פשוט להדפיס אותו.
ואכן, שים לב החבר שני כאן.
לא רק לעליון קיימת, אבל נמוך, ש
למעשה עונה על השאלה שבשבילי.
>> עכשיו כל מי שכתב את הדברים האלה, 10s של שנים לפני, אתה יודע מה?
מיושם לעליון והוא להוריד באמצעות קוד כזה.
אבל שוב, עולה בקנה אחד עם הרעיון הזה של הפשטה משם,
רמת סוג של, נמוכה יותר פרטי יישום.
ועומד על כתפיהם של אנשים שבא לפנינו, תוך שימוש בפונקציות
כמו לעליון ונמוך, ש נפלא מספיק הם יפה
שם להגיד מה שהם עושים, הוא הפרדיגמה נפלאה לאמץ.
>> עכשיו, מתברר שאם אני קורא דף האדם ל, אומר, לעליון,
אני לומד משהו אחר.
אז איש toUpper.
זה קצת מוחץ.
אבל שימו לב, כאן זה שאזכור קובץ הכותרת שאני צריך להשתמש.
במאמר מוסגר, כי זה הוא מטעה, הפונקציה
משתמש ints במקום תווים מסיבות של בדיקת שגיאות.
אבל אנחנו אולי נבוא אחזור לזה בעתיד.
>> אבל שים לב, כאן, לגרים העליונים אות c לאותיות רישיות במידת האפשר.
אז זה די פשוט.
ועכשיו בואו נהיה קצת יותר ספציפי.
בואו נסתכל על החלק מ דף איש תחת ערך החזרה.
הערך המוחזר הוא ש מהמכתב שהומר.
או ג, אם ההמרה לא היה אפשרי,
כאשר c הוא הקלט המקורי.
שאני יודע מכאן, מ הטיעון לעליון.
>> אז מה הוא האוכל המוכן לכך?
הערך המוחזר הוא ש של המכתב המומר,
או ג, המכתב המקורי, אם ההמרה לא הייתה אפשרית.
מה שיפור שאני יכול להיות ולכן להפוך לעיצוב של הקוד שלי?
כן?
>> קהל: אתה יכול להסיר אותם.
דוד י מלאן: אני יכול להסיר את ההצהרה אחרת,
ולא רק ההצהרה אחרת.
>> קהל: אתה יכול להסיר [לא ברור].
>> דוד י מלאן: אני יכול להסיר את כל המזלג
בכביש, אם אחר לגמרי.
אז אכן, תן לי לפתוח הגרסה הסופית של זה,
לנצל-2 ושימו לב עד כמה, אם אתה, סקסי, הקוד הוא מקבל עכשיו,
בכי אני כבר מופחת מכמה שבע או כך קווים לארבעה,
הפונקציונליות שנועדתי פשוט על ידי קורא לעליון,
עובר בים סוגר i, והדפסה את, עם% c מציין המיקום,
אופי מסוים.
>> עכשיו ניתן לטעון, יש באג, או לפחות את הסיכון לבאג,
בתכנית זו.
אז רק כדי לחזור לאוכל מוכן קודם לכן,
מה אני צריך כנראה גם לעשות ב בתכנית זו כדי להפוך אותו חזקה יותר,
כך שאין שום דרך שהוא יכול לקרוס, גם במקרים נדירים?
קהל: ודא שזה לא NULL.
דוד י מלאן: ודא שזה לא NULL.
אז באמת, כדי להפוך סופר זה ראוי, אני צריך לעשות משהו כמו,
אם ים הוא לא NULL, אז קדימה ולבצע
שורות אלה של קוד, ש אז אני יכול לשנן כמו ש,
ולאחר מכן לשים בסד הקרוב שלי.
כל כך טוב קשירה יחד של שני הרעיונות.
כן?
קהל: האם אתה יכול להשתמש לעשות בזמן הלולאה, במקום?
דוד י מלאן: יכול אני עושה לעשות בזמן לולאה?
קהל: --you רוצה לוודא כי אתה בעצם [לא ברור].
דוד י מלאן: יכול אתה משתמש לעשות בזמן?
תשובה קצרה, לא.
מכיוון שאתה עומד להציג את מקרה פינה אחרת.
אם המחרוזת של אורך אפס.
אם למשל, אני פשוט פגע הזן, מבלי להקליד Zamyla.
אני הולך למסור לך בחזרה בפועל מחרוזת, כפי שאנו יהיו סופו של דבר לראות,
כי יש אפס תווים.
זה עדיין מחרוזת, זה סופר קצר פשוט.
אבל אם אתה משתמש לעשות בזמן, אתה הולך באופן עיוור
תנסה לעשות משהו עם לכבד למחרוזת ש,
ושום דבר לא הולך להיות שם.
>> קהל: ובכן, אם אתה עשית לעשות [לא ברור] ואילו s--
דוד י מלאן: אה אני רואה, לשמור מקבל מחרוזת מהמשתמש.
תשובה כל כך קצרה, אתה יכול, ולשמור על להציק
שלהם לתת לך מחרוזת זה קצר מספיק כדי להתאים בזיכרון.
בהחלט.
אני פשוט בחרתי שלא.
אם הם לא נותנים לי אני המחרוזת רוצים, אני מפסיק, אני מוותר.
אבל בהחלט, למטרה זו, אתה בהחלט יכול לעשות את זה.
>> אז קבצי הכותרת של הספרייה ש אנחנו מכירים אותם אלה, כאן ועכשיו.
קלט / פלט סטנדרטי, CS50.h, string.h, ctype.h, ויש, אכן, אחרים.
כמה מכם גילו ספריית המתמטיקה בmath.h.
אבל הרשית לי להציג בפניכם, עכשיו, ל משאב זה שצוות CS50 דווין,
ורוב, וגייב מסוים יש להרכיב.
כי בקרוב יהיה קישור על אתר האינטרנט של הקורס.
זה נקרא התייחסות CS50.
>> שרק כדי לתת לך מהיר טעם שלה, פועל באופן הבא.
תן לי ללכת לreference.cs50.net.
אתה תראה על יד שמאל צד רשימה מכרעת
של פונקציות שמגיעות עם ג.
אבל אם אכפת לי, לרגע, על משהו כמו strlen,
אני יכול להקליד אותו שם.
היא מסננת את הרשימה רק מה אכפת לי.
אני הולך ללחוץ עליו.
ועכשיו בצד שמאל, תראה את מה שאנחנו מקווים
הוא יותר פשוט, אנושי הסבר ידידותי של איך
פונקציה זו עובדת.
>> מחזיר את האורך של מחרוזת.
הנה תקציר, הנה איך אתה להשתמש בו במונחים של קובץ הכותרת,
ובמונחים של מה הפונקציה נראה כמו במונחים של טיעוניה.
ואז כאן, חוזר אורכו של חוט.
אבל לאלו מכם יותר נוחים, למעשה אתה יכול ללחוץ נוח יותר,
ואת התוכן של זה דף, עכשיו, ישתנה
להיות ערכי ברירת המחדל של מה ש אתה מקבל על ידי שימוש בדף האיש.
>> במילים אחרות, CS50 התייחסות היא פישוט
דפי גבר על ידי צוות, לסטודנטים.
במיוחד, אלה פחות נוחים ובין לבין, כך שאתה
לא צריך לנסות לעטוף המוח שלך מסביב, בכנות,
כמה תחביר למדי נסתר ותיעוד מתישהו.
>> אז לשמור את זה בחשבון בימים הבאים.
אז הנה, שוב, הוא Zamyla.
עכשיו בואו תשאלו את שאלה זה קצת יותר אנושי נגיש.
תודה לצ'אנג, מי שהייתה הדפסה יותר פילים
ללא הפסקה בימים האחרונים.
יש לנו הזדמנות לתת לפחות אחד מהם משם.
אם היינו יכול לקבל רק מתנדב אחד לבוא על עד לצייר על המסך.
מה דעתך על כאן?
>> בואו למעלה.
מה שמך?
אלכס: אלכס.
דוד י מלאן: אלכס.
בסדר.
אלכס, בחייך עד.
אנחנו עומדים לראותך כתב יד על המסך כאן.
בסדר, נחמד לפגוש אותך.
>> אלכס: נחמד שאתה פוגש אותך.
>> דוד י מלאן: בסדר.
אז, תרגיל סופר פשוט.
בר הוא לא גבוה ל לקבל פיל היום.
אתה משחק את התפקיד של getstring.
ואני הולך רק כדי להגיד לך המחרוזת כי אתה כבר קיבלת.
ונניח שאתה, getstring, כבר קרא.
והאדם, כמוני, יש לי הקליד בZamyla, Z--M-Y-L-.
פשוט להמשיך ולכתוב Zamyla על מסך כאילו אתה מקבל את זה
ואחסנתי אותו במקום כלשהו בזיכרון.
>> חדר יציאה למה יהיה מספר words-- אחר זה בסדר, ימשיך.
>> [שחוק]
>> אז Zamyla, מצוין.
אז עכשיו נניח שאתה, getstring, נקרא שוב.
ולכן, אני מספק לך, ב מקלדת, עם שם אחרת, בלינדה.
בסדר.
ועכשיו getstring הפעם הבאה הוא בשם, אני מקליד במשהו כמו גייב,
G-A-B-E. אתה באמת לוקח לזיכרון גישה אקראית לב.
שציור הכל באופן אקראי לחלוטין.
אישור.
>> [שחוק]
אלכס: מצטער כתב היד שלי היא רעה.
דוד י מלאן: לא, זה בסדר.
ומה דעתך על רוב, R-O-B. אישור.
טוב.
אז לא לצפות שהיית סוג של להניח דברים בדרך זו.
אבל אנחנו יכולים לעשות את העבודה הזאת.
אז איך אתה לא הולך על הנחת את התווים האלה בזיכרון?
במילים אחרות, אם אנו חושבים על מסך שחור מלבני זה
כמייצג זיכרון RAM, או הזיכרון של מחשב.
>> וזוכר RAM כי הוא פשוט חבורה של בתים שלם,
ובתים הם חבורה של ביטים כל.
וחתיכות הן איכשהו מיושם, בדרך כלל
עם צורה כלשהי של חשמל בחומרה.
אז זה סוג של שכבות שדיברנו על
ויכול עכשיו לקחת כמובן מאליו.
איך אתה הולך על להחליט איפה לכתוב
רוב לעומת גייב לעומת בלינדה לעומת Zamyla?
>> אלכס: אני רק עשיתי את זה ב להורות כי אתה אמר לי.
>> דוד י מלאן: וזה נכון.
אבל מה נשלטים איפה אתה שם את שמו של לינדה ואת שמו של גייב?
>> אלכס: שום דבר?
דוד י מלאן: [צוחק] אז זה עובד, זה בסדר.
אז מחשבים קטנים יותר מסודר מזה.
ולכן כאשר אנו implement-- להישאר שם רק moment-- כאשר אנחנו באמת
ליישם משהו כמו getstring במחשב,
Zamyla עשוי להיות ערוך פחות או יותר כמו שעשית על המסך, יש.
>> ומה הוא מפתח ליבחין כאן, מה שאלכס עשה,
הוא שיש סוג של תיחום בין כל אחת ממילות אלה, נכון?
אתה לא כתבת Z--M-Y-L-A-B-E-L-I-N-D-A-G-A-B--
במילים אחרות, יש כאן איזה ש תיחום אשר נראה כי,
סוג של, מרווח אקראי בין אלה מילות שונות.
אבל זה טוב, כי עכשיו אנחנו בני אדם יכולים
לדמיין כי אלה הם ארבעה מיתרים שונים.
זה לא רק רצף אחד של הרבה דמויות.
אז מחשב, ולאחר מכן, בינתיים, עלול לקחת מחרוזת כמו Zamyla,
לשים את כל המכתבים האלה בתוך בתים של זיכרון.
אבל המספר הזה הוא הרבה יותר גדול, כמובן, משישה תווים.
>> יש חבורה של זיכרון RAM כל.
וכך מעתה ואילך, זה רשת של תיבות הולכת
כדי לייצג את מה שאלכס רק עשה כאן על המסך.
ועכשיו, אלכס, אנחנו יכולים להציע לך כחול או פיל כתום מצ'אנג.
אלכס: אני אקח את פיל כחול.
דוד י מלאן: פיל כחול.
אז מחיאות כפות גדולות, אם היינו יכולים, לאלכס כאן.
>> [מחיאות כפות]
>> אלכס: תודה לך.
דוד י מלאן: תודה לך.
אז ממסעדה היא ש, למרות ש דפוס שינה את סוג של לאורך זמן, כאן
על הלוח, היה זה תיחום בין המחרוזות השונות
שאלכס הגיע לנו.
עכשיו מחשבים, בכנות, יכול לעשות את אותו הדבר.
הם סוג של יכולים היו לגלוש מחרוזות בכל מקום בזכרון RAM.
עד כאן, כאן, כאן למטה, כאן למטה.
>> הם יכולים לעשות בדיוק את זה.
אבל, כמובן, זה כנראה לא התכנון הטוב ביותר.
נכון?
אם אני כל הזמן שאל את אלכס לקבל שמות, כנראה שהוא הייתי
לשים קצת יותר כאן למטה, אולי עד כאן, כאן, כאן, סופו של דבר
כאן.
אבל עם תכנון קצת יותר, בהחלט, אנחנו יכולים להניח את הדברים החוצה יותר נקיים.
ואכן, זה מה שמחשב עושה.
>> אבל המלכוד הוא ש אם המחרוזת הבאה אני מקבל
לאחר Zamyla הוא משהו כמו בלינדה,
להציע שבו אנחנו יכולים לכתוב מכתב ב ביחס לרשת זו?
לאן תלך?
בצד הימין של, להלן z, מתחת ל?
מה היית האינסטינקטים הראשונים שלך יהיו?
קהל: להלן z.
דוד י מלאן: אז להלן z.
וזה פחות או פשוט, נכון?
זה סוג של מסודר, זה מה שאנחנו עושים על מקלדת כאשר פגעו הזן,
או בעת ביצוע דואר אלקטרוני רשימה עם תבליטים של דברים.
אבל המציאות היא שמחשבים מנסה להיות יעיל יותר,
ולדחוס בהחלט ככל נתונים לזכרון RAM ככל האפשר,
כך שאתה לא לבזבז את כל בתים.
כך שאתה לא לבזבז כל מסך הנדל"ן.
והבעיה, אם כי, היא ש אם אנחנו ממש שמנו את המכתב
ב לאחר, איך אנחנו הולכים יודע איפה שמו של Zamyla מסתיים
ושמו של בלינדה מתחיל?
אז אתם בני אדם בדיוק מוצעים, גם, לחץ על המקש Enter, במהות.
שים את זה למטה.
או אפילו כאלכס עשה, פשוט להתחיל לכתוב את השם הבא מתחת לקודמתה,
ומתחת לזה אחד, ו לאחר מכן מתחת לזה אחד.
זה סימן חזותי.
>> יש לי מחשבים אחר סימן חזותי, אבל זה קצת תמציתי יותר.
זה אופי פאנקי זה.
0 מהלך סרק, שהוא אולי מזכיר n הקו הנטוי,
וכן הלאה, עכשיו.
רצפי בריחה המיוחדים.
מהלך סרק 0 הוא הדרך של המייצג את שמונה אפס ביטים ברציפות.
0000 0000.
>> הדרך בה אתה מבטא את זה לא כדי פגע במספר אפס במקלדת,
כי בעובדה שהיא char ASCII.
זה נראה כמו מספר, אבל הוא למעשה מספר עשרוני
המייצג את החוזר גליף, הגופן העגול.
בינתיים, קו נטוי אפס פירושו, פשוטו כמשמעו
לשים שמונה אפס בתים כאן בשבילי.
>> אז זה הוא שרירותי במידה מסוימת.
אנחנו יכולים כבר השתמשנו בכל תבנית ביטים, אבל העולם
החליט כמה שנים לפני, שכדי לייצג
קצה חוט בזיכרון, פשוט לשים את החבורה של אפסים כל.
מכיוון שאנו יכולים לזהות את זה.
עכשיו זה אומר שאין אות של האלפבית יכול להיות מיוצג עם אפסים.
>> אבל זה בסדר, אנחנו כבר ראינו שבו אנו משתמשים 65 ב97 בעד.
אנחנו לא נגיע לשום מקום קרוב לכל האפסים.
אז בלינדה בזיכרון של מחשב הוא למעשה הולך כאן.
אני כבר ציירתי אותו בצהוב רק כדי למשוך תשומת הלב שלנו אליו.
והודעה, גם זה הוא שרירותי לחלוטין.
אני כבר ציירתי אותו כגריד.
כמו, זיכרון RAM הוא רק חלק אובייקט פיזי.
אין זה בהכרח שורות ועמודות, כשלעצמו.
זה פשוט יש לי חבורה של בתים שלמות מיושם בחומרה איכשהו.
אבל אם אחרי בלינדה אני הקליד את השם שלו של גייב,
הוא הולך בסופו של כאן בזיכרון, ואם אני הקלדתי את שמו של דייבן,
למשל, שהוא הולך בסופו של כאן.
ואני יכול להמשיך לכתוב עוד יותר שמות.
>> לרוע המזל, אם אני מנסה לכתוב את שם סופר ארוך,
אני יכול לרוץ סופו של דבר יצא מהזיכרון.
במקרה כזה, getstring הוא הולך להחזיר NULL, כפי שאמרנו.
אך לשמחתם, לפחות בזה חזותי כאן, אנחנו לא מקבלים די כל כך רחוקים.
>> עכשיו מה נחמד הוא שזה רעיון כללי של טיפול בדברים
כמו להיות בקופסות הוא נציג של תכונה של C
והרבה שפות, הידועה בשם מערך.
מערך הוא סוג אחר של נתונים.
זה מבנה נתונים, אם תרצה.
מבנה במובן של זה באמת, סוג של, נראה כמו קופסא, לפחות
בעיניי רוחכם.
מערך הוא רציף רצף של סוגים זהים נתונים,
גב אל גב אל גב אל גב.
>> אז מחרוזת, באחר מילות, היא מערך של תווים.
מערך של תווים.
אבל מתברר שאתה יכול להיות מערכים של אשכולות של דברים.
למעשה, אנחנו יכולים לשים אפילו מספרים במערך.
אז הטופס שבו אנחנו הולכים להתחיל
הכרזת נתונים זה מבנה הידוע כמערך
גם הוא הולך להשתמש בסוגריים מרובעים.
אבל סוגריים מרובעים האלה הולכים יש משמעות שונה בהקשר זה.
>> ובואו לראות את זה באופן הבא.
נניח שפתחתי עד קובץ חדש כאן.
ואני שומר את זה כages.c.
ואני אשמור את זה בתיקייה שלי כאן.
ועכשיו אני הולך קדימה והתחל להקליד משהו
כמו כולל CS50.h, כולל stdio.h, int חלל מרכזי.
ואז בתוך כאן, אני רוצה יש הראשון int נקרא גיל.
>> ואני הולך להשתמש בזה כדי לקבל int מהמשתמש לגילו או שלה.
אבל בתכנית זו נועדה לשימוש על ידי אנשים רבים, מכל הקשר.
יש לי תור של אנשים.
לכולם יש להקליד בהם גיל לאולי קצת, אני לא יודע,
תחרות, או אירוע כי הם כבר הגיעו ל.
אז האדם הבא, אני צריך עוד משתנה.
>> כי אם אני רק עושה גיל מקבל getInt, זה
עומד להכות, או להחליף הגיל של האדם הקודם.
אז זה לא טוב.
אז האינסטינקט הראשון שלי יכול להיות, הו, בסדר,
אם אני רוצה לגרום לאנשים של מספר רב של ages-- בואו נקרא age1 זה,
age2 int מקבל int, age3 int מקבל getInt.
ועכשיו אני הולך להשתמש כמה קוד pseudocode כאן.
>> לעשות משהו עם המספרים האלה.
נשאיר ליום אחר מה אנחנו עושים שם, כי אנחנו היחידים
לדאוג לרגע על age1, age2, age3.
לרוע המזל, ברגע שאני לקמפל תכנית זו
ולשים אותו בחזית של משתמשים בפועל, מה העניים ביסוד העיצוב
החלטה נדמה לי שעשתה?
כן?
קהל: [לא ברור]
דוד י מלאן: כן, אני אפילו לא ניסיתי
כדי להבין גילים כמה אני באמת אכפת?
אם יש לי פחות משלושה אנשים כאן, ולכן פחות משלושה גילים,
אני עדיין בעיוורון אני מצפה שלוש.
החס וחליל ארבעה אנשים להופיע.
התכנית שלי פשוט לא אפילו לתמוך בהם.
>> וכך הסיפור הזה, ארוך קצר, לא הרגל טוב.
נכון?
אני היה בעצם העתקה ו הדבקת קוד ורק tweaking
השמות משתנים.
ו, אלוהים שלי, אם היה לך, לא שלוש גילים, אך 10, או 100, או אפילו 6,500
סטודנטים לתואר ראשון, למשל.
זה לא הולך להיות במיוחד קוד אלגנטי, או בר קיימא.
אתה הולך צריך לשכתב את התכנית בכל פעם
המספר שלך של שינויי אנשים.
>> אז לשמחתי, בבפועל שלנו קובץ ages.c להיום,
יש לנו פתרון חכם יותר.
ראשית, אני הולך לשאול לבנות שהשתמשנו כמה פעמים,
זה לעשות בזמן הלולאה, על מנת לקבל מספר האנשים בחדר.
אני רק הולך להציק למשתמש, שוב ושוב, עד שהוא או היא נותנת לי
ערך של n זה מספר חיובי.
>> אני היה יכול להשתמש, אחרון זמן לקבל int החיובי.
אבל אין לנו ש אמיתי, אז הלכתי קדימה
ומחדש יישם את הרעיון הזה.
עכשיו כאן למטה, זה הטריק החדש.
בשורה 27, כהערות בשורה 26 מרמזת,
להצהיר על מערך שבו כדי לאחסן הגיל של כולם.
>> אז אם אתה רוצה לקבל, לא int אחד, לא שני ints, אבל חבורה של ints כל.
באופן ספציפי n מספרים שלמים, היו אולי n יהיה שלוש, עשוי להיות 100, יכול להיות 1,000.
התחביר, בפשטות, הוא למשל, אילו נתונים סוג אתה רוצה?
מה אתה רוצה לקרוא נתח זה של זיכרון?
מה אתה רוצה לקרוא לרשת שנראה כמו זה באופן ציורי?
>> ובסוגריים כאן, אתה אומר כמה גדול אתה רוצה המערך להיות.
וכך קודם לכן, כשאמרתי תחביר הוא קצת שונה כאן,
אנחנו עדיין משתמשים בסוגריים מרובעים, אבל כשאני הגדרה של מערך,
המספר הפנימי של אמצעי סוגריים מרובעים
עד כמה גדול אתה רוצה המערך להיות.
>> בניגוד לכך, כאשר אנחנו משתמשים בים סוגר i לפני רגע, זה, מחרוזת,
אכן מערך של תווים, אבל כשאתה לא מכריז משתנה,
כמו עם מילת מפתח זו כאן, אתה פשוט מקבל
מדד ספציפי, ספציפי אלמנט ממערך ש.
ברגע שאנו יודעים את זה, כל השאר לכך הוא פשוט.
אם חדש אני הולך ראשון להדפיס מה הגיל של מספר האדם שאני.
איפה אני פשוט אומר מספר אדם אחד, מספר האדם שני, מספר האדם שלוש.
>> ואני פשוט עושה חשבון, כך שאנשים רגילים כמו,
אנו סופרים מאחת לכך תכנית, ולא מנקודת האפס.
אז אני קורא getint, אבל אני לאחסן התשובה בגילים ממסגרת i.
שהוא גיל i'th במערך.
אז בעוד שהפעם האחרונה שהיינו בטיפול תיבות אלה כתווים לשמו של Zamyla,
ואחרים.
עכשיו, תיבות אלה מייצגים 32 סיביות, או ארבעה בתים
שבו אנחנו יכולים לאחסן int, int, int.
כולם, שוב, הם אותו סוג נתונים.
>> עכשיו אני עושה משהו מטופש, כמו שהזמן עובר, רק
כדי להצדיק את כתיבת תכנית זו.
ולאחר מכן כאן למטה, אני שוב לחזר על המערך אומר שנה מעכשיו,
מספר אדם רצון אחד להיות בן שנות משהו.
וכדי להבין את זה math-- אני מתכוון, זה
לא מסובך מאוד arithmetic-- אני רק אוסיף אחד לגיל שלהם.
רק כדי להדגים, שוב, זה.
>> בדיוק כמו שאני יכול מדד למחרוזת, של, גם אני יכול מדד למערך של גילים,
כמו שיש.
אז איפה זה הולך להיות לוקח אותנו?
אז נוכל לראות, סופו של דבר, כמה דברים בימים הבאים.
אחד, כל הזמן הזה, כאשר כתיבת תוכניות משלך,
כמו מריו, חמדנים, אשראי.
אתה כבר להקליד את השם התכנית ולהכות על Enter.
ולאחר מכן מקבל קלט של המשתמש.
>> עם getString, getInt, getLongLong, או משהו דומה.
אבל מתברר שתומך C משהו שנקרא שורת הפקודה
טענות, שהוא הולך לתת לנו למעשה לקבל במילים שאתם מקלידים,
בשורת הפקודה המהבהבת, אחרי השם של התכנית שלך.
>> אז בימים הבאים, אתה אולי להקליד משהו כמו קיסר,
או ./caesar מספר 13, לאחר מכן.
נצטרך לראות איך זה עובד.
כי אכן, ב בעיה להגדיר שתי, אנחנו
הולך להציג בפניכם למשהו קטן
מזכיר ראלפי של לאתגר קודם של מיפוי.
האמנות של ערבול מידע.
זה, למעשה, הוא מאוד מזכיר את מה שראלפי עשה.
>> זוהי דוגמא של הצפנה אלגוריתם שנקרא rot13, R-O-T 13.
אשר פשוט אומר לסובב את אותיות באלפבית 13 מקומות.
ואם אתה עושה את זה, אתה תראה עכשיו מה הוא, אולי, ביטוי מוכר.
אבל הדרך בה אנו הולכים להשתמש זה, בסופו, הוא באופן כללי יותר.
>> בP להגדיר שני, במהדורה סטנדרטית, אתה ליישם כמה צופן,
אחד בשם קיסר, אחד בשם Vigenere.
שניהם סיבוב צופן, שבאיכשהו אתה
להפוך אות אחת לאות אחרת.
והקיסר הוא סופר פשוט.
אתה מוסיף אחד, אתה מוסיף 13, או למספר עד 26.
Vigenere עושה את זה על למכתב בסיס.
אז Vigenere, כפי שתראה במפרט, הוא בטוח יותר.
>> אבל בסופו של היום מה ש אתה תהיה היישום וP להגדיר שני,
הוא שהמפתח שאתה משתמש בשניהם להצפנה ופענוח.
בהתייחסו לתהליך של הפיכה טקסט רגיל, כמה הודעה מקורית,
לטקסט סייפר, אשר הוא משהו מוצפן.
ולאחר מכן פענוח את זה שוב.
>> במהדורת ההאקר, בינתיים, אתה תהיה
המוטל עם משהו דומה ברוח, שבו אנחנו אתן לך
קובץ, מLinux טיפוסי, או Etsy מחשב בשם Mac, או יוניקס
סיסמא, אשר מכילה את כל חבורה של שמות משתמש וסיסמאות.
וסיסמאות אלה לכל הוצפן, או מרוסק,
אם אפשר לומר כך, יותר כראוי כפי שתראה במפרט.
>> ומהדורת ההאקר תאתגר לך עם לקיחת קלט כמו זה,
ופיצוח הסיסמה.
כלומר, להבין מה הסיסמה של האדם בעצם הייתה.
משום, אכן, סיסמות בדרך כלל לא מאוחסן בברור,
ובאופן כללי סיסמאות צריך להיות קשה לנחש.
זה לא קורה לעתים קרובות.
>> ומה חשבתי שכדאי לעשות הוא תסיים בכמה דקות
מבט חטוף בבמיוחד בחירה גרועה של סיסמאות
מסרט שאתה עלול להיזכר בחיבה.
ואם לא, אתה צריך לשכור.
>> [וידאו השמעה]
>> -Helmet, אתה השטן, מה קורה?
מה אתה עושה לבת שלי?
>> -Permit לי להציג את מנתח פלסטי צעיר מבריק,
הדוקטור פיליפ Schlotkin.
עבודת אדם האף הכי גדול ב יקום כולו ובוורלי הילס.
>> -Your הוד מעלה.
>> עבודת -Nose?
אני לא מבין.
כבר היה לה ניתוח פלסטי באף.
זה היה מתוק שלה 16 נוכחי.
>> 'לא, זה לא מה שאתה חושב.
זה הרבה, הרבה יותר גרוע.
אם אתה לא נותן לי שילוב למגן האוויר,
רופא Schlotkin ייתן לך בת לגבות את אפה הישן.
- [התנשפויות] Nooooooooooooo.
מאיפה הבאת את זה?
>> כל להיטים תקין.
אני אגיד לי, אני אגיד לי.
>> 'לא, אבא, לא.
אתה לא חייב.
>> "אתה שזכותי יקרה.
אני אתגעגע אל האף החדש שלך.
אבל אני לא אגיד להם שילוב לא משנה מה.
>> גם -Very.
רופא Schlotkin, לעשות הגרוע ביותר שלך.
>> ההנאה -לוח.
>> 'לא!
חכה, חכה.
אני אגיד לי.
>> 'אני יודע שזה יעבוד.
בסדר, תן לי את.
>> -The שילוב הוא אחד.
>> -One.
שתיים.
שלוש.
-Four.
-Five.
-אז השילוב הוא אחד, שתיים, שלוש, ארבעה, חמש.
זה השילוב הכי המטומטם אי פעם אני שומע בחיים שלי.
זה הסוג של דבר אידיוט היה על המטען שלו.
>> תודה לך, הוד מעלתך.
>> [CLICKS REMOTE]
>> 'מה עשית?
>> 'אני כיביתי את הקיר.
>> 'לא, אתה לא, אתה כיביתי את הסרט כולו.
>> זו בטח -אני לחצה על הכפתור הלא נכון.
>> "טוב, החזרת אותו על!
שים את הסרט בחזרה על!
>> -כן, אדוני!
כן, אדוני.
'תן נלך, ארנולד.
בואו, גרטשן.
כמובן שאתה יודע שאני צריך לחייב אותך על זה.
"טוב?
האם זה עובד?
איפה המלך?
>> 'זה עבד, אדוני, אנחנו יש לי שילוב.
-Great.
עכשיו אנחנו יכולים לקחת כל נשימה האחרונה אוויר צח מהכוכב Druidia.
מה השילוב?
>> -One, שתיים, שלוש, ארבעה, חמש.
>> -One, שתיים, שלוש, ארבעה, חמש?
-כן.
-That מדהים.
יש לי את אותו שילוב על המטען שלי.
הכן 1 spaceball ל יציאה מיידית.
>> -כן, אדוני.
>> -ואז לשנות את שילוב על המטען שלי.
[SOUND סגירת דלת]
[נקישת הדלתות להכות קסדה]
-Ahh.
[END הפעלת וידאו]
דוד י מלאן: זהו זה ל CS50, נתראה בשבוע הבא.
קריין: ועכשיו, עמוק מחשבות, על ידי ךייבן Farnham.
>> להתפלל Farnham: הקידוד בC הוא כל כך הרבה יותר קשה מסריטות.
printf, גירוד היה שקר.
>> [Soundbite שחוק]