>> רמקול 1: בסדר.
ברוך שובך.
זהו שבוע שני CS50, ויש לנו עד כה השתמשתי בפונקציות אבל
במידה רבה, לקח אותם כמובן מאליו.
אנחנו השתמשנו בו יש printf תופעת לוואי של הדפסה
דברים המופיעים על המסך.
אנחנו השתמשנו לקבל-int, לקבל לצוף.
>> אבל מה אם אתה באמת רוצה ליצור פונקציות משלך, כחלק
ייתכן שכבר החלו לעשות בשביל סט בעיה אחת, אם כי
לא נדרש להקפיד?
ובכן, בואו נלך קדימה ולבקר שוב כי בעיה של רק לשאול את המשתמש עבור
השם וההדפסה שלהם על משהו מסך, אבל מנסה גורם קצת
המכנה המשותף של שיש לנו ראה בקוד שלנו עד כה.
זאת על ידי כך אני מתכוון שלאחר מכן.
>> אני הולך להמשיך וליצור תכנית חדשה, פשוט להתקשר
זה hello.c כרגיל.
אני הולך קדימה ולתת לעצמי כולל io.h הסטנדרטי בחלקו העליון.
אני הולך גם לתת לעצמי מנע ספריית CS50 כך
אני לא צועק על ידי המהדר.
ועכשיו אני הולך קדימה ולהכריז int, ראשי, הריק.
>> ולאחר מכן בפה, זה מקום שבו אני רוצה כדי להתחיל להעביר למיקור חוץ פונקציונליות
איזה תפקיד אחר שאני בעצמי הולך לכתוב אבל זה לא
קיימים כיום.
לדוגמה, נניח שאני רוצה לכתוב פונקציה שמאפשרת לי
להדפיס את שלום, פסיק, ו לאחר מכן שמו של משתמש מסוים.
במקום להמשיך לעשות printf הלו,,% s לא יהיה זה נחמד אם
היו רק פונקציה הנקראת לא printf אבל שם הדפסה?
>> אז במילים אחרות, אני רוצה להיות מסוגל לכתוב תכנית שעושה קצת
משהו כזה.
ראשית, אני הולך לומר printf שלך שם, ובכך גרם למשתמש
תן לי את השם שלו או שלה, ולאחר מכן אני הולכים להשתמש במחרוזת ים המוכר ל
להכריז על מחרוזת.
תן לי משתנה מסוג מחרוזת, קורא לזה ים, וחנות שב
לגרום לקורא לקבל את המחרוזת.
אבל עכשיו בשבועות האחרונים, שיהיה לי קצת עייפה עשה שלום,% s / n.
>> ובמילים אחרות, אנחנו כבר ראינו את זה דוגמא חבורה של פעמים, וזה
דוגמה טריוויאלית בגלל שיש רק אחד שורת קוד כך שזה ממש לא
עניין גדול כדי לשמור על הקלדה שוב.
אבל נניח שהקו הזה של קוד למעשה היו הופך לנטל, ו
זה לא שורה אחת של קוד אבל זה 10 שורות קוד כמה שבועות עכשיו,
ואתה רק מקבל עייף של העתקה והדבקה או
הקלדה מחדש באותו קוד.
האם לא יהיה זה נחמד במקום לעשות printf שלום,%, S וכן הלאה
האם לא יהיה זה נחמד אם היו רק פונקציה שנקראת שם שההדפסה
לוקח טיעון -
במילים אחרות, זה לוקח קלט -
ולאחר מכן פסיק.
אז פונקציה ש, לא הייתה זה יהיה נחמד אם זה היה קיים?
ואז לא הייתי צריך לדאוג מה הוא printf, מה% כל ים ו
המורכבויות האלה, כי הם לא כל כך מעניינת.
הם שימושיים.
>> אז שם הדפסה, למרבה הצער, לא היה המציא איזה לפני 40 שנה פלוס.
אף אחד לא חשב לכתוב אותו.
אבל זה היופי של בעל שפת תכנות, בדיוק כמו ב
שריטה באפשרותך להגדיר בלוקים מותאמים אישית, כך ב-C, ורוב כל שפה, אתה יכול
מגדיר את הפונקציונליות שלך, יכול אתה מגדיר את פונקציות משלך.
אז למרות שאנחנו מקבלים עיקרי על ידי באופן אוטומטי ללא תשלום, אנחנו יכולים להצהיר
הפונקציות שלנו.
>> אז אני הולך לעשות קצת מקום עד כאן למעלה, ואני הולך להכריז עליי
פונקציה שלו שהולכת להיראות קצת מוזר בהתחלה, אבל אנחנו נבוא
בחזרה לכל כך הרבה זמן לפני.
אני הולך לומר חלל, ובכך המציין פונקציה זו עושה
משהו, יש לו תופעת לוואי, אבל זה לא מחזיר לי משהו ב
אותו אופן שמקבל int או מקבל מחרוזת עצמה עושה.
ואני הולך לתת לי פונקציה זו שמו של שם דפוס, ואני הולך
לציין שהבחור הזה הולך לקחת מחרוזת, ואני הולך לקרוא לזה
שם מחרוזת.
אני יכול לקרוא לזה מה שאני רוצה, אבל אני רוצה הקוד שלי יהיה תיעוד עצמי.
במילים אחרות, אם אחד מכם היית לפתוח קובץ זה ולקרוא אותו, אתה יכול
סוג של להסיק משמו של ש קלט איזה תפקיד הוא אמור לשחק.
>> ועכשיו מתחת לזה, אני הולך לפתוח מתולתל סד וסד סגור מתולתל,
ואז שם לב שאחרי אותו דפוס על קווי ארבעה עד שבע כ
אני עוקב אחרי במשך שבוע בתוספת טוב עכשיו בין, יניח, קווים ותשעה
14 המרכיבים עיקרי.
במילים אחרות, להדפיס את השם היא פונקציה אחרת.
כעת, המהדר לא הולך לדעת לקרוא את הדבר הזה באופן אוטומטי
כי אני ממש ממש המצאתי את זה, אבל זה עדיין יודע לקרוא עיקרי
באופן אוטומטי, ולאחר מכן כמובן ב קו 13, אני קורא לפונקציה שלי.
ומכיוון שאני כבר הצהיר כי פונקציה על קו ארבעה לפני ראשי,
זה הולך ללמד את המהדר מה ציטוט, סוף ציטוט ", שם הדפסה"
אומר ומה היא צריכה לעשות.
אז אני נותן לו סוג של מנהג חדש לחסום בהקשר של, יניח, שריטה.
>> אז הנה, אני יכול לשים את זה נפוץ מאוד או תבנית חוזרת של קוד אני שומר
כתיבה בכיתה, printf -% S שלום,% s / n ",
מה שאני רוצה לשים כאן?
S?
אז אני רוצה לשים את השם בהקשר זה.
אז שם לב קצת הדיכוטומיה כאן.
כי אני מכריז הפונקציה שלי ויש לי במידה מסוימת נקרא באופן שרירותי
שמו להדפיס, וכי יש לי צוין בסוגריים שזה
הפונקציה לוקחת טיעון אחד, הסוג של אשר היא מחרוזת - כך שזה מילה
או ביטוי או משהו כזה - ו אני קורא בשם טיעון זה, כי
הפירוש משתנה רק שהוא ב היקפו, אם אפשר לומר כך, הוא שם.
>> S קיים רק בין מה ששתי סוגריים מסולסלים, כמובן?
ובכן באמת, בדיוק כמו קו 10 דרך 14, אז בדיוק כמו ביום שני לא יכול להשתמש
S, אך מה אני יכול לעשות הוא לעבור S לשם הדפסה.
שם להדפיס פשוט קורה כל כך לתת לו כינוי, שם נרדף, כינוי,
קורא לזה שם, ועכשיו השימוש בו בתחום הזה.
אז עכשיו תן לי לשמור את זה, להקטין את התצוגה.
>> תן לי להמשיך ולעשות שלום.
נראה טוב.
לא לירוק את כל שגיאות. . / שלום על Enter.
מה השם שלי?
דוד.
שלום ודוד.
אז לא כל כך מרגש, אבל רק לחשוב עכשיו.
כעת יש לך אותו מרכיב כפי שעשינו בהתחלה כדי
להפוך את הפונקציות שלנו.
>> אבל יש קצת תפסתי אותך.
נניח שאני באמת לא חשבתי זו דרך ואני ממש בלי
באמת חשבתי על זה כתב שפונקציה כאן למטה.
מרגיש סבירים בהחלט.
בגרד אין מושג של מיקום בתסריטים שלך.
אתה יכול לשים את אחד כאן, אחד כאן, אחד עד כאן, וזה עלול להתחיל
להסתכל קצת מבולגן אם לא להניח אותה החוצה בצורה מסודרת, אבל זה לא עושה
משנה איפה פיזית את התסריטים היו על המסך.
לצערנו ב-C - וזאת, בניגוד שפות כמו ג'אווה ופייתון
ואחרים שאתה עשוי להיות מוכר עם - למרבה הצער ב-C, כדי עושה
משנה כי מה לצפות הולך לקרות עכשיו.
>> פונקצית ברירת המחדל שקורה לביצוע הוא, כמובן, עיקרי.
העיקרי היא הולך לקרוא שם על ההדפסה קו שמונה, אך למרבה הצער,
מהדר אפילו לא יודע את השם של ההדפסה ש קיים עד שהוא מגיע לקו 11,
שלמרבה הצער היא הולך להיות מאוחר מדי.
אז בואו נעשה לעשות שלום.
ועכשיו, שתי שגיאות הארורות שנוצרו.
אז עכשיו בואו לגלול עד מאוד ראשון, כפי שאנו תמיד צריכים לעשות, ו
שם לב שהוא צועק עליי, "הצהרה המרומזת של פונקציה
להדפיס את השם ".
>> אז ראינו את ההודעה לפני, הצהרה המרומזת של תפקוד.
כאשר יש לנו לראות סוג כזה של שגיאה?
כשלא כלל את ספרייה.
אם שכחתי cs50.h ואני אקבל צעק על למקבל מחרוזת או לקבל int.
אבל במקרה הזה, פונקציה זו הדפסה שם לא נמצא בספרייה, נכון?
זה ממש בקובץ זה, ולכן מה באמת הבעיה?
>> ובכן למרבה הצער ב-C, זה לוקח לך כך, פשוטו כמשמעו, שאם אתה מאוד
רוצה פונקציה שנקראת שם להדפסה קיים, אתה גם צריך ליישם
הפונקציה שבחלקו העליון שלך קוד כך שיהיה נגיש להורדה
פונקציות, אבל בכנות, שהופך להיות מרושל במהירות רבה.
אישית, אני אוהב לשים ראשי ראשון כי אז זה מאוד ברור מה זה
תכנית עושה במבט הראשון.
ובנוסף, אתה יכול להיכנס לפינה מוזרה מקרים שבם אם x רוצה להתקשר
Y אבל Y יכול לקרוא X, אתה פשוט מבחינה פיזית לא ממש יכול לשים אחד
מעל השני.
>> אבל מתברר בC, אנחנו יכולים לפתור את זה פשוט מאוד.
אני הולך לשים קצת שטח עד כאן, ואני רק הולך
מנע, אם כי במידה מסוימת מיותר, הולך ללמד
מהדר כי קיימת פונקציה קראתי בשם הדפסה, זה לוקח מחרוזת,
ואני הולך לקרוא זה שם פסיק.
>> אז זה עכשיו בקו ארבעה, שבו אנו לא ראה בעבר, היא הצהרה
משם הדפסת פונקציה, אבל זה רק הבטחה שפונקציה זו
סופו של דבר להיות מוגדר, סופו של דבר להיות מיושם.
זה עכשיו אני יכול להשאיר אותו לבד, כי עכשיו זה הוא ההגדרה,
יישום, סוג של המייל האחרון מיישום זה
פונקציה מסוימת.
אז בכנות שזה טיפשי, זה מעצבן, אבל זו הדרך C הוא, וזה
כי זה לוקח אותך, פשוטו כמשמעו, מאוד וכפי שמחשב צריך כנות,
רק שבדיוק את מה שאתה אומר לו לעשות, ועל כך שההזמנה היא חשובה.
>> אז לזכור את זה שוב ושוב, כדי להתחיל שים לב להישנות של דפוסים.
רוב הסיכויים שירצה, אם יש לך לא כבר, מתחילים להיתקל בהודעות
ככה שבמבט הראשון נראה סתום לחלוטין, אבל אם אתה מתחיל
כדי לחפש מילות מפתח אלו כמו "הכרזה משתמעת", אזכור שמו של
פונקציה במקרה זה - ולמען האמת, אתה לפעמים אפילו מקבל קצת ירוק
סמל גזר שאומר לך איפה הבעיה היא כנראה -
אתה יכול להתחיל לעבוד בדרך שלך דרך עדיין הודעות שגיאה בלתי נראות.
כל שאלות על הכתיבה שלך תפקוד שלו בדרך זו?
>> בואו נעשה משהו שהוא קצת יותר משכנע.
ולא רק לעשות משהו שיש לו תופעת לוואי של הדפסה, תן לי ללכת
קדימה ולשמור את הקובץ חדש ואנו יהיו קורא positive.c זה, למרות שזה
הולך להיות קצת שונים לעומת פעם שעברה.
והפעם, אני רוצה לשוב וליישם דוגמא positive.C האחרון של הזמן, אשר
היא לאלץ את המשתמש לתת שלי מספר שלם חיובי.
אבל אני הייתי צריך להשתמש לקבל הפעם האחרונה int.
האם לא יהיה זה יכול להיות נחמד אם היה פונקציה שנקראת לקבל int החיובי
שאני יכול פשוט למיקור חוץ את זה פיסת פונקציונליות?
אז ההבדל כאן הוא שאנחנו יהיו ליישם מקבל int החיובי, אבל בניגוד
שם הדפסה שהייתה תופעת לוואי - זה לא החזיר לי משהו כמו
מספר או מחרוזת -
מקבל int חיובי, כמובן, הולך תחזור, בתקווה, int חיובי.
>> אז בואו לעשות את זה.
כולל cs50.h, כלול הסטנדרטי io.h.
Int החלל ראשי.
ועכשיו לכאן, אני הולך קדימה ותניחו int, קורא לזה n, שווה
לקבל int החיובי.
ובדיוק כמו לקבל int כבר קיים משום שצוות כתב אותו, אני הולך
להניח לרגע שיקבל int החיובי קיים, ועכשיו אני הולך
ללכת קדימה ואומר printf, תודה על% i / n ", n.
>> אז עכשיו אם אני לקמפל תכנית זו, מה הולך לקרות במסוף שלי
חלון בחלק התחתון של המסך?
אני הולך כנראה לקבל את זה אותה שגיאה כמו קודם.
אז בואו ננסה את זה.
הפוך חיובי.
ושוב, הצהרה המרומזת של פונקציה, מקבל int החיובי.
אז אנחנו יכולים לפתור את זה ב כמה דרכים.
אני הולך לשמור את זה פשוט ופשוט לשים את ההצהרה שלי כאן ולקבל
int החיובי.
אני צריך את החתימה של מה שנקרא.
החתימה מתייחסת רק לאסתטיקה של
השורה הראשונה של התכנית.
אז מה צריך לקבל חיובי int תמורה?
>> אז int.
אני מתכוון באופן אידיאלי, זה יחזור משהו כמו int החיובי, אבל זה
לא קיימת.
אנחנו כבר לא ראינו כי בין הנתונים שלנו סוגים, ולכן אנחנו צריכים להתמודד עם
עובדה שיש לנו מעט מאוד סוגי נתונים כדי לעבוד איתו.
אבל אנחנו יכולים להחזיר int ופשוט מקווה שזה יהיה חיובי.
זה הולך להיקרא לקבל int החיובי.
>> ועכשיו מה דעתך על טענותיו?
האם זה ייקח כל קלט?
האם זה צריך כל קלט?
אז זה לא צריך לדעת בכל דבר מראש.
קבל מחרוזת לא, לקבל int לא.
Printf עושה - זה צריך להיות חלק קלט עבר לתוך זה - ושם הדפסה
צריך קצת קלט, אבל מקבל int החיובי לא עושה.
אז אני הולך באופן מפורש תגיד את חלל מהדר.
הריק הוא היעדר כל דבר אחר.
כך ששום דבר אמצעי הריק הולך בפנים בסוגריים האלה, פסיק.
>> ועכשיו בחלק התחתון של התיק שלי - ו סוג שוב, אני פשוט להיות של אנאלי
כאן לשים ראשי בחלק העליון, אשר היא פרקטיקה טובה, כי בדרך זו,
בכל עת שאתה או מישהו אחר פותח את הקובץ,
פונקציונלי הוא ממש שם.
אתה יכול לצלול מריבוע אחד.
אז עכשיו אני הולך לשכפל את זה, לקבל חלל int חיובי, אבל אני לא
הולך להכות פסיק עכשיו.
אני הולך לפתוח סוגריים מסולסלים, ועכשיו אני צריך ללוות
כמה רעיונות מיום שני.
>> אז כפי שאתם זוכרים, שעשינו משהו רוצים לעשות את הדברים הבאים תוך
משהו היה נכון.
ומה עשיתי?
אני עשיתי משהו כמו לתת לי שלי מספר חיובי,
קצת מהיר.
אני יכול להשתמש בכל מילים שאני רוצה.
ואז השתמשתי במה?
Int n שווה לקבל int, אין טענות אליו.
>> ותבחין בהבדל.
כשאתה קורא לפונקציה, בעת שימוש פונקציה, אתה לא לשים בחלל הריק.
אתה רק עושה את זה כאשר הכריז פונקציה, מלמד מה מהדר
הוא צריך לצפות.
אז אתה לא צריך לשים יש לבטל את עצמך.
>> ועכשיו מה המצב שלי?
ובכן, n הוא לא שווה לחיובי, אבל זה רק פסאודו קוד.
אז איך אני יכול להביע את זה יותר נקי?
אז פחות או שווה לאפס.
אז שוב, שים לב שאתה יכול לעשות פחות או שווה ל.
למרות שזה שתיים נפרדים סמלים, אתה יכול לעשות את זה על
המקלדת שלך ככזה.
>> אבל עדיין יש באג ש גם אני פשלה בפעם האחרונה.
אני חייב להצהיר -
בדיוק.
אני חייב להצהיר n מחוץ של הלולאה.
אז אני צריך לשים את n עד כאן, ואני לא רוצה לחזור ולהכריז עליו בפה
שמא אני מקבל את משתנה חדש.
אני רק רוצה להקצות ערך לכאן.
>> ועכשיו אני לא עשיתי די לכאן.
תנו לי להתקדם בעצמי ולהעמיד פן שאני עושה.
הפוך חיובי, ועכשיו יש שגיאה חדשה.
שליטה מגיעה לסוף פונקציה שאינה מבוטלת.
אז הודעת שגיאה חדשה, אבל אם אתה מסוג של להקניט בנפרד כל אחת מהמילים, זה
כנראה מרמז על מה לא בסדר.
>> לשלוט בו.
שליטה רק אומרת לצו פעילות בתכנית.
המחשב הוא בשליטה ו משהו השתבש.
אז הוא מגיע לסוף פונקציה שאינה מבוטלת.
איזה תפקיד זה ככל הנראה בהתייחסו ל?
מה היא פונקציה שאינן מבוטל?
אז קצת לקבל int החיובי, ו מבלבל בכך שכן,
זה סוג של החלל.
יש לו מפרט של החלל עבורה טיעונים, אבל התפוקה שלה עומדת
להיות מהסוג n.
אז המילה בצד השמאל היא מה שנקרא סוג תמורה.
המילה בצד הפנימי כאן היא אפס או יותר את הטיעונים
שפונקציה לוקחת.
>> אז מה אני צריך לעשות?
בשלב זה בקוד שלי, קו 21 שבו הפקודה מהבהבת כרגע היא, אני
יש לי חיובי int בתוך של משתנה בשם n.
כיצד אני יכול להחזיר אותו לדף הראשי?
פשוטו כמשמעו.
לחזור פסיק n.
>> אז חזר פיסת בדיוק כמו קולטון נייר עם תשובה אליי על ידי הטלת
פיסת נייר בשחור הקטנה תיבה על השולחן, לעשות את זה ב
קוד, אתה ממש פשוט לכתוב, לחזור n, וזה כאילו היו קולטון
הושיט לי משהו פיזי בחזרה.
במקרה זה, מה שקורה הוא לקבל int החיובי הולך יד בחזרה
מה יש להניח חיובי שלם למי?
איפה ערך שסופו של דבר?
כי בסופו של משתנה זה, N, ו לאחר מכן אנו ממשיכים עם קו תשע.
>> אז במילים אחרות, לפי סדר פעולות, תכנית זו מתחילה
ביצוע, והמהדר מבין, אה, אתה רוצה את הספרייה?
תן לי ללכת לתפוס כל מה שיש בפנים.
אה, אתה רוצה ספריית IO הסטנדרטית?
תן לי ללכת לתפוס כל מה שיש בפנים.
מה אומר לעצמו מהדר כאשר הוא יגיע ארבעה קו?
אה, אתה הבטחת ליישם פונקציה שנקראת לקבל חיובי, אבל
אנחנו נחזור לזה בהמשך, משהו בכיוון הזה.
>> החלל עיקרי int רק אומר שהנה את האומץ של התכנית שלי.
קו שבעה הוא רק סד מתולתל.
קו שמונה אומר בצד השמאל, לתת לי 32 סיביות למספר שלם, קורא לזה n.
בצד ימין, זה אומר לקבל int החיובי.
עכשיו בואו להשהות שסיפור כי עכשיו אני לא להמשיך לנוע למטה הסמן שלי.
הסמן שלי עכשיו יורד פה כי עכשיו לקבל int החיובי מבצע.
Int n הוא הכריז.
בצע את הפעולות הבאות.
Printf נותן לי מספר שלם חיובי.
>> קבל int מהמשתמש, לאחסן אותו בn, ואולי לעשות את זה שוב ושוב.
לולאה זה אומר שהקוד הזה עלול לבצע למעלה ולמטה כמו זה שוב
ושוב, אבל כאשר המשתמש סוף סוף משתף פעולה ונותן לי חיובי
int, אני מכה קו 21, בשלב שבי מספר הוא החזיר, ואשר אחד
אני צריך להדגיש עכשיו?
תשע.
שליטה, כביכול, חוזרת בשורה תשע.
זו השורה שעכשיו בתשלום.
>> אז זה מה שקורה בכל הפעם מתחת למכסת המנוע, אבל
כאשר יש לנו להשתמש בפונקציות כמו printf או אפילו לקבל מחרוזת שמישהו אחר
כתב לך, השליטה הייתה להיות הושיטה שורת הקוד של אותו למישהו אחר
בשורה אחרת השורה.
זה פשוט לא היינו יכולים לראות את זה ואנחנו לא ממש יכול לתאר אותו בזה
התכנית בגלל שזה בחלק אחר קובץ על הכונן הקשיח
ללא ידיעתנו.
אז בואו באמת לקמפל ולהפעיל את זה עכשיו.
>> הפוך חיובי.
לקמפל, זה התקדמות.
. / חיובי.
תן לי את מספר שלם חיובי.
בואו להיות קשה.
1 שלילי.
אפס.
בואו ניתן לו 50.
תודה על 50, וכן בקרה עכשיו חזר.
על כל שאלה, ולאחר מכן, ביום זה?
כן?
>> [לא ברור].
>> אומר שוב.
אה, שאלה טובה.
אז אולי שמתם לב כי במקביל כאן אני סוג של חיתוך בפינה.
בקו 12, שאני אומר, לקבל int החיובי מחזיר int, אלא על ידי אותו
היגיון, זה עומד כיום על דעת כי ב קו שש, אני אומר שתשואות עיקריות
int, אבל מה שיש לנו לעולם לא היה בכל התוכניות שלנו?
אף פעם לא היו לנו אזכור של מילת מפתח שיבה זו.
>> אז מתברר כי ב-C, לפחות הגרסה של זה שבו אנו משתמשים
עשיתי בשנת 1999, מבחינה טכנית, זה קורה לך באופן אוטומטי.
בכל פעם שאתה מיישם את תכנית ואתה ליישם פונקציה הנקראת ראשי,
שהפונקציה תחזיר אפס על ידי כברירת מחדל, אם אתה לא אומר אחרת,
ואפס הוא רק מוסכמה.
העולם מחזיר אפס ובכך המציין כי הכל טוב,
יעילות והשאיר אותנו עם ארבעה מליארד דברים אפשריים שיכול ללכת
לא נכון כך שאם אנחנו חוזרים אחד, כי אולי מסמן קוד שפירוש זה
דבר לא השתבש.
אנחנו יכולים להחזיר שתיים, מה שאומר דבר שני זה השתבש.
אנחנו יכולים להחזיר את ארבעה מליארד, אשר פירוש דבר שני זה השתבש.
>> ואם עכשיו אתה חושב על עצמך PC או Mac, אתם אולי זוכרים כי
לפעמים אתה מקבל הודעות שגיאה מסתוריות מתוכנה שאתה
משתמש, ולפעמים יש לו אדם תיאור ידידותי, אבל יש
לעתים קרובות קוד או מספר על המסך?
אם זה לא מגיע למוח, רק לפקוח עין על זה.
זה בדרך כלל מה אלה קודים מתייחסים.
הם כלולים ב-Microsoft Word ו תוכניות אחרות, כך שאם אתה קובץ
דיווח באג עם החברה, אתה יכול אומר להם, הו, יש לי מספר שגיאת 45.
וחלק אחורי מתכנת בחברה יכול להסתכל למעלה, כי בו או שלה
קוד ואומרים, אה, זה בגלל שאני עשיתי הבאג הזה ובגלל זה המשתמש
קיבל הודעה זו.
>> אבל בכנות, זה רק קצת מסיח את הדעת וקצת משעמם
להסיק כי, לפחות עלינו כמה תוכניות הראשונות, ולכן יש לנו
כבר השמטתו.
אבל כל הזמן הזה בכל אחד משלך פונקציות העיקרית יש לו בסתר זה
קו נוסף באופן אוטומטי עבורך על ידי מהדר, רק על ידי אמנה ל
לחסוך לך קצת זמן.
>> [לא ברור].
>> אתה לא צריך לכלול אותו בראשי.
זה בסדר.
אתה צריך לכלול אותו אם היית יישום פונקציה כזאת.
אחרת שטוח הפונקציה את לא יעבוד.
אבל בראשי, זה לא הכרחי.
בשבוע או שבועות, נתחיל לקבל להרגל שברגע שאנחנו רוצים להתחיל
מסמנים שגיאות.
באמת שאלה טובה.
>> הפסקה מילולית כל כך מהר להזכיר כי ביום שישי הקרוב, אנחנו לא אוכלים צהריים
כשלעצמו, אבל יהיו לנו ארוחת ערב עם חלק מהתלמידים ואנשי צוות.
אם ברצונך להצטרף אלינו, מרגיש חופשי ללכת לcs50.net/rsvp.
06:00 יום שישי הקרוב.
שטח הוא, כמו תמיד, מוגבל, אבל אנחנו להמשיך לעשות את אלה בכמעט
בסיס שבועי אם החלל נגמר השבוע.
>> אז הסחרור המסוכן שהפסקנו על יום שני היה שמייתרים יכולים למעשה
להיות צמוד אליו, שרק אומר לך יכול לקבל בתו הראשון,
דמות שנייה, הדמות השלישית וכן הלאה, כי אתה יכול
יעילות חושב על מחרוזת, כמו שלום, כמו להיות במקרה זה חמישה
אותיות בתוך קופסאות.
ואתה יכול לקבל בכל אחד מאלה תיבות עם מה שעשה לנו תחביר
להציג ביום שני?
אלה סוגריים מרובעים במקלדת.
שנועד רק לעבור למיקום אפס.
>> אנחנו מתחילים לספור על אפס, כך סוגר אפס מסמל שעות, סוגר אחד
מסמל דואר, וכן הלאה.
ולכן כל הזמן שבו אנחנו כבר באמצעות המיתרים והקלדת "שלום"
ו" עולם ", ועל דברים אחרים המסך, זה היה מאוחסן
בתיבות מהסוג הזה.
ותיקח ניחוש.
מה משמעות של כל תיבה מייצגת פיזית חלק פנימי של המחשב שלך?
>> [לא ברור].
>> סליחה?
>> תווים.
>> אז אופי, בוודאי במקרה של מחרוזות, ואופי הוא פשוט
שמונה סיביות או בית אחד.
אז אתה כנראה לפחות במעורפל מכיר את העובדה ש
יש בזכרון מחשב.
יש לו שני סוגים של זיכרון לפחות.
אחד מהם הוא הדיסק הקשיח שבו אתה שומר דברים באופן קבוע, וזה
גדול בדרך כלל, כך שאתה יכול להיות סרטים ומוסיקה וכן הלאה.
>> אז יש לך סוג אחר של זיכרון נקרא זיכרון RAM, R--M, גישה אקראית
זיכרון, וזה הסוג של זיכרון המשמש כאשר המחשב שלך הוא
פועל, אבל אם אתה מאבד את כוח שלך או מת סוללה, מה שמאוחסן
בזכרון RAM נעלם אם אתה מאבד את כוח לגמרי כי זה לא
מתמשך.
אתה בדרך כלל יש, בימים אלה, הופעה שלו, שתי הופעות, אולי יותר.
והיתרון של זיכרון RAM הוא שזה הרבה יותר הרבה, הרבה יותר מהר מאשר דיסקים קשיחים
או מצב מוצק גם מניע בימים אלה, אבל זה בדרך כלל יקר יותר ולכן
יש לך פחות מזה.
>> אז השיחה של היום באמת מתייחסת ל-RAM, זה סוג של זיכרון ש
קיים רק בזמן שיש כוח שמוזן לתוך המחשב שלך.
לכן, כאשר אתה מקליד בH-E-L-L-O, Enter ב המקלדת, H עומדת באחד
בייט של זיכרון RAM, E הולכת ב בתים נוספים של זיכרון RAM, וכך גם
שאר המילה.
אז זוכר מה היינו יכול לעשות פעם האחרונה היה זה.
תן לי ללכת קדימה ולפתוח את הקובץ כי אנחנו נקראים string.c, ולהיזכר
כי זה נראה קצת משהו כזה.
תן לי בעצם לחזור ולשנות זה בדיוק מה שזה נראה,
מחרוזת באורך של שעות.
>> אז להסתכל על התכנית כאן.
אנו כוללים ספריית CS50 כך שאנחנו יכולים להשתמש מקבלים מחרוזת.
אנו כוללים io.h הסטנדרטי כדי שנוכל להשתמש בprintf.
מדוע אנו כוללים string.h?
זה היה חדש ביום שני.
אז אנחנו רוצים אורך מחרוזת.
Str leng.
אנשים החליטו לפני שנים, בואו פשוט להיות תמציתי.
במקום לקרוא לזה "אורך מחרוזת," בואו נקראים לזה "רח נג" ולתת לי
דמות עולם שבחוץ, ואז זה מה שאנחנו מקבלים גישה לעם string.h.
>> זה מוכר.
זה מוכר.
זה קצת חדש.
בקו 22 - ואנחנו נחזור לזה, אך לעת עתה יודע -
והיית יודע שזה רק מפני שיש קראו את התיעוד או אם
אתה יודע כבר C -
מקבל מחרוזת לפעמים יכולה לפשל.
אם המשתמש הוא באמת יריב או לא משתף פעולה, והוא או היא פשוט
לא יקליד דבר במקלדת או סוגים כל כך הרבה במקלדת ש
זה מציף את הזיכרון של המחשב, בתאוריה, מקבל מחרוזת יכולה לחזור
משהו אחר מאשר מחרוזת של תווים.
זה יכול להחזיר ערך מיוחד הנקרא NULL בכל הכובעים, N-U-L-L, וזה
רק מה שנקרא ערך זקיף.
זה ערך מיוחד שמסמל משהו רע שקרה במקרה זה.
זהו העדר חוט.
>> אז אני בודק null לכך שפשוט, עוד סיפור קצר, וstr leng
פונקציות אחרות שמגיעות עם C, אם הם מצפים מחרוזת אבל אתה עובר אותם
העדרו של מיתר, אם אתה עובר שלהם null, המחשב או התכנית
יהיה פשוט יתרסק על הסף.
זה יהיה תלוי באוויר.
זה יהיה לזרוק את הודעת שגיאה כלשהי.
דברים רעים לא יקרה.
גם אם זאת היא עדיין לא מוגדר היטב -
זה יהיה הגיוני יותר בשבוע או שתיים - בקו 22, זה רק
דוגמה לבדיקת שגיאות הגנה עצמית רק במקרה אחד מתוך זמן
מיליון משהו משתבש, ב לפחות התכנית שלי לא תתרסק.
>> אז אם זה לא עושה שווה משהו רע, יש לי את זה ללולאה, וזה היה
שבו היו לנו אחרים יצירה חדשה של תחביר.
יש לי ללולאה מiterating אפס ועד לאורכו של ים.
והנה, הייתי להדפיס את ים סוגר לי, אבל למה אני משתמש% ג כל
פתאום במקום% s אפילו למרות שהים הוא מחרוזת?
זה אופי, נכון?
S הוא מחרוזת, אבל סוגר של משהו, סוגר שלי שבו אני הוא אפס
או אחד או שתיים, זה פרט תו במחרוזת, וכן עבור
ש, printf צריך להיות הודיע ​​כי זה אכן אופי לצפות.
>> ולאחר מכן זוכר, מה שעשה את זה תכנית לעשות בעצם?
>> הדפיס את זה בטורים.
>> כן, בדיוק.
זה פשוט הדפיס את המילה שאני מקליד ב טור, תו אחד בכל שורה.
אז בואו תראה את זה שוב.
אז להפוך את המחרוזת.
מלוקט על אישור. . / מחרוזת.
תן לי להקליד בH-E-L-L-O, Enter, ו אכן אני מקבל את זה, אחד בכל שורה.
>> אז תן לי לעשות אופטימיזציה אחד כאן.
אם אתה חושב על זה, במיוחד אם אתה כבר מתוכנת בעבר, יש
ניתן לטעון חוסר יעילות בקו 24.
במילים אחרות, זה לא בהכרח העיצוב הטוב ביותר.
פשוט, לפחות ברגע שאתה זוכר מה הוא str leng, אבל זה
עושה משהו טיפשי שעלול להיות.
מה זה יכול להיות?
>> [לא ברור].
>> בדיוק.
זה בדיקה לאורכו של ים בכל פעם שלמרות
H-E-L-L-O הוא הולך תמיד להיות חמישה תווים.
בכל פעם שדרך לולאה זו, חמישה לא משתנים.
יכול להיות שאני להגדיל כולי, אבל מה הוא אורכו של ים על כל
איטרציה של לולאה זה?
זה חמש, זה חמש, זה חמש, ו עדיין אני בכל זאת שואל את זה
שאלה שוב ושוב ושוב.
עכשיו בכנות, המחשב הוא כל כך מחורבן מהר, שאף אחד לא ישים לב אל
הבדל במקרה זה, אבל סוגים אלה של החלטות עיצוב עניות יכול
מתחיל להוסיף את עצמו אם מהדר לא לנסות לתקן את זה בשבילך אשר
זה בדרך כלל לא, ב לפחות במכשיר.
>> אז אני הולך לעשות את זה.
אני הולך להוסיף פסיק אחרי המשתנה הראשון שלי, אני.
אני הולך לתת לעצמי עוד משתנה, קורא לזה N, רק על ידי
כנס למספרים, ולאחר מכן אני הולך להקצות n את הערך של מחרוזת
אורכו של ים.
ואז אני הולך לשנות המצב שלי להיות מה?
אני הולך לשנות את המצב שלי לזמן שאני פחות מ n.
>> אז עכשיו, כמה פעמים אני בדיקת אורכו של ים?
פעם אחת, אבל זה בסדר כדי לבדוק שאני נגד n שוב ושוב כי עכשיו אלו
ערכים לא ממש משתנים.
עכשיו לעכשיו, רק יודע שכל פעם שאתה לקרוא לפונקציה, יש קצת
מעלינו, לא מספיק כדי להרתיע אותך באמת אי פעם שימוש בפונקציות, אבל
בוודאי כאשר יש שורת קוד אוהב את זה - ואת הקווים יקבלו
יותר מעניין לפני זמן רב - שבו יש הזדמנות לחשוב, אם אני
הקלד את הקוד הזה, כמה פעמים יהיה זה ביצוע?
אתה מתחיל לראות לאורך הזמן ביצועים של התוכניות שלך יכולים
אכן תשתנה.
>> למעשה, אחד של הבעיה קובע שיש לנו נעשה בשנים האחרונות כולל
יישום, כפי שאתם אולי זוכרים מ בשבוע שאפס, בודק איות, אבל
בודק איות שנועדו לתמוך מילון של 150,000 בתוספת
מילים שאנחנו נותנים לך חבר 'ה.
היית צריך לכתוב קוד שנטען את המילים האלה לזיכרון RAM, כך לתוך
תיבות כמו שראינו על מסך רגע לפני, ומהר אז כמו שאתה
יכול, אתה צריך להיות מסוגל לענות על שאלה של הצורה, היא מילה זו
שגוי?
האם מילה זו שגויה?
>> ובמשהו כזה מה שיש לנו נעשה בשנים האחרונות הוא הפך אותו ל,
אם כי בopt-in בסיס אופציונלי, תחרות של מיני, לפיה
תלמידים המשתמשים בזכרון RAM ופחות פחות זמן, מחזורי CPU פחות, בסופו של
מבעבע לראש קטן לוח מנהיג או דירוג שאנחנו שמים על
בדף הבית של הקורס כפי שיש לנו נעשה בשנים האחרונות.
אז שוב, לחלוטין לא חובה, אבל זה מדבר אל הזדמנויות העיצוב
שהם קדימה ברגע שאנחנו מתחילים בנייה על גבי כמה מאלה
אבני בניין בסיסי.
>> אז תן לי לחזור לתרשים זה ל רק לרגע ולחשוף קצת
עוד משהו.
זו אכן היא מחרוזת, ואנחנו כבר לקחנו יתרון של כמה ספריות,
io.h הסטנדרטי שיש -
>> Printf.
>> Printf, בין השאר.
cs50.h, אשר מקבל int ולקבל מחרוזת וכן הלאה, string.h, אשר
היה לי str leng.
אבל מתברר שיש עוד.
למען האמת, יש המון המון כותרת קבצים שמצהירים פונקציות
לספריות, אבל ctype.h זה באמת הולך להיות קצת
יתרון משום שאני הולך להמשיך וליישם אחד
תכנית אחרת כאן.
>> תן לי ללכת קדימה ולפתוח משהו אני כתבתי מראש הנקרא
capitalize.c, ובואו ניקח תסתכל על איך זה עובד.
שימו לב שאני משתמש בגרסה זו שלו, שלושה קבצים מוכרים.
שים לב שבשורה 18, אני מקבל שורה של טקסט.
הודעה בקו 21, בטענה שאני את הקוד הבא הוא הולך
לנצל ים, מה שמשתמש הקליד ב, ואיך אני עושה את זה?
ובכן, אני לוקח את -
לקח מהפעם האחרונה -
אני מכריז שאני וn וiterating על התווים במחרוזת.
ואז מה הוא בלוק של זה קוד בקו 24 עד 27
עושה במונחים של ההדיוט?
>> אותיות קטנות מכתב בחזרה.
>> בדיוק.
אם סוגר שלי - כך שאם i-ה דמותו של ים, שהוא ספציפי
char במחרוזת, הוא גדול יותר מאשר או שווה לאותיות קטנות ו--
זוכר שאמפרסנד כפול מסמן ו--
ואת אותה הדמות, של סוגר אני, היא קטן או שווה לאותיות קטנות z,
זה אומר שזה או B או C או נקודה, נקודה, נקודה, או Z, שפירושו
זה אותיות קטנות.
מה אני רוצה לעשות במקרה זה?
ובכן, אני יכול לעשות את זה במידה מסוימת מסתוריות, אבל
בואו להקניט את זה לגזרים.
>> אני הולך להתקשר printf, מדפיס% ג כי אני רוצה להדפיס מחדש את זה
דמות על המסך.
אז אני הולך לקחת את זה שאני סוגר, דמות i-th בים, ולאחר מכן מדוע
אני עושה את זה טריק קטן כאן, אותיות קטנות הון מינוס?
מה שהולך לתת לי לי, באופן כללי?
>> [לא ברור].
>> בדיוק.
אני לא ממש זוכר -
זה היה 65 להון א 'אני לא ממש זוכר מה אותיות קטנות היא,
אבל לא משנה.
המחשב יודע.
אז באומרו, אותיות קטנות מינוס הון, זה מוזר להיות
הפחתת char אחד למשנו, אבל מה הם תווים מתחת למכסת המנוע?
הם פשוט מספרים.
אז כל מה שהמספרים האלה הם, לתת למחשב לזכור את זה
ולא לי האדם.
>> אז אותיות קטנות הון מינוס הוא הולך לתת לי את הבדל.
זה קורה להיות 32, וזה יהיה במקרה של ב אותיות קטנות ובירה ב '
וכן הלאה.
הוא נשאר עקבי, תודה לאל.
אז אני בעצם אומר, לקחת את אותיות קטנות מכתב, לחסר את זה
הבדל סטנדרטי, וכי סוגר שאני בעצם s שינויים מ
אותיות קטנות, כמובן, באותיות גדולות, בלי באמת שיש לי לחשוב
על או זוכרים, מה היו אלה מספרים שדיברנו עליו, כאשר שמונה
מתנדבים עלו על במה?
עכשיו בינתיים, באחר, אם זה לא אות קטנה, כפי שנקבע
על ידי קו 24, רק להדפיס אותו.
אני רק רוצה לגעת דמויות שהיו
למעשה מקור אותיות קטנות.
>> אז בואו יראו את זה.
הפוך לנצל.
מלוקט, על אישור.
. / לנצל.
ותנו לי להקליד בH-E-L-L-O באותיות קטנות, Enter.
ושים לב שהיא מומרת לאותיות רישיות.
תנו לי לעשות את זה שוב עם מילה אחרת.
מה דעתך על D--V-I-D עם הראשון D מהוון כשמו הוא בדרך כלל?
Enter.
שים לב שזה עדיין נכון.
זה פשוט שoutputted ראשון ללא שינוי D דרך שלבנות אחר.
>> ולכן יש לזכור, אם כן, כמה דברים כאן.
אחד, אם תרצה אי פעם לבדוק את שני תנאים בפעם אחת, שאתה יכול ואותם
ביחד כמו שאנחנו חזו.
אתה יכול להשוות את דמויות בדרך זו ולטפל ביעילות בדמויות כמו
מספרים, אבל בכנות, זה כל כך מחורבן אף פעם לא נסתר אני הולך לזכור
איך לבוא עם זה מהתחלה ללא חשיבה דרכו די
קצת זמן.
>> האם לא יהיה זה יכול להיות נחמד אם מישהו שם כתב את פונקציה שנקראת הוא
תחתון שיכל לענות לי נכון או שקר, הדמות הזאת היא אותיות קטנות?
ובכן שמחתי, מי שכתב ctype.h עשה בדיוק את זה.
עזוב אותי לכאן ולהוסיף ctype לג סוגים, ועכשיו תן לי ללכת לכאן ו
לשכתב את הקו הזה באופן הבא.
>> אז אם זה נקרא נמוך יותר, אני טוען, S סוגרי, אז אני הולך למחוק
שתי שורות אלה לחלוטין.
אז עכשיו מישהו אחר, אני מקווה, כתבתי פונקציה שנקראת היא נמוכה יותר, וזה
מתברר שהם עשו והם הכריזו זה חלק פנימי של ctype.h.
ועכשיו אני הולך לעזוב את הקו 27 לבד, אני הולך לעזוב את הקו 31
לבד, אבל שים לב כמה הרבה יש לי הידק את הקוד שלי.
עכשיו זה נקי יותר.
זה פחות קשה להסתכל דרך כי עכשיו את הפונקציה, יתר על כן, היא
כך שם זה פשוט להפליא עושה מה שהוא אומר.
>> אז עכשיו אני הולך לשמור את זה.
אני הולך להקטין את התצוגה.
ובדיוק כמו בגרד יכול להיות לך Booleans, ערכים בוליאניים נכונים או
שקר, זה בדיוק מה שהוא להפחית ביעילות תשואות.
תן לי הידור מחדש.
תן לי להפעיל מחדש.
ועכשיו בואו ננסה את זה שוב, H-E-L-L-O, Enter.
זה די טוב.
ולנסות את זה שוב, לוודא שאני לא ידפוק משהו.
שמהוון גם כן.
>> אבל זה לא מספיק טוב, כי דבר שני שאני אף פעם לא הולך
זוכר, אלא אם כן אני עובד דרכו באמת בזהירות על, יניח, הוא נייר
הקו הארור הזה.
האם לא יהיה זה נחמד אם היו פונקציה שנקראת לעליונים?
ובכן מסתבר שיש הוא בctype.h גם כן.
אני הולך קדימה, הקלד -
תנו לי להביא את זה קו אחורי.
במקום זה כאן, תן לי ללכת קדימה ואומר, להחליף את ג%
תוצאה של קריאה לפונקציה זו כדי עליון בדמותו של ה-i-ים.
ועכשיו שם לב שזה מתחיל קצת מאוזנת.
אני חייב לעקוב אחר כמה סוגריים שנפתחתי ונסגר.
>> אז עכשיו זה אפילו נקי יותר.
עכשיו תכנית זו משתפרת ו טוב יותר נועד לטעון כי זה
הרבה, הרבה יותר קריא, אבל זה לא בוא נתקן.
הפוך לנצל.
. / לנצל.
H-E-L-L-O. בואו להפעיל אותו שוב, D--V-I-D. אוקיי, אז אנחנו עדיין ב
די צורה טובה.
>> אבל עכשיו לעליון.
אני מציע שיש עוד אחד עידון שאנחנו יכולים לעשות שיהיה
ממש נחמד, כי באמת יכול להדק את הקוד הזה ובאמת לתת לנו חמש
מתוך חמישה לעיצוב, למשל.
מה יהיה נחמד להיפטר?
ובכן, תראה כמה ארור ארוך בלוק של זה קוד הוא רק כדי לעשות משהו פשוט.
>> עכשיו כצד, כמו שיש לך ראה בסופר הסעיף הזה בעבר
בסוף השבוע, אתה לא צריך להקפיד סוגריים מסולסלים, כאשר יש לך רק אחד
שורת קוד, למרות שאנחנו הצענו שמירה על אותם כך שהוא עושה הרבה
יותר ברור, כמו בצורת U של Scratch בלוקים, מה שבפנים של הסניף.
אבל לא זה יהיה נחמד אם לעליון, כאשר נתון הקלט שלה, הפך אותו ל
אותיות גדולות אם זה לא, ומה יהיה יהיה נפלא במקרה ההפוך, אם
זה כבר אות גדול?
רק להעביר אותו דרך ולהשאיר אותו לבד.
>> אז אולי הוא עושה את זה.
אני יכול לנסות ורק מקווה שזה, אבל תן לי
להציג דבר אחד.
במקום להשתמש מובנה במסוף זה חלון כאן למטה, זוכר כי
סמל שחור מרובע זה נותן לך חלון מסוף גדול יותר שאני יכול מלא
מסך אם אני רוצה?
אז מתברר שהם סוג של מוזר בשם, אבל יש את הדברים האלה שנקראים
דפי man, דפים ידניים, גבר בקיצור, ואני יכול לגשת אליהם על ידי
הקלדת אדם -
מה שאני רוצה להקליד?
אדם העליון.
>> ועכשיו שם לב אם קיים לתפקד בתוך המחשב, ב
מקרה זה מכשיר, שהוא רק מערכת ההפעלה לינוקס, שזה הולך
לתת לי סט סתום במקצת של תפוקה, אבל לך תמצא לאורך זמן, כי
זה תמיד מעוצב פחות או יותר אותו כדי שתתחיל להתרגל לזה.
שימו לב שבחלק העליון לעליון, ו ככל הנראה הוא אותו התיעוד
ללהנמיך.
מי שכתב אותו היה חיתוך חלק פינות ולשים את הכל בעמוד אחד.
המטרה 'את הדברים האלה ב חיים הוא להמיר
מכתב לעליון או אותיות קטנות.
>> שים לב כי על פי תקציר, דף האדם הוא מלמד אותי את מה שיש לי קובץ
לכלול להשתמש בדבר הזה.
זה נותן לי את חתימות לאלה פונקציות, שניהם, ואפילו
למרות שכרגע אנחנו רק אכפת אחד.
הנה עכשיו תיאור.
לעליונים ממיר את האות ג לאותיות גדולים, אם אפשר.
>> ובכל זאת לא כל כך מאלף, אבל תן לי נראה כעת תחת ערך החזרה, הדבר
מה שהחזיר.
אז הוא הערך המוחזר של מכתב או ג יומר אם
המרה לא הייתה אפשרית.
מהו ג?
>> הדמות המקורית.
>> אופי המקורי ואנחנו יודעים כי על ידי, שוב הולך, עד
תקציר, ומי שכתב את זה פונקציה פשוט החליטה שהקלט
לעליון ותחתון הוא רק כדי באופן שרירותי הולך להיקרא ג.
הם יכלו לקרוא לזה משהו ביותר הם רוצים, אבל הם שמרו את זה
פשוט כמו ג.
אז אני כבר התייעצתי דף האדם.
משפט זה מרגיע אותי שאם זה לא אות קטנה, זה
הולך רק כדי להחזיר לי את C, שהוא מושלם, מה שאומר שאני יכול להיפטר
המצב אחר שלי.
>> אז תן לי לחזור לgedit, ו עכשיו תן לי רק לעשות את זה.
אני הולך להעתיק הצהרת printf שלי.
אני הולך קדימה, וממש בתוך להדפסת לולאה שיצאה, ולקבל
להיפטר מכל זה עכשיו אם מבנה.
היה רעיון לא רע, וזה היה מאוד נכון ועולה בקנה אחד עם הרבה
כל מה שהטפנו, אבל פשוט אין צורך.
ברגע שאתה מבין כמה ספרייה פונקציה קיימת שמישהו אחר
כתב, או אולי אתה כתב במקום אחר ב את הקובץ, אתה יכול להשתמש בו ובאמת
להתחיל להדק את הקוד.
>> וכשאני אומר את דברים כמו סגנון טוב, העובדה שהאדם הזה שנקרא
תפעל לעליון, או בעבר הוא נמוך להפליא שימושי כי
הם מאוד תיאורי.
לא היית רוצה לקרוא לפונקציות שלך X ו-Y ו-Z, שיש לי
הרבה, הרבה פחות משמעות.
כל שאלות על סדרה ש שיפורים?
>> אז די לומר אחד מזנונים הוא אפילו כבעיה שלך
סט - אולי בעיה סט אחד, אבל בהחלט P להגדיר שתיים והלאה, אפילו
כשהם לא בהכרח נכונים אומר שהם פשוט מושלמים
עדיין או במיוחד מעוצב היטב.
זה ציר האחר להתחיל לחשוב על.
אז זה היה בתוך מחרוזת שלך הזיכרון של המחשב, אבל אם יש לך
חבורה שלמה של דמויות כמו H-E-L-L-O חלק פנימי של זיכרון RAM, ומניח
כי אתה בתכנית שלך קורא את המחרוזת מספר פעמים כזה שאתה
קורא לקבל מחרוזת פעם אחת, אז אתה קוראים לקבל מחרוזת שוב.
ובכן, מה הולך יקרה לאורך זמן?
>> במילים אחרות, אם יש לך שורה של קוד, גם אם מחוץ להקשרו, כמו
מחרוזת של מקבל -
בואו נעשינו את זה.
שם המיתרים שווים מקבלים מחרוזת.
אז נניח שהשורה של קוד נועדה לשאול את המשתמש שלו או את שמה.
השורה הבאה של קוד זה נועדה כדי לשאול למשתמש שלו או של בית הספר שלה, ו
הקו הזה הבא, וכן הלאה.
נניח שאנחנו חוזרים ושואלים המשתמש אחר ול
מחרוזת עוד אחד ועוד.
הם הולכים להישאר בזיכרון באותו הזמן.
אחד לא הולך להרביץ את השני.
בית הספר הוא לא יחליף את השני.
אבל לאן כולם בסופו של זיכרון?
>> ובכן, אם אנחנו מתחילים לצייר על המסך, שבו אנו יכולים להשתמש בדבר הזה
כאן כמו לוח וגיר, אם זה שחור מלבן מייצג המחשב שלי
זיכרון, אני הולך להתחיל באופן שרירותי חילק אותו לריבועים קטנים,
כל אחד מהם מייצג ייט אחד של זיכרון.
למען האמת, אם יש לך ג'יגה של זיכרון RAM בימים אלה, יש לך מיליארדי בתים
זיכרון במחשב שלך, אז מיליארדים של ריבועים אלה.
אז די אם נאמרתי, זה הוא לא באמת בקנה המידה.
>> אבל אנחנו יכולים לשמור על ציור כל אלה ברור שלא בקנה מידת ריבועים, וזה
ביחד מייצג הזיכרון של המחשב שלי.
עכשיו אנחנו רק נעשה נקודה, נקודה, נקודה.
אז במילים אחרות, כשאני עכשיו תבקש משתמש עם מחרוזת להגיע ללתת לי
מחרוזת, מה קורה?
אם המשתמש מקליד ב" שלום, "כי בסופו בH-E-L-L-O. אבל נניח
משתמש אז בסוגים -
למעשה, אני לא הייתי צריך לעשות שלום בגלל שאנו מבקשים
אותם לשמות שלהם.
אז בואו נחזור אם אני יכול לעשות את זה.
>> אז אם אני בסוג D--V-I-D לשם שלי, אבל לזכור כי בשורה השנייה של
קוד שיקבל מחרוזת שוב כדי לקבל את הספר שלהם.
איפה מילה שהמשתמש סוגים בהולכים הבא?
טוב, אולי זה הולך להיכנס H--R-V--R-D. אז למרות שיש לי
נמשך זה כשתי שורות, זה רק חבורה שלמה של בתים בך
זיכרון RAM של המחשב.
יש בעיה עכשיו, כי עכשיו אם אני שימוש בזיכרון RAM בזה סביר מאוד
אבל סוג של דרך תמימה, מה אתה יכול לא להבחין ככל הנראה?
איפה אחד מתחיל ואיפה אחד מסתיים, נכון?
הוא סוג של טשטוש יחד.
>> אז מתברר המחשב לא לעשות את זה.
תנו לי בעצם לגלול אחורה בזמן כמה תווים, ובמקום הרווארד
הולך מייד אחרי שמו של המשתמש, המשתמש מקבל למעשה, מאחורי
הקלעים, אופי מיוחד הוכנס על ידי
מחשב בשבילו או שלה.
/ 0, הידוע גם בתו הריק מעצבן בשם N-U-L, לא
N-U-L-L, אבל אתה כותב את זה כ/ 0.
זה פשוט כל הביטים אפס הוא סמן ב בין המילה הראשונה ש של המשתמש
הקליד והשני.
>> אז הרווארד מסתיימת ממש עכשיו את כרצף של תווים
ועוד אחד / 0.
אז במילים אחרות, על ידי בעל אלה ערכי סנטינל, שמונה אפס רציף
ביטים, עכשיו אתה יכול להתחיל להבחין תו אחד למשנהו.
אז כל הזמן הזה מה שהיה "שלום" הוא בעצם "שלום" עם / 0, ו
בינתיים, מאוד ייתכן שגם להיות די קצת יותר זיכרון RAM
חלק פנימי של המחשב.
>> תן לי לעשות דבר אחד עכשיו.
מתברר שכל ריבועים אלה אנחנו כבר ציור, הם, כן,
מחרוזות, אבל באופן כללי יותר, הדברים האלה הם מערכים.
מערך הוא רק נתח של זיכרון זה גב אל גב אל גב אל גב,
ואתה משתמש בדרך כלל מערך בדרך של סימון סוגר המרובע הזה.
אז אנחנו הולכים לראות אותם לא מעט לאורך זמן, אבל תן לי ללכת קדימה
להיפתח, בואו נקראים לזה המון זמן.
ושים לב למה שאנחנו יכולים לעשות עם אלה קטנים אותם טריקים,
קצת יותר תחביר כאן.
>> אז בקו 17 של תכנית זו - בעצם, תן לי להפעיל את התכנית ראשונה
כדי שנוכל לראות מה הדבר הזה עושה.
תנו לי להתקשר להפוך לגילים לקמפל תכנית זו.
גילים /..
כמה אנשים בחדר?
קוראים לזה שלוש.
גילה של האדם הראשון?
18, 19, ו -20.
ועכשיו קצת מגוחך, אני פשוט עשה תכנית שגילים אלו
שלושה אנשים.
>> אז יש באופן ברור הזדמנות לקצת חשבון כיף כאן.
למרבה המזל, המתמטיקה היא נכונה.
18 הלכו ל19, 19 הלכו עד 20 וכן הלאה.
אבל מה שבאמת אמור להיות המחשה כאן הוא איך אנחנו אחסון
הגילים של אותם שלושה אנשים.
תנו לי להתקרב במה קורה כאן.
>> אז קודם כל, כמה השורות הראשונות אלה צריכים מקבל די מוכר.
אני רק להציג הודעה למשתמש עבור מספר האנשים בחדר.
אז אני משתמש לקבל int ולעשות בזמן כדי לעשות את זה שוב ושוב ושוב.
ראינו את תבנית שלפני, אבל קו 27 הוא חדש ולמעשה די
שימושי, ויהפוך יותר ויותר שימושי.
שים לב כי מה שונה בקו 27 זה שאני מופיע להיות הכרזה
int גילים שם, אבל חכה.
זה לא רק גילים int.
יש סוגריים המרובעים האלה, בתוכה הוא n.
>> אז n סוגר בהקשר זה, לא בתוך הצהרת printf כאן, אבל
בקו בלעדי זה 27, הקו הזה הוא אמר, תן לי n ints, כל אחד מהם
הוא מסוג int.
אז זה דלי, כביכול, של, במקרה הזה, שלושה שלמים חזרה ל
גב אל גב, כך שאני ביעילות יש שלוש משתנה.
האלטרנטיבה, להיות ברור, יהיה זו.
>> אם אני רוצה של התלמיד הראשון גיל, אני יכול לעשות את זה.
אם אני רוצה של התלמיד השני גיל אני יכול לעשות את זה.
אם אני רוצה של התלמיד השלישי גיל, אני יכול לעשות את זה.
וחס וחליל שאנחנו צריכים כולם גיל בחדר הזה -
אני מתכוון, זה לעזאזל של הרבה של עותק, להדביק שוב ושוב ושוב.
ועוד פעם אחת אני לקמפל תכנית זו, אם תלמיד אחר נכנס מעל החוצה
מהדלת הזאת, עכשיו את המספר שלי של משתנים אינו נכונה.
>> אז מה שיפה הוא שמערך ברגע שאתה מתחיל להרגיש את עצמך
העתקה והדבקה, סיכויים הם שזה לא הגישה הטובה ביותר.
מערך הוא דינמי שעלול להיות.
אני לא יודע בכמה אנשים מראש הולכים להיות בחדר,
אבל אני יודע שאני צריך n שלהם, ואני יהיה להבין n בבוא העת.
קו זה של קוד עכשיו אומר, תן לי נתח של זיכרון שנראה כך
שבו מספר התיבות על המסך הוא תלוי לחלוטין בn כי
משתמש הקליד פנימה
>> אז עכשיו את שארית של תכנית זו היא בעצם די דומה למה שאנו
פשוט עשיתי עם דמויות.
שימו לב שיש לי ללולאה מתחיל בקו 30.
אז מייד אחרי שאני מקבל את המערך, אני לחזר מY שווה אפס בעד n.
אני רק צריך מאלף printf זה הודעה רק אומרת, תן לי הגיל
של אדם #% i, כך מספר אחד, מספר שתיים, מספר שלוש.
ולמה אני עושה את זה?
למען האמת, בני אדם מעדיפים לספור מאחד בעד ואילו מדעני מחשב,
אפס על למעלה.
מדעני מחשב לא הולכים להשתמש בתכנית מסוג זה, כך שאנחנו
הולך רק כדי להתחיל לספור באחד כמו אנשים נורמלים.
>> ועכשיו בקו 33, תבחין במקצת פיסה אחרת של תחביר.
גיל ה-i במשתנה שמהסוג מערך הוא הולך לקבל int.
ועכשיו סוף סוף, זה רק חשבון כאן למטה.
החלטתי בלולאה נפרדת לתבוע כמה זמן עובר, ועכשיו בזה
לולאה נפרדת, שורות אלה לבצע.
>> שנה מיום, אדם שאני יהיה אני שנים, אבל שם לב שזה לא
משתנה לי.
זהו עכשיו אני% עבור int.
והודעה כמציין המיקום הראשון, אני התוספת שבתוספת 1, ולכן אנו סופרים כמו
אדם נורמלי.
ולאחר מכן לשווי של גילם, ל אני בן, אני לוקח את סוגר גילים
אני - ולמה אני עושה ועוד אחד כאן?
הם פשוט הזדקנו.
זו הבחירה שלי המטופשת של תוכניות.
הם רק בני שנה אחת.
אני יכול להקליד כל מספר ש למעשה אני רוצה שם.
>> אז מה בעצם כל רלוונטיות כאן?
ובכן, הרשה לי בעצם לגלול אחורה כאן ומצייר תמונה
של מה שלפנינו.
מה יהיה לנו לעשות עם הבא שלנו סט שתי בעיה הוא מתעסק ב
עולם של הצפנה.
אז זה הוא מחרוזת של תווים, ולכן רצף של תווים מרובים, ומה
זה אומר?
זה לא בגרסה המקוונת של השקופיות.
>> אז אני טוען שזה שווה את זה, פרסומת טיפשית משנים רבות
לפני שבאמת עשוי להיזכר אחד ממקורותיו.
אז זו דוגמה להצפנה או הצפנה.
מסתבר שאם אתה רוצה בעצם לשלוח מידע או לשתף
מידע עם מישהו באופן מאובטח, כמו הודעה כזאת, אתה יכול
לטרוף את המכתבים.
אבל בדרך כלל, המילים הן לא מקושקשת באופן אקראי.
הם permuted בדרך כלשהי או השתנו בדרך כלשהי, כך ש-- אופס.
זה ספוילר כיף לפעם הבאה.
>> אז אתה יכול למפות את מה שהוא ככל הנראה O להודעה ב 'שקווים עד
מבחינת שווי.
ככל הנראה R הופך דואר.
ככל הנראה, ה-F-H-E-R הופך S-U-R-E. כך מתברר שיש מיפוי, ובשינה
מקרה זה יש די טיפשי מיפוי אם מישהו הבין את זה?
זה משהו שנקרא רוט 13, סובב 13.
זה הטיפשי ביותר של הצפנה מנגנונים כי זה ממש פשוט
מוסיף 13 לכל אחד מהמכתבים, טיפשים במובן זה שאם אתה רק
יש קצת זמן פנוי על ידי שלך ועיפרון, או שאתה פשוט חושב שזה
דרך בראש שלך, אתה יכול לנסות כל תוספות האפשריות - אחד, שתיים,
שלוש, נקודה, נקודה, נקודה, 25 רק לסובב את כל האותיות, ו
סופו של דבר, יהיה עליך להבין מה היא הודעה זו.
אז אם אתה עשית משהו כזה ב בית הספר יסודי להעברת מסרים שלך
חברו הטוב ביותר, אם בבית הספר היסודי שלך מורה פשוט לקרוא
הודעה וזרוע אילץ את הפתרון, יש לך אולי קיבל
תשובה על ידי זה.
>> עכשיו כמובן, בעולם האמיתי, ההצפנה היא מתוחכמת יותר.
זהו קטע טקסט מ מערכת מחשב שיש לו שמות משתמש ו
סיסמאות, כפי שכמעט כולנו עושות, ו זה מה שאולי את הסיסמה שלך
נראה אם ​​מאוחסן בך קשה אבל לנהוג בצורה מוצפנת.
זה לא רק סיבוב של מכתבים, הוא B ו-B הוא C. זה הוא
הרבה יותר מתוחכם, אבל הוא משתמש מה שידוע בדרך כלל כמפתח סודי
הצפנה.
התמונה הזאת אומרת לי הבאה סיפור עם כמה סמלים.
>> בצד השמאל, יש לנו מה אנחנו קוראים לטקסט רגיל.
בעולם של קריפטוגרפיה, רגיל טקסט הוא רק ההודעה המקורית
נכתב באנגלית או בצרפתית או בכל שפה שהיא.
אם ברצונך להצפין אותו, נצטרך לעבור זה ציורי דרך מנעול, ולכן
סוג מסוים של של אלגוריתם, תפקיד כלשהו או תכנית שמישהו כתב
כי טורף בתקווה האותיות יותר מאשר רק אופן מורכב והוסיף 13
לכל אחד מהם.
>> מה לך לצאת מזה בתהליך המרכז שם נקרא cyphertext.
אז סוג של מילה סקסית.
זה רק אומר שזה מוצפן גרסה של הטקסט רגיל.
ורק אם יש לך אותו סוד, 13 או מינוס 13, אתה מסוגל
לפענח מסר כזה.
>> אז בבעיה להגדיר שתי, בין הדברים תעשה אם בהאקר
מהדורה, תצטרך לכתוב קוד כדי לפצח סיסמאות האלה, להבין
מה שהם היו ואיך הם היו מוצפן, למרות שאנחנו עושים לך קצת
של הדרכה לאורך הדרך.
במהדורה רגילה, אנחנו מציגים כמה צפנים, הצפנה
מנגנונים, אחד בשם קיסר, אחד קראתי Vigenere, שעדיין
צופן סיבוב שבו הופך משהו ', ב' הופך להיות משהו, אבל
אתה צריך לעשות את זה באמצעות תכנות כי יש אכן יהיה סוד
מפתח המעורב שהוא בדרך כלל מספר או מילת מפתח שרק
שולח והנמען של אלה מסרים צריכים להבין.
>> עכשיו, יש לזה ממש גלגולים בעולם האמיתי.
זו, למשל, היא יתום קטן הטבעת של אנני סוד מפענח, ואתה
למעשה אלה יכולים ליישם צופן סיבוב -
הופך למשהו ', ב' הופך להיות משהו - עם כמה גלגלים,
אחד בחוץ, אחד בפנים כך שאם אתה מסובב את הגלגל או
הטבעת, למעשה אתה יכול להסתדר בשורה אותיות עם אותיות שונות,
מקבל קוד סודי.
וכך, כסחרור מסוכן להיום, מה חשבתי שאני רוצה לעשות הוא קצת
נסיגה שאם אתה מדליק את טלוויזיה ב -24 בדצמבר, אתה יכול לצפות
עד זרא לסרט 24 שעות ברציפות.
אבל היום, אני אפתח את זה כאן ולתת לנו רק שתי דקות
סיפור חג המולד פדגוגי רלוונטי עם בחור קטן בשם ראלפי.
>> [השמעת וידאו]
>> -אם זה ידוע לכל ומשונים ש ראלף פארקר מתמנה בזאת
חבר של היתומה הקטנה אנני הסוד המעגל והוא זכאי לכל
הכיבודים וההטבות התרחשות שהוכנסו בו.
>> על החתום,, יתומה הקטנה אנני.
תשובה, פייר אנדרה בדיו.
כיבודים והטבות שכבר בגיל תשע.
>> [צועק ברדיו]
>> יאללה, בואו נגמור עם זה.
אני לא צריך את כל זה על ג'אז מבריחים ופירטים.
>> תקשיב, מחר בלילה ל הרפתקה מסכמת של שחור
ספינת פירטים.
עכשיו, הגיע זמן לסוד של אנני מסר בשבילך חברים
המעגל הסודי.
זכור, ילדים.
רק חברי המעגל הסודי של אנני יכול לפענח המסר הסודי של אנני.
זכרו, אנני היא תלוי בך.
הגדרה שלך לסיכות B2.
כאן הוא המסר.
12, 11, 2 -
>> -אני בפגישה החשאית הראשונה שלי.
>> -25, 14, 11, 18, 16 -
>> פייר היה נהדר בקול ערב.
אני יכול לספר לי ההודעה של הלילה כי היה באמת חשוב.
>> -3, 25.
זה מסר מאנני את עצמה.
זכור, לא לספר לאף אחד.
>> -90 שניות מאוחר יותר, אני בחדר רק בבית שבו ילד בן תשע
יכל לשבת בפרטיות ובפענוח.
אהה, הלכתי ב 'למשנהו.
א 'המילה הראשונה היא "להיות". ס זה היה קרוב יותר קל עכשיו.
ע '25.
זה ר '
>> -יאללה, ראלפי.
אני חייב ללכת.
>> -אני אהיה ישר, אמא.
בחיי.
>> -T. O. הקפד.
הקפד מה?
מה הייתה יתומה קטנה אנני מנסה לומר?
הקפד מה?
>> -ראלפי, רנדי יש לי ללכת.
האם תוכל בבקשה לצאת?
>> -בסדר, אמא.
אני מייד החוצה.
>> -אני מתקרב לעכשיו.
המתח היה נורא.
מה זה היה?
גורלו של כדור הארץ עלולה תלוי ועומד.
>> -ראלפי, Go חייב של רנדי.
>> -אני אהיה זכות לצאת ל בוכה בקול רם.
>> -כמעט שם.
האצבעות שלי עפו.
המוח שלי היה מלכודת פלדה.
כל נקבובית רטט.
זה היה כמעט ברור.
כן, כן, כן, כן, כן.
>> -הקפד לשתות השוקו שלך.
שוקו?
מסחרי עלוב?
בן זונה.
>> [השמעת וידאו הסוף]
>> 1 דובר: זה CS50, וכי יוגדר בעיה שנייה.
להתראות בשבוע הבא.
>> רמקול 2: בסמוך CS50, זה קורה.
>> רמקול 1: אז נושא אחד יש לנו לא הביט בו עד כה
זה של מצביעי פונקציות.
עכשיו, מצביע לפונקציה הוא רק הכתובת של ציבור
פונקציה, אבל הרבה יותר כמו -
בנו של -