>> [השמעת מוסיקה]
>> דוד Malan: בסדר.
ברוך שובך.
זה CS50, ואת זה הוא שבוע אחד, המשיך.
אז אחת הסיבות שאנחנו כבר עוברים סביב טכנולוגיות כמו
גוגל הזכוכית היא שהם מגיעים עם משהו שנקרא API,
ממשק תכנות יישומים.
ומה זה אומר הוא שעם קבצים הנכונים ועם הזכות
תיעוד, למעשה אתה יכול לכתוב תוכנה עבור מכשירים אפילו כמו אלה.
>> ואז מה שיש לנו בראש לכיוון סוף הסמסטרים הוא, אם פרויקט
מעורבת, למשל, גוגל עשויה זכוכית ערעור, נראה מה אנחנו יכולים לעשות ב
מבחינת משדלת אותך עם כמה loaner חומרה, כמו גם
API ציבורי נגיש, כך שאתה יכול למעשה להתחיל ליצור תוכנה
שפועל על אותו שגוגל זכוכית.
>> מכשיר נוסף שיש לנו כבר משחק עם של המנוח שחשבנו שיכולים להיות
כיף בסוף הסמסטר הוא הדבר הקטן הזה כאן.
זה נקרא Motion קפיצה, ומה שאתה עומד לראות הוא מבחינה טכנית
פרסומת למכשיר, אבל זה אין מה לדבר זה בפרט
מכשיר מסוגל.
וזה גם מגיע עם ה-API באמצעות שבו אתה יכול לכתוב תוכנה כדי
לשלוט במחשב שלך באופן ממש כמו סרט של דקה אחת זה כאן.
>> [השמעת וידאו]
>> [השמעת וידאו הסוף]
>> אז עכשיו, מכשיר זה קורה לי ייעשה באופן קצת USB
מחבר שאתה יכול לחבר אליך מחשב, אבל אני לא אתפלא
אם לפני זמן רב שיש לנו סוגים שונים של אלה טכנולוגיות בקבוצה הבאה של מחשבים
ומקינטוש, כך שאתה יכול, ואכן, אינטראקציה עימו ב
אופן כזה.
למעשה, מה שחשבתי שאני רוצה לעשות, יותר מדי, הוא אני משכתי את הפגנה קטנה
תכנית שמגיע עם תוכנה זו.
אז שמו לי חיישן הקטן מול המחשב הנייד שלי.
>> וכמו שאתה יכול לראות, זה כבר מבין כי את היד שלי היא שיש
השולט בה.
וכל יישום שזה עושה זה swimmingly דברים קטנים כמו זה.
אבל אתה יכול לראות כי, אכן, יש לי חמש אצבעות שם.
אם אנחנו יכולים לקבל את זה כדי לעשות את כל 10, אתה יכול לדמיין פסנתר מסודר
יישום או משהו דומה.
אז אם אתה רוצה לבוא אחרי השיעור היום ולשחק עם זה כמו
טוב, אתה מוזמן.
נוסף על כך שלקראת סוף הסמסטר.
>> אז כמה מנהלי הכרזות.
אחד, לעשות סעיף על ידי ביום שישי הקרוב בצהריים בcs60.net/section.
כתובת אתר שהוא על הקורס של דף הבית גם כן.
בינתיים, אם כי, supersections יהיה הופעה ראשונה ביום ראשון הקרוב.
Supersections הוא דבר חד פעמי, כי זה לוקח לנו קצת זמן לעבוד
את מי שבסעיף ובו.
>> אז יום ראשון הקרוב זה, יהיה אחד סעיף פחות נוח לאלה,
סעיף אחד למי יותר נוח.
ואלו מכם אי שם ב בין מוזמנים ללכת
או בשניהם או אף אחד.
שני אלה יהיו מצולמים.
הם יהיו באולם גדול יותר סעיף בדרך כלל להיות בו
אבל המטרה כאן היא לצייד אותך עם נחמה עם בעיה מוגדרת אחת,
עם C, עם מכשיר CS50, זה בסוף השבוע, גם לפני שתמצא אותך
הקצאת סעיף פורמאלית.
אז אתה פוגש TF שלך ושלך קטן יותר קבוצה של sectionmates בכ
הזמן של שבוע.
>> שעתי עבודה, בינתיים, כבר קורה.
האם לנצל אותם הלילה או הלילה אם אתה רוצה מחר.
סט 0 בעיה הוא עקב ביום שישי.
זהו יום יאוחר מ באופן קבוע, מתוכנן ביום חמישי.
אבל עם 1 סט בעיה, אתה תראה שזה כולל כמה חימום
תרגילים שבה אתה עצמך יכול להאריך אותך
מועד אחרון להגשת יום חמישי ליום שישי.
1 סט בעיה, בינתיים, יהיה הופעה ראשונה באתר האינטרנט של הקורס הקרוב
יום שישי, אם אתה רוצה להתכרבל עם זה כמו שעשיתי פעם, לפני הרבה זמן מאוחר
יום שישי בלילה בחדר שלך.
>> אז cs50.net/appliance הוא המקום שבו אתה יכול לקבל את מכשיר CS50
שהתחלנו להשתמש ביום שני.
אנו נשתמש בזה קצת יותר היום.
אבל היה סמוך ובטוח כי הבעיה להגדיר 1 המפרט תעבור
בדיוק את השלבים שאתה צריך לקום ושהפעלתו.
אז אל תדאגו לעשות את זה לפני 1 Pset אם אתה מעדיף שלא.
>> בסדר.
אז אנחנו נראים ביום שני בקוד מקור, אבל בהקשר של חדש
שפת תכנות, כלומר ג ו-C, שלא כמו שריטה, לא גרפי.
זה לא חידת חתיכות.
זה יותר כמו אנגלית תחביר.
ויש עוד כמה צעדים המעורבים בעצם כתיבה ובהפעלתו
תכנית ב-C, משום שחוץ ממקור קוד כזה, אתה צריך משהו
נקרא מהדר.
ובמונחים של הדיוטות, מה אין מהדר לעשות עבורנו?
כן.
>> תלמיד: הוא ממיר את הקוד שאתה כותב ל0s ו 1s.
>> דוד Malan: טוב.
אז הוא ממיר את הקוד ש אנו כותבים כדי 0s ו 1s.
הוא ממיר את קוד מקור של מה שנקרא ל קוד יעד, האחרון שבם נראה
משהו קטן כזה.
וזה המעבד שלך, את המוח בתוך של המחשב שלך, שבגלל
אנשים שיצרו את המחשבים האלה, יודע מה הרצפים האלה
ממוצע של 0s ו 1s.
>> אולי זה אומר שהדפסה.
אולי זה אומר שבנוסף.
אולי זה אומר שחיסור.
אולי זה אומר להציג בצורה גרפית.
יש דפוסים מוגדרים מראש של ביטים שהעולם החליט אומר
דברים מסוימים.
אבל על פי רוב בקורס זה, אנחנו נעבוד ברמה גבוהה יותר, ו
אנו לוקחים כמובן מאליו שקיימת דברים כמו מהדרים שיכולים
להפוך את פונקצית קוד המקור שלנו בדרך בה אנו מתכוונים.
>> אז התכנית הראשונה שכתבנו בשבוע שעבר ולאחר מכן החל לנמל, ולכן כדי
לדבר, C האחרון יום שני, היה זה.
כשלחץ על הדגל ירוק, לומר שלום.
זה היה, כמובן, נכתב בסריטות.
ואני טענו שאת המקבילה תכנית ב-C נראית קצת
משהו כזה.
>> אז מה חשבתי שאנחנו היינו עושים בהתחלה הוא, בואו להפריד את מה שנראה בתחילה
מבט חטוף, יש להודות, כמסתורי למדי תחביר, אבל אתה מתחיל לשים לב
דפוסים די מהר.
מה שאנחנו נעשה גם היום הוא מספקים לך עם מודל המנטלי לחלק
הקנונית, כמה מבנים סטנדרטיים בתכנות.
ואז אנחנו באמת תוכלו לשים את ידינו מלוכלך עם כמה דוגמאות, כמו גם.
>> אז לאלה מכם יותר נוחים, להבין שזה שבוע ולאחר מכן הבא
שבוע עשוי להיות קצת ביקורת טובה מאוד.
אבל במיוחד כאשר מהדורת ההאקר בעיה של 1 סט יוצא ב
באתר הבית של הקורס ביום שישי, אני חושב תגלו שגם לך למלא
כמה מקומות ריקים במהלך השבוע הבא או שתיים, אתה מתחיל לקבל יותר ויותר
מאותגר ונתקל דברים חדשים וחדשים יותר.
>> אז בואו להקניט מלבד תכנית זו כמה שורות בכל פעם.
בחלקו העליון, יש לנו מה נקרא טכני
הוראת preprocessor.
זוהי רק שורת קוד שאומרת כדי לכלול את התוכן של קובץ,
קרא לי סטנדרטי / N, קלט סטנדרטי - או, סליחה, קלט / פלט הסטנדרטי, תקן
קלט / פלט,. שעות, בתוך בתכנית שלי.
>> אז במילים אחרות, אם אני כתבתי את זה תכנית עם עורך טקסט פשוט כמו
gedit, המקבילה הפשוטה יותר של משהו כמו Microsoft Word, ש
הוראה, # כולל stdio.h, היא רק הולך לספר את המהדר, לתפוס
תוכן של קובץ אחר ש, stdio.h, ולהדביק אותם כאן.
>> עכשיו, למה אכפת לי?
מה שאנחנו טוענים הוא בתוך קובץ זה קרא stdio.h, אשר מאוחסן
מקום בכונן הקשיח שלי, או בזה מקרה, אי שם במכשיר CS50?
מישהו אחר שם אותו שם בשבילי.
אבל מה יש בו?
>> כן, כך שזה הכרזה פונקציה בשם printf.
אז נזכר printf הפונקציה ה מילים ותווים ומציגים
מספרים המופיעים על המסך בהצעה שלי.
אבל אני לא כתבתי את זה.
CS50 לא כתב אותו.
שנים לפני שמישהו כתבו אותו, והם בעצם נתן לנו את המתכון לזה
בקובץ שנקרא stdio.h.
כך שהשורה ראשונה רק נותנת לי לגשת לפונקציות שמישהו אחר
כתב לפני שנים, בין אשר printf.
>> עכשיו, בשורה הבאה אני הולך לנופפי ביד, לפחות עד השבוע הבא.
אבל לעת עתה, יודע שהוא int הראשי (חלל) בעצם שווה ערך לכך
פיסת הפאזל צהובה כאשר הדגל ירוק לחיצה עליו.
העולם, לפני שנים, החליט שאם אתה כותב בתכנית
שפה בשם C, אתה מתחיל התכנית שלך עם קו
זה נראה ככה.
כמעט בזמן של שבוע, זה יעשה תחושת int מה הוא, מה הוא חלל ריק.
אבל לעת עתה, רק לחשוב על זה כפיסת הפאזל הצהובה הזה.
>> עכשיו הבא, יש לנו סד מתולתל ואחרי על ידי סד מתולתל קרוב אחר,
אם אפשר לומר כך.
ואנו רואים בכל אלה תוכניות ב-C, כמו גם
JavaScript ו-PHP.
ואלה הם רק לתמצת קווים הקשורים של קוד.
הסד המתולתל הפתוח למעשה אומר, הנה מגיע קצת קוד.
וסד המתולתל הסגור, שהוא זווית לכיוון השני, בדיוק
אמצעי, זהו זה ל הקוד הרלוונטי.
>> אז השורה עסיסית בזה ראשון תכנית היא אחרון, printf,
במרכאות, שלום עולם.
ואני קראתי את הדבר בין ציטוטים מה הפעם האחרונה?
אז זה מחרוזת.
ומחרוזת היא רק טכנאי טווח עבור רצף של
דמויות, מילה, משפט.
יכלה אפילו אות אחת להיות מצוטט כפול.
אבל זה רצף של אפס תווים או יותר.
>> לוכסן-N, אם כי, נראה קצת מוזר.
אבל זה פשוט התכוון למשהו פשוט למחשב.
מה קו נטוי-n?
קו חדש.
אז זה פשוט רצף המיוחד של דמויות שהעולם החליט
אמצעי לשים מעבר שורה ממש שם, בגלל המהדר למעשה יקבל
מבולבל, בדרך כלל, אם אתה, מאוד מובן, אבל באופן שגוי, רק
תתחיל להכות על Enter כדי לשים קווים חדשים בקוד שלך.
אתה צריך להיות קצת יותר מפורש עם קו נטוי-n.
>> ואנו רואים שיש כמה אחרים כגון דפוסים לתווים מיוחדים.
למשל, אם אתה רוצה לתת לך אכפת לנדוד למקרה פינה,
נניח שאני רוצה להדפיס ציטוט כפול על המסך עבור
מהסיבה כלשהי, שהיה נראה להיות בעייתי, ממש קטן?
כי אם אני שם את ציטוט כפול ב אמצע "שלום, העולם", לכל מה
סיבה, מדוע שנראה פוטנציאל בעייתי?
זה שובר את המחרוזת.
>> מהדר הוא רק תכנית.
תכנית כמו מהדר היא רק הולכת לקרוא את הקוד שלך למעלה עד למטה,
משמאל לימין.
ואם רואה שלוש מרכאות כפולות במקום לשתיים, זה לא הולך לדעת
אם אתה אומר שהדבר שמשמאל צריכה להיות מחרוזת, או דבר
הנכון, או את כל העניין.
זה לא ברור, ואז מה טיפוסי מהדר הייתי לעשות הוא פשוט להתחרפן,
ואתן לך הודעת שגיאה כלשהי, ו לגרום לך להתמודד עם הבעיה.
>> אז בהתחשב בכך שהלוכסן-n פירוש חדש קו, מה היה האינסטינקטים שלך עכשיו
להתחיל להיות בו אם אתה רוצה לכלול משהו חריג כמו כפול
תצטט את החלק הפנימי של זה מצוטט אחרת מחרוזת?
ציטוט נטוי הפוך כפול.
וכך יהיה לנו לראות את זה סוג של דפוס מדי.
>> אם אתה רוצה לעשות משהו קצת מוזר, אתה תמצא כי
פתרונות לעתים קרובות לעקוב אחר דפוס, וקו הנטוי
מציין רצף בריחה.
וזה רק אומר שמשהו מיוחד שאנחנו צריכים לייצג ב
דרך אחרת.
באשר לאיך אתה מייצג קו נטוי, ובכן, אנחנו
תחזור לזה.
אבל התשובה, גם היא למעשה קצת ברור.
>> אז בואו עכשיו להכניס קצת אחר תכנות בונה
שראית בלגרד.
יש לך כנראה מובן מאליו כבר אם כבר צלל לתוך
בעיה מוגדרת 0.
אבל בואו עכשיו להציג את התחביר ב-C לאלה אחרת אינטואיטיבי למדי
רעיונות, לפחות חלק מהם.
>> אז הרעיון הזה של תנאי או סניף, בעוד שבעברנו
ייצג אותו עם קוד שנראה ככה בצד השמאל בלגרד -
אם x קטן מ-y, אז אומרים כך -
במקום כעת ב-C - תנו לי לחדד במקרה הפשוט ביותר -
אנחנו פשוט הולכים להגיד, אם, פתחו סוגריים, משהו נכון -
ביטוי בוליאני הוא הולך שבו שכבר אמר מצב -
סגור סוגריים, אז מה בתוך הסוגריים המסולסלים האלה.
>> אז גם כאן, בסוגריים המסולסלים הם כמו סוג של שריטה של
חלקי הפאזל בצורת פרסה.
לעשות את מה שבתוך סוגריים מסולסלים אלה.
במקרה זה, לחתוך לקצץ.
ומבחין זאת היא קדימה לקצץ, לא קו נטוי.
קו נטוי, קו נטוי, למי הוא כבר מתוכנת
בעבר, רק אומר -
זה רק הערה.
תגובה היא לא קו של קוד, כשלעצמה.
זה קו של אנגלית שאתה, אנושי, שכתב לעצמך כדי
אולי להזכיר לך לעשות משהו, כדי להסביר לעצמך, כדי להסביר לי
מישהו אחר, מה הקוד שלך עושה.
זה רק תגובה תיאורי.
>> עכשיו, כמובן, אנחנו יכולים להיות דו סטרי מזלג על הכביש רק על ידי עושה את זה,
מזלג שלוש דרך בכביש על ידי עושה זה, ואם ימשיכו כך
דפוס, אתה יכול לקבל דרך ארבעה, חמישה כיוונים, שישה מזלגות דרך בכביש אם
אתה צריך לטפל בו, ואכן, כי תנאים רבים.
ואז שם לב להקבלה כאן -
אם (תנאים), אחר אם (מצב), ורק אחד שזה קצת
המוזר הוא שעבר, שבי כי הוא פשוט אחר.
אבל שוב, זה זהה, מבחינה מושגית, על מה שעשינו
כבר, למרות שהתחביר יהיה לוקח קצת זמן להתרגל.
>> עכשיו, בדוגמה זו, יש חלק תחביר מוזר אחר.
אנו רואים printf שוב, סוגריים פותחים, וסוגריים קרובים.
ובתוך קיים מחרוזת מצוטטת.
בסוגריים, בהקשר של printf, ללכת בצד השמאל
וזכותו של מה?
מה שאנו מתארים שצוטטנו מחרוזת כבאופן כללי יותר?
>> אז זה ויכוח.
בכל פעם שיש לך פונקציה, כמו printf, ולאחר מכן paren פתוח ו
paren הקרוב ומשהו בתוך זה, בין אם זה מחרוזת, או
מספר שלם, או כל דבר אחר, הדבר ב בין הסוגריים האלה נקרא
טיעון.
>> וויכוח רק משפיע ההתנהגות של הפונקציה.
במקרה זה, זה די ברור איך.
X <Y הוא מה שמועבר ב, אם אפשר לומר כך, כטיעון.
Printf והולך להדפיס בדיוק את זה.
כי מה שבטוח, לפני השנים האדם שיושם printf היה לי מושג
מה שאנו ממשיכי אדם היו הולך להשתמש printf ל.
אז זאת הסיבה שהטיעונים קיימים, כדי להשפיע על התנהגות לאחר הפונקציה של
כבר נכתב.
>> עכשיו, ביטוי בוליאני.
אלה שראינו לפני כן בגרד.
מתברר בC אתה יכול גם "או" אותם ביחד, אם אפשר לומר כך.
שני קווים אנכיים אומר שהבלוק הזה של קוד, זה עושה את זה, יהיה
לבצע אם התנאי הראשון הוא נכון או התנאי השני הוא נכון.
ולמרות שאתה אולי לא הייתי עושה זה בסריטות, אתה יכול באמת
לעשות את זה בסריטות, ואתה יכול גם להביע את עצמך באופן שונה -
אם התנאי הראשון והשני המצב נכון, אז אין מה
בתוך הסוגריים המסולסלים.
>> ובדיוק כמו בצד, סיבה שזה אמפרסנד כפול וכפול
פס אנכי, נראה בסופו של שבר אנכי יחיד ו
אמפרסנד יחיד למעשה יש שונה כלומר בג אז לעת עתה,
כפילות זו של סמלים הוא מכוון.
>> אז בואו נציג, בקצרה, קצת אחרים כך של תחביר.
זה לא ממש לשאת מעל ל שריטה, אבל אני טוען שאני יכול
ליישם את הרעיון של אם אחר, אם דבר אחר, אם אחר, אם הצהרה אחרת באמצעות
משהו שנקרא הצהרה בורר.
והסיבה היחידה שזה באמת קיים הוא פשוט לתת לך, המתכנת,
דרך לפתרון קצת שונה במקצת בעיה, למרות שזה הגיוני
לא נותן לך את כל יכולות חדשות.
>> בכך אני מתכוון לזה.
כשאתה אומר מתג, ולאחר מכן רווח, ולאחר מכן זוג סוגריים, בתוך
אשר הולך ביטוי -
וזה יכול להיות קצת לא ברור, בהתחלה, אבל זה לא ויכוח,
מבחינה טכנית, כי מתג אינה פונקציה.
אז לעת עתה, רק להניח כי אנו משתמשים סוגריים במקומות שונים
מסיבות שונות.
>> אז לעבור על ביטוי אומר שאני יכול לשים בתוך משתנה מאלה
סוגריים שבו כתוב ביטוי.
ולאחר מכן, אם כי משתנה -
מניח שזה נקרא X, ו זה רק מספר שלם -
אז אני יכול למנות בשקופית שלי כאן משהו כזה.
אם x הוא משתנה שלי, ואני רוצה לעשות משהו אם x
שווה 1, אני יכול לעשות את זה.
>> אם אני רוצה לעשות במקום משהו אם x הוא 2, אני יכול לעשות את זה.
דבר אחר, אם אני רוצה לעשות משהו אחר לגמרי, אני יכול לקבל את ברירת מחדל במקרה
מקרה שבו אני עושה את הדבר האחר הזה.
אז במובן הזה, זה שווה ערך ל אם x שווה שווה 1, אחר אם אחר,
אבל אני מזכיר את זה עכשיו רק בגלל אנחנו תראו את זה שוב.
אבל לעת עתה, רק יודע שזה קיים.
>> בסדר.
אז הזוג האחרון אלה הם קצת יותר מורכב במבט הראשון, אבל הם עושים
משהו פשוט למדי.
ללולאה ב-C הוא נתח של קוד ש פשוט עושה משהו שוב ו
שוב ושוב.
והדבר המעצבן רק על זה הוא שהוא שזה קצת סתום
להביע את עצמך בזה מחזורי דפוס, אבל העולם טופל על
הדרך הבאה.
>> כאשר אתה משתמש בלולאה, יש לך זוג סוגריים שוב.
ושים לב את שני פסיק לשם.
אלה שני פסיק שלוש נפרד ביטויים שונים בתוך של
סוגריים.
אחת הוא מה שנקרא האתחולים.
אחד מהם הוא המצב שנקרא.
ואחת הוא את העדכונים שנקראו.
>> הסתכלתי באופן מופשט, זה לחלוטין לא ברור, אז בואו נראים
בדוגמה קונקרטית.
בשריטה שהיו לנו גוש חוזר.
ובלוק זה אמר לחזור 10 פעמים, אומר "שלום, עולם". תן לי לתבוע
עכשיו, ואנחנו עוד נחזור לזה, ו גם את זה, יקבל יותר מוכר
לך לפני זמן רב, שווה ערך C קוד יכול להיות אמר להיות זה -
להצהרה וחלל, זוג סוגריים, שימו לב לפסיק ב
שם, מה שיפריד בין שלוש ברורים דברים, האתחול, את
מצבו, ואת העדכון.
>> ותיקח ניחוש מה הראשון הוא עושה.
אני int = 0.
במונחים של הדיוטות מחוספסת, מה היא שעושה לנו, כנראה?
אז כן.
זה שהכריז על משתנה בשמי, וזה מה שנותן לו ערך?
0.
אז זה יוצר משתנה בשם אני, אחסון 0 הערך בו.
זה האתחול מה שנקרא.
>> בסדר, עכשיו אני טענו לפני כי הדבר באמצע, אני
<10, הוא המצב.
אז מה הוא עושה?
ובכן, מה עושה כאשר ללולאה תכנית עם ללולאה לרוץ, הוא
בכל פעם שמחשב פועל באמצעות לולאה זו, מלמעלה למטה, עד הראש
תחתון, בדיוק כמו שאתם עשית כש סופרים את עצמכם ולשבת,
שוב ושוב ושוב, המחשב הולך
כדי לבדוק את המצב הזה.
ואם אני הוא פחות מ -10, זה יעשה את זה שוב.
אם אני הוא פחות מ -10, זה יעשה את זה שוב.
אם אני פחות מעשר, זה יעשה את זה שוב.
כך שנראה כי מראה כי אני מקווה שאני משתנה.
אחרת, תהיה לנו ללולאה אינסופית.
ואכן, אני משתנה, כי הדבר האחרון שאחרי פסיק יש
הוא התחביר הסתום משהו של i + +.
אבל אלה מכם שכבר עשו את זה בעבר, זה רק אומר
די פשוט מה?
>> תלמידים: [חציצת קולות].
>> דוד Malan: 1 הוסף לי.
להגדיל לי.
אז ראינו את הפאזל סריטות חתיכה בשביל זה, בעצם.
זה לא נראה כמו אני + +, אבל זה פשוט פירושו, בפשטות, להגדיל
אני מעריך עד ליום 1 בכל פעם שאתה עושה את זה.
כך, פשוטו כמשמעו, אתה מתחיל על ידי אני מאתחל ל -0.
אתה ולאחר מכן לבדוק את המצב שלך.
האם 0 פחות מ 10?
כן.
אנחנו עוברים את הלולאה.
>> הדבר הבא שאני טוען את המחשב של הולך לעשות הוא שזה הולך
כדי להגדיל לי.
אז אני כרגע הוא 1.
הוא בודק את מצבו.
הוא פחות 1 מ 10?
כמובן.
אז עושה את זה שוב.
אז זה מרווחים + + ל 2.
האם 2 פחות מ 10?
כן.
ושוב ושוב ושוב.
וסופו של דבר, בגלל בתוספת-plussing, אנחנו מקבלים אני שווה 10.
האם 10 פחות מ 10?
ובכן, ברור שלא.
וזה הנקודה שבה ללולאה פשוט מפסיק.
ואם יש לך יותר על קוד מסך למטה, המחשב
תמורה להפעיל קוד שבמקום.
>> אז שוב, למרות שזה הולך נראה ומרגיש קצת מוזר ב
ראשון, ובוודאי לאלו מכם ש אף פעם לא תכנתתי לפני, זה
פשוטו כמשמעו, מפחית מושגית למה שאחרת מאוד
חידה פשוטה חתיכה בלגרד.
>> בסדר, הבטחתי שיש הייתי להיות אנלוגים אחרים בלגרד.
אין זה אחד יותר מדי.
וראינו בפעם האחרונה לזמן קצר זה.
אבל תזכור לנצח לחסום בסריטות?
זה פשוט עושה משהו לנצח?
אני טענו שאתה יכול ליישם זה בדרך זו.
ולמעשה אתה יכול ליישם את זה בכמה דרכים שונות.
>> אבל את הלולאה בזמן היא פשוט שונה הדרך ב-C של לבטא את עצמך.
בסופו של היום, אתה לא יכול לעשות כל דבר עם לולאה בזמן שאתה
לא יכול עם ללולאה.
ולכן הם בסופו של יום פונקציונלי זהה.
אבל זה מאפשר לך להביע את עצמך קצת אחר ב
הדרך הבאה.
>> עם הלולאה בזמן, זה מה שיש ב סוגריים שבדקו שוב ו
שוב ושוב.
וברגע שביטוי זה הוא שקר, לאחר מכן הלולאה מפסיקה ביצוע,
והמחשב ממשיך לרוץ כל קוד האחר
יש בקובץ שלך.
>> אבל מה שמעניין הוא כאן כי אני ממש הקלדה נכונה.
ואמת היא סוג של הערך בוליאני, ערך אמת או שקר.
כל כך נכון יכול אי פעם להיות שקר, אם יש לי, פשוטו כמשמעו,
בקידוד הקשיח אותו בתוכנית שלי?
אז לא.
זה קצת מוזר שעשיתי את זה.
אבל האמת היא אמת.
אין שום תוספת-plussing.
אין שימוש במשתנים בכאן.
אז בגלל שאני בקידוד קשיח בזמן נכון, זה לולאה היא תמיד הולכת להעריך
שוב ושוב ושוב.
>> אז כמה פעמים הוא שלום העולם הולך להדפיס על המסך?
לנצח.
מספר אינסופי של פעמים עד סוללה מת או חלק חיצוני אחר
אירוע שקורה.
אז זה כנראה לא את התכנית הטובה ביותר לכתוב, כי אם המשתמש
לא יכול להפסיק את התכנית שלך, זה כנראה לא מה שהתכוונת.
>> אבל לפעמים, תוכניות צריכות יש לולאה אינסופית.
לדוגמה, אם המחשב שלך יש שעון על זה, זה בהחלט יהיה
נחמד אם השעון שלך זה לשמור על העדכון עצמו לנצח, אם כי פעם אחת
שני או אחת לדקה או משהו כזה.
לולאות אינסופיות אז גם האם יש המקום שלהם.
>> בסדר.
לבסוף, זה אחד.
ואת זה הוא קצת שונה תפקודי, ואנו נחזור אל
זה כנראה ב1 Pset.
אבל יש עוד סוג של לולאה קרא לעשות בזמן שהלולאה.
וההבדל היחיד בין כאן לעשות בזמן לולאה ו, אומרת, לולאה בזמן,
הוא שמצבו לא נבדק לפני שאתה מבצע את הקוד, אבל אחרי
שלך לבצע את הקוד.
אז בראש ובאילו לולאה, ואילו לעשות בזמן
בודק אותו בתחתית.
>> וזה רק אומר שהלולאה בזמן יהיה בדרך כלל לבצע פעמים נוספות
או פחות פעמים מאשר לולאה בזמן?
פעמים עם פוטנציאל ליותר, כי לעשות בעוד לולאה בבירור אומרת לעשות את זה,
רק לאחר שיצביע לך לבדוק אם בתוך מצבו של
סוגריים הוא נכונים.
>> אז אנחנו תראו את זה שוב כנראה ב1 Pset.
אם אי פעם אתה רוצה לעשות משהו ב לפחות פעם אחת, ואז אולי קצת יותר
פעמים, זה טוב לבנות לשימוש.
אבל לולאה בזמן, לעומת זאת, תהיה לבדוק את המצב הראשון שלה.
וזהו זה ללולאות ב-C, אין בזמן, ואילו, וללולאות.
ושוב, הם די יפה למפות בחזרה לשריטה, מלבד זה לא עושה
יש בדיוק אותו הדבר האנלוגי בלגרד.
>> ובכן, מה לגבי, עכשיו, משתנה?
אז ככה אני הכריז על משתנה תחבירי יום האחר.
היה לי int, שטענתי הוא מספר שלם.
אז היה לי נגד נקרא משתנה, ולאחר מכן פסיק.
אז מהו הקו הזה של הקוד עושה?
זה, בפשטות, שהכריז משתנה -
כלומר, שואל את המחשב, תן לי איזה זיכרון, תן לי כמה פיסות - ב
שבו אני יכול לאחסן את מה?
Int.
והפסיק רק אומר סוף שורת קוד.
>> עכשיו, הקו השני הוא כנראה די ניחוש.
מהו נגדי = 0; עושה?
זה הקצאת 0 נגד.
ואז זה דבר האחר זה קצת מעצבן
לעומת, יניח, אלגברה.
ואילו באלגברה, סימן שוויון פירושו שווים, כאן ב-C, שווה
סימן פירושו משימה.
אז זה אומר לשים את מה בצד הימין אל מה בצד השמאל.
ואנו רואים סמל אחר, שווים שווה, כאשר אנו רוצים לבדוק באמת
לאיכות, קצת מעצבן.
>> אבל זה קצת לא יעיל.
זה סוג של מעצבן שיש לי כדי להצהיר על משתנה ו
לאחר מכן לתת לו ערך.
כך למעשה מאפשר לנו C לפשט את זה ופשוט לעשות את זה בבת אחת.
אתה יכול להצהיר על המשתנה בצד השמאל.
אתה עדיין יכול לעשות את המשימה על זכות על ידי הצבת שסימן שוויון ב
האמצע.
אז בסופו של היום, שני אלה הם שווה, אבל זה, בכנות,
כנראה את הרגל טובה יותר להיכנס רק בגלל שזה קצת פחות
קוד, שזה קצת יותר קל לקריאה, וזה רק מחמיר את
הקוד שלך, אם אפשר לומר כך.
>> על כל שאלה עד כה על הלולאות, על משתנים, על תנאים, על
Booleans, בין אם מבחינה טכנית או רעיוני?
בסדר.
אז עכשיו הבא זה מקבל קצת יותר מעניין.
וזו הדוגמא שהצבתי שעבר זמן שרק ממפה דוגמא סריטות
מעל לג
>> אז פונקציה.
במונחים של הדיוטות, מה זה פונקציה?
צריך להיות נועז יותר עם התשובה שלך.
מה פונקציה?
>> תלמיד: האם משהו.
>> מלאן דוד: מה זה?
>> תלמיד: האם משהו.
>> דוד Malan: האם משהו.
אישור.
נתחיל שם.
אז פונקציה עושה משהו.
אז זה קטע קוד זה למעשה מיושם במקומות אחרים, כי
אכן עושה משהו.
עכשיו, מה שמעניין בפונקציה הוא שזה יכול לקחת קלט,
וזה יכול לייצר תפוקה.
ובוא באמת ניקח תסתכל על זה.
>> אז האיש מאחורי הווילון היה מכוון לפני רגע.
כאן יש לנו שולחן.
אבל נניח שזה בעצם מייצג תיבה גדולה.
אז זה מה שנקרא קופסה שחורה.
ובכלל, בעיצוב, במחשב מדע, קופסות שחורות רק כדי להפנות
פיסות פונקציונליות שמישהו יישם, ואתה לא
בהכרח יודעים או אכפת לי איך זה יישם מתחת למכסת המנוע.
אכפת לך רק שהקופסה שחורה הזאת, שאנחנו עכשיו נתחיל לקרוא
פונקציה, עושה משהו.
>> כך, למשל, אם הקופסה השחורה הזה על השלב כאן מייצג printf,
פונקציה, אני יודע מדוגמאות קודמות שלוקח printf אחד או יותר
טיעונים, וראשון מאלה טיעונים צריכים להיות מחרוזת, כמו
"שלום, עולם". ובכן, אם אני האדם כותב את התכנית, ואני רוצה
להשתמש printf, אני, למשל, עלול לקחת פיסת נייר ריק פה ו
בטוש שחור ולכתוב עליו -
אני שגוי "עולם" -
H-E-L-L-O.
>> אז אני אקח את הטוש השחור שלי ואני לכתוב, גדול וכקריא שאני יכול על
זה חתיכת נייר, "שלום, עולם", ו עכשיו אני טוען שזה הטיעון שלי.
זוהי מחרוזת מיוצגת עם פיסת נייר לבן.
והקלט שלי עכשיו לפונקציה printf הולך להיות זה.
אז אני קורא printf, עובר טענה כי כקלט אליו.
>> ועכשיו, אני לא יודע איך האדם ש printf כתב עשה את זה לפני שנים, אבל
אני יודע שמהתיעוד שלה מטרתו בחיים היא להדפיס את מה שאני
לספק לו כקלט.
וכך, למרות שיישום זה הוא ללא ידיעתי
מתחת למכסת המנוע, עכשיו אני רואה, הו, זה נעשה.
זה כבר הדפיס משהו על המסך.
ועכשיו לשלוט בתכנית, אם יש היו יותר שורות קוד, הייתי
עכשיו חזר אליי.
וכן את העובדה שקולטון -
יברך את לבו, הוא מסתתר כאן תחת שולחן לפני כולכם -
מכוון שבאיני יודע ולא אכפת לי איך הוא printf
יושם.
אני רק יודע, שוב, משלה תיעוד, מה היא עושה ואיך אני
אני אמור להשתמש בו.
>> עכשיו, זוכר שprintf יכול לקבל קצת יותר מתוחכם.
שוב, אנחנו מדברים רק על מקבילה של הבלוק תגיד של סריטות.
אבל אני גם עשיתי את זה בפעם האחרונה.
אני רוצה להפוך את תכנית שלום שלי קצת יותר דינמי ולא רק קשה
קוד משהו כמו "עולם", ו בהחלט לא משהו שקוד קשה
שרירותי כמו D--V-I-D לתכנית.
רציתי לשאול את המשתמש שלו או שלה שם, ואז לעשות משהו עם
שהמחרוזת שהם מספקים.
>> אז יש משהו קצת שונה כאן. printf, לפני רגע,
לא, באמת, לעשות משהו, אבל זה לא החזיר לי כלום.
נכון?
קולטון לא מסר לי שום דבר בחזרה, לא פיסת נייר.
היה רק ​​תופעת לוואי.
מתן שלי "שלום, העולם", כפי טיעון להביא קולטון ב
תופעת לוואי של מילה, כמה מילים, המופיע על המסך.
>> getstring, אם כי, הוא קצת שונה. getstring גם
פונקציה, אבל היא מחזירה ערך כלשהו.
זה לא רק שיש לי תופעת לוואי אסתטית.
זה נותן לי בעצם, האדם התקשרות או באמצעות הפונקציה,
משהו בחזרה.
אז במקרה הזה, הוא getstring התקשרתי עם getstring הפתוח
פארן, קרוב paren.
האם getstring, אם כן, לקחת כל טענות או קלט?
לא, זה לא נראה.
מטרתו בחיים היא רק כדי לקבל את מחרוזת.
זה לא צריך שום פירוט רב יותר מזה.
אז הרשה לי להמשיך ולהעמיד פן ש, שוב, קופסה שחורה זה לא printf,
אבל getstring, ותן לי, האדם כתיבת תכנית זו, להתקשר או להשתמש
getstring רק על ידי כתיבה G-E-T-S-T-R-I-N-G, פתוח פארן, קרוב
פארן, getstring.
>> עכשיו, אין לי מושג איך צוות CS50 יושם getstring, אבל אני יודע ש
אם תחכה מספיק זמן, הוא יעשה את שלו דבר מתחת למכסת המנוע, אולי באמצעות
חלק מהמשתנים, אולי בעזרת כמה תנאים, אולי בעזרת כמה לולאות,
אולי בעזרת כמה פונקציות, אולי באמצעות -
רק מנסה דוכן - אולי באמצעות כמה תכונות תכנות אחרות.
אבל אם אני אחכה מספיק זמן - במציאות, במחשב, זה קורה
סופר מהיר -
אם אחכה מספיק זמן, פונקציה זו getstring הוא הולך לקבל מחרוזת
מהמשתמש, שהוא ככל הנראה להקליד את זה על המקלדת שלהם, ו
לאחר מכן, כשאתה מקבל getstring נעשה אותם תווים מהמשתמש
ואחסונם למחרוזת, כי פונקציה, getstring, הוא הולכת להיות
מוכן בשבילי כמה פלט שבו אני הולך לאחזור בדרך של
אופרטור ההשמה.
>> ואם אני הולך, אכן, לפלט כאן, יש לו בנדיבות Obosi
השתתף, בלי לדעת את זה ב לקדם, על ידי כתיבת השם שלו על זה
משתנה, אשר מייצג מחרוזת.
עכשיו, מפעיל המשימה אומר, גם אם כי זה עלול להרגיש קצת
מיותר, אני באמת צריכה לעשות כדי להפוך את העותק זה שלי.
כי ביד השמאל צד - אופס! -
שם לב שיש לי בעצם מחרוזת שם בצד השמאל.
אז אני גם הולך לעשות עותק משלי לכך.
וזה קצת שקר לבן, בגלל שנראה בשבוע או שניים של
זמן שמייתרים הם לא ממש מה שהם נראים.
>> אבל לעת עתה, הנה ערך ההחזרה.
הנה העותק שלו שלי אחרי באמצעות אופרטור ההשמה.
ועכשיו, מה אני רוצה לעשות עכשיו?
עכשיו יש לנו את השנייה משתי שורות של קוד.
אז עכשיו אני רוצה לקרוא לprintf.
בואו נעמיד פנים שעכשיו שחור תיבה היא חזרה שוב להיות
printf ולא getstring.
>> Printf זמן זה הולך לקחת כמה ויכוחים?
אז תראה, זה כמו שתיים.
יש שני פסיקים בשם, אבל אחד מאותם פסיקים, זה
בתוך המרכאות.
אז הטענה הראשונה היא, פשוטו כמשמעו, זה הולך להיות.
H-E-L-L-O, פסיק, באחוזים ים, קו נטוי-n.
ועכשיו אני מתן לא טיעון אחד, אבל שני טיעונים לprintf.
>> ומה printf אמור לעשות עם שתי הכניסות האלה אחרי שאני עובר אותם ב
כטיעונים?
זה אמור לקחת שני של שלהם, שקראתי בהשם, ולכן
קטע שני של נייר שכתבתי את לפני רגע הוא קרא בשם.
זה הולך התוספת של הערך בתוך של משתנה שלתוך מציין המיקום,
% S, כך ששוב, ברגע של זמן, אנו רואים תופעת לוואי של
לאחר שקראנו printf, לפיה עכשיו אנחנו לא רואה את "שלום, עולם", אבל "שלום,
Obosi ".
>> אז מחיאות כפיים לשניהם המתנדבים שלנו, רק שאחד מהם ידעו
זה לא היה קורה.
בסדר.
אז, אולי, פשוט כמו שהיה, בהחלט, אם אתה כבר מכיר
עם כזה, אני מקווה שאתה לעולם לא לשכוח כי חזותי מסוים של איך
פונקציות יעבדו.
>> אז יש יותר מאשר רק getstring.
בתוך ספריית CS50, יש חבורה שלמה של פונקציות, אשר כולם
מהוונים רק כדי להבהיר שכתבנו את הפונקציות האלה.
בדרך כלל, ב-C, כמעט בכל השני פונקציה שתשמש אותך היא אותיות קטנות.
אבל אנחנו בכוונה להשתמש באותיות גדולות רק כדי להבהיר, כי אלה
הם גלגלים עזר מסוגים כי תוכל להשתמש רק כמה שבועות כי
לפשט את התהליך של קבלה קלט מהמשתמש.
>> ספריית CS50 לא עושה שום דבר שאתם עצמכם לא היו יכולים לעשות על ידי
רק באמצעות קוד C מ ספר לימוד אולדסקול.
אבל, שוב, אנחנו משתמשים בם כאימונים גלגלים של מיני עבור רק כמה
שבועות, כך שנוכל להיפטר מ מורכבות שבקרוב תוכל להבין
את עצמך לעשות משהו כמו יחסית פשוט כמו לקבל
קלט ממשתמש.
>> אז תדע שיהיה לך גישה לgetchar, GetDouble -
כפול.
ממה - ולאחר מכן GetFloat.
מה מצוף?
בואו נתחיל שם.
>> תלמיד: [לא ברור].
>> דוד Malan: כן.
זה מספר עם נקודה עשרונית.
אז אילו int הוא מספר שלם, אשר הוא רק מספר עם 0 עד 9,
איזה מספר החזרות ממנו, מצוף הוא משהו
עם נקודה עשרונית.
וכפול, בינתיים, הוא גם מספר עם נקודה עשרונית, אבל יותר
מספרים לאחר הנקודה העשרונית נקודה, שעלול להיות.
>> אז אנחנו נחזור לזה עוד הרבה לפני.
אבל בדרך כלל, כל אחד מסוגים אלה הנתונים, כל אחד מסוגים של משתנים אלו
שספרייה כמו שלנו יכולה לחזור ל לך, להשתמש במספרים שונים של ביטים ל
אחסון מידע.
בדרך כלל, תו, שרק אומר תו אחד, משתמש 8 סיביות.
וזה בעצם עולה בקנה אחד עם שלנו בתים של מתנדבים בשבוע שעבר ש
עלה וייצג את אחד תווי ASCII בכל פעם.
אז תו הוא 8 סיביות.
>> לצוף במקרה 32 סיביות, בדרך כלל.
וכפול, כמו שאתם יכולים לנחש, הוא למעשה 64 סיביות, שהוא פשוט יותר,
מה שאומר שאתה יכול להיות גדול יותר מספרים או יותר דיוק.
אבל שוב, עוד על כך בפעם אחרת.
GetLongLong, בינתיים, אם כי בטיפשות בשם, הוא באמת רק
מספר שלם שהוא גדול פי שניים, פי שתיים ארוך, באופן פוטנציאלי, כפי שקבוע
מספר שלם, 64 סיביות במקום 32.
וGetString אנחנו כבר משתמשים.
>> אבל מתברר, בספריית CS50, אשר מיושם, כפי שנראה, ב
הצורה של שני הקבצים, שהאחד מהם נקרא cs50.h, יש שתיים אחרים
סוגי נתונים.
Booleans לא קיים בC. אתה יכול לדמות אותם רק על ידי שימוש 0s ו 1s
לאורך כל התוכניות שלך.
אבל אנחנו בספריית CS50 יצרנו הסמלים "אמיתיים" ו "שקר"
לייצג ו1 0 כדי שלא יש למשהו קוד קשה
ממש כמו 1 ו -0.
אבל אנחנו תראו אותם שוב.
>> המיתרים, גם לא קיים.
וזה למה שהזכרתי זה קצת שקר לבן לעת עתה.
אבל נצטרך לקלף כי שכבה לפני זמן רב.
אבל לעת עתה, היא מחרוזת רצף של תווים.
>> בינתיים, ב-C, אתה אכן יש סוגי נתונים שונים.
שים לב אלה הם אותיות קטנות.
אז את הפונקציות שראית לפני רגע הם פונקציות שנכתבו על ידי CS50
אחזור אליך ערך שנופל לאחת מהקטגוריות הללו.
>> כמה רמות גיליונות רק כדי לשתול הזרע כאן. printf לא פשוט
לקחת% s כמצייני מיקום.
זה לוקח% d עבור מספרים שלמים עשרוניים, או% אני עובד גם כן.
% F הוא צף ערכי נקודה. % ג הוא עבור char, אם אתה רוצה רק כדי לחבר אחד
תו למחרוזת מעוצבת מראש כמו שאנחנו כבר עושים, אתה יכול להשתמש% ג.
>> ואז, קצת מעצבן, LLD% הוא למספר עשרוני שלם רב, רב מאוד,
רק אומר שאם אתה צריך באמת מספר גדול ואתה משתמש במשהו
שם ארוך ארוך, שאנחנו נבוא בחזרה בpset, אתה יכול להשתמש ל% LLD
תגיד printf, תקע גדול באמת מספר שלם בדרך שלו שני או
איזה ויכוח אחר.
>> ולבסוף, הבטחתי כי יש כמה בריחה אחרת
רצפים שprintf תומך בם.
ראינו את הקו הנטוי-n.
לוכסן-R אתה יכול לראות.
זה סוג של דבר מאסכולה ישנה.
אם אי פעם השתמשו במכונת כתיבה אמיתית שנים לפני ואתה משך על הארכובה
אשר לא רק מסובב את הגלגל כדי להזיז את ההרכב, הוא גם עבר
כל העניין כל הדרך חזרה אל מהשמאל, ובכן, קו נטוי-R פשוט
בעצם מעביר את הסמן אחורי לתחילתו של הקו
בלי להזיז אותו.
אבל שוב, נוסף על כך, אולי, בעתיד.
>> לוכסן-ציטוט, קו נטוי הפוך כפול, קו נטוי קו נטוי, הוא
פתרון לחידה קטנטנה אני רמזתי קודם לכן.
וקו הנטוי-0 היא למעשה די מעניין.
אבל אנחנו נחזור אל כי לפני זמן רב.
>> אז תן לי להיכנס, עכשיו, CS50 מכשיר, ובואו בעצם עושים
מהיר להתחמם עם אחת דוגמאות אנחנו כבר ואז לעבור ל
משהו קצת יותר מורכב.
אז אם אני פותח את התכנית שלי נקרא gedit -
זו היא העורך הגרפי שלי.
ואני יכול לעשות את זה -
תנו לי לסגור את החלון שיש -
בדרך של סמל זה כאן למטה, gedit, בחלק התחתון השמאלי
פינה הבאה לתפריט.
>> אני הולך להמשיך ולהתקדם, ו להציל את הדוגמא הזאת ל, תניח, ג'ון
התיקייה של אוניברסיטת הרווארד.
התיקייה של ג'ון הרווארד היא רק ביתו ספרייה שבה כל הקבצים שלו לחיות
כברירת מחדל.
ואני הולך לשמור את זה כ קובץ בשם hello-0.c.
ואני בחרתי את השם הזה רק כדי שאותו שורות עם הקוד לדוגמא על
האתר של וכמובן ב קטעי וידאו באינטרנט.
>> אז עכשיו אני הולך להתחיל לכתוב את התכנית הראשונה שלי.
תן לי להתקרב לקריאות.
ואני הולך קדימה, ואומר int החלל ראשי, שהוא בדיוק כמו ש
פיסת הפאזל צהובה ש מתחיל תכנית.
אני מקבל את הרגל מעל שנים של פתיחת הסד המתולתל שלי, ולאחר מכן
גם לסגור אותו ולאחר מכן חוזר ל שבו אני רוצה לשים את הקוד שלי, רק
כי זה עוזר לי לשמור על הכל מאוזן, במיוחד כ
התכנית מקבלת ארוכה.
>> ועכשיו, כאן, אני הולך קדימה ואומרים, printf, מירכאות,
שלום עולם, קו נטוי-n, קרוב ציטוט, סוגריים קרובים, פסיק.
אז אני פשוט חוזר על כל מה שיש לנו כבר לוקח כמובן מאליו עד כה.
עכשיו אני הולך להקטין את התצוגה.
>> וחלון המסוף הזה כאן למטה, מה האם מותר לי לעשות את זה בשחור
ולבן חלון?
מה אני יכול להשתמש בו ל?
אז זה מקום שבו אני מפעיל את הפקודות ו שבו אני יכול לאסוף את הדברים.
ואני הולך לשמור את זה פשוט.
אני הולך להשתמש בתכנית קראתי הפוך, שאינו
מבחינה טכנית מהדר.
קלאנג בשמו של המהדר, אבל אנחנו נחזור לזה ב
שבוע או שתיים של זמן.
>> לעת עתה, אני רק הולך להקליד לעשות שלום-0, אבל אלו מכם שהיו
השוואה במוחך את מה שאני רק הקליד למה שהייתי צריך להיות מוקלדות רשאי
כבר יודע שאני עשיתי משהו כאן לא בסדר.
עכשיו, יש באופן ברור כמה טעויות.
לפני שאני אפילו מסתכל על מה שהם, בכל מחשבות על מה שעשיתי לא בסדר?
>> תלמידים: [חציצת קולות].
>> דוד Malan: כן.
חסר לי קובץ הכותרת של הספרייה.
כל אחד מהקבצים. H אלה נקראים כותרת קבצים, והם ביחד
שייכים לדברים בשם ספריות.
ספריות הן רק גושים של קוד שאנשים אחרים כתבו.
אז [הסטנדרטי? אני?] ספרייה היא אוסף של קבצים המכילים קוד
שאנשים אחרים כתבו.
>> אז אני מפספס את זה.
אז למה אני מקבל הודעת שגיאה?
ובכן, הרשה לי לגלול לגבות ב חלון המסוף שלי כאן.
ולרוע מזל, ב-C, כמו בהרבה שפות תכנות, בעיקר
אם כל זה חדש לך, השגיאה הודעות הן מדויקות, אבל הם גם
די סתום.
והשגיאה כאן, באדום, היא "פונקצית ספרייה במרומז הכרזה
printf סוג עם ", ואז זה מגילות לשורה הבאה, "int const char *,
... "זה פשוט מקבל באמת מכריע במהירות.
>> אבל מה שאתה צריך להתחיל לעשות, אם, שוב, חדש לכל זה, הוא רק כדי
מתחיל לחפש מילות מפתח.
באופן ברור, אני לא יכול להבין מחצית מהמילים שאני רואה כרגע.
אתה, לעומת זאת, בפרק הזמן של שבוע.
אבל אני רואה printf.
וזה צריך להתחיל, לפני זמן רב, כדי לרענן את זכרונך, בסדר, printf.
משהו לא בסדר עם printf.
האם אני מאיית את זה לא נכון?
לא, זה לא נראה כמו - הו.
אני לא יכול להשתמש בו, אלא אם כן אני מלמד המהדר שהוא קיים.
וכך, שוב, ללכת עם האינסטינקטים שלך, גם אם אתה לא ממש מבין
הודעות השגיאה בפועל.
>> ואכן, הפתרון כאן הוא פשוט לכלול אותו בחלק העליון של הקובץ
ככה, resaving את התיק שלי עם שליטה-S או בתפריט הקובץ.
ואם עכשיו אני חוזר לכאן, אני הולך לנקות את זה.
שליטה L הוא פשוט דרך נחמדה כדי לנקות את המסך.
ולאחר מכן אני הולך להקליד "לעשות שלום 0 "Enter, ועכשיו אני עדיין רואה
רצף מסתורי של סמלים, אבל אנחנו נחזור לזה.
זה מה שהוא עושה יעשה בשבילך.
זה מיכון התהליך של לקיחה הפקודה די מעצבן מעורבת
קלאנג, המהדר בפועל.
אבל העובדה שיש לי אין שגיאות אומרת כי דבר זה אמור לעבוד.
>> אז אני עכשיו הולך לעשות - תנו לי להתקרב שוב -
./hello-0 הזן, ואכן, אני רואה "שלום, עולם". אז בואו עכשיו לשפר
זה אי פעם כל כך מעט, רק כדי לשכפל הצעדים שנועדנו.
אני הולך לשנות את השם הזה עם שמירה בשם לhello1.c.
ועכשיו אני הולך להכריז על משתנה קרא בהשם, ולכן שם מחרוזת
ואני הולך לשים את זה ערך של מרכאות
D--V-I-D-ציטוט פסיק קרוב.
ועכשיו אני הולך להחליף את "העולם" עם מה שמציין מיקום עבור מחרוזת?
% S.
>> ועכשיו, כמה טיעונים צריכים printf לקחת את הזמן הזה?
אז שתיים.
אז אני יוצא החוצה מהציטוטים.
אני מקליד "שם" אחרי פסיק.
אבל אני כבר עשיתי משהו בעיה אחרת הפעם.
אבל בואו נניח שאין לי מבין את זה עדיין.
עזוב אותי כאן.
>> ושים לב, יותר מדי, אני מקבל קצת משועמם של הקלדה "לעשות שלום 0" כל
זמן, "לעשות" וכל זה.
אז, כך מתברר, בינוס שאתה יכול לעתים קרובות פגע בחץ למעלה עליך
מקלדת, ולמעשה אתה יכול לגלול דרך כל הפקודות שאני כבר
להורג קודם לעכשיו.
אז אם אני עושה את זה, למעלה, למעלה, יש לעשות שלום 0.
אני לא רוצה את זה.
אני רק רוצה לשנות את זה כדי שלום 1 הפעם, Enter.
סופו של דבר, שיהיה לחסוך לך קצת זמן.
>> בסדר.
למרבה הצער, אין הוא שגיאה.
אז בואו לגלול אותי.
זה נראה כמו שאני באמת שחט תכנית זו.
אני מתכוון, אלוהים שלי, זה שתי שורות של קוד, ו 10 שורות של שגיאות.
אבל תסתכל על אחד העליון ראשון.
שימוש במחרוזת מזהה לא מוצהרת.
האם אני מתכוון סטנדרטי אני n?
לא, אני לא.
התכוונתי למחרוזת.
>> אבל איפה הוא משתנה המחרוזת סוג הכריז, DD אנחנו אומרים?
אז זה בCS50 הספרייה.
כך שזה לא יספיק, באלה ראשון כמה שבועות, רק כדי להשתמש
מה שנותן לנו ג.
אני גם הולך לעלות לכאן, ואני אפשר לשים אותו מעל או מתחת, אבל אני יהיה
רק לשמור את זה אלפביתי כדי לשמור על דברים מסודרים.
אני מתכוון לכלול cs50.h, אשר הותקן מראש עבור
לך על מכשיר CS50.
וזה קוד פתוח, כך שגם אנשים באינטרנט יכול להשתמש בו עליהם
מחשבים משלו.
אבל זה בא עם מכשיר CS50.
>> אז עכשיו תן לי לחזור ולהדר מחדש זה עם לעשות שלום 1.
לעזאזל.
ובכל זאת עוד שגיאה.
בואו לגלול עד הראשון, אבל.
זה אחד זה קצת מורכב.
אופי רב אופי קבוע.
זה לא עוזר לי.
אבל שימו לב, קלאנג הוא לפחות קצת קצת הגון, לפיה עם קצת
תו ירוק סמל, הוא אומר כאן מקום שבו אני דפוק.
למה הוא מצביע, שעם קצת חץ ירוק, לציטוט הבודד הבא
לשם שלי?
>> אז זה אחד מהדברים שאתה רק להתרגל אליו, במיוחד אם אתה כבר
תכנות בפייתון, או JavaScript, או בשפות אחרות שבו פרט זה
לא משנה.
ב-C, זה כן משנה.
אם אתה מכריז מחרוזת, שהוא רצף של 0 או יותר תווים,
אתה באמת חייב להשתמש במרכאות כפולות.
אז בעצם אני צריך לשנות את זה בחזרה כדי לפתוח הצעת מחיר, לסגור את הציטוט, עם
מרכאות כפולות.
לעשות יחיד ציטוטים יש להם מקום, אבל רק כאשר אתה משתמש באדם
תווים, אבל עוד על כך בפעם אחרת.
לעת עתה, במרכאות הכפולות הם הכרחיים.
>> אז עכשיו, תן לי לחזור למסוף שלי חלון, לעשות שלום 1.
ומי בטוח?
האם התכנית הזו עכשיו הולכת כדי לקמפל בצורה נכונה?
אישור.
אז שלושתנו חושבים שזה.
בסדר.
Enter.
וזה באמת עשה.
כך שאין טעויות בזמן הזה, אפילו למרות שתכנית זו היא לפשוט קצת
מורכב יותר.
אם אני עכשיו עושה נקודת לוכסן שלום 1, הזן, זה הולך להגיד "שלום, דוד".
>> אבל בואו נעשה איטרציה השלישית מזה, שבו
התכנית היא דינמית באמת.
תן לי ללכת קדימה ולשנות את הקובץ שם, רק בשביל עקביות עם
קבצים יהיה לך זמין אחר כך לך באינטרנט.
Enter.
ועכשיו אני הולך להיכנס ולא לאחסן "דוד" המקודדים קשה כאן.
מה אני יכול לעשות כדי פשוט מאוד לשפר את התכנית זו?
>> אני יכול להתקשר getstring.
זה יכול להיות זה מה שאינו מובן מאליי קטן עומד לקרות, אז אני הולך
לבעצם להוסיף קו נוסף, printf, ולומר את השם, מעי גס, ציטוט קרוב, רק
כדי לתת למשתמש מהיר על המסך.
ועכשיו אני הולך כאן, ואני הולך להשתמש בקיצור המקשים שלי.
אני הולך למעלה, למעלה, ולשנות שלום 1 לשלום 2, Enter.
ותודה לאל, אני עושה התקדמות.
>> ועכשיו אני הולך לעלות לנקודת לוכסן שלום ו
לשנות את זה ל 2, Enter.
ועכשיו התכנית שלי -
אני להתקרב - הוא מקבל קצת יותר יפה.
שם הוא הולך להיות, נניח רוב הפעם, הזן, הלו, רוב.
אנחנו יכולים לעשות את זה שוב.
שם, לורן, Enter.
שם, יוסף, Enter.
שם, בואו ננסה להיות קשה, Enter.
אה.
זה לא באמת באג.
אז זה רק קטן ומכוער.
אז אולי אנחנו יכולים לפתור את זה בעתיד, לא עכשיו.
>> אבל איך היית אינסטינקטיבי ללכת על טיפול
אתגר מסוים הזה?
זה פשוט נראה טיפשי.
איך להימנע מדברים מחפש טיפש?
אז אנחנו יכולים לעשות, בסדר, שמעתי בני זוג של דברים, ומצב לולאה.
אנחנו יכולים להשתמש בו, אחד, מצבו, כדי לבדוק את מה האורך של המחרוזת
המשתמש נתן לנו?
ואם זה 0, זה פשוט מירכאות, הם פשוט על Enter, ולאחר מכן
אולי כדאי לי לצעוק עליהם ותנחה אותם שוב.
אבל איך שתנחה אותם שוב?
ובכן, גם אני שמעתי את הלולאה, ושאני יכול לעשות את זה שוב ושוב ושוב
להציג הודעה למשתמש על אותו הדבר.
>> ובכן, בואו נעשינו את הדוגמא השנייה שימוש שונה
פונקציה בספריית CS50.
תן לי לסגור את הקובץ הזה.
תן לי ליצור אחד חדש.
ואני אתקשר אליו adder.c, רק בגלל זה קל לעשות חשבון פשוט,
למרות שזה יהיה לגמרי underwhelming עם מה שאתה יכול לעשות
עם כל מחשב מודרני.
>> אבל תן לי ללכת קדימה ועכשיו -
אני למדתי את הלקח שלי בפעם האחרונה - כולל cs50.h, להכליל את stdio.h, int
החלל מרכזי, אשר, לעת עתה, אני רק לקחת על אמונה עיוורת, אבל נניח
שיבין מה זה אומר שלפני זמן רב.
ואני הולך להגיד משהו כמו "תן לי int".
>> ועכשיו, איך אני מגיע int?
אני רוצה להכריז על סופו של דבר משתנה בשם X מסוג int ו
לאחסן אותו במספר שלם מהמשתמש.
אז זה היה בפה מלא.
אבל אם מישהו רוצה להציע, איך אני מצהיר בשם X מספר שלם?
x int.
>> אז זה באמת פשוט ש.
תן לי int.
קוראים לזה x.
עכשיו אני משתמש באופרטור ההשמה.
ואיך אני יכול לאחסן מ עזב את ערכו של המשתמש?
אני לא רוצה לקרוא לgetstring, כמובן, אלא getint.
כל ויכוחים?
לא.
כך שזה פתוח פארן, קרוב paren באופן מיידי, ולאחר מכן
פסיק מסתיים הקו.
>> עכשיו תן לי לעשות את זה שוב.
תן לי int אחר.
הפעם אני אעשה int, בואו קורא לזה Y, שווה getint.
ועכשיו תן לי לעשות משהו סופר פשוט כמו קצת מתמטיקה.
אז printf, הסכום של% d הוא מציין מיקום עבור int.
ו% ד, תקופה, קו נטוי-n.
>> בסדר.
אז זה לא ממש מתמטיקה.
אבל אם אני רוצה להגיד את הסכום הזה ערך בתוספת ערך זה שווה את זה
ערך אחר, כמה טיעונים ל אני סה"כ צריך לתת printf,
סופו של דבר?
אז ארבעה, נכון?
מחרוזת זו ולאחר מכן את שלושה הערכים.
אז X הוא הראשון שאני רוצה להיות פקוק בראשון ל% d.
Y הולך להיות הבאה.
>> ועכשיו אני סוג של רוצה לומר Z, אבל z לא קיים.
אבל זה לא עניין גדול.
כי מה שהיית עושה באופן אינסטינקטיבי, במיוחד אם היה לך
גרפים מחשבון, מה אתה מקליד?
מה דעתך על X ועוד Y?
אז זה לא משתנה בפועל.
זה רק הסכום של שני משתנים אחרים.
וזה לגיטימי לחלוטין.
C בהחלט מבין פשוט חשבון כזה.
>> פסיק, לשמור.
עכשיו תן לי ללכת לכאן ו הקלד להפוך אפעה, Enter.
אין שגיאה, אז זה גם התקדמות.
הקלד אפעה.
וקיצור מקשים אחר, אם אתה מתחיל להשתעמם
עם כל פקודות -
אם אתה מתחיל להקליד פקודה, כמו נקודה לקצץ את המודעה, וזה מקום שבך
שעמום בעיטות, אתה בדרך כלל יכול לפגוע כרטיסייה למחשב יש לסיים את
שאר הביטוי בשבילך אם זה לא מה שלא ברור צריכים לבוא אחרי מודעה.
>> אז תן לי ללכת קדימה עכשיו ואתה לוחץ על Enter.
תן לי int, 1, 2, ו תודה לאל, שזה 3.
אבל כמו תמיד, לבדיקת תוכניות לא צריך להפחית ל
רק מנסה את זה פעם אחת.
תן לי לנסות מקרה פינה, כמו שלילי 1, תן לי 1, וכי אחד
בודק את גם כן.
ואני כנראה רוצה לעשות עוד קצת בדיקות מחמירות, אבל אני די
שבו בנוח עם זה בבית.
>> ובכן, עכשיו בואו ננסה תכנית אחרת שהפעם משתמש
קצת תחביר אחר.
תן לי ליצור קובץ חדש.
אני אתקשר conditions0.c זו בשורה עם כמה דוגמת קוד באינטרנט.
ותן לי ללכת ולעשות כולל cs50.h, כולל
stdio.h, בחלל עיקרי -
אישור.
שם אנחנו הולכים.
יש לנו מוכן מראש הרגיל שלנו.
>> והפעם אני הולך לומר printf, "הייתי רוצה int, בבקשה," רק כדי
להפוך את הפקודה קטנה ידידותי יותר.
ועכשיו אני רוצה לקבל int מהמשתמש.
אני הולך לקרוא לזה n הפעם, רק משום n נשמע כמו מספר.
getint, ועכשיו, מה לעשות אני רוצה לעשות עם זה?
ובכן, אם n הוא - ואני להתקרב -
אם n הוא גדול מ 0, אני רוצה כדי לבצע את הפעולות הבאות -
printf "אתה הרים מספר חיובי." דבר אחר, אני הולך להקליד printf "אתה
הרים שלילי
מספר. "בסדר.
אז התכנית הזאת, למרות שאני עשיתי את זה מהיר, נראה נכונה מבחינה תחבירית.
תן לי לנסות את זה.
הפוך את מצבו 0.
נראה לרוץ.
מצב 0, להיכנס.
בואו ניתן לו int של 50.
הרמתי מספר חיובי.
בואו ננסה את זה שוב.
מצב 0.
שלילי 50.
הרמתי מספר שלילי.
>> אבל עכשיו, תן לי לבחור את מה שאנחנו נשמור קורא מקרה פינה, שהוא יותר
מקרה מעניין שאתה חושב אולי ייתן לך קצת בעיות, 0.
עכשיו, אני די בטוח שזה אחד פינת מקרים שבהם הוא אפס
לא חיובי ולא שליליים, כך שלי תכנית, אם כי בבחינה תחבירית
תיקון - זה הידור, הוא פועל - לא הגיוני נכון.
אז מה התיקון פשוט כאן אם אני רוצה כדי לזהות, אם אני רוצה להתמודד עם n
שווה 0 בנפרד?
>> אז אם n שווה 0, אז אני רוצה לומר משהו כמו printf "אתה הרים 0".
תן לי לנסות את זה עכשיו.
תן לי לחזור לכאן, נקה החלון שלי, והקומפילציה.
הממ.
ליצור שגיאה אחת.
אבל אני רוצה לבדוק אותך אם n שווה 0.
>> אז שוב, עוד דבר טיפשי להתרגל, סימן שוויון הוא
אופרטור ההשמה.
אז זה בעצם טעות בכך, מבחינה טכנית, למרות שהמהדר
הגנה עליי מעצמי, הייתי מבחינה טכנית ניתן להעתקת 0 N, אשר
זה לא מה שאני רוצה.
אני רוצה לבדוק לשוויון עם שווה שווה.
וכך שעכשיו יכול להיות הפתרון טוב יותר שלי.
>> תן לי לשמור מחדש למעשה זה כמו, יניח, conditions1, להיות חדש ומשופר.
אז עכשיו אם אני הידור מחדש את זה, זה יגרום תנאים -
אופס - להפוך conditions1 נקודת לוכסן conditions1, הזן, "הייתי רוצה int,
בבקשה. "אני מתכוון ללכת קדימה, הקלד 50.
זה עדיין טוב.
50 שלילי, עדיין טוב.
0, וזה, אכן, זוהה שהרמתי 0.
>> אז מה יותר עכשיו אני יכול לעשות עם זה?
ובכן, אנחנו בהחלט יכולים לעשות יותר ויותר דברים מורכבים.
אבל מה שאני רוצה להציע הוא שאנחנו בסופו על הפתק הזה כאן.
אם אנחנו מושכים את זה, תראה, אולי, סרט מצויר אהוב שלך
עד היום אתה יכול מעולם לא הבין.
וזה בערך את האיכות של הצחוק אתה צריך לקבל עם בדיחות CS.
אז זה בערך נכון.
>> אבל יותר משכנע, חשבתי שאני הייתי לתת לנו טיזר קטן ליום השני.
אז אנחנו כבר התחלנו להשתמש במספרים שלמים.
אנחנו כבר התייחסנו למרחף.
אפילו אנחנו כבר התייחסנו לזוגות, אשר, שוב, לתת לך מספרים
לאחר נקודות עשרוניות.
>> אבל מתברר שצף זוגות, ובאמת, מחשבים,
ביסודו, לא יכול להביע את כמה ערכים בדיוק.
אנחנו יודעים משיעורים במתמטיקה, כי אתה יכול יש כל מספר של מספרים לאחר
נקודה עשרונית.
ואתה יכול גם לשים פס אנכי לומר אלה יימשכו לנצח.
>> למרבה הצער, אתה לא יכול באמת לעשות את זה במחשב.
וכך מתעוררים מקרים פינתיים.
לדוגמה, נניח שאתה עושה משהו כלכלי.
אתה עושה מתמטיקה עם האחוזים, ו
עם דולרים וסנטים.
והסנאט האלה לא בהכרח שורה למעלה.
ובכן, מתברר שברים של פרוטות יכולות להתחיל להוסיף עד מתי
דגם עם מערכת מחשב בצורה כזאת, כי חכמה
בני אדם יכול לנצל.
>> ואלו מכם שלא ראו, היינו רוצים לתת לך טיזר של 30 שניות של
סרט נפלא המכונה שטחי משרדים, אשר לצייר תמונה של
בעיה שנתמודד איתה הדבר ראשון ביום שני.
אם היינו יכול להעלות את עוצמת הקול קצת, אני נותן לך 30
שניות של שטחי משרדים.
>> [השמעת וידאו]
>> , אני מתכוון, לך, לך לא היה מראה ואתה מקבל כדי לשמור על העבודה שלך.
>> -למעשה, אני המקודם.
>> אני יכול לתכנת-וירוס שהייתי לקרוע את המקום שבגדול.
>> -ובכן, איך זה עובד?
>> -כל פעם שיש עסקת בנק שבו ריבית מחושבת, ויש
אלפי ביום, המחשב מסתיים עם שברים של אחוזים אלה.
>> אבל, אני לא הולך ל לעשות משהו לא חוקי.
>> -בלתי חוקי?
סמיר, זה אמריקה.
>> -אנחנו צריכים נשבעים באלוהים.
>> אם אף אחד לא יודע, על זה אבל לנו, בסדר?
אין בני משפחה, אין חברות, אף אחד.
>> -כמובן.
>> מוסכם.
>> , אל תדאג, גבר.
אני לא אספר לאף אחד או.
>> [השמעת וידאו הסוף]
>> דוד Malan: אז זה, אם כן, הוא CS50, שהיה שטחי משרדים, וזה יהיה כל
הגיוני ביום שני.
לראות אותך אז.
>> קריין: בCS50 הבא, רוב מתאים להיות את
תכנית ארוחת הרווארד.