[Powered by Google Translate] הדוד י Malan: בסדר, זה CS50, וזה
תתחיל בשבוע השני.
תודה.
בואו נתחיל כאן בשיחת טלפון.
אני עומד לחייג 617-באגים CS50.
CS50: זה CS50.
לילד תעופה, לחץ על 1.
כדי להתחיל מחדש, לחץ 9.
הדוד י Malan: אז הוא אמר לילד הסעות, לחץ על 1.
אז אנחנו הולכים לקש 1.
CS50: מהו המוצא שלך?
למרובע, לחץ על 1.
מאת'ר, קש 2.
בוילסטון, לחץ על 3.
למונט, 4 עיתונאים.
ממ הול, 5 עיתונות.
כדי להתחיל מחדש, לחץ 0.
הדוד י Malan: אנחנו קש 1 למרובע.
CS50: המעבורת הבאה יוצאת ברגע זה ממש בשעת 1:10, ו
לאחר מכן בשעת 1:20 בערב, 1:30, 1:40.
זה CS50.
>> הדוד י Malan: אז זה הקול של CS50.
וזה דוגמה של סוג עבודות גמר, עבור
למשל, אתה יכול לנשוך את הכיוון
סוף הסמסטר.
לדוגמה, shuttleboy.cs50.net שקיים -
למעשה פרויקט שאני ראשון שכתבתי לאחר נטילת CS51
בזמן שהייתי סטודנט לתואר ראשון.
וכאן ההשראה הייתה אז, כל מה שהם היו היה
את לוחות זמנים המודפסים הסעות, ולא היו שום
רעיון של מחפש דברים באינטרנט.
ואז אני סוג של יונה בסוף שבוע אחד, שהסתננתי דרך
מודפס לוח זמנים, וזה מועבר לתוכנת מחשב.
באותו הזמן, תכנית המחשב שקרתה לי להיכתב
בג ואתה אכן העברת אותה על ידי הקלדה בוי הסעות
מהבהב ינחה כמו שעשינו עד כה.
אבל במשך השנים, זה התפתח לרגע
הודעות בוט.
זה התפתח לאחרונה באתר אינטרנט זה, לתוך
כלי SMS מבוסס, כמו גם לכלי מבוסס קול הזה.
וזה לרמוז על מיני דברים שאתה יכול
תעשה לעצמך עד הסוף הסמסטר.
>> למשל, שם, בגרסת ה-SMS של וי הסעות קורית
לפעול כדלקמן.
אם, בטלפון הסלולרי שלך, אתה שולח הודעת טקסט ול41411
לאחר מכן שלח את sboy הסמל המיוחד, לילד תעופה,
אחרי A ו-B, שבו הוא מקור וB הוא
יעד -
למשל, בוילסטון החלל Quad -
מה שאתה צריך לחזור תוך כמה שניות הוא טקסט
הודעה מנערת הסעות אומרת לך בדיוק מתי
כמה המעבורות הבאות הן, מאותה נקודה והולכת כי
נקודה ב '
וזו דוגמה כללית יותר של מה שנקרא
באמצעות API.
>> כך למשל, כאן הוא פשוט shuttleboy.cs50.net,
גלגול מבוסס אינטרנט אמיתי של זה.
אבל הנתונים שunderlines יישומים אלה ואחרים שCS50
פתח כולם חשופים לכולם כאן בצורה
של APIs, ממשקי תכנות יישומים.
וזה רק דרך מפוארת להגיד שאנשים אוהבים אותנו על
האינטרנט ואחרים בילו קצת זמן ביצירה
תוכנה שאתה יכול להשתמש כדי לתפוס את הנתונים מאתנו ו
לאחר מכן לבנות יישומים משלך על גבי
שמערכת הנתונים.
כך למשל, בדף זה הסעות וי API כאן, ש
במקרה בCS50 הידני, מהות מסמכים
איך אתה יכול ללכת לשאול CS50 שרתים לנתונים.
לדוגמה, אם אתה מכיר את קבצי CSV, פסיק
להפריד ערכים, אלה הם רק סוג של מהיר ומלוכלך
קבצי Excel דמויים.
אז אתה יכול לשאול את ילד הסעות לכל נתונים על כל
בתים והקואורדינטות GPS שלהם, ותקבל
חזרה, למעשה, גיליון אלקטרוני כמו ש
אז אתה יכול לקרוא לתכנית משלך ולאחר מכן
יצירת תוצאות, כמו בוי הסעות עצמו
קורה שהוא עושה.
לייצוגים אלה מוכרים ומודרניים יותר נתונים
כולל JSON, סימון אובייקט JavaScript.
משהו יחזור אליך לכיוון
סוף הסמסטר.
>> אבל שוב, זה רק אחד מכמה של APIs של CS50 עצמו.
והדבר המרגש הוא עכשיו, בימים אלה, ופייסבוק
טוויטר וגוגל וכמעט בכל אתר אינטרנט פופולרי החוצה
שם יש איזה API, מה שאומר שאם אתה קורא
תיעוד באתר שלהם, לך להירשם ל
חשבון, אז אתה יכול להתחיל לכתוב תוכנה על גבי
כל כלי או נתונים שמספק חברה יש.
וכן אחד מהחברים להוראה שלנו לפני כמה שנים
כתב גרסת מק של זה.
אז בקישור שכותרתו מק כאן בפינה שמאלית עליונה, למעשה אתה יכול
להוריד יישומון Mac OS הפועל על Mac שלך לעשות
אותם מיני דברים.
אז זה הכול העניין של בנייה על גבי ערכות נתונים כמו אלה.
אבל גם על זה לקראת סוף הסמסטר.
>> אז בואו לצלול במהירות רבה מאוד לבאג, רק כדי לקבל סוג של
דברים חממו את היום, ולחשוב שוב על כמה
דברים שנראו בשבוע שעבר.
בפרט, תן לי ללכת קדימה ולמשוך את, יניח,
דוגמה זו כאן.
Buggy1.c, זה זמין באתר האינטרנט של הקורס, אם אתה מעדיף
רוצה להוריד אותו ולחטט בעצמך.
אבל בואו להתקרב כאן בתכנית קצרה למדי, ורק
סיכום מהיר במיוחד של כמה מאבני הבניין הבסיסיים ש
אנחנו באמת הולכים רק להתחיל לקחת כמובן מאליו.
>> אז החומר הכחול, בקווי 1 עד 9, הם רק
כדור אחר כדור.
אז אלה הם רק תגובות.
אין להם משמעות פונקציונלית.
אבל הם הערות במובן זה שהם מציינים כי
אני, האנושי, עשיתי לעצמי כל כך שבהרצאה ואחרי
הרצאה, שאני יכול באמת זוכר מה זה תכנית
עושה מבלי לקרוא את הקו אותו על ידי קו ו
יצירה מחדש של ההיסטוריה במחשבתי.
יתר על כן, אם אני מגיש תכנית זו למישהו אחר כמו
לך, זה הרבה יותר ברור לך, בגלל הערות כמו זו,
מה התכנית בעצם עושה, או לפחות מה
התכנית אמורה לעשות.
בין אם זה נכון, זה כבר עניין אחר לגמרי.
עכשיו, ב-C, עם הערות מרובות שורות, להיזכר בכך בשורה
אחד כאן הוא סמל הקסם, / *.
זה אומר שהנה מגיע תחילת תגובה.
ושום דבר אחר לא חשוב עד שתגיע לסוף השליחות הקטלנית,
אשר * /, את ההפך.
לכן העובדה שיש לי 80 ומשהו כוכבים מזדמנים לכאן מ
משמאל לימין הוא באמת רק פרט אסתטי.
אין לו משמעות תפקודית.
>> עכשיו מה לגבי שורת 11?
מה זה עושה במונחים של ההדיוט?
מה זה?
קהל: כולל סטנדרטי.
הדוד י Malan: בסדר, טוב.
אז זה כולל ספריית stdio.h.
אז מה זה אומר?
ובכן, בתוך קובץ, stdio.h, חבורה שלמה של
הצהרות פונקציה -
כלומר, קוד שמישהו אחר כתב.
ודוגמה מושלמת לתפקיד זה הוכרז ב
stdio.h הוא -
שאהוב עד עכשיו?
אז printf, אחד מאלה הנפוצים ביותר לשימוש, ללא ספק
כבר בשלב מוקדם, שמהספרייה היא שם.
אם אני מוציא את שורת הקוד, קלאנג הולך לצעוק
בהמשהו על שימוש בסמל לא מוצהר.
משהו שלא נאמר הוא כנראה מילת מפתח, כי
יש לנו לא הודיע ​​למהדר מה printf נראה
אלא אם כן אנחנו רוצים לכלול את הקו הזה.
ויותר לכדור הארץ, באמת, מה קו שאומר הוא
לפתוח את הקובץ ש, stdio.h, בכל המקום בו נמצא בשרת של
כונן קשיח, או כונן הקשיח של המכשיר, והעתקה והדבקתו
ממש שם לקובץ שלי, מבלי שאני
יש לעשות זאת באופן ידני.
>> עכשיו, ברגע שאנחנו מקבלים כאן לראשיים, נהיה לנו בקרוב נתחיל
מתגרה מלבד מה int ומה הוא מבוטל.
אבל לעת עתה, בואו נסתכל על השלוש השורות
בתוך 15 עד 17.
זה כאן אני טוען כעגלה.
קו 7 בהערות שלי אומר "צריך להדפיס 10
כוכביות אבל לא. "למה זה לא מדפיסים, למעשה,
10 כוכבים כאלה?
קהל: [לא ברור].
הדוד י Malan: בדיוק.
אז שם לב שאנחנו מתחילים לספור מ 0.
וזה בעצם כינוס בתכנות ו
מדעי מחשב באופן כללי יותר, מתחילים לספור
מ0 במקום 1.
וזה באמת רק נובע מהעובדה שבמשך
למשל, כאשר היו לנו עד שמונה אנשים על הבמה, כש
אף אחד לא מרים את ידם, הם היו
כל האפסים ביעילות.
ולכן זה רק סוג של ועידת מחשבים כך,
לכן, כדי להתחיל לספור מ 0.
אם זה המספר הנמוך ביותר שאתה יכול לייצג בינארי.
>> אז הנה אנחנו כבר התחלנו אתחולי ל 0.
אנחנו כבר קבענו שאני שווה 0.
אבל אז עשיתי את הטעות הזאת כאן, ואמר לי היא פחות או
שווה ל 10.
אבל אם אתה חושב שדרך, אם אני מתחיל ב 0 ואז אני הולך
עד 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, אני בעצם הולך
להדפיס את 11 כוכבים למסך, כי אני כבר עליתי
ולשווה ל 10.
אז התיקון הקל כאן אז מה?
קהל: [לא ברור].
הדוד י Malan: רק לשנות אותו בפחות מ.
אם אתה באמת רוצה, אתה יכול לעשות את זה.
אבל באופן כללי, זה בעין יפה.
וכך מתחיל לספור מ 0 הוא רק משהו שצריך
בדרך כלל להתרגל אליה.
עכשיו, מה עם כל זה לבנות בעצמו?
15 זה demarks קו ללולאה for.
אז בשביל זה לא פונקציה.
זה רק הצהרה.
שהוא מבנה לולאות, כמו שראינו בהתחלה.
ויש לו שלושה חלקים.
שים לב שיש חלק הראשון
מהשמאל לפסיק.
יש בחלק האמצעי בין שני הפסיק.
ואז יש את החלק הימני בצד הימין
של הפסיק השני.
עכשיו, הראשונה שבן עושה מה?
קהל: [לא ברור].
הדוד י Malan: חזרה לשם?
כן?
קהל: אתחול.
>> הדוד י Malan: אתחול.
אז מה זה אומר?
אנחנו הכרזנו על משתנים בשם i.
זה מהסוג int, כי אני כבר צוינתי אני int.
ואני מאתחל אני לערך של 0.
אז מה זה באמת אומר?
זה למעשה אומר למחשב היי, נתן לי מספיק
מספיק הזיכרון RAM, כך שיתאימו למספר, ולאחר מכן לשים
מספר 0 שבנתח של זכרון RAM.
ואגב זה, כמה גדול הוא בדרך כלל int, לפחות בפנים
של המכשיר?
קהל: 32 ביט.
הדוד י Malan: 32 סיביים.
אז זה אומר לתת לי 32 סיביים, הידוע גם בכינויו 4 בתים,
ולשים את ערך 0 בזה, וזה די קל כי
זה רק אומר להגדיר את כל החתיכות ל0.
>> אז עכשיו, החלק השני כאן הוא המצב.
ומצבו, כפי שהשם מרמז, הוא מה שהוא בדק
שוב ושוב ושוב, האם זה נכון או לא נכון.
אז זה רק אומר לעשות את שורות קוד הבאות -
כלומר 16 קו, משום שהוא היחיד מסוכסך
מתחת -
כל עוד אני הוא פחות מ 10.
ולאחר כל איטרציה בלולאה הזאת, לעשות
incrementation, אשר במקרה זה הוא i + +.
עכשיו, זה לא חייב להיות i + +.
זה יכול להיות לי -.
אבל אם עשיתי את זה, מה שההתנהגות הולכת
להיות בתכנית זו?
קהל: זה הולך להיות לולאה אינסופית.
הדוד י Malan: זה הולך להיות סוג של לולאה אינסופית,
אלא אם נהיה לנו מזל לאחר 2 מיליארדים שליליים או משהו כזה.
אולי דברים לעטוף, רק על ידי האופי הסופי
מספר הביטים שיש לנו שהוקצו עבור int.
אבל זה בהחלט הולך לחזר הרבה יותר מ 10 ו
בהחלט יותר מפי 11 כאן.
>> ועכשיו, בדיוק כמו בצד, מבין שאני + + ואני -
הם באמת רק סוכר תחבירי.
זה פשוט סימון מקוצר למה קצת יותר
נכתב במפורש כדלקמן:
אני = אני + 1.
שהנו זהה לi + +.
זה פשוט סוג של נראה יפה יותר לומר אני + +.
זה יותר תמציתי, קריא יותר.
ולכן, רוב האנשים עושים את זה במקומו.
אבל זה זהה מבחינה פונקציונלית ל
מה שראינו זה עתה.
אז בקיצור, הפתרון המהיר כאן הוא רק כדי לומר לי לחזר
מ 0 כל הדרך עד פחות מ 10.
ואז אנחנו אכן מקבלים 10 כוכבים.
>> אז בואו ננסה את זה.
בואו יפתחו לי את הטרמינל בתחתית.
תן לי ללכת לספרייה שזה פנימה
ואני הולך לאסוף אותו באופן ידני עם קלאנג לעת עתה.
ואני הולך לקמפל זה כbuggy1.c, Enter.
ועכשיו buggy1, מדוע אין כזה קובץ או ספרייה
קרא buggy1?
קהל: [לא ברור].
הדוד י Malan: כן.
אז זה בעצם נקרא a.out.
אז אם אתה זוכר רק להפעיל קלאנג, שם קלאנג הוא
מהדר, ולא תציינו את השם שאתה רוצה
לתת לתכנית שלך, זה הולך לברירת מחדל לa.out.
אז אכן, אם אני עושה ls -
אופס.
ואני לא - נושא שחור ולבן חלק
אתה מתמודד תוקן.
אבל תן לי לעשות את זה.
יש לנו a.out בצד השמאלי שם.
אז יש לנו לרוץ a.out במקום buggy1.
>> אז תן לי ללכת קדימה ולעשות את זה.
. A.out /, Enter.
ונראה שאני לא עושה את מה?
קהל: שמור.
הדוד י Malan: שמור את הקובץ שלי.
כך שנפתר בקלות על ידי להכות S בקרה, או הולך
קובץ, שמור, כמו ברוב התוכניות.
תן לי ללכת לכאן, לנקות את המסך, להריץ אותו שוב.
ועדיין יש באג.
אז מה שקורה -
קהל: אתה לא לקמפל.
הדוד י Malan: אה, טוב.
אני לא לקמפל אותו.
כמו אידיוט, אני מסתכל על הקוד כדי לראות מה לא בסדר.
אז buggy1.c להרעיש, ועכשיו a.out.
ואוף, הצילו.
>> אז זה נראה קטן ומכוער בגלל שאין קו חדש
בכל מקום בתכנית.
אבל שוב, זה רק פרט אסתטי.
ולפחות אם אנו סופרים את אלה, עלינו
עכשיו ראה 10 כוכבים כאלה.
ובכן, מה לגבי למשל חימום שני?
אז בbuggy2, אני טוען שגרסה זו גם תהיה להדפיס
10 כוכבים, אחד בכל שורה.
אז הפעם, יש לי אופי שורה חדש, רק כדי
דברים קצת יותר יפים.
אבל במקום מה שאני מקבל הוא זה.
אז תן לי לעשות buggy2.c להרעיש, ולחץ על Enter.
עכשיו הוא נקרא שוב a.out.
Enter.
אני רואה שורה אחת חדשה, רק הקו החדש מאוד שעבר רק ש
נע פקודה לשורה הבאה.
ובכל זאת ברורה שאני מדפיס *, ולאחר מכן קו חדש,
*, אז שורה חדשה.
אבל מה באג כאן?
כן?
קהל: [לא ברור].
>> הדוד י Malan: בדיוק.
אז בניגוד לשפות מסוימות, כמו פייתון, שבו כניסה
למעשה יש משמעות תפקודית, ב
שפה כמו C -
כפי שנראה, PHP, JavaScript -
הכניסה היא באמת רק לטובתם של בני האדם.
לכן העובדה שאני כבר מסוכסך 16 וקו 17 נראית נהדרת,
אבל אין לה כל משמעות תפקודית כאן.
אם אני רוצה את שני הקווים לביצוע כחלק מ
לולאה, ואז אני חייבת לעטוף אותם בסוגריים מסולסלים ידי עושה את זה.
אתה יכול לחתוך רק פינה ושלהשמיט את הסוגריים המסולסלים אם
מה המצב?
קהל: רק שורה אחת.
הדוד י Malan: רק שורה אחת.
אז זה פשוט סוג של מין יפה פירוט תחביר כך
אתה לא תבזבז את זמן כתיבת שלושה קווים, שניים מהם
סוגריים מסולסלים, רק כדי לכתוב שורה אחת של קוד.
אבל אם יש לך שתי שורות או יותר, אנחנו
אכן צריכים לעשות את זה.
>> אז עכשיו בואו להציל אותי זה.
תן לי ללכת קדימה וקלאנג להפעיל מחדש.
אז תן לי שידור חוזר a.out, ועכשיו אני מקבל אותם אחד בכל שורה.
עכשיו, שוב a.out הוא סוג של שם מטומטמים לתכנית.
איך אני יכול להגיד לי קלאנג בעצם לתת לי את שם קובץ
זה יותר ידידותי למשתמש, כמו buggy2 עצמו?
קצת יותר ברור?
קהל: [לא ברור].
הדוד י Malan: בסדר, אז אני יכול למעשה לקחת מאוד
קיצור ידידותי למשתמש ופשוט לכתוב להפוך buggy2.
אני לא אציין. ג במקרה זה, ועל Enter.
ומה לעשות עושה זה הידור buggy2.c לי על ידי
שואל קלאנג לעשות את זה.
באופן ספציפי, שהיא ממכנת קלאנג, הוא פועל באמצעות קלאנג דרך יותר
טיעוני שורת פקודה או מתגים ממה שבאמת זקוק.
בזמן, אנחנו נחזור למה שכל אלה שונים
ביטויי מקף מסתוריים אומרים.
אבל לעת עתה, זה סתם חוסך ממני את הטרחה
צורך לזכור ולהקליד את כל אלה
ביטויי מקף שונים.
והיתרון שלו הוא בסופו
כי עכשיו יש לי buggy2.
אם אני רוצה לעשות את זה באופן ידני, אם כי, אני
במקום זאת יכולה לעשות את זה -
צלצול-o buggy2 ולאחר מכן buggy2.c.
וכי בדומה ייתן לי קובץ שנקרא buggy2.
>> אז בקיצור, קלאנג של המהדר.
הפוך הוא רק כלי ידידותי למשתמש שאנחנו משתמשים בו יותר
ועוד, משום שהוא רק מתחיל
לפשט את הדברים עבורנו.
ואנחנו חוזרים 0, לבסוף.
לעת עתה, רק בגלל, אבל תתחילו מקניט את החלק הזה
היום וביום רביעי.
כל שאלה בכל זה?
כן?
קהל: [לא ברור]
ls בציטוטים שם?
הדוד י Malan: אישור.
כשls המוקלד בציטוטים, שעושה לי קצת קסם
מאחורי הקלעים כדי לתקן את הבאג.
שכחתי, כמו שאנחנו כבר אומרים שרבים מכם על
לוחות דיונים, לעשות -
אנחנו נעשה את זה עכשיו - yum-y sudo עדכון appliance50.
אופס, שזה מאוית נכון.
אז המכשיר הוא כמו מערכת הפעלה.
זה פועל מערכת הפעלה זו נקראת פדורה.
ועכשיו בגלל החיבור האיטי לאינטרנט שלי, יש לי
באמת רסס אותו.
אז ריצת עדכון yum sudo, כפי שאמרנו לך לעשות ב
סט בעיה, הוא בעצם רוצה לרוץ עדכונים אוטומטיים
ב-Mac OS או Windows.
והסיבה לריצה זה בתחילה מאוד של
סט בעיה הוא כי כאשר יצרנו את המכשיר, אני
פשלתי, ואני עשיתי טעות את כל התוכניות שלך נראה
שחור על מסך שחור, וזו הסיבה שאתה לא רואה אותם
כברירת מחדל.
אבל הגרסה האחרונה של המכשיר פותרת את זה.
ואני אסדר את זה פעם אחת במהלך חופשה יש לי אינטרנט
קישוריות.
>> אז את הציטוטים רק מסתירים את הטעות שלי, מאוד דיסקרטי,
כנראה.
שאלות אחרות?
כן?
קהל: איפה עושה את בא?
[לא ברור]
הדוד י Malan: שאלה טובה.
איפה עושה את בא?
זוהי תכנית לינוקס שקיימת כבר שנים רבות, הרבה
לפני CS50.
וזה מגיע עם מערכת הפעלה כמו פדורה.
זה לא בא מCS50 הספרייה.
למעשה, הדברים היחידים שמגיעים מCS50 הספרייה
עד כה, שאנחנו ראינו, הם GetString, GetInt, כל
אלה קבלו פונקציות, ומילת המחרוזת, ולאחדים
מידה, מילת bool.
אבל אנחנו נתגרה כי מלבד כאשר אנו לצלול לתוך CS50
מכשיר עצמו.
>> אז כן, עוד שאלה אחת כאן.
קהל: כשאתה אמרת ולאחר מכן להפוך את העגלה, איך
מחשב יודע [לא ברור]?
הדוד י Malan: שאלה טובה.
לכן, כאשר אתה פשוט לרוץ לעשות buggy1 או לעשות buggy2, איך
עושה את יודע?
אז כברירת מחדל, אם תקליד להפוך buggy1, להפוך את המראה ל
קובץ שנקרא buggy1.c.
ואז היא מבצעת את פקודות הצלצול המתאימות,
וכך לעקוף את קובץ פלט ברירת המחדל נקרא a.out.
למעשה, אם נסתכל על מה לעשות, מה -
בואו נפסיק עם זה.
אם אנחנו מסתכלים על מה שעושים בעצם עושים, לעשות buggy2,
זה כבר מעודכן.
אז בואו תסירו לי את פקודת rm,
תכנית שכתבתי בעבר.
הקלדת Y-E-S כדי לאשר שאני רוצה להסיר אותו.
אם עכשיו אני כן עושה, שים לב כי בשורה הארוכה מאוד הזה,
יש דבר אחרון זה כאן,-o buggy2.
את כל האיפור עושה עובר טענה כי, כביכול, כדי
קלאנג, כך שאני לא צריך להקליד אותו בעצמי.
>> בסדר, אז כמה מהיר של מנהלי
הכרזות.
אז לחלקים, שהחל באופן רשמי את זה בא
יום ראשון, אתה תמיד רוצה להביא, אם
יש לך אחד, מחשב נייד.
אם אין לך מחשב נייד, אל תושיט לי על ידי
יורד לי מייל.
ואנחנו כבר נחשוב על זרימת עבודה.
מה בדרך כלל תמצא בסעיף הוא שהם יהיו חלק
, חלק רעיוני על ידות.
אנחנו דווקא נשתמש בקטע של שאלות, חלק מ
סט הבעיה של השבוע, האפשרות לטייל בחלק
חומר תיאורטי מהרצאות.
וזה כל הבעיה בערכה הנוכחית.
ואנו גם לצלול לכמה פעילויות על ידות, לפעמים
אשר יידרש להגיש, לפעמים של
שלא.
לדוגמה, בשבוע הראשון, הם אמורים בדיוק כמו
תרגיל חימום.
ואתה תמצא שהבעיות האלה הן באמת רק זה.
הם אמורים להיות קטנים למדי, אך לא בהכרח
תוכניות טריוויאליים לכתוב, שאינו בהכרח
מרגשות בפני עצמו, אך הזדמנויות טובות ל
להתאמן עם תחביר, עם פונקציות חדשות, בנוחות של
קטע שבו יש לך כמה מחבריך לכיתה להציג כמו
גם TF שלך.
>> ומה שנעשינו לאורך הזמן הוא להשתמש בכלי שנקרא CS50 Spaces,
לפי במקום רק באמצעות CS50 Appliance, אתה
במקום ללכת לדף אינטרנט בדפדפן, שם תוכל
לכתוב קוד בחלון דפדפן במהלך קטע.
ואז, אם אתה מצטרף, עמית ההוראה שלך אז יכול להראות
מה שזה לא שאתה מקליד על המסך שלך בדפדפן שלך
עד חלון בקדמת הכיתה, בין אם בעילום שם או
ציבור, כך שהוא או היא יכולה אחר כך ללכת דרך עם
לכיתה שלך את מה שעשה טוב, מה שלא עשתה כן.
ושוב, היה סמוך ובטוח שכל זה יכול להיות אנונימי יפה.
אבל זה יהיה הזדמנות טובה להרבה יותר
אינטראקטיביות מאשר משהו כמו הרצאה מאפשרת.
>> בינתיים, שנהיה לנו את הדברים האלה בשם סופר
חלקים, שהם אופציונליים, אך פתוחים לכולם ב
כיתה, כך שאתה יכול לעשות את זה יותר במשותף ל
בעיה מוגדרת אחת.
הנה לוח הזמנים.
זה גם פורסם בדף הבית בcs50.net.
שים לב שיש אהיה האקר ספציפי
מחר אחר הצהריים אחד.
ואנחנו נצלם אחד היום ואחד מחר ולפרסם אלה
באינטרנט בתוך 24 שעות.
אז אם אתה לא יכול לעשות כל הפעמים הללו, לא לדאוג.
ושוב, את לוח הזמנים הוא מחובר בcs50.net.
>> במונחים של חתך עצמו, אתה צריך להביא את
הודעת דוא"ל המנחה אותך ללכת לדף הבית של הקורס למצוא
את הקטע שלך.
אם החיים השתנו ואתה צריך לשנות את הסעיף שלך,
לא בעיה.
חזור לאותה כתובה URL, cs50.net/section, ייחודית,
ואתה למלא את הטופס הדומה, כך שאתה יכול
אז לתת לנו את העדפותיך.
ואנו נחזור אליו עד סוף השבוע על מה שאנחנו יכולים
להכיל.
בשבוע שעבר, זוכר שהצענו באמצעות CS50 לדון,
הכלי של קורס הדיון, בהרצאה.
אז היו לנו 40 שאלות שנשאלו ו
תשובה במהלך הרצאה.
כך לפחות זה נראה לעבוד היטב, ולכן אנחנו נמשיך
מנסה לעשות את זה.
אם, בעת ההרצאה, אתה לא מרגיש בנוח גיוס
היד שלך, לא בעיה.
עבור לcs50.net/discuss, לפרסם שם, ואחד מההוראה שלנו
עמיתים יהיו גם לענות עליה אלקטרוניים או להעלות אותם
יד בשמך בעילום שם כדי לשאול, בהתאם
על טיבה של השאלה.
ובמונחים של משוב, בדרך psets יהיה
חזר בשבוע שעבר.
כי זה לוקח קצת זמן כדי להשיג חלקים
שיווי משקל, pset 1, 0 ו 1, יהיה קצת
עיכוב שכדברים יירגע.
אבל להישאר מכוון לכי בשבועות הבאים.
>> בסדר, אז בואו תעמידו אותי לשלי רציני
קול רק לרגע.
אז זה בעצם אקלים מעניין להיות
מנהל את השיחה הזאת, מה עם כל דברים האחרים
קורה הבמתייחסים אל קמפוס.
אבל CS50 בהחלט הייתה תולדותיה של זו בפרט
נושא, באותה מידה כמו בכל שנה, את הקורס הזה, עבור רבים
שנים, Ad-לוחות בערך 3% מהכיתה.
השנה האחרונה, 2011, CS50 מודעות עשויים עץ 35 סטודנטים.
זה לא, אני חושב, בגלל חוסר הבהירות.
להבין כי בסילבוס של הקורס, יש עמוד של
הצהרה המסבירה את הקווים בם.
באותו המשפט חוזר על עצמו בכל אחד מ
בעיה מציבה על עמוד אחד.
>> אז אני מזכיר זאת היום באמת רק כדי לגרום
אנשים מודעים לזה.
ואנחנו כבר ניסינו דברים שונים.
ומה שחשבתי שנוכל לעשות היום היא פשוט לקחת רגע כדי
למעשה מסתכל על כמה מקרים בעבר שעלו.
במקום לשמור על הסודות קטנים כמזוהמים האלה, בעצם
להצביע על מה שהתלמידים עשו ואיך שזוהינו
זה ובאמת מה מוטיבצית העל הוא עבור
אפילו את השיחה הזאת.
אז עם זה אמר, קו למעשה הוא זו -
לתכנית הלימודים, אתה מוזמן, אתה עודדת, כדי
לדבר עם החברים לכיתה.
זה כל המטרה של אלה שיש שיתוף פעולה
שעתי עבודה באננברג ואנשים מעודדים עבור
פרויקט גמר לעבודה משותפת.
אבל הקו מצויר כשזה מגיע זמן לכתיבה,
הפתרון הסופי שלך.
אם כבר מדבר באנגלית, בסדר גמור, דבר בקוד מדומה,
בסדר גמור.
משלוח דוא"ל לכיתה pset, ומאפשר להם להסתכל על
המסך כידות להמשיך להקליד,
מעבר לקו גם כן.
אל תסתכלו לתכנית הלימודים לקווים המסוימים.
>> אבל רק כדי לצייר תמונה של איך זה, למרבה הצער
מציאות, להבין שיש אתרים שם בחוץ, כי
יש פתרונות מסוג זה ושיעורים רבים נוספים.
העובדה שאתה או 3% מכם יודע שזה קיים
משמעות דבר הוא שאנחנו יודעים שזה קיים.
העובדה שיש אתרים כמו זה שבו אתה
יכול לשלם למישהו כדי באמת לעשות סטי הבעיה שלך - זה היה
מקרה אמיתי שעלה בשנה שעברה.
זה אתר שנקרא odesk.com.
וטים היה השם של האדם כאן שפרסום על
אתר זה ובקש ממישהו שיעשה pset 7 ב
מקרה ספציפי זה.
ובכן, הוא מאוד odesk.com גוגל הצליחה, וכך גם אצלנו
טוב מאוד בGoogling.
גם כאן, יש אתרים - ופעם זה
אכזרי, בכנות.
[שחוק]
הדוד י Malan: הדבר המצחיק על האתר הזה הוא אם
אתה קורא על הדף, הם מדברים עליהם ארגוניים
שירות לקוחות של התרבות ואיך הוא המספר אחת שלהם
עדיפות, כדי לוודא שמטלותיך לקבל
פנה בזמן.
>> אבל בכל הרצינות, שוב, העובדה שאתרים אלה
קיים, אנחנו מבינים, גם הם מודעים
אלו סוגים של אתרים.
וכדי לתת לך תחושה של מה שמהווה, בדרך כלל,
לוקח, אנחנו בדרך כלל לא צריכים שערוריות גדולות שבו אנשים
משתפים פעולה בכל סוג של קנה מידה מסיבי, אלא
זה רגעים של שעות מאוחרים אלה של חולשה, שבו יש לך כל כך
הרבה מה לעשות, זה 4:00 לפנות הבוקר, אתה מותש, ואתה
חושב לעצמך, טוב, תן לי רק תסתכל עליי
שותפת הקוד של החבר שלי או של או כמו.
והביטויים של זה, למרבה הצער כרוכים סטודנטים
משהו כמו הגשת הגשת B סטודנט וזה
משהו כזה, שללא ספק, במחשב
כיתת מדע, היא קלה להפליא למדעני מחשב
כדי לזהות בתוכנה.
זהו עוד פרדיגמה משותפת, שבו יש לך סוג של
עבד לצדו של מישהו, אולי מדבר ב
,, Pseudocode בסדר גמור אנגלית.
אבל אז מגיע זמן להגיש למעשה, ואת psets
פשוט ללכת להחליף באמצעות דוא"ל או Dropbox או כמו.
אבל בניסיון לעשות את זה פחות ברור שזה הוא
מה שקרה, אז זה מה שהוגש.
גם זה לא להכשיל את החתיכות כתובות היטב של
תוכנה כמו שיש לנו בעצם לזהות
אלו סוגים של דברים.
ואכן מה שאנו עושים הוא תוכנת ריצה שמשווה כל
ההגשות של שנה זו, כנגד כל שנה של העבר
הגשות, נגד כל מה שמצאו על
אינטרנט, מתנגד לכל אתר עבודה בחוץ.
כל זה מאוד אוטומטי.
ולכן אנחנו עושים את זה באמת בהגינות רבה ל97% ש
באמת עובדים את התחת שלהם בזה ובשני
שיעורים ולשים בכל המאמץ כדי שהעבודה
הם סופו של דבר להגיש הוא שלהם.
ואני יכול להמשיך לכל גילים.
>> אלה הם רק קומץ של מקרים בשנה שעברה.
כמה תלמידים הגישו את הקבצים הללו באופן זהה לpset 2,
pset 3, 4 pset, 5 pset, 6 pset, 9 pset.
במקרה זה, זה היה חידון 0 ובשנה שעברה, שבה שתיים
תלמידים הגישו את המשפט הזה זהה בקרב רב
אחרים, "בקשה מהסוג -" הנקודה, נקודה, נקודה.
כך שגם בכיתה של 600 לא נזהה זה
בהוגש חידונים.
אז בקיצור, זה - בכנות, אני שונא סוג כזה של
שיחה - אבל זה באמת מאמץ מכוון
שנה זה כדי לנסות להוזיל את המספר הזה.
כי למרות שאנחנו אומרים דברים כאלה כל
שנה, אני חושב שהעובדה שיש לי התעכב עליה כמה
עוד שניות מרגילות ולמעשה רק מצביע
מה שאולי נראה כמו, אה, לא כזה ביג דיל, לפחות
חושב לחזור לרגע המסוים הזה, הוא בהגינות כלפי
את עצמך וחבריך לכיתה כאן.
אז אם אי פעם יש לך שאלות כמו לאן הקו
הוא, בבקשה להגיע אליי באופן אישי.
אבל התשובה היא תמיד, הדגיש לחלוטין
ברגע אחרון, במזומן באיחור של יום.
אם זה עניין של לא נתקל כל ימים מאוחר או,
בכנות, שלח לי באופן אישי.
אנחנו כבר נחשוב על משהו.
נא לא לשים את הזמן שלך כאן ברווארד בסיכון.
>> עכשיו, אני חושב שאנחנו צריכים להבהיר את מצב הרוח, ולכן אני
כלל זה כמו השקופית הבאה.
[שחוק]
הדוד י Malan: אתר זה היה נהדר.
אני דווקא קבלתי קצת לא מרוכז.
יש את זה.
ואז זה היה מדהים.
אוקיי, אז חשב על זה חתלתול בשעת הלילה מאוחר בעת ביצוע
החלטות אלה.
בסדר, אז חזרה למהנים יותר וחמורים פחות הדברים, כמו
תנאים.
>> בסדר, אז דברו בקצרה על אלה.
זה משהו שכנראה די מוכר מ
העולם של גרד.
ובעולם של גרד, יש לנו את הצורך הזה לפעמים
תלכו לעשות מזלגות בכביש.
או לעשות את זה או שזה או דבר אחר כאן.
וכאשר אנחנו רוצים לעשות את זה, אנחנו יכולים להשתמש בג עכשיו, זה אם
אחר לבנות.
והנה יש לנו ביטויים בוליאניים.
לדוגמה, ביטויים בוליאניים כאן, אנחנו יכולים או
אותם ביחד, במובן זה שיש לנו מצב זה או
תנאי זה.
אנחנו יכולים ואותם ביחד, במובן זה שאנו רוצים
לבדוק את המצב הזה וזה מצב.
וכאן יש לנו הצהרה לעבור עכשיו, וזה לא כל כך
דומה מבחינה תחבירית לסוג כזה של תנאים, אבל זה
מאפשר לנו לעשות את המקבילה של אם, אם אחרת, אם אחרת, אחרת
אם, וכמו על ידי פשוט ממספר אותם כל מקרה לגוף
בכל מקרה.
אז מי שראינו בפעם האחרונה.
ואז התחילו לגעת בדברים כמו לולאות.
ראינו אחד כזה רק לפני רגע.
אבל יש מבני looping אחרות אלה.
>> לדוגמה, זה שכאן.
אז בזמן (מצב), עושה את הדבר הזה שוב ושוב.
אז באופן בסיסי, מה שנראה שונה בין זה
ללולאה ולולאה בזמן זה כאן?
זה ללולאה והלולאה בזמן הזה.
כן?
מה זה?
קהל: [לא ברור].
הדוד י Malan: טוב.
אז בעוד שבמצב ללולאה, יש באופן ברור
יותר תחביר.
יש אתחול זה, יש עדכון זה.
בלולאה בזמן, יש רק מצב זה.
אז נראה שזה קצת קצץ את מול ל
לולאה, מה שאומר שאם אנחנו רוצים שנהיה לי משתנה ואנחנו רוצים
יש incrementation, אנחנו באמת צריכים
לעשות את הדבר הזה בעצמנו.
>> אז תן לי ללכת קדימה, לפתוח את gedit.
תן לי לעבור למכשיר.
ובואו נעשה דוגמה קטנה ומהירה ש
מבחין אחד מאלה מהצד השני.
ובחלק האחורי של המוח שלי כאן, אני צריך לומר דבר אחד.
אני דווקא הזכרתי את השם טים.
טים היה דווקא מישהו שתלמיד ניסה למצוא לעשות
שיעורי הבית שלהם בשבילם.
לא היו לנו טים באותו סעיף מסוים.
אז תבין, פן ייחשף תלמיד, זה לא היה סטודנט.
זה היה אדם מקרי באינטרנט עושה דברים
בשנה שעברה פרוקסי.
וכך אנו מוצאים גם את זה.
אז במקרה הזה כאן, תן לי ללכת קדימה ו
לפתוח את קובץ חדש.
קובץ, חדש.
זה נותן לי כרטיסייה כאן.
תן לי ללכת קדימה ולשמור אותו כloop.c.
תן לי ללכת ולחץ על שמור.
ואז כאן, בואו נלך קדימה ולהתחיל לכתוב
# כולל .
בואו להתקרב פנימה
עכשיו אנחנו נעשה int main (void).
עכשיו תן לי ללכת קדימה ולעשות עבור (אני int = 0; i <
הו, 10; אני + +).
ועכשיו אני הולך קדימה, וניתן להדפיס את הכוכב שאני
עשה קודם לכן.
ואז בסוף התכנית הזו, אנחנו רק הולכים
להדפיס שורה חדשה, רק כדי שהפקודה שלי
לא נראה כל מבולגן.
להחזיר 0.
נראה תחבירי נכון?
עד כה.
אז בואו נראה.
>> אז בואו להתרחק, לך לחלון המסוף שלי.
ותן לי להמשיך ולהפעיל את הלולאה, כי את זה קרא
loop.c. דבר
אז להפוך את הלולאה.
נראה לקמפל אישור.
תן לי לנהל את הלולאה, ועכשיו Enter.
ונראה שהוא מודפס 10 כוכבים.
אז בואו פשוט להמיר את זה ללולאה בזמן ולראות מה
מיני סוגיות שטיול הסתיים.
אז במקום זה, תן לי ללכת לכאן ואומר בזמן שאני הוא
פחות מ 10 -
תרשה לי להיפטר מלולאתי.
אוקיי, אז יש לנו כמה בעיות כבר.
אז המצב הוא אותו הדבר, אבל ברור שאני חסר
אתחול.
אני חסר incrementation.
אז מה צריך המהדר עשוי לומר לי כאשר אני מנסה
לקמפל תכנית זו?
כן?
קהל: [לא ברור].
>> הדוד י Malan: טוב.
אז זה הולך להגיד משהו כמו לא מוצהר - בזה
מקרה, משתנה i.
ואכן, שימוש במזהה לא המוצהרת.
ואז זה בניגוד לשפות כמו PHP ו
פייתון ורובי, עם שכמה מכם יכולים להיות מוכר,
שבו אתה יכול רק סוג של התחלת שימוש במשתנים
מכורח המציאות ולא צריך לדאוג להצהרה עליהם
תמיד במפורש.
ב C ובשפות כמו Java ו-C + +, אתה צריך להיות
סופר מפורש.
ואם אתה רוצה משתנה בשמי, שיש לך להגיד לי
איזה סוג של משתנה זה.
אז אנחנו הולכים לעשות כדי לתקן את זה באופן בא.
אני הולך צריך ללכת לכאן ולהקליד אני int, ולכן
אני הכרזתי על משתנה בשם i.
עכשיו, אני כבר דלגתי על שלב אחד.
אני כמובן לא כבר אותחלתי זה, אבל בוא נראה אם ​​כי ב
תחנת קלאנג לפחות גורם מתלוננת.
אז בואו לסדר לי תכנית זו.
>> בסדר, עכשיו זה רק מתלונן
מסיבה אחרת.
"משתנה 'אני' היא לא מאותחל בעת שימוש כאן." בסדר, אז
זה די ברור.
אותחל רק אומר שהגדיר אותו שווה לערך.
ואנחנו כבר לא עשינו את זה, אז תן לי לנסות שווה 0.
עכשיו בואו ננסה את זה שוב וקלאנג להפעיל מחדש.
מלוקט שלב זה.
ואני עומד להפעיל אותו.
אבל לולאה אינסופית ישנה וגדולה, כי מה שעשיתי
אתחול, מה שעשיתי את המצב, אבל אף פעם לא עשיתי
כל סוג של incrementation.
אז איך אני יכול לעשות incrementation?
ובכן, בלולאה בזמן, זה מרגיש כאילו אני הולך יש לי
כדי לעשות את זה בפנים של הלולאה, כי בדומה הראשון
דוגמאות של השבוע של עשייה בונה looping, כמו עם
את הגרביים ועם הספירה העצמית, שהיינו צריכים לעשות
משהו ממש בסוף, רוצה לחזור לשורה הבאה.
מה אם אני אלך ואעשה את זה אני + + כאן?
בואו אפילו לא לקמפל את זה.
תפוס אותי כבר.
מה לא בסדר כאן?
קהל: [לא ברור].
>> הדוד י Malan: אז זה בהחלט לא int.
זה אני.
וסוגריים המסולסלים, כמו קודם,
הכניסה היא לא מספיק.
אז עכשיו יש לי את זה לבנות.
אז בזמן שאני הוא פחות מ 10, הדפס כוכבים,
אז להגדיל אני.
והדרך בזמן עבודות לולאה היא שברגע שאתה מכה
תחתון של הלולאה, שבמקרה זה נראה כמו קו 10,
זה הולך לחזור לקו 6, ובשלב
מצב ייבדק שוב.
ואם אני עדיין פחות מ 10, אנחנו נעשה את הקווים 8 ו
אז 9, אז אנחנו פגענו 10, ולחזור ל6, שוב ו
שוב ושוב ושוב, כל עוד אני הוא פחות מ 10.
אז בואו להפעיל מחדש לעשות כאן.
>> אוקיי, צרף בסדר.
תן לי לולאה מחדש ריצה.
ועכשיו זה ממש נראה לעבודה.
אז יתרונות וחסרונות לכאן?
טוב, עד כה יש בעצם לא לגמרי של אש"ף -
כל כך חמוד.
בסדר, שהיה - אה, זה היה תאונה.
בסדר, אז בואו נחזור ללולאה.
אז עבור לולאות הם נחמדים כי הם סופר מפורשים.
ואף על פי שהם קצת מסורבלים לכתוב, זה
חזק מאוד, וזה מאפשר לך לעשות
דברים מרובים בבת אחת.
בעוד לולאות לא נראה שיש כמות עצומה של ערך רק
עדיין, כי זה מרגיש כאילו אנחנו רק צריכים לעשות את עבודה יותר.
אנחנו צריכים לשים את האתחול עד כאן,
תעדכן כאן למטה, ויש לנו לזכור לעשות את כל זה.
כך תוכל לראות בזמן שלולאות בעוד שלמעשה להלוות
את עצמם להקשרים שונים, רק נתונים שונים
מבנים כמו רשימות וטבלאות hash, דברים שאנחנו נגיע ל
אמצע סמסטר.
אבל לעת עתה, יודע שיש סוג שלישי זה ידוע כעשה
תוך לולאה.
ואנחנו רואים את זה בקצרה.
וזה עשוי להיות מועיל במיוחד עם 1 pset.
כל פעם שאתה רוצה לעשות משהו ולאחר מכן בדוק אם
המשתמש שתף פעולה, ואם הם לא, יעשו את זה שוב, עשה
תוך לולאה משאילה את עצמו לסוג כזה של היגיון.
כי כמו הזמנה מלמעלה עד למטה כאן מרמזת,
פשוטו כמשמעו, אין פירושו לעשות את זה.
ולעשות את זה שוב ושוב, מה זה יכול להיות?
אולי זה אומר שGetInt קורא או GetString ולאחר מכן
בודק את הערך של GetInt או GetString ולאחר מכן צעקות
במשתמש אם הם לא שתפו פעולה בכך ששאל אותם
שוב ושוב ושוב.
איפה אתה רוצה לעשות משהו פעם אחת,
ואז לבדוק איזה מצב.
>> אז בואו ננסה את זה.
תן לי למעשה לשנות את זה עכשיו לעשה תוך לולאה.
ואני מתכוון להמשיך ולבצע את הפעולות הבאות.
אז בצע את הפעולות הבאות.
בואו לעשות אני int = GetInt (); אבל בואו נגיד שהמשתמש הראשון
מה לעשות.
אז קצת שונה הפעם.
"תן לי int".
אז אני אשתמש printf בשביל זה.
ועכשיו אני הולך לרדת כאן, ואני הולך לעשות את זה
ואילו אני הוא, אניח, יותר מ -
בואו נראים, אני הוא, אניח, פחות מ 0, או אני הוא
יותר מ 10.
במילים אחרות, אני רוצה מספר בין 1 ל 9, רק
באופן שרירותי.
אז אני משתמש בביטוי בוליאני משולב לכאן
לוודא שהוא פחות מ 0 או גדול מ 10, שבו
מקרה שאני אעשה את זה לולאה לכאן שוב.
אז שוב, לעשות את זה -
ואילו אני הוא פחות מ 0 או i גדולות מ 10.
>> אז עכשיו בואו נלך ותעשה את זה ברגע שעשינו את זה.
בואו פשוט לעשות בדיקת שפיות מהירה.
printf ("תודה, אני הוא% d", i).
אז התכנית הפשוטה הזה שואל את המשתמש לint,
מוודא שזה בטווח מסוים 1 עד 9 ועד בכלל,
ואז מודה למשתמש על ידי הזכיר להם את מה שהם רק
הקליד ב, רק כבדיקת שפיות קטנה.
אבל בואו נראה אם ​​זה עובד כמתוכנן.
תן לי ללכת בראש לכאן ולהפעיל מחדש להפוך את הלולאה.
הממ.
"שימוש במזהה לא מוצהרת 'אני'". זה מוזר.
חשבתי שפתרנו את זה.
סימפטום זהה, אך קוד שונה.
כן?
קהל: [לא ברור] בתוך הימים, שאנחנו צריכים
[לא ברור].
>> הדוד י Malan: בדיוק.
אז זה בעצם מוביל אותנו לנושא הידוע כהיקפו.
מתברר שC, שוב, זה באמת לוקח אותך, פשוטו כמשמעו.
ואם אתה עושה משהו כמו זה שבו אתה מצהיר int
ולאחר מכן להקצות אותו ערך כלשהו, ​​אבל אתה עושה בתוך של
זוג סוגריים מסולסלים, מה C עושה זה מניח שאתה
רוצה את ביטי 32 ידועים כאני להתקיים בתוך רק
הקשר של הסוגריים המסולסלים האלה, בהקשר של קווים
6 עד 9. אז אני מכריז, ומיוחס לו
ערך בשורה 8, אבל ברגע שאתה מקבל מחוץ
קו 9 להלן הסד המתולתל, אני כבר לא ב
היקפו, אם אפשר לומר כך.
S-C-O-P-E. זה כבר לא בהקשר הנכון.
אז עכשיו אין לי, אז זה כאילו לא היה לנו אפילו
הכריז עליו בכלל.
>> אז מה לתקן אז למשהו כזה, אם
סיבה לכך היא שאני מוכרז בתוך הסוגריים המסולסלים, אשר
כנראה רע?
כאן?
קהל: [לא ברור].
הדוד י Malan: כן.
אז אנחנו יכולים לאתחל אותו בחוץ.
אז תן לי ללכת קדימה ולמחוק את החלקים שלפי ההצהרה
אני לציין את הסוג, ונתתי לי לעשות את זה כאן.
אז בשורה 5, זה עכשיו אומר "תן לי int." תקרא לזה אני.
שים לב בקו 9, אני לא רוצה לעשות את זה, כי אני
כבר יש לך את החלקים 32.
אני לא רוצה לשאול את המחשב ל
ביטים 32 שונים.
אני רוצה להשתמש באותם 32 הביטים האלה.
ועכשיו, בגלל שאני הצהרתי בקו 5, זה עדיין חוקי
כדי להשתמש בו בשורת 11 ו 12 קו.
>> אז תן לי לנסות להדר את זה ולראות
אם קלאנג מפסיק לצעוק.
להפוך את הלולאה.
אז עכשיו זה "הצהרה המרומזת של פונקציה
'GetInt' אינו חוקי בC99. "מה זה?
כן?
קהל: [לא ברור].
הדוד י Malan: כן.
אז עכשיו שאני בעצם משתמש GetInt, זה לא משהו
שרק מגיע עם C. זה מגיע מCS50.
אז אנחנו צריכים את זה כאן.
ותן לי לחזור לפקודה מטה
כאן ולהפעיל מחדש לעשות.
אוקיי, סוף הסוף.
עכשיו אנחנו כבר החלטנו וששגיאות אחרות.
תן לי עכשיו לרוץ לולאה ולראות מה קורה.
"תן לי int." אני אתן לו 11.
אני אתן לזה -1.
אני אתן לו foo.
אני אתן לו 5.
ועכשיו זה אכן עובד.
אבל ההנחיה השתנתה מסיבה כאן.
למה זה אומר לנסות שוב אחד מהזמנים האלה אבל תנו לי
int בשלוש פעמים האחרות?
למה היא התנהגות ששונה?
קהל: נתן אותו בחוט.
הדוד י Malan: סליחה?
קהל: אתה נתת לו חוט.
הדוד י Malan: כן.
אז נתתי אותו חוט בניסיון שלישי זה,
כאשר הקלדתי foo.
Foo הוא מחרוזת.
זה כמובן לא int.
ואופן שבו יישם CS50 GetInt הוא שאנחנו
לא לבדוק אם משהו לא פחות מ 0 או גדול מ 10
בשבילך, כי איך אנחנו יודעים מראש איזה סוג של
int שאתה רוצה?
אבל אנחנו יכולים לבדוק מינימאליים עבורך, האם לפחות המשתמש
הקלד מספר שלם?
ואם הם לא עשו זאת, אנחנו צועקים על המשתמש על ידי הקלדה "נסו שוב" על
המסך.
>> אז עכשיו יש לנו תכנית הלופים. אוקיי.
עכשיו, איזה מהם הוא סוג של המבנה הטוב יותר?
אז כאן דברים מתחילים לקבל קצת מבולגנת,
עובדה שאתה צריך לזכור כדי להצהיר על משתנה כאן
אם אתה רוצה להשתמש בו בתוך כמה
פלטות ומחוץ מתולתלות.
אבל גם אם זה נראה לא ברור מספיק בהתחלה
מבט, רק שוב, יזכור את ההיגיון הפשוט.
על מנת להשתמש בכל דבר ב-C, בין אם זה פונקציה או
זה משתנה, יש לך לכלול אותו אם זה פונקציה
בספרייה כלשהי, או שאתה צריך להצהיר על זה.
אבל עכשיו אתה צריך להיות זהיר, במיוחד לעובדה כי
אתה מצהיר על זה בהיקף הנכון.
אתה לא לשים אותו בחוזקה רבה מדי בתוך סוגריים.
>> אז תן לי בעצם לחזור.
אם אחזור לדוגמה שלנו מקודם, ואני הולך
בחזרה לint, int i = 0; אני <10: אני + +, ואני
לעשות כוכבי printf, כמו זה, ואז פארן קרוב, ועכשיו
printf הוא עכשיו -
על פי אותו ההיגיון, מה יקרה כאשר אני מנסה
לקמפל תכנית זו?
קהל: מזהה לא חוקי.
הדוד י Malan: אז זה עוד מזהה לא חוקית,
מזהה לא מוצהר.
עכשיו, הסיבה קצת שונה.
ודאי שאין כאן סוגריים מסולסלים, אבל באותה
רעיון, אותו הסיפור של היקף חל.
אם הצהרת על משתנה כמו שאני פנימי של
ללולאה, גם אם לא נכתב במפורש מתולתל
פלטות, חושבות עליהם כנפש עדיין להיות שם, שבו
מקרה אני נמצא בתוקף רק ללולאה.
זה לא חוקי ברגע שאתה מגיע לשורה הבאה, שב
מקרה זה הוא עכשיו 10.
אז רק כמה נושאים של היקף וכדומה.
בסדר, כל שאלה?
>> בסדר, אז זה סוג של תכנית טריוויאליים,
הדפסת כוכבים קטנים בלבד.
אבל בואו נראים אם אתה זוכר את השיר הזה כאן.
זה שיר מעצבן מאוד את הילדים היו שרים על
אוטובוס לבית הספר וכדומה.
אבל מה שיפה זה שיש לה מחזוריות זו,
לפי זה "99 בקבוקים של בירה על הקיר,
99 בקבוקי בירה.
קח אחד למטה, להעבירו ממקום, 98 בקבוקי בירה על
קיר. "ואז השיר חוזר על 97, אז 96, אז
95, אז 94, כל הדרך למטה עד 0 אם אתה באמת קבלת את זה
הרבה באוטובוס.
אז זה תכנית נחמדה למיין של מכשיר, בגללי
אלוהים, אם רק היית יכול ליישם את זה עם כמה
שורות של קוד, אתה יכול לירוק החוצה את המילים השלמות לזה
שיר די מהר.
אבל לאורך הדרך, אנחנו יכולים להתחיל עכשיו כדי להקניט מלבד כמה
של מבנים בסיסיים אלו לולייניות ועכשיו גם
להציג את הפונקציות שאנחנו כותבים את עצמנו, להחזיר ערכים
שאנחנו מעבירים ביניהם.
אבל קודם כל, למה אנחנו לא ללכת קדימה ולקחת חמש הדקות שלנו
לשבור כאן?
וכשנחזור, אנחנו נשיר את השיר הזה.
>> בסדר, אז אנחנו חוזרים.
וכשאני אומר אנחנו עכשיו נשיר את השיר הזה, אני מתכוון
תכנותי, לא באופן מילולי.
אז הנה יש לנו beer1.c, שהוא אחד מיישום זה
שיר מסוים.
ורק שיהיה ברור, למי שמכיר את מה
הדבר הזה נראה, תן לי ללכת קדימה
ולעשות beer1, Enter.
עכשיו תן לי לרוץ beer1, ומה שאנחנו נראה - כמה בקבוקים
בירה תהיה שם?
אני אקליד ב99, כמו שאומר השיר.
Enter.
ועכשיו אם אנחנו לגלול -
אופס - אם לגלול את כל זה, נראה כי
זה אכן היטיב לשיר את כל השיר.
חכה רגע.
פס הגלילה שלי קצת מבולגן.
בואו להשתמש בחלון הגדול יותר.
אז beer1, 99, יש לנו ללכת.
אז הנה יש לנו את כל שיר, שר הרבה יותר מהר על ידי
מחשב מאשר זה היה יכול להיות אצלנו.
אז זאת, הבחין, האופי המחזורי כאן.
זה אומר 99, אז 99, אז "לקחת את אחד, להעביר אותו
מסביב, "אז 98.
ועכשיו שהוא חוזר שוב ושוב.
>> אז זה בעצם הזדמנות מושלמת לסוג מסוים של
looping לבנות.
שים לב שאני סוג של חיתוך פינה כאן.
שים לב שאני אומר "98 בקבוקי בירה על הקיר,
97 בקבוקים של בירה על הקיר ", וכי היו פשוט כל כך
כי כשנגיע לאחד מבקבוקי בירה, אין לי
לדאוג דקדוק האנגלי.
אבל אנחנו גם יכולים לתקן את זה עם קצת אם
מצב, אולי.
אם מספר זה הוא מיוחד במינו, קדימה ואומר "בקבוק",
אחרת אם זה לשון רב, לומר "בקבוקים".
אבל לעת עתה, אני חותך את הפינה שלחלוטין.
אז בואו נראה מה יש לנו כאן.
אז יש לנו כמה הערות בראש.
אני כולל שתי ספריות אלה, כפי
אנחנו כבר נפוצים.
ועכשיו הרשו לי לגלול למטה כדי 1
קווים בפועל של קוד.
קו 17 בעיטות מחוץ ראשי.
21 קו 20 ויש כמה בקבוקים של בירה תהיה?
ואז אני מתקשר GetInt.
ועכשיו יש לי קצת ביקורת על שפיות.
>> אז זה כנס שעכשיו יתחילו לאימוץ
יותר קפדנות לבדוק הקלט של המשתמש.
לפעמים אתה פשוט לא רוצה להנחות אותם שוב
ושוב ושוב.
אם ברגי המשתמש ולא משתף פעולה, בסדר.
צא ופשוט לא להתמודד איתם.
ואז זה מה שאני עושה כאן.
אם n הוא פחות מ 1, אני רק הולך לצעוק על המשתמש,
"מצטער, זה לא הגיוני". ואז אני הולך
באופן שרירותי לחזור 1.
אז שוב, זה רק כנס כדי להתרגל.
לעת עתה, קח את זה באמונה.
אבל עד עכשיו, יש לנו תמיד חוזרים 0, משום
שאמרנו חוזר 0 מסמן מה?
קהל: הצלחה.
הדוד י Malan: הצלחה, זה הכל.
אז עכשיו שאנחנו סוף סוף מתחילים לחשוב על
אי - הצלחות -
במילים אחרות, במקרים פינתיים, מצבי שגיאה -
עכשיו יש לי אספקה ​​אינסופית, או לפחות 4000000000
דברים אפשריים שיכולים להשתבש בתוכניות שלי.
ואני יכול להתחיל בהענקתן מספרים בודדים.
עכשיו, בדרך כלל זה מספיק רק כדי לחזור
משהו אחר מאשר 0.
אז אנחנו הולכים פשוט לחזור 1 לעת עתה.
אבל הסיבה לחזרת 1 היא שברגע שאתה חוזר
1, נחש מה קורה לשאר התכנית?
הוא נעצר.
זה הכל.
לכן העובדה שאני מחזיר 1 היא ביעילות
קצר חשמלי ביצוע של התכנית הזאת, ש
שום דבר מתחת קו 27 ימשיך ביצוע.
ברגע שחוזר עיקרי, שהוא אותו.
>> בסדר, כך שאם המשתמש עושה תשתף פעולה ונגיע קו 30
משום שהם הקלידו במספר לגיטימי, כאן הוא שלי
ביצוע של השיר הזה.
אז אני מדפיס לראשונה תו שורה חדש, רק בשביל
אסתטיקה.
עכשיו יש לי ללולאה.
ושים לב שאני עושה את הדברים בקצת
מכיוון אחר.
אני לא צריך לעשות פחות מ, אני לא צריך לעשות + +.
אני יכול להגיד במקום לאתחל משתנה i, להגדיר אותו שווה
n, מספר משתמש הקליד ב, ואז לעשות את הפעולות הבאות, ולכן
כל עוד אני הוא גדול מ 0, אז אני -
לאחר שסיימת איטרציה אחת מהלולאה הזו.
אז אנחנו יכולים לספור את השימוש ללולאה גם כן.
עכשיו, זה די הרבה דברים בשבוע אחד עכשיו, עם printf.
אז "בקבוקי% d של בירה על הקיר". הדפסה הדפסה "% d
בקבוקי בירה. "" קח אחד למטה, להעבירו ממקום ". הדפסה
"בקבוקי% d של בירה על הקיר". אז זה עדיין ד%, אבל
שם לב שהטיעון לprintf משתנה.
אחרי הפסיק, יש לי שאני, בגלל שאני רוצה להגיד 99.
אחרי פסיק זה, יש לי שאני, בגלל שאני רוצה להגיד 99.
אחרי פסיק זה, יש לי i - 1, משום שאני רוצה לומר ב98
איטרציה זו ראשונה, וכן הלאה.
ועכשיו לכאן, יש לי רק איזו הערה קטנה וטיפשית.
ואז קו 42, אני חוזר 0 באמצעות אמנה, מסמן שיש
הכל בסדר.
>> אז מה אם אני פשלתי?
מה יכול להיות כאן טעות נפוצה?
ובכן, מה אם אמרתי בטעות גם, אני רוצה לספור
עד 0, 0 אני רוצה בקבוקים של בירה על הקיר?
אז אני אומר, אני הוא גדול או שווה ל 0.
מה הולך להיות הסימפטום שאני עכשיו לראות אם אני הדר
beer1 ולהפעיל אותו?
קהל: שלילי.
הדוד י Malan: כן, זה הולך להיות שלילי.
זו שגיאה מ, על ידי אחד, מאוד
טעות נפוצה לעשות.
בואו באמת נחזור לחלון המסוף ולעשות את זה
כאן, כדי שנוכל לראות יותר בכל פעם.
הזן, 99 בקבוקי בירה.
סגור, אבל אנחנו הלכנו מעט שבמעט רחוקים מדי.
שרנו השיר עמוק מדי, כזאת שאנחנו עכשיו פגענו
מספר שלילי.
אז זה לא ממש עובד.
>> בסדר, אז אנחנו יכולים בקלות לתקן את זה על ידי חזרה ל
כמו שהיא הייתה.
אבל מה הן כמה הזדמנויות עכשיו
שיפור?
ובכן, הרשה לי לפתוח וbeer2.c לגלול למטה כאן ולקחת
להסתכל על גרסה זו.
מה הדבר הראשון שקופץ לך כשונים
בגרסה זו כאן?
קהל: [לא ברור].
דוד י Malan: כן, אז אני לא יותר, כי זה עלה בדעה
אתה יודע מה, אני שואל את המשתמש עבור n, ואז אני
הגדרה אני שווה ל-n, ואז אני משנה לי, אבל אני לא
נגיעת n שוב.
אז מה לעזאזל הייתה הנקודה שלך הקצאה נוספת 32
ביטים נקראים אני פשוט כל כך שאני יכול לקבל משתנה אחרת?
אז במקרה הזה, אני סוג של הכרה שמיותרת
תכונת עיצוב.
ועכשיו אני הולכת להגיד בעוד n הוא גדול מ 0, עבור
קדימה ולהדפיס את אותו שיר, עובר לn printf כ
טענה שנייה, וn - 1 כטענה השנייה כאן למטה.
ולאחר מכן בכל איטרציה של לולאה זה, קדימה ופשוט
הפחת n עצמו.
עכשיו, מבחינה תפקודית, תכנית זו
הולך להיות זהה.
אם אני מקליד ב99, n מתחיל ב 99.
אני decrement, הפחתה ב, הפחתה ב, הפחתה ב.
אני הולך לקבל את כל הדרך למטה עד "בבקבוק אחד של בירה על
הקיר, בקבוק אחד של בירה.
קח אחד למטה, להעבירו ממקום.
0 בקבוקים של בירה על הקיר ". הסוף, כי אני עשיתי
לקבל את המצב נכון.
זה גדול מ 0.
אני לא עושה את הטעות הזאת.
>> אז מה עדיף, גרסה אחת או גרסה 2?
אז שמעתי חבורה של מלמולים לשתיים.
למה שתיים?
מה זה?
קהל: [לא ברור].
הדוד י Malan: אה, אוקיי.
אז זה לא ילך מתחת 0, אך יש לזכור, בגרסה אחת,
גרסה נכונה מקורית לא ללכת מתחת 0 או.
אז לזכור שזו הגרסה הנכונה.
אז בוא לפחות להשוות בין שתי גרסות הנכונות.
מה נימוק לגרסה
2 להיות, מממ, טוב יותר?
כן?
קהל: היא משתמשת בפחות מקום.
הדוד י Malan: אוקיי, אז הוא משתמש בפחות מקום, נכון?
הואיל ואחד המשמש גרסה 32 סיביים עבור n, ואז עוד
32 הביטים ל.
גרסת 32 סיבית 2 משתמשת רק עבור n, כך ש
נראה שיש בתוספת.
מחשבות אחרות?
האם מישהו רוצה לטעון לטובה אחד?
כן?
קהל: אתה צריך להשתמש בקו נוסף של קוד עבור n -.
>> הדוד י Malan: אוקיי, בטוח.
אז זה הוגן.
אז זה פשוט, לפחות לי -
אני מתכוון, זה באמת מרגיש קצת מבולגן, העובדה ש
אני לא יכול כאילו לתמצת את כל ההיגיון שלי באחד
שורה יפה, ללולאה, כללולאה יכולה.
הנה, אני סוג של צריך טקטיקה על n זה -
בסוף הלולאה, כי
זה הגיוני הכרחי.
אבל זה סוג של משפשף אותי בצורה לא הנכונה, רק בגלל שזה
נראה נפרד מהתפישה של עד כאן, למרות,
שוב, זה הכרחי.
מחשבות אחרות?
כן?
קהל: [לא ברור].
>> הדוד י Malan: כן.
אז מה אם במקום זאת, בסופו של השיר, רצה
להדפיס שוב את שמו של השיר?
כמו "תודה ששחק 99 בקבוקי הבירה", או משהו כזה
כזאת מטומטמת?
אבל נקודה היא, שרצית גישה לערך המקורי.
העובדה שאתה מוטציה או שינית n בכל
איטרציה ולכן הרסה את ערכו המקורי
המשמעות הוא שאתה פשוט לא יכול לעשות את זה בסוף.
כעת, ללא ספק, ברור לנו לא רוצים לעשות
כי בתכנית זו.
אז למי אכפת?
אבל זה נקודה מאוד תקפה.
ואם להיות כן, אין באמת אף אחד
זכות לענות כאן.
הם שניהם באותה מידה נכונות.
אני יכול להיות משוכנע בכל מקרה.
אני אומר את זה, באופן כללי, זה עיקרון טוב אם אתה
שאלתי את המשתמש לערך מסוים ואתה מאוחסן במשתנה
כמו n, רק קצת בעיקרון, זה כנראה טוב
כדי לשמור שמסביב.
וכל נתונים שאתה רוצה להשתנות שוב ושוב, רק
לתת לעצמך עותק של אותו משתנה, רק כדי שאתה
יש גישה למקור.
אתה מבלה 32 עוד חתיכות, אבל המציאות היא זו
מחשב, כמו, שתי ג'יגה בייט של זכרון RAM בימים אלה,
ואנחנו quibbling מעל 32 סיביים?
ממש לא כזה ביג דיל.
וגם על המכשיר הזה כאן, עם חצי חלטורה או
תיגה של זכרון RAM, 32 סיביים לעומת 64 סיביים,
לא כזה ביג דיל.
אין ספק שהיום, זה הולך להיות הדרך המומה הגודל
של התכנית עוצמה, שהולך להיות כמה מאה
קילובייט, אם לא כמה מגה, בימים אלה.
>> חששות סבירים, אז תשובה הנכונה אף אחד.
אבל לפחות אלה הם מחשבות שצריכים להתחיל
לעבור את דעתך?
מכיוון בpset 0, למרות שאנחנו באמת צפויים רק
נכונותו, או לפחות ויתור באגים שונים ש
ייתכן שנתקלת, ככל שאנחנו מתקדמים, עיצוב הוא
הולך להיות עוד היבט מרכזי, הן של כתיבת קוד
וגם שלנו הערכת קוד.
וכך לפחות חשבתי לתת לדברים כאלה.
ורק בגלל שמשהו עובד לא אומר שזה טוב,
זה לא אומר שזה תוכנן היטב.
וזה אחד מהדברים שהחברים להוראה ו
סטי בעיה יעזרו לנו להקניט חלק לאורך זמן.
>> ובכן, מה עם, יניח, גרסה זו כאן?
תן לי לעשות משהו קצת סקסי כאן ברגע.
ראשית הרשה לי להיפטר מזה לי.
ועכשיו בואו ולתקן בעיה זו דקדוקית.
אז בגרסה זו, אני רוצה לתקן את הדקדוק כך ש,
ולא רק לומר של סוגריים, כמו "בקבוק"
או "בקבוקים" -
אני לא רוצה לחתוך את הפינה הזו -
אני גם רוצה באופן דינמי כדי להדפיס את המילה "בקבוקים"
או "בקבוק", ובכך להשתמש במצייני המיקום של% אלה היום.
אז אני צריך תנאי כדי לבדוק מהו הערך של i.
ואם זה 1, אני רוצה להגיד "בקבוק", ואם זה משהו
דבר אחר, אני רוצה לומר "בקבוקים". אז בואו ננסה לעשות את זה.
אז אם אני == 1, אז תן לי ללכת קדימה ולהכריז -
אני זקוק למחרוזת, אז תן לי לעשות את המחרוזת s1, כי זה
המחרוזת הראשונה שמטריד אותי עכשיו.
אני הולך לומר "בקבוק". ואז, בואו נראים, מחרוזת
s2 - ואני אסביר לאן אני הולך ברגע -
"בקבוקים". אז תזכור, כי בשיר הזה, אנחנו צריכים להיות מסוגלים
להדפיס דברים, שתי מילים שונות באופן פוטנציאלי.
אז אם אנחנו מסתכלים אחורה כאן, שימו לב שכאשר אנחנו מגיעים ל
זו דוגמה כאן, "שני בקבוקים של בירה על הקיר,
שני בקבוקי בירה, להוריד אחד, להעביר אותו סביב ", אני רוצה
השורה הרביעית זה עכשיו אומר "בקבוק אחד של בירה על
קיר ". אז אני צריך להחליט, האם אני רוצה לומר" בקבוקים "או
"בקבוק"? אז אני הולך לומר באופן שרירותי, בסדר,
אני הולך עכשיו להכריז נקרא s1, מחרוזת משתנית
אחד, שהולך להיות יותר מחוברות לכאן וגם כאן,
בגלל המילים האלה הן תמיד זהות, רק בגלל
טבעו של השיר.
ואני הולך לקרוא s2 מה מילה שאני רוצה
סופו של דבר מופיע כאן למטה.
עכשיו, פשוטו כמשמעו, 99 פעמים מתוך 100, זה הולכים להיות
אותו דבר בשני המקרים האלה, כי 3 הם ברבים, 2 הם
ברבים, 4 הם לשון רבה.
אבל במקרה של פינה זו, שבו אנחנו מקבלים עד 2 ואז 1, או
אפילו 1 ואז 0, אני זקוק להיגיון הזה.
אז יש לי לבלות קצת זמן בקוד שלי מקבל את זה נכון.
אז אם אני עושה את זה, אם אני == 1, אז s1 השווה ל" בקבוק "שנקבע
וs2 שווה "בקבוקים", כי זה יהיה עבור 1
בקבוק, וזה יהיה עבור 0 בקבוקים.
וזה כאן, מה זה מייצג?
רק שיהיה ברור.
זוהי רק תגובה.
לכן העובדה שאתה יכול לקבל הערות של שורה אחת אומרת שאתה
יכול להעיר את הקוד שלך ככה, אבל אחר נפוץ
הפרדיגמה גם היא שאם יש לך משפט קצר שסופר
אתה רוצה לשים את עצמך וזה פשוט קריא יותר לשים
זה ממש בסוף של שורת הקוד, אתה יכול
בהחלט לעשות משהו כזה.
>> אז עכשיו מה אם אני עושה את זה? אחר אם אני לא שווה ל 1.
אז מפץ שווה -
סימן קריאה המכונה "מפץ".
אז מפץ = 1.
אז אם אני לא שווה ל 1, מה אני רוצה לעשות במקום?
ובכן, המילה הראשונה שאני רוצה להיות מה?
אז מחרוזת 1 צריכה להיות "בקבוקים" לבקבוקים רבים,
ואז זה יהיה רב "בקבוקים", כמו גם, לעת עתה.
ונראים אם זה באמת מביא אותנו ל
לאן אנחנו רוצים ללכת.
אז עכשיו אם אני לגלול למטה כאן, שים לב שאני חיבור
לא רק אני, אלא S1.
אני חיבור i ו s1.
ואז כאן, אני פחות 1, שזה אותו הדבר כמו
בעבר, אבל s2.
במילים אחרות, אני רוצה את המילה האנגליה לשינוי הבסיס
על ההיגיון הזה.
עכשיו, יש כבר כמה בעיות בקוד זה.
מה שנשבר כבר מחוץ לשער כאן?
כן?
קהל: [לא ברור].
>> הדוד י Malan: בדיוק.
אז אני כבר הפרתי את הלקח של היקף.
אז אני כבר הכרזתי S1 ו S2, אבל אני כבר עשיתי את זה בתוך
סוגריים מסולסלים, מה שאומר, כן, את הקוד הזה יעבוד עד
עד קו 42, אבל ברגע שפגעתי בקו 43, נחש מה לא
כבר לא קיים?
ובכן, נחש מה כבר לא בהיקפו - לא s1 או s2.
אז אנחנו צריכים לתקן את זה.
אז בואו ימחקו לי את ההצהרות.
ואני אשאיר את שמות משתנים ולמחוק את זה כאן
ולמחוק את זה כאן.
ובאיזה קווים צריך להצהיר שאני באמת את הדברים האלה?
קהל: [לא ברור].
הדוד י Malan: כן, אז כנראה
ממש עד כאן, 33-ish.
אז s1 מחרוזת ולאחר מכן מחרוזת s2.
ומתברר, שאני יכול לעשות את זה.
אם אתה מצהיר על שתי משתנה מאותו הסוג,
אתה בעצם יכול פשוט להשתמש בפסיק ולעשות את זה בכל ג
נכון, אז עכשיו יש לי שני משתנים -
S1 ו S2.
אני מקצה להם ערכים באלה
תנאים כאן, או כאן.
ואז אני משתמש בם למטה.
כמה טוב שעכשיו זה הולך לעבוד?
>> טוב, זה עדיין עגלה קטנה, אבל בוא לפחות לראות
כמה רחוק שכבר התחיל.
אז תן לי ללכת קדימה ולעשות beer3.
האם זה beer3?
כן, זאת beer3.
ועכשיו תן לי ללכת קדימה ולהפעיל beer3.
399 99.
אנחנו כנראה יכולים לדלג על רובם.
וכאן למטה, תראה את זה.
"בקבוק אחד של בירה על הקיר, בקבוק אחד של בירה, לקחת
אחד למטה, להעביר אותו בסביבה, 0 בקבוקי בירה על הקיר ".
אבל אני מפנה את תשומת הלב לרק חצי מהפתרון.
סוג של פשל כאן.
לכן נראה כי במקרים הפינתיים מתעוררים כאשר אני שווה מה
שני ערכים?
קהל: 2, 1.
הדוד י Malan: 2 ו 1.
זה לא 1 ולא 1.
זה באמת רק שני הבתים האחרונים של השיר הזה.
אז מה אני רוצה לעשות במקום?
אז נראה שתפס את המקרה שבו אם אני הוא == ל 1,
אז המילה הראשונה היא "בקבוק", אך המילה השנייה
הוא "בקבוקים". אבל כאן, אני רוצה לשנות את זה כדי להיות == 2.
ואם זה מקרה, מה שאני רוצה
המילה הראשונה להיות?
קהל: "בקבוקים".
הדוד י Malan: "בקבוקים", כך לשני בקבוקים.
ואז המילה הזאת כאן צריכה להיות -
קהל: "בקבוק".
הדוד י Malan: "בקבוק", מיוחד.
>> בסדר, בואו להתרחק, לחזור לכאן, הרץ מחדש לעשות,
להפעיל מחדש beer3, סוג 99 שוב.
אוקיי, "אשמת פילוח (ליבה זרקה)."
מה עשה לא בסדר?
קהל: אין לך ערך [לא ברור].
הדוד י Malan: אה נקודה, מצוינת.
בסדר, אז מה לא בסדר כאן?
אז אשמת פילוח, ואנחנו ממש הולכים לראות
לא מעט פעמים בעתיד, במתכוון.
אבל לעת עתה, מה זה בעצם אומר?
אשמת פילוח כמעט תמיד אומרת שיש לך
ניסיתי איכשהו לגשת לזיכרון, זכרון RAM במחשב שלך,
שלא שייך לך, כי אתה לא באמת שאלת
מערכת הפעלה עבור.
לכן, במקרה זה, שים לב למה שעשיתי, שהוא
פגום בהיגיון שלי.
אני הקציתי S1 ו S2 ערך אם אני שווה 1.
גם אני עשיתי את זה אם אני שווה 2.
אבל אני לא עשיתי את זה במספר האינסופי של השני
אפשרויות -
בפרט, 3 או 4 או נקודה, נקודה, נקודה, 99.
אז תיקון אחת לכך יכול להיות רק בואו
יש מצב אחר.
ותנו לי ללכת לכאן ואומר s1 שווה -
מה זה צריך להיות כאן?
קהל: [לא ברור].
>> הדוד י Malan: "בקבוקים", כי במקרה הנפוץ,
זה פשוט אותו הדבר.
אז שווי ציטוט, סוף הציטוט, "בקבוקים". אז לרבים
בקבוקים, ולאחר מכן עד לכאן, לבקבוקים רבים.
אוקיי, אז עכשיו תן לי לחזור לחלון המסוף שלי,
קומפילציה, הרץ מחדש את זה.
99.
ואווה.
ובואו לעשות בדיקת שפיות מהירה.
מבחינה טכנית, הייתי רוצה לקרוא את כל אלה כדי לוודא
הם נכונים, אבל בואו יסתכלו על
לפחות את הפושעים הידועים.
3 בקבוקים, 2 בקבוקים, 2 בקבוקים, 1
בקבוק, בקבוק 1, 0 בקבוקים.
אנחנו נראים לפחות שתקנו את זה לעת עתה.
אבל לתפוס כאן הוא שאיזה בלגן נורא אל זה
רק כדי לפתור טיפש
תווי פרט אחד דקדוקית.
אז יש מין סיבה שאני חותך הפינה הזאת
מוקדם יותר, כי זה פשוט מעצבן לחלוטין לצריך
לכתוב הרבה קוד זה.
אבל מתברר שיש דרכים קצת יותר אלגנטיות של
מבטא את אותו דבר בדיוק.
ואנחנו יכולים לעשות זאת באופן הבא.
>> בואו יעזבו אותי זה על המסך לרגע ו
להציג משהו ידוע כמפעיל משולש.
זה סוג של קו תוחם אחד שפשוט נועד להופכנו
חי סקסי קטנה, כפי שהובטח.
ואני הולך לעשות את זה באופן בא.
תן לי את מחרוזת בשם s1, ונתת לי
להקצות אותו באופן בא.
(I == 1)?
"בקבוק", אחרת "בקבוקים". מחרוזת s2 מקבלת (i == 2)?
"בקבוק", אחרת "בקבוקים".
ואז מה ההבדל כאן?
שני קווים אלה של קוד, אני טוענים, יכול
להחליף את כל הבלגן הזה.
אז אני קורא לזה בלגן, רק בגלל שזה סוג של משפשף אותי
הדרך הלא נכונה שזה כל כך הרבה שורות של קוד.
לא טעה.
זה לא עיצוב רע.
אוהב, זה בהחלט נכון ובסדר גמור.
אבל הקידוד מייגע אם יש לך להביע את עצמך כל כך
לעזאזל דווקא שוב ושוב ושוב בצורה פשוטה
תרחיש כזה.
אז C יש כמה קיצורי דרך, כמו זה.
אז זה בעצם אומר להכריז מחרוזת s1 וקראה
להקצות אותו, או שזה ערך או ערך זה אם אני הוא == -
מצטער, אני צריך להגיד את זה בצורה ברורה יותר.
להכריז על s1 משתנה, להקצות את הערך הזה, אם זה נכון.
אחרת, להקצות את הערך הזה.
אז במילים אחרות, זה סוג של דרך קו אחד
אם אומר דבר אחר, אבל עושה משימה לאורך הדרך.
אז אם אני הוא 1, אז קדימה וקורא "הבקבוק" הזה. ו -
אז זה דבר אחר, קורא לזה "בקבוקים". בינתיים, s2,
מילה שנייה שאנחנו צריכים להגדיר, אם אני שווה 2, אהיה
להגדיר s2 ל" בקבוק ". אחרת, קובע "בקבוקים". ומה
זה אומר כרגע הוא שאני יכול לעבור את זה ולמחוק את כל
קווים אלה של קוד.
וכאשר אני אומר, קצת מגוחך, שזה עתה
סקסי, זה סקסי בסוג של תחושה סגנונית.
העובדה שתפקודית, קוד זה הוא למעשה הולך
לעשות את אותו דבר בדיוק.
ולמרות שזה עשוי להיראות סתום מעט בהתחלה
מבט אחד, מפני שלא ראו את זה לבנות לפני, הייתי
טוען שסופו של דבר הולך להיות כל כך הרבה יותר
קריא ולכן הרבה יותר קל לנו, בני האדם כדי למיין של
להבין, כי עכשיו אתה יכול פשוט לקרוא
קוד כולו בשורה אחת.
זה עדיין דומה ברוח אם, שבו זה
המצב ואז זה מה שבפנים ואם זה
הוא מה שבפנים אחר.
אבל אנחנו יכולים לעשות את זה פשוט הרבה יותר באלגנטיות.
>> ואם אני עכשיו חוזר למסוף שלי, לאחר שמחק את כל
את השורות האלה והחליפה אותם רק עם שני אלה,
קומפילציה, בקבוקים להפעיל מחדש של בירה עם 99, שהודעה שלי
דקדוק הוא, למעשה, עדיין נכון.
אז שוב, משהו להתחיל בו.
2 בקבוקי בירה, בקבוק 1 של בירה.
נראה נכון.
כן.
אז יש לנו את פתרון תמציתי הרבה יותר.
אז גם את זה, כמו שאתה מקבל יותר בנוח עם C, לא
בהכרח עם pset הראשון או אפילו שני, אבל
להבין כי מבנים אלה יכולים לאפשר לנו לעשות דברים שאי פעם
יותר באלגנטיות.
עכשיו בואו לעשות דבר אחד אחר כאן.
תן לי ללכת קדימה, לפתוח את return1.c.
עכשיו בואו נתחיל לפתור בעיה אחרת באופן ש
מאפשר לנו לכתוב קוד מתוחכם יותר.
>> אז הנה תכנית קטנה ופשוטה שמטרה שלו בחיים
הוא להגדיל ערכים.
ובאמת, בואו ניקח צעד אחורה.
תן לי לעשות זאת באופן ידני.
תן לי לעשות וכולל int ראשי (ריק).
ותנו לי להתקשר increment.c זה.
ומה שאני רוצה לעשות?
אני הולך קדימה, ואומר משהו כמו -
יהיו אנו קוראים את מספריו -
x int.
אז x int מקבל 2; x printf הוא% d, קו חדש, x.
אז אני מקליד מהר, אבל מסוג הזה מוכר כעת.
ואז אני הולך לעשות x + +.
ואז אני הולך להדפיס אותו המשפט שוב.
ואז אני הולך להחזיר 0 רק כדי לצאת מהתכנית.
בסדר, אז זה הוא תכנית ה
מרווחים של מספר.
זה הולך ראשון לאתחל משהו 2, ואז זה
הולך להגדיל אותו ולהדפיס אותו שוב.
>> אז בואו לרוץ תוספת, תכנית פשוטה להפליא.
אבל תניח עכשיו שאני רוצה קוביית הערך, כדי לעשות
משהו שרירותי.
ואני באמת רוצה לעשות x מקבל את הקובייה שלו.
אז אני יכול להשתמש במה שקרא לפונקצית השבויים, אבל אני לא
באמת יודע איפה זה עדיין.
אז אני הולך לעשות את זה בדרך הישנה.
x פעמים זה שווה x פעמי x פעמים x.
אז אני עוקב הערך, הכפיל אותו בעצמו שוב
ושוב ושוב, כך שאנו מקבלים את הכח
מתוך 3 במקרה זה.
אז עכשיו אני צריך את המספרים מודפסים צריכים להיות, כפי שנראים
כאן - להפוך את תוספת, כך שזה בעצם לא ממש להגדיל
יותר, אבל אנחנו משאירים את השם בלבד -
2 ואז 8.
עכשיו, יש לנו את ראשיתה של הזדמנות לחידוד
כאן, לפיה דבר עקוב הזה של הכפלת מספר
בעצמו בעצמו בעצמו מרגיש כמו זה יכול להיות רק
שימושי יש כפונקציה, כמו שמישהו החליט
לפני שנים - אתם יודעים, מסוג שימושי אם אחד מאיתנו מתיישב
וכותב printf כך ששאר העולם יכול להשתמש בו,
למה אנחנו לא לשבת ולכתוב פונקציה שנקראת קובייה
שעושה את זה בשבילנו עקוב כך שאנחנו לא צריכים באופן ידני
ליישם את הרעיון של ערכים עקבו כאן?
>> אז דוגמה פשוטה, אבל בואו נלך קדימה ולהשתמש בזה כ
ההזדמנות לכתוב הפונקציה שלנו.
אז עד כה, יש לנו בשימוש רק ראשי, ואנחנו כבר בשימוש אחר
הפונקציות של אנשים, אבל אנחנו לא כתבנו משלנו.
אז הנה זה בא.
אני הולך להמשיך ולכתוב פונקציה שנקראת קובייה.
ואני הולך לה לקחת קלט.
אז הקלט שלה הולך להיות מספר שלם.
ומה זה יעשה?
זה הולך להכריז פלט int = פעמי קלט קלט
פעמי קלט.
ואז זה הולך לחזור פלט.
ואז אני צריך להיות ספציפי כרגע.
פונקציה זו הולכת להחזיר int.
הנה אפוא כמה היית לכתוב פונקציות משלך.
אתם תחליטו תחילה מה השם שלך
הפונקציה הולכת להיות.
ובאופן כללי, משהו הסבר טוב, אז אני
קוראים לזה קובייה.
ואז אתה צריך לציין מה זה הולך לחזור, מה
הפלט שלה הולך להיות.
ואין לנו אפשרויות רבות שעדיין.
Int, char, float, bool, מחרוזת.
לעת עתה, אני הולך להישאר עם int, כי אני רוצה את זה
כדי להחזיר מספר שלם.
ואז אתה צריך לציין מה התשומות שלה, אם בכלל, הם.
ואם לוקחת קוביית ויכוח, לוקח משהו בין
סוגריים, יש לך לתת לטענה ששם כך
אפשר לקרוא לזה משהו כמו שאתה מיישם או כתיבה
פונקציה זו, ואתה צריך לתת לו סוג, אשר בזה
המקרה הולך להיות int.
אז בקיצור, קובייה היא פונקציה שלוקחת מספר שלם
כקלט ומחזיר מספר שלם כפלט.
>> אז מה הוא עושה עם זה קלט?
ובכן, בקו 14, אני מצהיר תפוקה משתנית בשם, ואני
להקצות לו את הערך, פעמי קלט קלט פעמי קלט.
ואז אני חוזר פלט.
אז איך אני יכול להשתמש בזה אז?
מה אני יכול לשנות את התווים מודגשים אלה על קו
7 להיות, לדעתך?
קהל: [לא ברור].
הדוד י Malan: כן, אז קובייה של x.
אז x הוא משתנה, מה שאומר שהיא מחזיקה איזה שהוא ערך.
למרבה המזל, זה של שלם סוג.
וכי x הוא int, זה אומר שאני יכול להעביר אותו לקובייה.
ולמרות שאני מבטל את הערך של x עם הערך
של x קובייה, כפי שהיה המקרה עד כה, בכל פעם שאתה
יש סימן שוויון ושורת הקוד, חומר בצד הימין
מקבל להורג ולאחר מכן מקבל הוקצתה
ערך בצד השמאל.
אז סדר פעולות הוא כפי שהיינו מקווה.
אז זה עובד?
ובכן, הרשה לי לרדת לכאן.
תן לי לפתוח את חלון מסופי שלי.
תן לי עושים תוספת, לחץ על Enter.
"הצהרה המרומזת של 'הקובייה' הפונקציה אינה חוקית ב
C99. "במאמר מוסגר, C99 מתייחס לשפת C כמו שזה היה
הוגדר בשנת 1999, שהיה עדכון על הגרסה מ
שינה 1989, אשר היא עדכון על מקורי.
אז זה כל מה שאומר.
>> אז מה זה אומר כי "הצהרה המרומזת של
'הקובייה' הפונקציה אינה חוקית? "זה ממש כאן.
זה ממש שם בקו 12.
קהל: [לא ברור].
הדוד י Malan: מה זה?
קהל: זה לא לפני.
הדוד י Malan: זה לא לפני.
אז זה דבר.
C היא סוג של טיפשים, או מהדרי C הם סוג של טיפשים.
הם באמת עושים רק מה שאומרים להם לעשות.
והם, בפרט, לקרוא את הקוד שלך רק למעלה עד למטה,
משמאל לימין.
אז אם המהדר, קלאנג, הוא קורא את הקוד שלך, קו 1, אותו
מוצא דרך לעשות את זה.
הו, הנה מגיע עיקרי.
אוקיי, תן ​​לי ללכת קדימה ולהכריז משתנה.
בואו להדפיס לי משהו.
קו 7, מה לעזאזל הוא קובייה?
זה לא הוכרז בstdio.h.
זה לא מגיע עם ג אין לי מושג מה לעשות.
וכך קלאנג רק bails ונסגר עם שהודעת השגיאה.
אז אנחנו יכולים לתקן את זה בכמה דרכים.
אנחנו יכולים ללמד את קלאנג מה קובייה היא רק על ידי ההזזה בי
הכרזה היא.
אז לגזור ולהדביק אותו על גבי ראשי.
עכשיו מבין שרק בגלל שעיקרי הוא כבר לא ראשון, זה
עדיין להורג כברירת מחדל.
העיקרי הוא ראשי.
זה הפונקציה בשם ברירת המחדל.
זה לא משנה איפה זה בקובץ.
אבל לפחות עכשיו קלאנג ראה קובייה לפני שאני משתמש בו.
אז בואו לראות אם קלאנג הוא יותר מאושר עכשיו.
הפוך תוספת, זה לא לקמפל שלב זה.
>> תן לי לנהל את תוספת.
ואכן, נראה שזה עובד.
עכשיו, אתה יכול לבוא עם תרחישי סופו של דבר שבו
זה לא ריאלי לשים את כל פונקציה
מעל כל תפקיד אחר.
אתה נתקע בלולאה אינסופית זה במציאות,
איפה הבחור הזה רוצה להיות כאן, אבל זה
בחור צריך להיות שם.
אז זה לא תמיד עובד.
אז לשמחתי, C יש פתרון אלגנטי יותר.
אני הולך להחזיר את זה שבו היה, רק בגלל שאני
מעדיף, כעניין שבעיקרון, שתמיד יהיה עיקרי
בחלק העליון, כי זה פשוט נחמד לראות מה זה תכנית
עושה כברירת מחדל.
ומה אני הולך לעשות כאן הוא מצהיר מה שנקרא
אב טיפוס.
אני מתכוון לחזור להכריז פונקצית קובייתי, פשוטו כמשמעו, על ידי
העתקה והדבקה.
למעשה, זה לא ממש.
אז ממש העתקה והדבקה של קו 15
מעל הקו 6.
זה לא משנה מה הקו הזה מסתיים ב.
זה קורה להיות על קו 4.
אבל זה צריך להיות לפני ראשי.
אבל תבחין בהבדל.
קו 4 מסתיים בנקודת פסיק, מה שאומר היי,
קלאנג, יסמוך על המילה שלי בשביל זה כי קיימת פונקציה
שם קובייה שלוקחת int ומחזיר int.
אבל אני לא הולך להגיד לך מה זה בכלל.
רק יודע שאני מבטיח לספר לך בסוף.
ואכן, עכשיו זה בסדר כי זה למטה.
>> אז זה בדרך כלל טוב יותר, כי אז בראש
הקובץ שלך, אתה יכול פשוט לזרוק את, מהירה אש, שורה אחת
כל אחד, מה השמות של הפונקציות שלך, מהם
תשומות הן, מה התפוקות שלהם.
וכדי להיות ברור יותר, קלט בדרך כלל אומר שטיעון או
פרמטר, מילים נרדף.
פלט משמעות ערך החזרה, מה זה
יד חזרה אליי.
אז במקרה הזה כאן, קובייה הוכרזה בחלק העליון, אבל
מוגדר, הידוע גם יישם, בתחתית.
אז עכשיו בואו נחזור לכאן ולהפעיל מחדש את זה.
אז עכשיו תן לי להמשיך ולהפעיל מחדש לעשות, תוספת להפעיל מחדש.
ועכשיו נראה שזה עובד בסדר גמור.
אז עכשיו אנחנו יכולים ללכת קדימה וגורמים משהו כמו
בירת דוגמה לגרסה הרביעית זו.
אז בואו לגלול למטה כאן.
ושים לב שאפשר לומר שהייתי שיעור זה ללב רק עכשיו.
העובדה שאני שר אותו הבית שוב ו
שוב ושוב, באותה שורת מקהלה בשיר, הרגישה
כמו למה את לא גורם שמחוץ לפונקציה?
ואכן, זה אמור להיות אחד מהמניעים.
מלבד העובדה שמישהו אחר בעולם שירצה
כדי להשתמש בפונקצית קובייה -
זה סיבה טובה גורם משהו ולכתוב שלך
פונקציה מותאמת אישית -
אם יש נתח של קוד בתכנית שלך שרק גורמת
מובן רעיוני, שאתה סוג של רוצה לתת לזה
שם - כמו במקרה זה, פזמון -
אז אתה יכול לכתוב באופן דומה כי כפונקציה נפרדת.
אתה לא צריך לכתוב כל דבר בעיקרי אם זה רק
מרגיש נקי יותר כדי להפריד אותו ולתת לו שם.
>> אז במקרה הזה כאן, שים לב שיש לי הערה על גבי
פונקציה זו שרק שרה על
מספרים מפורטים של בקבוקים.
שים לב כאן שאני לא צריך לקרוא לאלה
דברי קלט ופלט.
למעשה, הזמן הזה אני רק קראתי ב הקלט שלי לבקבוק.
ושים לב כאן, החלל מציע מה?
זה פזמון -
קהל: האם לא להחזיר אותו.
דוד י Malan: אינו מחזיר ערך.
ואכן, פונקציות לא צריכות להחזיר את הערכים.
הם פשוט יכולים לעשות משהו.
הם יכולים לקבל את מה שנקראים תופעות לוואי, אשר בזה
מקרה הוא פשוט חבורה שלמה של הדפסה על המסך.
אז שם לב שהקוד הזה כאן, אני ממש ממש גנבתי מן
בדוגמא הקודמת.
ההבדל היחיד הוא שבמקום להשתמש כ
משתנה, אני כרגע משתמש ב כמשתנה שלי.
אז יש לי ב כאן למטה, יש לי ב כאן למטה, יש לי ב
פחות 1 כאן למטה.
אבל את הקוד הוא בדיוק אותו הדבר.
אבל רק כדי להראות לך עכשיו איך אנחנו יכולים להשתמש בזה, תן לי ללכת
קדימה ולמעשה לשנות את זה כדי להיות ללולאה.
עבור (אני int = n; i> n; i -).
>> אז מה שגנבתי את זה מהדוגמא הקודמת שלנו.
בעבר, זה בקו 37 שהייתי מתחיל
שר את השיר הזה המעצבן.
אבל במקום זה, אני פשוט הולך עכשיו לקרוא למקהלה שלי.
עשה.
אז עכשיו בכל איטרציה של לולאה זו, אני קורא לזה אחר
פונקציה, מקהלה, שיצא לי לכתוב.
זה לא נכתב על ידי מישהו אחר לפני שנים.
אבל מקהלה, בינתיים, משתמשת printf להדפיס
מתוך ארבעה הקווים הללו.
אבל העובדה שאני מתקשר פזמון שוב ושוב ב
לולאה אומרת שאני הולך לקבל, ממש בסוף,
אותו שיר בדיוק כפי שיש לי עד כה.
אז בקיצור, עכשיו אם אני מסתכל אחורה בקוד שלי, למרות
פונקציונלי זה שווה ערך, שים לב שזה
מתחיל להיות אפילו יותר קריא.
אני לא בדיוק יודע איך GetInt
מיושם.
בכנות, אני לא יודע איך פזמון מיושם.
אבל זה לא משנה לי.
לא אכפת לי, כי עכשיו אני יכול כאילו, כאדם, קראו
מלמעלה למטה זה.
ובגלל הפונקציות נקראות לפי מה שהם
לעשות, הקוד שלי הוא יותר ויותר קריא.
וכמו בתוכניות שלנו מקבלות הרבה יותר מורכב -
בסוף הסמסטר, אתה כותב מאה שורות
קוד בשפות כמו PHP ו-JavaScript וכמו -
אתה תמצא שזה כל כך הרבה יותר קל מאשר לעקוב אחר
את מה שעשית.
וכשאתה מתחיל בשיתוף פעולה עם חברים או
שותפים או עמיתים, יוכלו לכתוב הרבה יותר
תוכניות מסיביות על ידי מתחיל לממש את אלה בסיסיים
אובניים בניין.
>> אז עם זה אמר, למה אנחנו לא קוראים לזה היום?
ואנו רואים אותך ביום רביעי.
[מחיאות כפות]