>> [השמעת מוסיקה]
ג'ייסון הירשהורן: בסדר, כולם.
ברוכים הבאים למדור.
זה CS50, מאוד שלנו סעיף העל ראשון.
כפי שכולכם יודעים, בשבוע הבא סעיפים קבועים יתחילו,
אבל השבוע כולנו יחד.
>> יש את עצמי.
השם שלי הוא ג'ייסון.
אני מרצה במדעי מחשב.
יש לנו אנדי, מי הראש של ת"א CS50.
וScaz, פרופ 'בריאן Scassellati, הוא פרופסור במדעי מחשב.
>> אנחנו ראשי CS50 באוניברסיטת ייל.
אתה תמיד יכול לשלוח שלנו heads@cs50.yale.edu.
אנחנו נהיה בהרצאות.
אנחנו נהיה בשעתי עבודה.
אם יש משהו שאנחנו יכולים אי פעם לעשות בשבילך, כל דבר שאתה צריך,
אל תהסס להגיע אלינו.
>> אז מה אנחנו הולכים לעשות היום?
או לפני כן, מה מגיע השבוע?
אז שעות עבודה הן בימים שני, שלישי, יום רביעי, וביום חמישי, 8:00 עד 11:00.
יש לוח זמנים באתר.
>> סעיפים, כמו שציינתי, מתחילים בשבוע הבא.
ואתה תמצא את זה בשבוע שמה לתזמן את הסעיף שלך הוא, איזה יום היום,
ומי ת"א.
>> הבעיה סט 1 נובע ביום חמישי ב צהריים, יום שישי בצהריים עם איחור של יום.
כן, יש לך תשעה ימים מאוחר.
ויש תשעה סטי בעיה.
ויכול להשתמש רק באחד מאוחר יום לכל סט בעיה.
כן, בתוקף, כל הבעיה ערכות הן בשל יום שישי בצהריים.
זה הכל.
כל מה שפרטים הם על תכנית הלימודים.
>> בכל יום שישי, יש לנו ארוחות צהריים.
אנחנו אוהבים לעשות את זה גדול כמובן מרגישים קצת קטן יותר.
אז אתה מוזמן לאשר השתתפות.
ארוחת צהריים חינם עם בחור חבריו לכיתה וצוות.
cs50.yale.edu/rsvp.
>> כל הדברים האלה ש יש לי על המסך,
ו, אתה יכול למצוא יותר cs50.yale.edu או cs50.harvard.edu, אם אתה רוצה ללכת להרווארד
וצופים באינטרנט זה.
>> גם באתרי האינטרנט אלה, יש טון של משאבים בשבילך.
לכל הרצאה לא רק וידאו ההרצאה, אלא גם מציין.
מישהו יצפה להרצות ולרשום הערות בשבילך.
אז אתה יכול פשוט לשלם תשומת לב במהלך הרצאות,
או שאתה יכול להשתמש ברשימות שלהם / שלנו מציין להשלים הערות משלך.
>> יש מגלשות מקוונות.
המקור code-- הכל דוד ניגש בהרצאה,
או Scaz עובר על הרצאה, ש קוד המקור זמין באופן מקוון
כמו גם, כמו שאני כ, ציינו קטעי וידאו.
>> סעיפים, כמו כן, יהיו כולם צולמו.
כל שקופיות אלה יהיו זמינים.
כל קוד ש יהיה זמין עבורך.
יש מכנסיים קצרים באתר האינטרנט שבו חברי צוות CS50 לבלות חמש עד 10
דקות עוברות נושאים בשבילך.
חלק מאלה שיש לך כבר נתקל בבעית סטים.
>> שעתי עבודה, כפי שציינתי, בימים שני עד חמישי, 8:00 עד 11:00.
CS50 הלימוד הוא משאב נפלא.
יש בעיות בפועל, שקופיות מדגם, באגים ידועים
שתלמידים אוהבים לרוץ ל, למהות כולנו נושא
יכסה בקורס זה.
>> ולבסוף, בשקופית זו לפחות, Reference50
אשר נותן לך מידע על כל פונקציות C
האם אי פעם יכול אולי לקוות לשימוש והרבה, הרבה יותר.
>> שוב, כי נקודה נקודת נקודה ב החלק התחתון של המסך
הוא מצביע על כך שיש אפילו יותר משאבים בשני אתרים אלה:
cs50.yale.edu, cs50.harvard.edu.
>> אז, מה אנחנו עושים היום?
ובכן, קודם אני הולך לתת לי אתה מסתכל על המשאבים.
כבר עשה את זה אחד.
תראה לנו.
>> עכשיו, אנחנו הולכים לעבור על סוגי נתונים ומפעילים בג
אז אנדי יגיע לכאן ו ללכת על ספריות ב- C, printf (),
פונקציה שבה אתה כבר מוכר או יהפוך מהר מאוד
מוכר.
ואתה גם לעבור על התניות ולולאות.
>> ולבסוף, Scaz ילך על זיהוי CS50.
אם לא צלל ב כבר בבעיה הסט 1,
כמו גם אופן שימוש ב פקודות מסוף ושימושיים
ואז לתת לך כמה הדגמות ו קידוד בפועל בזיהוי CS50.
>> לפני שאני קופץ לזה תוכן בצד הזה,
האם יש מישהו כל שאלות עד כה?
גדול.
אוקיי.
שינוי הילוכים.
>> [מחליף הילוכים]
>> זה היה לי הסטה הילוכים במכונית ידנית.
אז סוגי נתונים ב- C, אתה לא יכול פשוט יש לי x משתנה ויש לו להיות בקו 10,
מספר שלם, אולי המספר 1, על קו 20, מספר עשרוני 10.5,
ולאחר מכן כמה קווים מאוחר יותר מחרוזת, אני אוהב את CS50.
>> ב- C, משתנים יכולים להיות רק דבר אחד, ודבר אחד בלבד.
ואז אתה צריך לתת להם סוגים.
ועל לוח זה, אנחנו יש רשימה של סוגים.
יש תווים, ש עומד לדמויות.
אז זה אות אחת, B, C, ד זה יכול להיות גם חלל,
או שגם יכול להיות אופי קו חדש.
>> יש מספרים שלמים, שהם רק מספרים, כל מספרים שלמים או אחר מספרים
rather-- אבל לא עשרוני.
>> לעשרוני, יש לנו מספרי נקודה צפה.
מספרי נקודה צפה מספרים עשרוניים עם.
>> אז יש משתוקק, שהם מספרים שלמים במהות עוד.
תוכל להבחין כי ארוך הוא 8 ואילו int הוא 4.
אני אגיע לזה בשנייה.
זה בגלל שמתגעגע יכול לאחסן אפילו יותר מאשר מספרים שלמים int יכולים לאחסן.
זוגי הוא לצוף ארוך.
>> ולבסוף, יש לנו מחרוזת, שהוא סוג
שיש לך כנראה השתמש בעבר.
אם אתה כולל hashtag # IncludeCS50.h בקובץ המקור שלך,
אז אתה יכול להשתמש בסוג מחרוזת.
זה לא בנוי למעשה לג
>> יש סוגי זוג אחרים גם כן.
אבל אלה הם העיקריים אלה עם שבו תוכל להשתמש ונתקלים.
C כ, שוב הזכרתי, כל variable-- זה
יכול להיות רק סוג אחד וסוג אחד בלבד.
זה בגלל שC הוא באופן סטטי שפת הקלדת, בניגוד
לשפות הקלדה דינמית שבו אם אתה יוצר משתנה
אתה יכול לשנות את מה שהוא מאוחסן ב זה כמו שאתה הולך על בתכנית שלך.
כאן על יד ימין צד, יש לי בגדלים השונים
אלה סוגים של נתונים בבתים.
אז דמות היא 1 byte.
זה 8 סיביות.
וזה אומר כי 8 ביטים יש שמונה 0s ו 1s.
ראינו הדגמות אלה בראשונים שבוע עם שנורה בינארי.
>> עם 8 סיביות או בתים 1, אנחנו יכולים מייצג מספרים 0-255.
תקין.
אם כל 8 הביטים הם 0 זה 0.
אם קצת הראשון הוא 1, זה המספר אחד, וכן הלאה, כל הדרך עד 255.
ולכן לדמויות שאתה יכול יש בעצם עד 255 מהם,
אבל זה מספיק כדי לכסות את כל הדמויות שאנחנו צריכים להשתמש.
>> למספרים שלמים, אתה יכול להיות 0 ו אז יש לך 2 למינוס 32 1.
אלה הם כמה אפשרויות יש לך למספרים שלמים.
>> במשך זמן רב, יש לך 0 2 למינוס 64 1.
אז יש לך רב, רב, אפשרויות נוספות למתגעגע.
>> מחרוזות, זה סימן שאלה כי זה סחרור מסוכן לשימוש מאוחר יותר.
כן.
אני יכול לספר לכולם זה על קצה המושב שלהם,
כמו מה זה סימן השאלה?
זה סחרור מסוכן.
אנו סופו של דבר יכסו את גודל מחרוזות ולדבר יותר על מיתרים.
בגלל מחרוזת היא למעשה אחד מגלגלי העזר
אנחנו שמים על זה ב כמובן בתחילת
ולאחר מכן להמריא מאוחר יותר ב, כי מחרוזות בC
הם מצביעים למעשה למערכי אופי.
אבל שוב, זה סחרור מסוכן לשימוש מאוחר יותר.
בטרם אעבור על כל שאלות, הערות, חששות לגבי שקופית זו?
>> אוקיי.
אני חייב להיות מסביר פנטסטי.
גם כאשר אתה מתכנת, אתה הולך להשתמש באופרטורים אלה.
סימנים ממש פשוטים שיכול לעשות פשוט פעילות, שבה אתה כנראה
כבר מכיר היטב.
>> לדוגמא, בצד הימין צד, אנו רואים להוסיף.
כדי להוסיף, אתה פשוט עושה סימן הפלוס.
וכך אולי יש לך שני משתנים x ו- y.
אתה יכול לעשות y + x בקוד שלך.
אולי אתה רוצה לומר שאתה צריכה-- 7 ו -3 יש מספר,
אתה רוצה לאחסן ש בסכום משתנה בשם.
אתה יכול לעשות int לסוג, החלל סכום, השם המשתנה, = 7 + 3;
>> מה היית חנות שבסכום?
כל אחד?
אם היה לי בסכום = 7 + 3.
מה יהיה מאוחסן בסכום?
אתה יכול פשוט לצעוק את זה.
קהל: 10.
>> ג'ייסון הירשהורן: 10!
זה בדיוק נכון.
מה לגבי בסכום = 7 - 3, רק אני משתמש כי סימן מקף.
מה הולך להיות מאוחסנים?
קהל: 4.
ג'ייסון הירשהורן: 4.
סכום הוא כנראה השם הלא נכון ל משתנים זה, אבל 4 יהיו מאוחסן.
>> להכפיל ב- C, להשתמש במעט דמות כוכב, אתה לא משתמש בx.
לחלק, להשתמש קדימה סלאש לא סמל החטיבה.
ומודולו, להשתמש בסמל אחוזים.
>> אז בואו נגיד שאני רוצה לראות את int z = 7% 3, מה יהיה מאוחסן בz?
אז, זה בעצם שואל מה מודולו עושה?
האם מישהו יודע מה עושה מודולו?
כן.
y 4.
1 דובר: זה את השארית.
ג'ייסון הירשהורן: זה שארית כאשר אתה מחלק.
אז 7 מחולקים 3 הוא 2 שארית 1.
אז 1 יהיה מאוחסן.
>> אתה עשית את חיסור, אבל ככה זה עובד.
זה מה שעושה מפעיל מודולו.
זה לוקח מספר חלק על ידי מספר אחר וחוזר אליך
את השארית.
אז שוב, 7% 3 נותן לך 1, כי 7 מחולקים 3 היא 2 שארית 1,
ומחזיר את השארית.
>> מה לגבי בואו נחזור עד צעד אחד שלסימן החלוקה.
אם אני עשיתי 7 / מחולק 3 עושה מישהו יודע מה שיחזיר?
>> SPEAKER 2: 2.
>> ג'ייסון הירשהורן: למה 2 ולא 2.333?
>> SPEAKER 2: אני חושב שזה חותך את אחרי המספר השלם.
ג'ייסון הירשהורן: אז זה בדיוק נכון.
ב C, אם אתה עושה את חלוקת שני מספרים שלמים 7 מחולקים 3,
הוא מקבל את התשובה ש במקרה זה 2.3333 לנצח
והוא מוצא שנקודה עשרונית ו צלעות את כל מה שאחרי הנקודה העשרונית
וזה פשוט מחזיר אותך 2.
>> אז אם עשיתי 8 מחולק 3.
כי למעשה, אנחנו יודעים כי לחזור 2.666,
אבל זה צלעות את הכל ב העשרוני, חותך את כל זה,
ורק חוזר אליך 2.
אז 6 מחולקים 3, 7 מחולקים על ידי 3, 8 מחולקים 3,
כולם הולכים לחזור אליכם 2.
>> האם מישהו יודע, או שיש לי ניחוש, כיצד אני יכול למעשה לקבל
התשובה המלאה, אם אני רוצה עשרוני ש?
כן.
לך על זה.
SPEAKER 3: השתמש לצוף?
ג'ייסון הירשהורן: מה זאת אומרת?
3 דובר: מכיוון שאתה אמר לצוף הוא למספרים [לא ברור]
ג'ייסון הירשהורן: ימין.
אז, זה בדיוק נכון.
7 הוא מספר שלם.
אבל אם אני רוצה להפוך את זה למספר נקודה צפה,
הייתי צריך לאחסן ש כ7.0 בגלל המחשב
הוא באמת stupid-- ראו ש עם example-- PB וJ
זה יעשה רק בדיוק מה אתה אומר את זה.
>> אז אם אתה כותב 7, זה חושב שזה מספר שלם.
אם אתה כותב 7.0, למרות שאנחנו יודע את הדברים האלה הם שווי ערך,
היא מתייחסת לזה כמו צף מספר נקודות.
אז אם אתה עשית 7.0 מחולק על ידי 3, או מחולק ב -3.0,
זה הייתי אומר, אוקיי, עכשיו עם צף יש לנו עסק.
אני אחזור אליך 2.333333 לנצח.
אבל לא ממש לנצח, כי כמו גם שראינו בהרצאה,
מספרי הנקודה צפו אלה הם לא בדיוק מדויקים.
>> אז אם אתה רוצה עשרוני ש, או חלק מעשרוני ש,
אז אתה צריך use-- אחד מהם צריך להיות מספר נקודה צפה
והמחשב יש להבין כי מדובר בנקודה שאתה צף
התמודדות עם, לא שלם.
כל שאלות על שולחן שעל בצד ימין, כל כך רחוק?
או צד השמאל שלך, שלך עזב, הצד השמאלי שלך.
כן.
4 רמקול: ימין.
רק רוצה רגיל מספרים שלמים, שהיית
write-- היית צריך לכתוב לצוף?
>> ג'ייסון הירשהורן: כן כן.
ובכן, אם ברצונך ליצור משתנה זה לצוף,
אתה צריך להגיד לצוף z שווה משהו.
>> 4 רמקול: אישור.
>> ג'ייסון הירשהורן: אבל אם אני רוצה לעשות 7 מחולקים 3 ולקבל עשרוני ש,
הייתי עושה z לצוף = 7.0 / 3.0; ו שייתן לי את הנקודה הצף
מספר.
>> 4 רמקול: אישור.
>> ג'ייסון הירשהורן: אם אני עשיתי משהו כמו int z = 7 / על ידי 3,
שייתן לי מספר שלם, כי אלה הם כל המספרים השלמים.
האם זה הגיוני?
>> 4 רמקול: כן.
>> ג'ייסון הירשהורן: אישור.
גדול.
שאלות אחרות על שולחן זה?
באמת?
אני כל כך מתרגש.
אוקיי.
>> אז כמה דברים אחרים שאתה תשתמש, לעתים קרובות בתנאים או לולאות,
סוגים אלה של operators-- סוגים אלה של ביטויים בוליאנית.
וכפי שלמדנו, == זה מה שאתה להשתמש בו כדי לבדוק אם שני דברים שווים.
>> אז הנה אני בודק אם y x ==, בוא שוב להניח x שהוא 7 ו- y הוא 3.
אז אם כתבתי 7 == 3, מה ש היה שיחזור אליי?
האם זה נכון או לא נכון?
>> קהל: לא נכון.
ג'ייסון הירשהורן: אישור.
אני מרגיש כמו כולם יכול לקבל את זה.
אז כולם, מה שהיה שיחזור?
קהל: לא נכון.
ג'ייסון הירשהורן: שקר.
גדול.
7 לא שווים 3.
אז 7 == 3 יחזור שווא.
האם יש לך סימן לא שווה, כך שאם אני בדק 7! = 3, מה היית שיחזרו?
קהל: נכון.
ג'ייסון הירשהורן: נכון.
מצוין.
מישהו היה מאוד תקיף ב הגב ומעריך את זה.
אז יש לך פחות ממפעיל, פחות או שווה למפעיל,
גדול ממפעיל, גדול יותר או שווה למפעיל.
>> אז עוד בדיקת שפיות אחד.
אם היה לי 7 הוא גדולים יותר או שווה ל 3.
מה היית שתחזור?
>> קהל: נכון.
ג'ייסון הירשהורן: נכון.
כן.
שהחדר אחורי, צד אחורי מהחדר, פנטסטי.
ניתן לשלב הבאים ביטויים אם אתה כן רוצה,,
עם והגיוני שהוא && או הגיוני או שהוא ||
||.
ואז עכשיו אתה יכול לבדוק שני דברים together-- האם זה מצחיק?
למה זה מצחיק?
>> אז אם אני רוצה, אני יכול לומר הוא 7 יותר מ 3 ו 2 הוא פחות מ 4?
ובכן, אם 7 הוא גדולים יותר מ 3, זה נכון.
2 הוא פחות מ 4, זה נכון.
אז כל הדבר הזה יחזור אמיתי.
>> אם בדקתי 7 הוא יותר מ -3 and-- אני רק לקטוף מספרים אקראיים כאן--
4 הוא פחות מ -2, טוב, זה שקר.
כל כך נכון ואיפור שקר שקר.
ואתה יכול ללכת על ואתה משלב כ תנאים רבים יחד כמו שאתה רוצה.
>> האם יש למישהו שאלות, הערות, דאגות עד כה?
ואני רואה שכמה מכם לצלם שלי במסך, שאני מעריך.
יש לקוות, שזה לא סנאפצ'ט.
יש לקוות, שזה להערות שלך.
אבל כל אלה הולכים להיות זמין באינטרנט.
אז אין לך לצלם תמונות של זה.
כמו שציינתי, כל מה ש יהיה זמין באינטרנט עבורך.
אוקיי.
אני עומד לקבל מאחורי הקלעים, כך גם אף אחד
רוצה לומר משהו לפני שזה יקרה?
שאלות?
>> [חציצת קולות]
>> ג'ייסון הירשהורן: הו, לעצור.
אתם נחמדים מדי.
אוקיי.
אני הולך לתייג החוצה.
בוא נלך.
>> ANDI פנג: אנחנו הולכים לעשות שינוי מיקרופון מביך עכשיו.
>> ג'ייסון הירשהורן: אני הולך לקחת את זה משם.
ANDI פנג: מעריך את התמיכה, בחורים.
אתה יכול לשמוע אותי?
האם זה טוב?
ללא רבב.
יפה.
תן לי רק לתחוב שב.
אוקיי.
אז, אני עומד לעשות כמו ענק מידע לזרוק עליכם עכשיו.
ואין דאגות כלשהן אם אתה לא כל שורה הבאה מעט ממה
אני עומד להראות לך.
כג'ייסון אמר, כל מה ש הוא מקוון לחלוטין.
רק שאנחנו הולכים לנסות להציג כולם למושגים מכוסים
בחלק משקופיות אלה.
אז פשוט פעלת יחד.
אל דאגה, אם אתה לא מבין הכל; עם זאת, אם בכל נקודה
אתה מרגיש אבוד, להעלותך יד, נפסיק, אין דאגות.
מגניב.
>> אז אני חושב שמשהו שיש לי דוד כבר הזכיר סוג של בהרצאה
וג'ייסון סוג של רמז היום הוא מה שהיא ספרייה.
אז בתכנות, יש לנו הדברים האלה נקראים ספריות.
איפה, בעצם, כל הם רק סט
של פונקציות, ש בעצם רק קוד זה
כבר נכתב על ידי מישהו אחר שכולנו יכולים
להשתמש בתוכניות שלנו.
>> אז איך עושה רגיל עבודה בספרייה, נכון?
אתה נכנסת לדלת הספרייה.
יש לך את כל אלה ספרים שאתה יכול לשלוף
ואתה יכול לגשת למידע בתוך הספרים האלה.
אותו דבר בתכנות.
>> יש לך ספרייה שכבר נכתב על ידי אנשים אחרים.
ואופן שבו אתה יכול, כמתכנת או סטודנט,
יכול לקבל גישה לספרייה ש הוא באמצעות #include hashtag.
>> לדוגמא, שבC יש שלוש C-- ביותר
נפוץ שלוש C סטנדרטי libraries-- ספריית קלט / פלט,
ספריית המחרוזת, וספריית המתמטיקה.
>> אז בתוכך ראשון בעיה הזוג קובעת,
אלה יהיו שלוש שלך שבעיקר משתמש.
אז כפי שכבר דוד הסביר בהרצאה,
אני הסטנדרטי / ספריית O, או קלט / פלט סטנדרטי ספרייה
עושה בדיוק את זה.
זה מאפשר לך, בקוד שלך, לכניסה שום דבר מהמשתמש והפלט ש
למסך, במהות הדפסתו על גבי המסך.
>> ולכן כל פעם שאתה משתמש בכל פונקציות, למשל printf () function ש
אנחנו הולכים לעבור על השקופית הבאה, הקפד לכלול את תקן קלט / פלט
ספרייה או אחר אתה לא הולך ל תוכל להשתמש בפונקצית printf ().
מכיוון שאתה, כמתכנת אף פעם לא באמת כתב פונקציה ש,
רק אתה משתמש במישהו הקוד שלהם בתוך הקוד שלך.
>> האם זה הגיוני שכולם?
מגניב.
>> ואז אנחנו בעצם מקבלים על ספריית string.h וmath.h
ספרייה, H רק מסמנת ספרייה, ספריות אחרות שסופו של דבר ימצא
להיות באמצעות בתוך הקוד שלך.
>> עם זאת, למטרות של ספרייה זו, אנחנו גם
נו-- של class-- זה יש לנו גם מה שנקרא ספריית CS50,
cs50.h, שבו אנחנו, ל העיון שלך יצר
פונקציות רבות חשובות ושימושיות.
כך שאתה כמתכנת יכול השכם מ
מה שכבר נכתבו, כך ש של פונקציה זמינה לך את זה
לשימושכם.
>> אני אהיה כיסוי כמה הפונקציות נפוצות,
אבל יודע שמדובר ב כל המקוון googleable.
תרגיש חופשי, למשוך את ספריית CS50 ו אז יש לך את כל הפונקציות שיש.
כן.
>> SPEAKER 5: אז אם לא היית שימוש בתוכנה ש
מסופק לנו על ידי הכיתה, עושה את זה
אומר שהיינו צריך להוריד ולמצוא כותרת זו להגיש את עצמנו ולומר לי
המחשב איפה זה?
>> ANDI פנג: שאלה גדולה.
בדיוק.
אז זה כמו שאם אתה לא נוכחים פיזי בספרייה,
אין לך דרך בעצם ללכת ולגשת אליו.
אז אותו הדבר עם תכנות בשפת C, ש
צריך לוודא שאתה משתמש בנו מכשיר כי הספרייה כבר
שולב בו.
ואז כשאתה hashtag #include, הספרייה שם.
כן.
שאלה טובה.
כולם טובים?
מגניב.
בסדר.
אז אנחנו הולכים להכות, בעצם, מה הוא
הפונקציה הראשונה ש אנו כמתכנתים הם
הולך להיות באמצעות בתוך הקוד שלנו.
זה נקרא printf () function.
אז, (פונקציה) printf, כפי שיש לי כבר אמר בשקופית האחרונה,
כלול באני הסטנדרטי / פלט, סטנדרטי קלט / פלט, ספרייה.
>> כדי לוודא שכל מה שאתה using-- הו, תן לי לתפוס את הלייזר pointer--
בכל פעם שאתה משתמש ב printf (הפונקציה),
אתה צריך לכלול את תקן קלט / פלט ספרייה או אחר, כאשר אתה לקמפל,
אתה הולך לקבל שגיאה כי המחשב יהיה כמו,
הו אני לא יודע איפה printf () הוא, אתה לא אומר לי איפה printf ()
הוא.
ובכן printf () כלול ב אני סטנדרטי / פלט, ולכן כאשר אתה משתמש printf (),
לוודא שיש ש קו מעל הקוד שלך.
>> כך למשל, printf () כאן היא פונקציה.
כל מה שעושה זה להדפיס משהו בתוך הסוגריים למשתמש.
האם מישהו רוצה לקחת דקירה מה זה קו ימין קוד
כאן הולך להדפיס?
לפיכך, התשובה היא שעל המסך.
כל אחד?
>> ורדים: התחתון.
>> ANDI פנג: ורדי, למה שלא תלכו קדימה ואומר כל ההצהרה?
>> ורדים: שלום, השם שלי הוא אנדי, ואני בן 20 שנים.
ANDI פנג: אה, יפה.
אז בקו הזה אנחנו הולכים להדפיס, שלום, השם שלי הוא אנדי,
ואני בן 20 שנים, ש היא למעשה הצהרה אמיתית.
>> תחביר.
אז כמה בעיות תחביריות ש אתם רוצים לוודא שאתה יודע.
ציטוטים.
מרכאות כפולות לספר מחשב שכל מה שבתוך
הולך להיות מודפס.
>> הכל בתוך קופסא פשוט להיות בדיוק איך
אתה מקליד אותה, פרט ל בדרך כלל בסוף,
אנחנו הולכים רוצים לכלול הו sorry-- n מקף hash--.
אז n מקף.
>> האם מישהו רוצה לקחת ניחוש על מה שעושה לקוד שלנו?
כן.
SPEAKER 6: מעביר אותו על קו חדש.
ANDI פנג: בדיוק.
אז כל המשמעות של זה הוא לאפשר כל מה שקורה
אחרי זה, לאחר הצהרה זו, שיודפס בשורה חדשה.
כך שכאשר אתה כותב קוד אין לך באופן אקראי דברים
מודבקים על לסוף כי אתה לא רוצה.
כל מה שמקבל בצורה מסודרת מודפס שורה אחת
ואז אנחנו מתחילים בשורה הבאה.
>> האם מישהו זוכר מה ש פסיק עושה כשאנחנו קידוד?
כן.
>> SPEAKER 7: הצהרה.
>> ANDI פנג: מצטער?
>> SPEAKER 7: האם זה סופו של ההצהרה?
>> ANDI פנג: כן.
אז ב- C, או כל תכנות שפה, פסיק
מציין את סוף שורת תכנות.
כך למשל, באנגלית אנו משתמשים תקופה לומר, הו זה סוף משפט.
בתכנות, אותו דבר, יש לנו פסיק כדי לציין את סוף השורה.
לעתים קרובות, כאשר אתה מתחיל לתכנת,
אתה מבין שאתה תשכח להוסיף נקודה-פסיק
ואז אתה מנסה להפעילך קוד וזה לא עובדים.
ואתה כמו, אה, אני לא יודע למה, זה צריך לעבוד.
>> רוב הסיכויים שאתה כנראה שכחת פסיק או הסוגר או משהו
אי שם.
אז, זה חשוב לזכור.
מגניב.
בסדר, הרמת ידיים, איך הרבה אנשים כאן יש אי פעם
לקח AP מדע או מחשב לתכנת ב- Java לפני, אי פעם?
אוקיי.
יפה.
זה לא יהיה ישים לאחר מכן, אבל ב- Java, אתה
יש משהו שנקרא System.out.println שאינו קיים בג
>> אז ב- C, בכל פעם ש רוצה להוסיף במשתנים
לכל דבר שאתה רוצה להדפיס, יש
תחביר ספציפי שאנחנו הולכים להשתמש.
זה נקרא placeholding-- בעצם
אנו מוסיפים מצייני מיקום במקום של המספר השלם או משתנה
כי אנחנו רוצים להדפיס.
>> אז כפי שאתם יכולים לראות שצרפנו כותרת ספרייה חדשה להגיש כאן.
ספריית CS50.
ובתוך שספריית CS50 היא פונקציה משותפת נהיה באמצעות
בקורס שלנו בשם GetInt ().
>> האם מישהו רוצה לקחת דקירה ב מה GetInt () עשוי להיות עושה.
>> קהל: [לא ברור]
>> ANDI פנג: מצטער.
לא יכולתי לשמוע אותך.
מאדים, אף אחד.
Maddie: הו, זה מבקש לך על מספר שלם.
ANDI פנג: בדיוק.
אז פונקציה זו, אחר פונקציה שכבר
נכתב על ידי מישהו אחר שאנחנו יכולים לקרוא לחברה.
כל זה הוא להנחות אותך, המשתמש, לקלט מה שאתה רוצה כקוד
פועל והוא מאחסן whatever-- במקרה זה אנחנו GetInt () - ING,
אז זה אומר שאנחנו קבלת מספר שלם.
>> ואנחנו הולכים לאחסון כי במספר שלם אחר
שאנחנו כבר עשינו רק בגיל שנקרא.
זה הגיוני לכולם?
מגניב.
>> אז עכשיו שאנחנו כבר מאוחסנים שלמים זה, שאנחנו כבר תתבקשו מהמשתמש,
במשתנה זה, יש לנו נוצר של int הסוג המכונה גיל,
אנחנו יכולים להמשיך ומקום כי פונקציה בprintf שלנו ().
אז התחביר בדרך כלל לprintf () הוא כי בכל מקום בגוף שלך בפועל
קו שאתה רוצה לכלול מספר שלם ש, אתה עושה סמל שממש שם,
סמל אחוזים, עם סוג של משתנה שאתה רוצה.
>> אז במקרה בגיל זה הוא מספר שלם.
אז אתה הולך לכולל % I כי זה מספר שלם.
ואז אחריך הצהרה, שאתה הולך
לעשות פסיק ו השם המשתנה.
>> אז הנה, אנחנו הולכים להדפיס את, שלום, השם שלי הוא אנדי,
ואני בן שנים ריקות.
Hashta-- או, sorry--, גיל עם כל מה שאני קלט.
אז אם אני היה לקלט 20 לGetInt () כאן,
זה יהיה להדפיס את בדיוק את אותו הדבר.
אבל, אם אני רוצה משהו קלט אחר, כמו אולי 40 או 45,
אז היית רואה שבאו לידי ביטוי בהתאם בקוד.
>> אז זה הוא דוגמא משהו בי
זה מדפיס ונראה ל אתה כאילו זה אותו הדבר,
אבל מתחת למכסת המנוע של המחשב יש למעשה
דברים שונים מאוד קורים.
מגניב.
בסדר.
אז מה אם אנחנו רוצים משתנים מרובים?
די קל.
אותו דבר.
יש לנו גם פונקציה חדשה כאן נקרא GetString (),
גם נכלל בספריית CS50, שכל שהיא עושה היא להציג למשתמש
למחרוזת, שהוא רק קבוצה של דמויות,
כך כמו משפט או כמו שם.
>> אז במקרה הזה, יהיה לנו שני מצייני מיקום% s עבורי מחרוזת ו%
למספר שלם.
ואנחנו הולכים למעקב שעל ידי שני משתנים
אנחנו רוצים כללנו, לפי הסדר שהם מופיעים במשפט.
כך למשל, השם שלי הוא ריק, אני רוצה שם שם,
אז אני הולך להיות השם ראשון.
ואז אחר כך, אני רוצה גיל, רוצה להיות שני בגיל.
ולכן אם אני רוצה קלט, שלום, של שמי אנדי, ואני בן 20 שנים.
אם אני הוזנתי אנדי ו -20, אותו דבר בדיוק היה להדפיס;
עם זאת, עכשיו יש לנו שני מאוחסנים משתנים של שם, כמו גם int.
כן.
>> SPEAKER 8: האם זה יהיה תוכל לרוץ אם אתה עברת
שם וגיל בסוף זה?
>> ANDI פנג: כן.
זאת שאלה ממש טובה.
אז סיפור ארוך קצר, לא.
בגלל השם וage-- מה סוג משתנה הוא שם?
>> SPEAKER 8: מחרוזת.
>> ANDI פנג: ומה סוג משתנה הוא גיל?
>> SPEAKER 8: מספר שלם.
ANDI פנג: אז הנה יש לנו מציין מיקום למחרוזת ושלמה, נכון?
אז אם היה לך לעבור אלה, המחשב לא הולך לדעת.
זה הולך לבדוק עבור מחרוזת, ואם אתה מנסה לתת לו int,
זה הולך להיות כמו לחכות אני מבולבל, אתה
אמר לי שאני צריך להיות הקצאת זיכרון עבור int.
וכאן, כש היא מצפה שלם
ואתה נותן לו שם ומחרוזת במקום,
זה גם הולך להיות מאוד מבלבל, זה לא יפעל בדיוק כמו שאתה צריך את זה.
אז הנה, שמות ותחביר הוא חשוב מאוד להפעלת קוד.
כולם טובים?
כן.
מאדים.
>> Maddie: הנה, אני יודע בדקנו בדוגמאות בכיתה, שבו הם שואלים
מה הגיל שלך, מה השם שלך.
הנה, זה יהיה אותו doesn't-- אם היינו להפעיל קוד זה,
זה לא הייתי מבקש את זה?
אבל היית רק שני מספרי הקלט ואז זה יהיה לרוץ ככה?
>> ANDI פנג: כן, בדיוק.
אז אם אתה רוצה שזה תצוגה, אנא הכנס בגילך,
אתה יכול פשוט להוסיף printf פונקציה () שאומר, נא להזין את הגיל שלך,
מעליו.
זו שאלה טובה.
כן.
>> SPEAKER 9: אז, יהיה כבר כלול בGetInt () [לא ברור].
ANDI פנג: לא, זה ממש לא.
אז כל המשמעות של זה הוא רק מבקש מסך ריק
למשתמש קלט משהו.
אם אתה רוצה את זה, אם אתה רוצה את זה כדי להדפיס משהו שמספר את המשתמש כמו החוצה,
אנא תן לי את הגיל שלך, אז אתה יצטרך printf () זה בעצמך.
כי כולם משתמש בזה פונקציה לדברים שונים,
אתה יכול להיות אחסון גיל, אתה יכול להיות אחסון כתובת,
אתה יכול להיות אחסון מספרי טלפון.
ואז זה באמת עד שימושים הבודדים "הבחורים שלך
על מה אתה רוצה שזה אומר.
כן.
>> SPEAKER 10: אז, רק כדי להבהיר, שבו אתה קלט שם והגיל
כך שהוא מופיע במקום של% s?
>> ANDI פנג: כמו במשתמש?
>> SPEAKER 10: כן, כמו איך אני להפוך it-- איפה שמתי את אנדי,
ואיפה אני שם את 20?
>> ANDI פנג: כן.
אז אם היה לך למעשה להפעיל קוד זה,
אני לא ממש פועל קוד, זה רק כאן עכשיו.
אם הייתי מפעיל את הקוד, הייתי לקמפל את הקוד, להפוך את הקובץ,
להפעיל את הקוד, ואז לא יהיה רק שני חללים לי לקלטו.
כן.
אתם תראו כאשר אתה משחק סביב עם הקוד בעצמך.
>> בסדר אנחנו הולכים לעבור לחלק הבא של מה ש
נהיה כיסוי היום.
אנחנו הולכים לעבור על מה ש הצהרות מותנות הן.
אז אם אתם זוכרים וזוכר מהרצאה,
הצהרות מותנות, כולם הם קבוצה
הוראות למחשב ב שאם מצב מסוים הוא אמיתי,
אתה לבצע את הקוד בתוך המצב ש.
>> אז בScratch-- בעצם הנושא הגדול מהיום
הוא שיש לכם כבר את כל ראיתי את ההיגיון מאחורי כל דבר
כי אנחנו מכסים.
וכל מה שאנחנו עושים הוא תרגום משהו
זה היה מאוד אינטואיטיבי ב שריטה, וקשה קידוד זה
לתחביר נהיה באמצעות למעמד שהוא ג
אז מבחינה לוגית, כל הבלוק הזה היה היא פיסת הקוד ממש שם.
כן.
אוקיי.
>> גם אנחנו להיכנס אם ... אחר הצהרה שהיא פשוט שכבה נוסף
של מורכבות לאם ההצהרה שבו המחשב לוקח מסתכל על זה
ורואה, אם מצב זה נכון, לעשות כל מה שיש בתוכו שני סוגריים אלה,
else-- כך כמו סוג של ברירת המחדל אם זה לא עומד בcondition-- לעשות את זה.
זה כמו מזלג בכביש.
אם יורד גשם בחוץ, אני מניח במעייל גשם, כל דבר אחר
אחר אני לא לשים על מעיל גשם.
>> האם היגיון שהגיוני לכולם?
מגניב.
בסדר.
אז כמו דוגמא קשה של זה שהיינו רואה בC
הוא אם אני רוצה ליצור שעות שיעורי בית נקראים משתנים.
ואם שעות שיעורי בית היא פחות מחמישה, אני אומר חיים הוא גדולים.
זה נפלא.
עם זאת, אומרים המאבק הוא real-- וזה מה שכולנו ביום שני זה
אחר הצהריים עד מדע היל הם כנראה עושה נכון now--
קהל: [צוחק]
ANDI פנג: הם בדרכנו היה, תודה לך על זה.
הדרך היינו hardcode זה ב- C הוא if-- נניח
כבר יש לנו משתנים מסוג int נקרא שעות שיעורי בית ממש כאן.
אם שעות שיעורי הבית היא פחות מ חמישה printf (), חיים הוא גדול.
זכור לשמור / n כי אתה רוצה קו חדש לאחר.
הדפסה אחרת, המאבק הוא אמיתית.
>> האם כולם מבינים איך אני עברתי מבלוק זה
לבלוק הזה של קוד?
מגניב.
בסדר.
>> אז עכשיו אנחנו הולכים להעיף מבט על הצהרות אם מרובות לגמרי.
אז בואו נניח מטרתה של תכנית זו
היה שננחה את המשתמש לכיתה.
אנו הפקודה באמצעות GetInt () ל כיתה, והם קלט ערך,
ואתה רוצה להציג איזה סוג של כיתה שיש להם.
>> אז אם אני היה לעצב תכנית, אני אומר בדרך כלל בכל עינינו,
90-100 הוא, 80-90 הוא B, וכן הלאה וכן הלאה.
מה לא בסדר עם זה פיסת קוד שזה לא
עושה מה שאני רוצה לעשות את זה.
כן.
>> 11 SPEAKER: יש להם גבולות נמוכים, אבל אין להם גבולות העליונים.
>> ANDI פנג: בדיוק.
האם כולם לשמוע מה היא אמרה?
יש הולך להיות עליון גבולות, אבל אין גבולות נמוכים יותר.
מצטער, להיפך, גבולות התחתונים, אין גבולות העליונים.
אז היית רוצה לקחת דקירה באומר
מה יהיה כתוב על זה מסך אם הייתי להפעיל קוד זה.
SPEAKER 11: טעות?
ANDI פנג: שגיאה?
ניחוש גדול, לא לגמרי בסדר.
האם יש למישהו ניסיון נוסף?
כן, אהרון.
>> אהרון: אם תשים ב משהו גדול יותר מ -90,
זה היה מראה את כל הציונים שיש לך.
זה היה מראה שיש לך, יש לך B, שיש לך ג
>> ANDI פנג: כן.
זה בדיוק נכון.
אז, זה יהיה נפלא.
עם זאת, הם הדדיים בלעדי, אני חושב.
אם הייתי לרוץ פיסת קוד זה.
ואז בואו נגיד, אני הוזן הכיתה של 95.
אז 95 מאוחסנים כעת ב INT נקרא כיתה.
>> וכך C הוא שפה שרץ מלמעלה למטה,
כך זה הולך תמיד לרוץ עד תחתית.
אז זה הולך לבוא לכאן, לקרוא אם הכיתה היא גדולה או שווה ל 90,
printf () שיש לך א גדול, אני יש 95, זה יותר מ -90.
זה הולך להדפיס, יש לי א זה הולך
לתסתכל על זה אם, זה הולך אומר, גם 95 הוא גם יותר מ -80,
זה הולך להדפיס גם שיש לך Got סימן ב 'סימן קריאה, וכן הלאה וכן
הלאה.
>> אז כפי שכולנו יכול לראות, מדובר בבאג נפוץ
שעלול להתרחש כאשר אנחנו כתיבת קוד כדי לחפש.
כל אחד, בכל שאלה ב למה שקורה?
גדול.
אוקיי.
>> אז איך אנחנו יכולים לתקן את זה, ללא ספק השאלה ההגיונית הבאה.
ובכן, יש לנו אלה יפים דברים בשם אם אם אחר אחר
אם דוחות אחר.
אז אתה יכול לראות, אם אתה רוצה לשנות בעיה ש,
אתה רוצה להפוך את כל אחד מ תנאים סותרים,
יהיה עליך להוסיף עוד ... אם הצהרה.
>> ואלה של course-- לחשוב עליהם כ סולמות, או כמו שלבים בladder--
אתה יכול להוסיף כמה שיותר מאלה שאתה רוצה לתנאים רבים ככל שאתה רוצה.
אז הנה, אם אני הוזנתי כיתה להיות 95.
אם הכיתה היא יותר מ 95, printf (), יש לי א גדול.
זה הולך לראות עוד ... אם וזה הולך יודע, הו לא,
אני כבר להורג הראשון אחר.
אני יודע-- או if-- הראשון אני יודע ש אני לא צריך להסתכל על כל אחד מאלה
כי אחד מהם כבר היה נכון.
אז זה הולך לרוץ מלמעלה למטה.
ברגע שהראשון הוא נכון, אז זה הולך לדלג על כל השאר
של ... IFS אחר.
האם זה הגיוני?
אז, בדרך זו יש לך רמות של בדיקה שונות
וברגע שאחד מהם הוא שקר, שאר הוא גם, שהם אפילו לא לבדוק.
מגניב.
בסדר.
>> אז זה הוא דוגמא שונה סוג של הצהרה המותנה
אנו רואים בתדירות נמוכה יותר, אבל אנחנו תראו אותם ולהשתמש בם.
והם לעתים קרובות יותר יעיל במקרים מסוימים.
אז יש לנו מה שנקרא הצהרה בורר.
אז לפני שאנחנו מכוסים מה אחר הצהרה, הצהרה אחרת אם ....
הנה, יש לנו מה הם נקרא הצהרות מתג.
>> אז אנחנו עושים כאשר משתמשים בבורר ההצהרות הוא המפתח?
אז בהצהרת מתג, אתה בדרך כלל, בדרך כלל, למעשה אתה
יכול רק מספרים שלמים קלט עבורך משתנה שאתה בודק.
אז אם אני רוצה לבדוק אם number-- מסוים לדוגמא
כיתה, אם יש לי 90.
אני רוצה אותו כדי לראות אם זה, יש לי B, או C. יכולתי מקרה כאן.
עם זאת, במקרה יש לי להיות קבוע אחר.
>> אז במובן הזה, מתג הצהרה יכולה רק
לבדוק לשוויון של שני מספרים.
זה לא לבדוק כל דבר אחר.
אז זה משהו מאוד זהיר כאשר אתה משתמש בזה.
אז הנה, אם אני רוצה לבדוק אם הכיתה של 90 שווה 90 או 80
או 70 או 60, ולאחר מכן הדפסה הכיתה המקבילה,
אני רוצה להיות מסוגל לכתוב ש בהצהרת מתג.
>> אז זה הולך לבוא לכאן, סימון הוא מספר שלם זה שווה לקבוע זה?
אם לא, זה הולך לדלג.
האם זה שווה לקבוע שני, וכן הלאה וכן הלאה,
עד שפגעת בברירת המחדל, אם אף אחד מהם שווים.
ברגע שאחד מהם מוגדר להיות שווה,
זה הולך לעשות את זה שורת קוד וההפסקה.
מה שאומר שזה הולך לפגוע ש לרוץ, לשבור, ופשוט לדלג לגמרי
לחלק התחתון של הקוד.
אז במובן הזה הסוג של פונקציות כמו אם אחר אם אם הצהרה אחרת.
>> אז הנה בטון דוגמא בשבילכם.
אז בואו נניח שאני רוצה ליצור משתנה בשם השנה נוסדה.
ואני רוצה לבקש מהמשתמש הקלט השנה שבית הספר שלהם הוקם.
אז אני יכול ליצור הצהרת מתג כאן.
ובואו נגיד, אני קלט 1,636.
>> קוד זה כאן הולך לראות מתג השנה נוסדה אשר שווה 1,636.
זה הולך לראות מקרה 1636, הו אלה הם שווים,
printf () לא כדאי לך להיות שבצפון בית הספר עד?
כי אנחנו מניחים שהם לא ללכת כאן אם הם הולכים לאוניברסיטת הרווארד,
לשבור ולדלג על הסוף.
>> אם הייתי קלט 1701, ש אני מניח שכולנו היית קלט,
זה יהיה לדלג מקרה זה, לבוא עד מקרה שני שהוא 1701,
וברוך הדפסה לייל!
לשבור, לדלג על הסוף.
אחר אתה כנראה לוקח את הקורס הזה באינטרנט שבו case-- מוזמנים מדהים
לYale-- זה הולך ללכת ל ברירת מחדל להדפסה, שלום אינטרנט!
ולשבור.
כן.
>> 12 דובר: האם אתה יכול להשתמש אחר במקום ברירת מחדל שם?
>> ANDI פנג: לא, כי דרך שכל פונקציה זו
מתג בנוי, תחבירך צריך להשתמש הוא מקרה ברירת מחדל מקרה.
זה כמו אם אחר אם, זה אחד זה מקרה ברירת מחדל מקרה. כן.
13 דובר: אתה אולי כבר אמר את זה, אבל אתה יכול להיות יותר משני המקרים?
ANDI פנג: כן, אתה יכול יש מקרים רבים ככל שאתה רוצה.
תחשוב על זה כפשוט אוהב לאין שיעור הוספה ב.
>> 14 דובר: אם אתה החליף 1,701 עם 1636,
זה לא ממש עושה זכות הבדל?
זה פשוט הולך להיות בדיקה לזה.
>> ANDI פנג: זה שאלה ממש טובה.
ואנו נוגעים ב זה מאוחר יותר, אבל רק
יודע שזה המתג הצהרה היא infinitely-- זה
יעיל יותר מזה ואם אחר אם כי זה פועל
באמצעות סוג של פונקציה שונה ש מאפשר לך, למהות, לרק
לקפוץ ישר ל מקרה שאתה צריך להיות ב.
כן.
14 מרצה: מגניב.
תודה.
ANDI פנג: כן
>> 14 דובר: ואתה לא יכול לעשות מקרים כמו ויותר מ.
ANDI פנג: מס '
אז, זה מה שמגביל על ההצהרה הבורר היא שיש לך
יש קבועים רק, רק מספרים שלמים.
כן.
אוקיי.
>> אז זה משהו שאתה בחורים ייתקלו בתדירות נמוכה יותר של,
אבל אני רק רציתי להציג אותו במקרה.
יש לנו כאן מה בשם מפעיל משולש.
איפה בעצם, זה בדיוק כמו אם הצהרה מלוקט לתוך שורה אחת.
הנה, אני אלך על השורה הבאה, הדף הבא, כי זה יותר קל לראות.
>> אז כל שראינו את זה נכון?
זה די קל לעקוב.
אם אני רוצה לעשות משתנה בשם של מחרוזת בשם, אם מספר מסוים
אני נותן לה הוא פחות מ -100, אני רוצה להקצות נמוך למחרוזת,
עוד אני רוצה להקצות גבוה.
>> זה כאן עושה בדיוק את אותו דבר שמונת קווים אלה של קוד עושים.
אז הנה אני רוצה ליצור מחרוזת משתנה.
וזה המצב שאני בדיקה, אם מספר הוא פחות מ 100,
אז אתה להקצות את הערך נמוך, אחר להקצות את הערך גבוה.
>> שקופיות אלה יהיו מקוונות, אין דאגות אם אתם לא מקבלים את זה.
זוהי רק דרך פשוטה יותר, יותר דרך יעילה של כתיבת קוד.
אוקיי.
>> אז עכשיו אנחנו הולכים ל להיכנס מה, עבור רוב האנשים
כמו מאוד, מאוד מבלבל דבר לחשוב על בהתחלה.
סעיף הלולאה.
אז היום, אנחנו הולכים לדבר על שלושה סוגים של לולאות.
אנחנו הולכים להתחיל עם זמן לולאה, ואז לדבר על לעשות בזמן לולאה,
ולאחר מכן לדבר על ללולאות.
>> אז בעצם, ליותר לומדים חזותיים בחוץ,
יש לנו, בעצם, גרפי תיאור של מה שלולאה בזמן שעושה.
אז בתכנות, אתה תתחיל והזן את הלולאה בנקודה מסוימת.
אתה בודק את מצב.
ואם המצב הוא נכון, אתה לבצע את הקוד בפנים.
ואתה חוזר סביב ולבדוק.
אם זה עדיין נכון לך להמשיך לרוץ קוד זה סביב סביב בלולאה.
>> עם זאת, השני ש המצב הופך להיות כוזב,
אתה הולך לשבור ולסיים את הלולאה.
וזה בעצם תחביר אתה הולך להשתמש.
בעוד מצב מסוים הוא נכון לעשות את זה, אם זה לא נכון,
אתה הולך לדלג על הסוף ולהתקדם עם התכנית שלך.
אוקיי.
>> האם יש למישהו דוגמא על מה שעשוי לקרות פוטנציאלי
אם אני מנסה להפעיל פיסת קוד זה?
אגב, SAJ-- זה Scaz, אנדי, Jason-- אנחנו לחתום המיילים שלנו,
אוהב, SAJ.
זה.
אוקיי.
>> למישהו יש דוגמא, או שיש לי מושג על מה זה היה להדפיס?
סוג של שאלה מכשילה.
אז הנה, זוכר את המצב אנחנו בודקים להוא תוך נכונים.
אז בזמן שזה נכון, זה הולך להדפיס, אני אוהב את SAJ!
האם יש נקודה שבנו הייתי לשנות את זה למשהו אחר?
לא, נכון?
>> אז כאן, יש לנו נתקל מה כנראה
הולך להיות מטריד הרבה התוכניות שלך, הלולאה האינסופית.
אתה תמצא שאם אתה לרוץ פיסת קוד זה,
זה רק הולך לשמור הדפסה, אני אוהב את SAJ!
בעוד אנו מעריכים את התמיכה, אנחנו לא רוצים מחשבים שלך
לקרוס בגלל שאתה להמשיך בהדפסה אני אוהב SAJ!
>> אז בבקשה, בבקשה, להימנע מהלולאה האינסופית
כי זה אף פעם לא קורה כדי להעריך שווא
ואתה אף פעם לא הולך לעזוב את הלולאה.
ואתה הולך להישאב בלנצח.
מגניב.
אוקיי.
הסוג השני של לולאה נדבר על היום
הוא לעשות בזמן הלולאה, לעשות בזמן הלולאה.
וזה נקרא לעשות בזמן לולאה כי יש לך לעשות וכמה זמן.
אז זה די דומה לזמן ש לולאה, אבל קצת שונה.
הנה, אתה הולך לעשות כל מה שיש בפנים של זה
בעוד מצב מסוים הוא אמיתי.
אז אם אני היה C והמחשב אני רץ במורד קטע קוד זה,
אני נסתכל בחלק העליון.
אני הולך לC, אני אומר לעשות את הדבר הזה.
ואז אני בודק, ואילו זה נכון, יש לי לחזור על זה.
אבל בזמן הזה הוא שקר, אז אני להתקדם
ואני אף פעם לא אחזור ללולאה ששוב.
>> מישהו יכול לקחת דקירה מה ההבדל
בין לולאה זה ואנחנו אחד רק הבטתי בהיה כמעט.
כן.
15 מרצה: המצב מגיע אחרי במקום לפני?
ANDI פנג: בדיוק.
אז היא אמרה את המצב מגיע אחרי, לא לפני.
סופו של דבר, ההבדל בין זה ותוך הלולאה
הוא שאתה פשוט הולך לעשות כל מה שיש בפנים זה ללא קשר ל
אם המצב שלך הוא נכון, ולאחר מכן לבדוק את מצבו.
אז במקרה הזה, אתה תמיד-- בדרך זו,
אתה תמיד לוודא ש כל מה שיש בפנים פועל לפחות
פעם אחת לפני הבדיקה כדי לראות אם אתה רוצה את זה כדי לרוץ שוב.
>> והנה דוגמא כאשר היינו להשתמש בו.
כך למשל, אם אני רוצה שיהיה לי משתנה מסוג int בשם גיל,
ואני רוצה לבקש המשתמש לגילם,
אני הולך לעשות printf () בן כמה אתה?
גיל = GetInt (), ש הוא להציג הודעה למשתמש.
>> וכמה אנשים יהיו ממש מעצבן.
ואתה לא רוצה באגים בך תכנית של מישהו מזינה כמו,
הו אני שלילי 4 שנים או משהו כזה.
במקרה כזה, אם הם לעשות את זה, זה מעריך
לנכון, מה שאומר שאני הולך צריך לשמור חוזרים ועושה את זה.
אז זה הולך לשמור משתמש הנחיה חוזרת
כדי לתת לך כמו אמיתי מספר גיל וזה
הולך לשמור חוזרת ומחדשת זה עד שהם נותנים לך גיל אמיתי
יותר מפעם אחת, או לא אפס.
>> אז לרמוז, רמז.
זה יהיה מאוד, מאוד שימושי לאחת מבעיות PSet.
כן.
>> SPEAKER 16: אופס, סליחה.
>> ANDI פנג: כן.
>> SPEAKER 16: האם יש, לא להיות אידיוט, but--
ANDI פנג: אין בעיה.
SPEAKER 16: --are שם כללים שונים כאן,
או שרק לך לשכוח לשים את הציטוט?
>> ANDI פנג: הו כן.
מצטער, זה לגמרי שלי רע.
זה היה בהחלט אמור להיות ציטוט.
לתפוס טוב.
זה היה לא לרוץ.
אוקיי.
>> אז הסוג האחרון של לולאה נדבר על וסופו של דבר, סוג של רוב
מורכב הוא ללולאה.
אל תדאג אם אין לך יודע מה זה אומר.
זה די מבלבל בהתחלה.
אנחנו נלך על דוגמא.
>> כל מה שקורה ללולאה הוא שיש לך שלושה דברים
שאתה הולך לכלול.
אז לדבר מסוים, אתה הולך לאתחל משתנה.
אתה הולך להוסיף את המצב ל שלולאה זה תמשיך לפעול.
ולאחר מכן, בסוף לולאה, אתה הולך לעדכן אותו.
אתה יכול לעדכן את משתנה שברצונך לעקוב אחר.
אז בדרך כלל אנחנו משתמשים ללולאות לכאשר אנו
רוצה לרוץ ללולאה כמות מסוימת של פעמים
ואנחנו כבר יודעים, הו אני רוצה לולאה זו לביצוע כמו 10 פעמים,
אז אתה do-- אני אלך על דוגמא בעמוד הבא.
>> אז הנה לדוגמא, בלגרד, אם אתה רציתי משהו לחזור 10 פעמים,
כל מה שאתה אומר היה, חזרו על תרגיל 10 פעמים אני אוהב SAJ!
שהוא מקובל יותר מפגן תמיכה בנו
ולא הלולאה האינסופית.
כאן, איך היית מעבר ל- C וכתיבה
כלומר לint-- אני הולך ליצור או להצהיר על משתנה מסוג int בשמי.
אני הולך לאתחל זה ל0, אז אני = 0;
וזה הולך להיות המצב שלי.
אז הוא שפחות מ -10.
ולאחר מכן בend-- ההצהרה האחרונה שאתה
הולך להיות הוא העדכון של מה קורה לאני משתנה
בסוף שלך ללולאה.
אז זה סוג של מבלבל, כי חלקים שונים של קו זה
קורים בשונה סוגים של הלולאה.
אבל אני אלך על דוגמא פסאודו קוד של ש
ואולי להסביר את זה רק קצת יותר טוב.
>> אז הנה.
זה הלולאה רק שראינו.
בעיקרו של דבר בפסאודו קוד, מה ש קורה בתכנית זו,
הוא ראשון אני יוצר אני, אתחולו ל -0.
אני בודק לראות אם הוא אני פחות מ -10, ובמקרה זה
בפעם הראשונה זה כי 0 הוא פחות מ -10.
כך הלולאה הולכת לרוץ.
ואז אני הולך להדפיס את הקו הזה.
ואז בסוף הקו הזה, נכון כאן, אני הולך לעשות תוספת i, i ++,
כל האמצעים שהם הגדלה על ידי אחד.
>> אז הוא עכשיו 1.
כי זה היה פעם אחת 0, אם אני להגדיל זה, עכשיו זה 1.
ואז אני הולך לחזור לתחילת הלולאה
ואני בודק את המצב.
האם המצב עדיין נכון?
כן, 1 הוא עדיין פחות מ -10.
אז זה הולך להדפיס את זה שוב, ללכת ולאחר מכן להגדיל i, ולבדוק
המצב ברציפות, ברציפות,
עד שסופו של דבר לקבל לנקודה שבה אני הוא 10.
>> אתה הולך להדפיס 10 פעמים ואז אני הולך להיות שווה 10.
אתה הולך לבדוק את מצבו.
האם 10 פחות מ -10?
לא, זה שקר.
לפיכך, לולאה זה לא הולכת לרוץ, זה הולך לשבור,
ואתה הולך להמשיך עם הקוד שלך.
>> אז כפי שאתם יכולים לראות, זה היא דוגמא גדולה באמת
של לולאה אתה יכול לתכנת שב פועל עבור סכום מסוים של פעמים.
כל אחד ברור?
כן.
>> SPEAKER 17: מה דעתך על תוספת באופן אקספוננציאלי, זה קידוד שונה?
>> ANDI פנג: אתה can-- נלך על זה בשקופית הבאה.
שאלה טובה.
האם anyone-- לפני שאעבור on-- מישהו בכלל מבולבל,
בגלל זה הוא מושג באמת קשה.
אין דאגות, אם you're-- אישור.
מגניב.
>> בסדר.
רק שקופית כללית.
תוך לולאה זה עושה אותו דבר בדיוק ללולאה היה.
זה פשוט נכתב בצורה שונה.
אתם יכולים לעיין בשקופיות לנוחותך בשלב מאוחר יותר.
אבל רק יודע שיש מספר רב של דרכים של כתיבת אותו הדבר
לקרות עם לולאות שונות.
אוקיי.
>> אז, עכשיו אנחנו מקבלים בשאלה של מה אם יש לנו לולאה בתוך לולאה.
אנחנו מקבלים לתוך אמיתיים דברים מסוג ההקמה כאן.
כאשר אתה רוצה לעשות דברים מרובים פעמים בתוך דברים אחרים
שעושים דברים מספר פעמים, אתה רוצה מה שנקרא מקונן ללולאה.
לאלו מכם שרואים את זה ראשון ו להתבלבל מאוד, כל מה שאנחנו עושים כאן
הוא נתקל ללולאה שבי יש לנו משתנים ברציפות.
אבל בתוכו, יש לנו גם אחרת ללולאה של עמודה משתנה בשם.
ואני מאוד ממליץ לכולכם מי מבולבלים לראשון לשמור
track-- לצייר את זה, לצייר את זה.
אל תנסה רק סיבה דרכו, למשוך אותו החוצה.
>> בראש שלך, על פיסת זו נייר, או מה, שורת כתיבה,
לעקוב אחרי מה השורה שווה ל.
לכתוב טור, לעקוב אחר ממה שהטור שווה ל.
ולעקוב אחר מה הוא הדפסה עם כל איטרציה.
כל איטרציה של לולאה זה, כל איטרציה של לולאה שגדולה יותר,
רק לשמור הבא ההיגיון.
ואני מבטיח לך, אתה תאהב את מה שאתה רואה,
כי זה מאוד גם ישים עבור סטי הבעיה שלך.
מגניב.
בסדר.
אז הדבר החשוב ביותר כי אתם כנראה כל
חושב על עכשיו, הם 1s הבעיה הוגדרה,
אשר עקב יום חמישי / שישי.
>> בתכנית water.c, לרמוז שאתה הולך יש לי
להציג למשתמש עבור קלט.
במסגרת תכנית mario.c אתה הולך לי
להשתמש מקונן ללולאה, שהוא ללולאה בתוך לולאה של ל,
להדפיס בלוק של פירמידה, במהות כמו מה מריו יש לקפוץ דרך.
ואז בתוך או greedy-- אולי ביצוע שינוי, אם מישהו מכם בחורים
האם אי פעם שמע על לראות-- אתה הולך צריך להיות מאוד
זהיר של ערכי נקודה צפו הראשונים.
זכור עשרוניים צף ו שלמים הם לא אותו הדבר.
עקוב אחר איזה מהם הוא ש.
ואתה הולך להשתמש הצהרות מותנות, כמו גם.
>> כל הדבר נכון, שעבר.
יש לי כמה דקות עזבו.
סגנון.
אז זה משהו שלא למעשה להשפיע על היעילות,
או הריצה בפועל של הקוד שלך.
עם זאת, זה משפיע לנו כ תלמידי כיתה שלך, כקוראים שלך.
זה משפיע על עצמך, אם אתה מנסה למצוא בעיה.
זה משפיע הקריאות של הקוד שלך.
>> אז סגנון, כמו כאשר אתה מנסה סגנון מאמר לאנגלית, אם אתה
לא היה לי סעיפים, יש לך הכל סוג
של ערבוביה בשורה אחת, זה עושה את זה ממש קשה למישהו
לקרוא המאמר שלך, גם אם הנקודות שלך הן לוגי קול.
אותו דבר בתכנות.
אתה יכול להיות נורא מעורפל קוד שScaz יכסה,
והוא עדיין יכול לרוץ ותפקוד.
אבל לנו, כTAS היפה שלך, שיהיה לקרוא והערכת PSets,
זה לא מאוד נחמד.
>> אז בבקשה, למען שלנו ואת עצמך,
כאשר אתה מנסה לתקן בעיה בקוד שלך,
ואתה מנסה לקרוא את הקוד שלך, להפוך את
בטוח שאתה מבין כמה מוסכמות שאנחנו הולכים לעבור על.
>> אז קודם.
תן המשתנים שלך שמות בעלי משמעות.
אם ברצונך לאחסן מספר שלם בשם גיל, בבקשה שם את זה בגיל.
לא שם את זה בגובה.
כאשר אתה מנסה לאחסן גיל בגובה,
זה הופך את הכל מאוד מבלבל עבורנו.
אנחנו לא רוצים להיות מבולבלים.
אתה לא רוצה להיות מבולבל.
אף אחד לא אוהב להיות מבולבל.
אם אתה הולך ליצור משהו, שם זה משהו משמעותי.
>> עם זאת, ללולאה, אחת משתני אופי הם בדרך כלל בסדר.
וללולאה, אם אתה רוצה רק אני, וי, יא, ירגיש חופשי רק כדי לעשות את זה.
>> אתחול עקבי.
אז מה זה אומר?
כלומר, מבחינה טכנית, באופן תיאורטי, אתה יכול ליזום וליצור
משתנים מרובים על אותו הקו.
כך למשל, אני יכול ליצור מספר שלם נקרא scaz_age,
ומספר שלם נקרא andi_age = 20, ומספר שלם נקרא jason_age
על אותו הקו.
ואני גם יכול להקצות רק אחד שלהם ולא לאחרים לערכים.
אנו מבקשים מכם בבקשה אל תעשו את זה.
כי כאן אתה כבר בעצם נוצר שלושה משתנים, אך רק אחד מהם
למעשה יש ערך.
ואז כשאנחנו מנסה לקרוא את הקוד שלך,
או אם אתה מנסה לתקן בעיה בקוד שלך,
זה מאוד מבלבל לעקוב.
אז רק לקריאות שלך, ל הקריאה שלנו, לא עושה את זה.
>> סוגריים מסולסלים עקביים.
יש אנשים שאוהבים אותם סוגריים מסולסלים במקומות שונים.
זה לא משנה באמת.
רק לוודא שאתה עולה בקנה אחד בך קוד של איפה אתה רוצה לשים אותם.
>> מרווח עולה בקנה אחד.
אם אתה שם את רווח אחרי ללולאה, תמיד עושה את זה.
לא רק סוג של רוצה לעשות את זה ב כמה מקומות, לא עושים את זה באחרים.
רק להיות עקבי.
>> שנית, אם מישהו הייתי רוצה לעיין במדריך סגנון CS50,
יש לנו באופן רשמי מדריך סגנון ש מספר את כל מוסכמות אלה,
ועוד ועוד.
זה באינטרנט.
זה כמו cs50.net/style או משהו כזה.
אתה יכול google זה.
>> עקביות היא מפתח.
אז אל תדאגו מה אנשים אחרים עושים,
רק לוודא שאתה עולה בקנה אחד בתוך הקוד שלך.
מישהו יש לך שאלות על זה?
כן.
>> SPEAKER 18: אז הדבר הנכון לעשות עם האתחול הוא פשוט
יש את כולם בנפרד קו, זה מה שאתה אומר?
>> ANDI פנג: אז אני כמעט ולא לזה לקרות.
אבל אם אתה רוצה, אם אתה רוצה להיות כמו חיסכון בשטח בקוד שלך,
או מה, אתה יכול לעשות את זה.
אנו מבקשים שאתה פשוט לא לאתחל דבר אחד ולא אחר.
אז אם אתה רוצה לעשות scaz_age int, int andi_age, jason_age int, זה בסדר.
רק אל לאתחל אחד ולא האחרים הוא כל.
>> שאלות?
בסדר.
אני הולך לעבור את מיקרופון, ומצביע לייזר,
ואת השרביט לScaz בשלב זה.
זה מביך.
הנה זה.
>> בריאן SCASSELLATI: תודה לך.
איך זה נשמע?
הקול הוא טוב? .
מצוין.
אוקיי.
אז, היי לכולם.
>> אני הולך לנסות לעבוד דרך דוגמא מעשית איתך.
ואנחנו הולכים להשתמש CS50 של סביבת פיתוח, מה שנקרא
סביבת הפיתוח המשולבת.
ושראית את זה הפגין בהרצאה.
ובבעית הסט 1, אתה הולך להיות הזדמנות
כדי להשתמש בו, ולשחק עם זה, ולהתרגל לזה,
כי אנחנו הולכים להשתמש בו דרך שאר הסמסטר.
>> אז בIDE זה, יש לך מה נראה כמו דפדפן קבצים מאוד מסורתי
על צד אחד.
יש לך חלק עד הראש לאן אתה הולך
כדי לראות את קוד המקור שלך, שלך Cfile, הקוד שאתה כותב.
ולמטה בתחתית, אתה תמצאו יש חלון מסוף
שאתה תהיה באמצעות ל שני לקמפל את התכנית שלך
וכדי להפעיל או להפעיל התכנית שלך.
אוקיי.
>> אז רק כדי לתת לנו קצת קרן, שבחלון המסוף,
אתה הולך להיות באמצעות סדרה של פקודות
כי הם פקודות סטנדרטיים בכל רוב מערכות יוניקס או לינוקס.
ולכן אם יש לך אי פעם נעשה שימוש כל צורה של יוניקס, אובונטו,
או כל הטעמים האחרים, אלה הולכים נראים מוכרים.
>> אם יש לך לא, אל תדאג.
אין שום דבר מסובך עליהם.
הם פשוט משתמשים בשונים תחביר, שמות שונים
אמנה ממה שראתה בעבר.
>> אז לרשימה את הקבצים בתוך ספרייה מסוימת,
הם הולכים להשתמש הפקודה נקראת LS, או רשימה.
אם אתה רוצה לראות הכל עם כל הפרטים,
תוכל להשתמש בפקודה טיעון קו עם -l LS.
ושאראה לך הכל בפירוט רב יותר, כוללים
ההרשאות לקובץ.
>> כדי לשנות ספרייה, תוכל להשתמש בפקודה cd.
ואתה יכול לשנות את הספרייה שני ללכת לספריית הבית שלך.
זה פשוט cd כל על ידי עצמו, תקליטור עם שתי
נקודות תחזיר אותך אחד רמה לספרייה הקודמת שלך.
ואתה גם יכול CD ל תיקייה על ידי הקלדת cd
ואת השם של תיקייה ש.
>> ניתן גם ליצור ספריות חדשות.
ואנחנו הולכים ללכת באמצעות זה בעוד דקה.
אבל רק כדי לשים כל מה שעל המסך.
כך שאתה יכול לראות אותם.
>> גם תהיה לך את היכולת לתפעל קבצים ישירות
משורת הפקודה.
תוכל להעתיק אותם, ל להעביר אותם, או כדי להסיר אותם,
כלומר, ביעילות, למחוק אותם.
>> IDE CS50 נותן לך מלא כוח של טיעוני שורת הפקודה.
וזה אומר שגם אתה יכול לעשות דברים מסוכנים ביותר.
אוקיי.
לדוגמא, אתה יכול להסיר, או שהוא מחיקה,
קובץ בלי לשאול לאישור.
ואתה יכול גם להסיר recursively-- זה
r מקף flag-- כל תיקייה וכל תכולתה.
אוקיי.
הם מופיעים באדום בגלל שאתה צריך לחשוב "סכנה" בכל פעם ש
אתה רואה את הדברים האלה.
אוקיי.
בסדר.
>> עכשיו סוף סוף, הדברים שהם הולך להיות באמת בעל ערך לך,
יש כמה טריקים טובים לדעת כפי שאתה מנווט
דרך חלון מסוף זה.
ראשית, אתה יכול לנקות את המסך ב כל זמן רק על ידי הקלדה בברורה.
ואתה הולך לראות שלי לעשות את זה לעתים קרובות למדי.
אתה יכול גם פשוט להציג הטקסט של קובץ
על ידי הקלדה יותר ולאחר מכן את שם הקובץ.
לאחר מכן תוכל לגלול אחורה ו הלאה עם זה רק עם מקש הרווח
ומקשי חצים.
>> אם יש לך, כפי שעשינו היום בהרצאה, תכנית שבו פועלת ברציפות
בלולאה אינסופית, ש יכול לעצור את התכנית ש
מביצוע על ידי הקלדה בשליטה, כי הוא מחזיק את הבקרה-C.
וייתכן שתצטרך לעשות פעמים רבות זה.
המחשב מקבל הרבה לפניך.
ולפעמים אתה צריך נותן לו כמה ניסיונות
לפני יהיה למעשה לבוא דרך. זה
>> תוכל גם להיות מסוגל דרך למיין את הפקודות
כי אתה פשוט הקלדת באמצעות המקש למעלה, מקש חץ, ולאחר מכן על מקש החץ למטה.
ומה שימושי ביותר הוא במקום להקליד את שמות קבצים ארוכים,
אתה תהיה מסוגל Tab השימוש ל השלמה אוטומטית כמה הוראות.
עכשיו אנחנו הולכים להפגין כל אלה רק שני.
אז אם אתה לא זוכר שלהם, אל תדאגו.
אלה הם דברים שאתה להרים ולהשתמש כמו שאנחנו הולכים יחד.
אוקיי.
>> אז בניגוד לC-- בScratch-- C הוא שפת הידור.
זה אומר שאנחנו הולכים לקחת מקור file-- זה הטקסט שאתה כותב,
הפקודות שאתה כותב, printf () דוחות, הלולאות,
הכל else-- ואנחנו הולכים לקחת קובץ ושלהעביר אותה
לתכנית בשם מהדר.
>> אז מהדר ייקח שטקסט שכתבת
ולתרגם אותו ל הוראות ינארי
שהמחשב שלך הוא באמת הולך להשתמש.
זה נקרא האובייקט או את קובץ ההפעלה.
אם אתה מסתכל על קובץ זה, אתה הולך כדי לראות את הקוד שכתבת.
אם אתה מסתכל על קובץ זה, אתה הולך לראות רצף של תווים אקראיים
שלא היה הגיוני שהיא.
זה בגלל שזה בינארי.
זה לא נועד לך להיות קריאה.
>> עם זאת, כל פעם שאתה רוצה להפעיל משהו, מה אתה הולך
להיות מפעיל הוא קובץ אובייקט זה.
אז אנחנו כאשר עובדים עם אלה קבצים, אנו לכתוב קובץ בג
אז לקמפל אותו, תוך שימוש ב הפקודה כמו איפור שיהיה להפעיל
צלצול מהדר לשפת C.
וזה יהיה לייצר אובייקט להגיש, כמו החוצה, או במקרה הזה,
שם, התיק שלי, כי אני כבר לשים ב.
בסדר.
>> אז בואו ננסה למעשה זה.
אז אני בא עם דוגמא ממה שאני רוצה לנסות.
ואחד הדברים ש מרתק אותי הוא אנימציה.
אז אנחנו הולכים לנסות לעשות קצת אנימציה
רק באמצעות תווי ASCII.
דמויות שאנחנו יכולים להדפיס בקלות עכשיו.
>> אז הנה הניסיון הכי טוב שלי ביצירת בשבילך
האנימציה של ארנב פועל באמצעות העשב הגבוה.
הנה הוא.
אוקיי.
אז הוא לא פועל עדיין, אבל הוא עומד שם בעשב הגבוה.
>> עכשיו, אם אני היה אנימטור, בבית הספר הישן
גרסה של אנימציה, מה ש תעשה הוא הייתי לייצר
תמונה של ארנב זה על הדשא.
ואז הייתי לייצר picture-- אחר
אחר מה שהם כינו cell-- ש היה הארנב עבר רק במעט.
ולאחר מכן שליש ש הארנב עבר קצת יותר.
>> והייתי לייצר כל רצף של תאים אלה.
חלק שבו הארנב נגמר על צד שמאל.
ולאחר מכן נע לאט, אחד על ידי אחד לקראת האמצע.
ואז מהאמצע מעל לימין.
ואם אני היה אז, באמת מזל, שאני יכול לשים את זה ביחד
ואני יכול להנפיש אותם.
ויש ארנב שלי פועל באמצעות הדשא.
>> זה PowerPoint הגדול שלי טריק ליום.
אוקיי.
אז זה טוב כמו שזה נעשה.
אוקיי.
אז, הנה עוד פעם אחת, כאן הוא שלנו באני פועל דרך הדשא.
>> SPEAKER 19: שוב.
בריאן SCASSELLATI: אחת יותר זמן, בסדר.
יש הארנב שלך.
אוקיי.
>> אז היום מה שאנחנו הולכים לעשות הוא שאנחנו הולכים
כדי לנסות להפוך את התהליך של ייצור תאים אלה.
אנחנו לא ממש מגיעים לנקודה של יכולת לשים את כולם יחד.
אבל, אנחנו הולכים לנסות להפוך את תהליך של יצירת הרצף הזה.
>> וזה הרבה ממה ש היום אנימציה הוא כמו.
כלומר, אתה לא עושה בהכרח דברים על ידי ציור הכל ביד.
אנו משתמשים במחשב לאוטומציה חלקים של תהליך זה.
אוקיי.
>> אז תן לי לעבור עכשיו לIDE CS50.
ואני יצרתי לus-- ולתת שלי להתמקד בכאן קצת bit-- לי
נוצר לנו נקודת התחלה.
>> בכל פעם שאנו מבקשים מכם לשבת למטה ולכתוב פיסת הקוד,
מה אנחנו באמת מבקשים ממך לעשות הוא אנחנו מבקשים לפתור בעיה.
ואופן שבו אתה צריך חושב על לעשות את זה
הוא על ידי הפעלה עם כמה חלק פשוט של פתרון זה.
ולאחר מכן לבנות מ- שחלק.
וזה מה שאנחנו הולכים לעשות היום.
>> אז במקום לנסות בבת אחת ל לכתוב כל החבורה של קוד זה
הולך לייצר אותם 10 תאי אנימציה,
אנחנו הולכים להתחיל במקום עם חתיכה אחת שעובדת.
ואז לבנות קצת סביב ש
וקצת יותר וקצת יותר.
>> עכשיו דבר טוב פתרון בעיות בדרך זו
הוא שזה יאפשר לך להתחיל תמיד עם משהו שאתה יודע
עובד ולהציג את השינוי הדרגתי.
וזה דרך מצוינת כדי ללמוד כיצד קוד,
כי בכל פעם שאתה עושה שינוי, אתה רואה את מה שיש לו השפעה.
אוקיי.
>> אז הנה נקודת המוצא שלנו.
אוקיי.
אז בתחילת הקובץ שלי, יש לי stdio.h #included חשיש.
זה כל כך שאני יכול לקבל printf () פונקציה לעבוד.
>> אז יש לי הפונקציה העיקרית שלי.
וזה עדיין נראה קצת מסתורי או מעורפל לכמה מכם.
זה בסדר.
כל זה אומר הוא ש הפונקציה העיקרית לוקחת
אמצעים לא מבוטלים arguments-- שום דבר בג וזה
תשואות על ידי אמנה שלם.
ראשי תמיד מחזיר מספר שלם, בדרך כלל קוד אומר דברים
הלכתי טוב או לא הולכים טוב.
אוקיי.
אבל עיקרי צריך להיות ש יוצר עבורנו עכשיו.
>> אז שמתי בשלוש שורות של קוד.
ויחד עם כל שורה של קוד, שמו לי תגובה.
עכשיו אחד הדברים ש אנו עומדים על כך שאתה עושה,
וזה כזה חשוב בפועל תכנות,
תמיד להגיב הקוד שלך.
תמיד לרשום ב אנגלית משהו תגובה
שאתה חושב הקוד אמור לעשות.
בדרך זו, בשלב מאוחר יותר, כאשר אתה חוזר ל את זה, אתה יכול להסתכל על זה ואתה יכול לומר,
הו, אני זוכר את מה שהייתי מנסה לעשות עם זה.
או כאשר ת"א מתיישבת איתך ל אנסה לעזור לך בשעתי עבודה,
הם יכולים להסתכל על זה וללכת, אני לראות את מה שאתה מנסה לעשות,
אבל במקום זה הוא מה באמת קורה.
אוקיי.
>> אז יש לי שלושה חלקים לקוד שלי, אני הולך קודם כל ההדפסה
כמה נקודות בתחילת.
אז ידפיסו אותי ארנב מאוד מפואר.
ועוד קצת קצת נקודות בסוף.
>> ושלוש הצהרות הדפסה אלה צריכים נראה לך מוכר, בשלב זה.
כל מה שאני עושה ב כל אחד מהם הוא אני
להדפיס את רצף של תווים.
אין משתנים מעורבים.
הכל הוא רק שטוח.
אוקיי.
>> אז אם אני יורד עכשיו לterminal-- בואו נראה אם ​​אני יכול לקבל את זה בחזרה out--
ואני הולך להקליד ברור שוב.
>> SPEAKER 20: האם אנו משתמשים קו נטוי כפול להגיב?
בריאן SCASSELLATI: האם להשתמש כן double--.
יש מספר דרכים להשאיר תגובות בג אחת
הדרך היא להשתמש בקו הנטוי הכפול.
האחרים הוא להשתמש בקו נטוי וכוכבים ולאחר מכן לסגור עם כוכב וקו נטוי.
בסדר.
>> קודם כל, אני הולך להתחיל לנווט כאן.
אז אם אני הולך לספריית הבית שלי, אני כבר שיניתי את הספריות שם,
אני הולך להסתכל ולראות מה בספרייה ש, LS, רשימה החוצה.
אני הולך לראות את זה לי יש לי שתי תיקיות המשנה.
בואו נעשה את זה קצת יותר גדול כאן, כך שנוכל לראות את זה כל.
>> אני יכול לראות שיש לי יש לי שתי תיקיות המשנה.
אני אשנה את הספרייה להיכנס לסביבת עבודה.
ואני הולך להקליד רק חלק ממנו, ולאחר מכן פשוט הקש על Tab.
וזה יהיה להשלים את שאר לי.
פנסי.
>> אני אסתכל ותראה בסביבת עבודה.
ועכשיו, אני עובד על SuperSection
שאנחנו מלמדים עכשיו.
אז אני אלך לספרייה ש.
ולבסוף, להסתכל ולראות.
ויש לי שbunny.c קובץ.
>> בסדר אז תן לי ברור פעם נוספת.
ואני הולך now-- שוב אני עדיין שוהה בספרייה ש
וזה אומר לי שאני ב שספריית SuperSection.
אני הולך קדימה ו להפוך את ארנב התכנית שלי.
ופקודה ש, להפוך את הארנב, בעוד שנשמע קצת מוזר,
גם מפעיל את מהדר הצלצול.
>> והוא מיוצר עבור שלי פלט שהוא
funny-- הפעלה קובץ הפעלה בשם ארנב.
אוקיי.
אז אני יכול, וזה נשמע אפילו יותר גרוע, לבצע ארנב.
אוקיי.
ובואו לראות מה זה עושה.
אוקיי.
זה קצת מה שציפיתי.
יש לי התמונה שלי באני לשם, אבל אני סוג של רציתי אותו בכוחות עצמו.
מה שאני לא מתגעגע?
>> SPEAKER 21: סלאש l או לקצץ n.
בריאן SCASSELLATI: n סלאש.
אוקיי.
אז בואו נחזור לכאן.
ואני אצא מזה.
ואני אחזור לזה.
ובואו נסתכל עכשיו מהפונקציה העיקרית שלי כאן.
>> אז מה אני צריך לעשות?
אני רוצה לסיים את הקו.
אז אני אשים בתגובה.
אני אשים בprintf ().
ומה אני צריך לשים ב?
/ N.
אוקיי.
מה אני צריך לעשות כדי לסיים אותו עם?
פסיק.
בסדר.
>> עכשיו, אחד באמת דברים חשובים הוא לוודא
בכל פעם שאתה מבצע שינוי בקוד שלך, שאתה שומר אותו.
אם לא שמרת את הקוד שלך, אתה הולך לשים לב לכוכב עד קטן שם.
וכוכב שאומר לך לא הציל את הקוד הזה.
>> אם אני לקמפל את זה עכשיו, זה לא הולך משקפים שינויים אלה,
כי מהדר מסתכל על הקובץ זה בדיסק, לא הקובץ זה
לפתוח בעורך שלך.
בסדר.
>> אז בואו לשמור אותו ואז נלך ימין למטה כאן ב, לחזור החוצה.
לרדת למסוף שלי.
ובואו לנקות את השטח שוב.
>> ואנחנו יכולים ללכת יותר קדימה ואחד זמן להפוך את תכנית הארנב שלנו.
ולבצע את הארנב.
גם זה לא עובד.
קו נטוי שגוי.
אז אם אתה מסתכל על מה שיש לי, אני שם / N שם, אבל היה לי הקו נטוי הלא נכון.
>> כל מה שהמחשב שלך עושה הוא מאוד מפורש.
אוקיי?
טעות קטנה אחת של סימני פיסוק, ו פתאום אתה לא מקבל את מה שאתה רוצה.
בסדר.
אז בואו גודל חזרה שוב.
אנחנו נחזור.
ובכן לעשות שתיקון מהיר מאוד.
אנחנו נשים את הקו הנטוי תקין ב.
אנחנו לשמור אותו.
אנחנו גודל חזרה ב.
>> מסיבה כלשהי, זה לא להיות מאושר, אבל בואו נלך קדימה
ואנחנו נחזור למסוף כאן.
נקה אותו.
אנחנו להתקרב.
ועוד פעם אחת, אנחנו נעשה את הארנב.
ועכשיו בטוח מספיק, זה עובד.
הידד.
אוקיי.
>> אז בואו ננסה לעשות את זה קצת יותר כללי.
בואו תראו אם במקום רק הדפסת מסגרת אחת מסוימת,
בואו נראה אם ​​אנחנו יכולים לעשות את זה כדי שנוכל לקבל את כל 10
של מסגרות אלה אנימציה שאנחנו רוצים להיות.
אז שוב, בואו ניקח זה צעד בכל פעם.
>> בואו להכלילו ראשון, לא כך שאני עושה את כל המסגרות,
אבל אז אני עושה כל אחד מסגרת שאולי אני רוצה.
אז מה ההבדל בין המסגרות?
האם הארנב את אותו הדבר?
קהל: כן.
בריאן SCASSELLATI: כן.
מה ההבדל?
>> קהל: מיקום.
בריאן SCASSELLATI: עמדתה, נכון?
ואיך אני שולט עמדתה?
כמה נקודות אני לשים בתחילת
וכמה נקודות אני לשים בסוף.
אז היה לי חמישה ב מתחיל וחמישה בסוף.
>> בואו להחליף חמישה שעם ללולאה.
אוקיי.
ואני הולך ליצור ל לולאה עכשיו זה הולך לומר,
אני הולך להדפיס כמה מספר של נקודות בתחילת.
אני הולך להשתמש במשתנה.
בואו נגיד, מה דעתך עליי כ הדלפק בלולאה שלי.
ואני הולך להכריז עליו למעלה.
>> ולאחר מכן ללולאה אני צריך לעשות שלושה דברים.
הדבר הראשון שאני צריך לעשות הוא שאני צריך לאתחל אני.
מה אני צריך לאתחל זה להתחיל להיות?
0.
אוקיי.
>> אז אני צריך להגיד, מה מצב הסיום?
מתי עליי להפסיק?
ובכן כמה נקודות אתה רוצה להדפיס על זה?
>> קהל: חמש.
בריאן SCASSELLATI: חמש שוב?
מה דעתך על בואו נעשה משהו שונה, שעשינו חמישה.
בואו להראות שזה שונה.
22 SPEAKER: שני.
בריאן SCASSELLATI: שני.
אוקיי.
אז אם אני רוצה שתי נקודות, מה אני צריך לשים כאן?
>> קהל: שלוש.
>> בריאן SCASSELLATI: שלוש.
אוקיי.
כמה פעמים היא ש הולך לעבור?
זה הולך לעבור שלוש פעמים, 0, 1, ו -2, נכון?
בסדר, בואו נחזור אל שתי.
עכשיו יהיו לנו שתי נקודות.
ומה לעשות שאני רוצה לעשות כל פעם שאני הולך דרך הלולאה?
מה יש לשנות בכל פעם שאני עובר?
>> SPEAKER 23: להוסיף נקודה.
>> בריאן SCASSELLATI: אני חייב להמשיך.
אני הולך להוסיף נקודה.
אני הולך להדפיס נקודה, בכל פעם דרך הלולאה.
אבל איך אני עוקב אחרי כמה פעמים רבות אני כבר דרך הלולאה?
אני משתמש אני, ש משתנה, דלפק ש.
>> אז בכל פעם דרך, אני הולך כדי להגדיל את המונה על ידי אחד.
עכשיו, זה אותו הדבר עבור שלי כאומר i = i + 1.
זה בסדר.
אני יכול לעשות את זה לראות-- אני אוהב קצרנות, אז אני הולך להגיד לי ++.
אוקיי.
>> בואו לעשות את אותו הדבר כאן למטה בתחתית.
רק אני סוג של עשיתי שאחד.
אני הולך לתת לכם לעשות את זה אחד לגמרי.
בסדר.
>> אז מה כדאי לי לכתוב כאן?
הנה שלי ללולאה.
אני הולך לעשות printf () ואני הולך כדי לעשות את זה כדי שאני רק להדפיס נקודה אחת
בתחתית ש.
>> מה עליי לכתוב בתוך זה ללולאה עכשיו?
ובכן, קודם כל מה ש משתנים כדאי לי להשתמש?
>> 24 מרצה: י.
>> בריאן SCASSELLATI: אני יכול להשתמש j.
האם אני יכול להשתמש באותו אחד?
האם אני יכול להשתמש אני שוב?
כן.
זה בסדר, כי האם שאני משתמש כאן,
אני לא צריך אותם שוב כש אני יורד לנקודה זו.
>> אז מה אני צריך לאתחלי?
25 מרצה: 10.
בריאן SCASSELLATI: 0.
מה עליי לבדוק?
כמה נקודות שאני צריך לעשות עכשיו בסוף אם יש לי שתי נקודות בהתחלה?
אני צריך שמונה בסוף, אז מה אני צריך לבדוק, אני פחות than--
>> קהל: שבעה, שמונה, תשע.
בריאן SCASSELLATI: שמעתי שבעה.
שמעתי שמונה.
ושמעתי תשעה.
אוקיי.
אז כולנו בצד הימין ball-- ג'ייסון אומר 10.
אוקיי.
>> אם אני זקוק לשתי נקודות ל הראשון, כמה לעשות
אני- ואני צריך שמונה נקודות ל אחרון one-- שמתי שני למעלה,
מה אני צריך לשים למטה?
>> קהל: שמונה.
>> בריאן SCASSELLATI: שמונה.
כי זה הולך לספור אפס דרך שבע.
וזה שמונה פעמים דרך הלולאה.
אוקיי.
ומה אני צריך לעשות בסוף?
>> קהל: i ++.
>> בריאן SCASSELLATI: i ++.
בסדר.
כך שמחפש די טוב שם.
בואו ננסה את זה ובוא לראות מה זה עושה.
אוקיי.
אז אנחנו הולכים לשמור אותו.
נחמד והציל.
>> אנחנו גודל חזרה החוצה.
ננסה כאן במסוף.
אנחנו להתקרב.
אופס.
אנחנו נעלה את, עוד פעם אחת, לעשות תכנית הארנב שלנו.
וללכת קדימה ולבצע ארנב.
וזה מה שיש.
>> אז יש הארנב שלנו.
איפה יש לו שתי נקודות בתחילת ושמונה נקודות בסוף.
כולם עדיין איתי?
אוקיי.
>> אז אנחנו בנינו אותו למעלה.
בנינו ארנב אחד, מסגרת מסוימת אחד.
עכשיו אנחנו כבר יכולים להכליל כי לבנות
יותר סוגים שונים, של מסגרות.
>> עכשיו בואו נלך קדימה, ויש לי זה ליצור לא רק אחד מסגרת,
אבל בואו ליצור 10 מסגרות, שבו אנחנו לאט
להפוך את הארנב להעביר את כל הדרך על פני השדה.
בסדר.
>> בואו נחזור.
ואנו ננסה עכשיו.
אז מה אני באמת צריך לשנות כאן?
מה אני צריך לשנות?
>> SPEAKER 26: אתה קודם צריך לשנות את מספר מרבי נקודות
בהתחלה.
כי אם אנחנו עושים 10 נקודות, זה הולך צריך את קנה מידה.
בריאן SCASSELLATI: כן.
אז עכשיו יש לי אותו סוג של קשיחה תמיד לעשות שתי נקודות בתחילת
ותמיד עושה שמונה נקודות בסוף.
>> אני רוצה לבנות לולאה אחרת, נכון?
כי אני לא רוצה לבנות רק תמונת ארנב אחד,
אני רוצה לבנות 10 תמונות ארנב.
אז אני צריך לבנות לולאה אחרת, וכמו שאני הולך דרך לולאה ש,
אני רוצה לשנות כמה נקודות אני להדפיס בתחילת
וכמה נקודות אני להדפיס בסוף, אשר מבוסס על המחזור דרך הלולאה
אני בפנים.
בסדר.
>> אז בואו לקבל מרשם אחר.
מישהו אמר לפני j, כך אנחנו נעשה j אחר.
ועכשיו, אנחנו הולכים לבנות עוד ללולאה.
>> מה הולך בתוך הלולאה ש?
החומר הזה צריך ללכת בתוך הלולאה, נכון?
האם יש לארנב ללכת בתוך הלולאה?
האם אני צריך ארנב ב כל אחד מאלה 10 מסגרות?
>> קהל: אה-הא.
בריאן SCASSELLATI: כן.
אני רוצה ארנב בכל של 10 מסגרות, נכון?
מה דעתך על הנקודות ב הסוף, אני צריך לעשות את זה?
אוקיי.
>> אז אני הולך להכנסת כולם.
אני הולך לסמן את כל זה, ואני הולך להכות Tab.
וזה הולך לדחוף אותם בכל רחבי קצת, כך שזה קל לי
כדי לראות מה יש בלולאה.
ואז אני בסופו של אותו.
נניח.
אוקיי?
>> עכשיו, בלולאה זה ש אני אופס building--,
לעשות את זה, כך שתוכל see-- יש לי j הדלפק שלי.
אני התחלתי את זה ב 0.
כמה פעמים אני רוצה ללכת דרך לולאה זה?
קהל: 10 פעמים.
בריאן SCASSELLATI: 10 פעמים.
אז מה מספר שאני צריך לשים כאן?
>> קהל: 9, 10.
>> בריאן SCASSELLATI: 9, 10, מישהו חייב לומר 11, נכון?
אני רוצה שתי נקודות לפני ולשים לי פחות מ 2.
אני רוצה שמונה נקודות, שמתי לי פחות מ -8.
עכשיו אני רוצה לעבור 10 פעמים, אז שמתי את j פחות than--
>> קהל: 10.
>> בריאן SCASSELLATI: 10.
יש לנו ללכת.
ומה עליי לעשות בסוף לj?
++, להגדיל אותו.
אוקיי.
עכשיו, הנה החלק הבעייתי, מה הולך לקרות עכשיו אם אני עושה את זה?
אני הולך להדפיס 10 מסגרות?
27 מרצה: אני חושב ש הם כל להיות זהים.
בריאן SCASSELLATI: הם כל להיות זהה, נכון?
כי כולם עדיין הולכים לשים שתי נקודות בתחילת.
אבל אני לא רוצה את כולם ל יש שתי נקודות ההתחלה.
כמה נקודות שאני עושה רוצה בהתחלה?
>> קהל: שינוי.
>> בריאן SCASSELLATI: אני רוצה שזה ישתנה, נכון?
אז מה יש לי כאן זה משתנה בכל פעם שהלולאה עוברת?
>> קהל: מספר הנקודות, j.
בריאן SCASSELLATI: j, מספר הנקודות.
אז אני יכול לשנות את זה כדי להיות j.
בפעם הראשונה ב לולאה, מה שהולכת להיות?
מה שאני כן נקבע j בהתחלה?
>> קהל: 0.
>> בריאן SCASSELLATI: אז כמה פעמים אני הולך לעשות את זה?
0.
בפעם השנייה דרך הלולאה, j של הולך להיות 1 כי אני מגדיל אותו.
כמה נקודות אני הולך להדפיס?
1.
הפעם השלישית דרך הלולאה, כמה נקודות אני הולך להדפיס?
>> קהל: שלוש.
בריאן SCASSELLATI: j הולך להיות 3.
כמה נקודות אני הולך להדפיס?
אה, סליחה, j הולך להיות 2.
כמה נקודות אני הולך להדפיס?
>> קהל: 2.
>> בריאן SCASSELLATI: 2.
אוקיי, אז אני הולך לשמור הגדלה שכפי שאנו הולכים יחד.
מה דעתך על למטה?
מה הולך כאן?
אני לא רוצה 8 תמיד בסוף כבר?
>> SPEAKER 28: 10.
בריאן SCASSELLATI: אני רוצה 10 נקודות?
גם אני רוצה שזה ישתנה,.
אז איך אני רוצה שזה ישתנה?
>> קהל: [לא ברור].
בריאן SCASSELLATI: ובכן, אם אני יש חמש נקודות בתחילת,
כמה נקודה שלי מקבל בסוף?
>> קהל: חמש.
>> בריאן SCASSELLATI: אם יש לי שש נקודות בתחילת,
כמה אני מקבל בסוף?
קהל: ארבעה.
בריאן SCASSELLATI: אם יש לי שבע נקודות בתחילת,
כמה אני מקבל בסוף?
קהל: שלוש.
בריאן SCASSELLATI: אם יש לי יש נקודות j בתחילת,
כמה אני מקבל בסוף?
10-J.
אוקיי.
אז בואו ננסה את זה.
>> אז אני הולך להציל את תכנית הארנב שלנו.
שוב אנו להקטין את התצוגה.
הנרד למסוף שלנו.
אנחנו לנקות אותה.
ולהתקרב.
אנחנו נכין תכנית הארנב שלנו, שוב.
ואנחנו יבצעו אותה.
או הו.
>> תחזיק חזק, בואו להקטין את התצוגה.
האם אני מקבל 10 פריימים?
ובכן, כמה ארנבות אני רואה שם למעלה?
1, 2, 3, 4, 5, 6, 7, 8, 9, 10.
יש לי 10 מסגרות.
האם הם כולם אותו הדבר?
קהל: כן.
מס '
>> בריאן SCASSELLATI: מס '
כי ראשון, ארנב הוא רחוק בצד השמאל.
וכאן, באני רחוק ב
SPEAKER 29: העכבר.
בריאן SCASSELLATI: אז, מה שכחתי לעשות?
30 מרצה: התחל בשורה חדשה.
בריאן SCASSELLATI: שכחתי כדי להתחיל שורה חדשה, שוב.
אותה טעות שעשיתי בעבר.
בסדר, בואו נלך לתקן את זה.
עכשיו, עדיין יש לי את הקוד שם כדי להפוך את הקו חדש.
למה זה לא עבד?
31 דובר: זה לא בתוך הלולאה.
בריאן SCASSELLATI: אה, זה לא בתוך הלולאה.
זה נכון.
זה יושב מחוץ כאן.
וללולאה הוא כל מה ש זה בתוך טקסט ש.
>> אז אני הולך לעבור זה בתוך לולאה.
ואני Tab מול זה ל להראות שזה במקום הנכון.
ועכשיו, אנחנו נשמור את זה שוב.
אנחנו להקטין את התצוגה.
אנחנו לעבור למסוף שלנו.
להתקרב.
אנחנו מחדש תכנית הארנב שלנו.
ועכשיו, עכשיו יש לנו 10 המסגרות שלנו.
>> [מחיאות כפיים]
>> בריאן SCASSELLATI: אישור.
כן."
כאן הוא שלנו מקונן ללולאות.
הצלחנו ליצור ב לולאה פנימית כמה נקודות שאני רוצה
להדפיס בהתחלה, בסוף.
ושלט בלולאה החיצונית כמה מסגרות שאני בונה.
התחלנו עם מעט אחד ליבה של הבעיה,
ובנינו החוצה מנקודה זו.
בסדר.
>> בואו נעשה עוד צעד אחד.
אתה מוכן?
יש דבר אחד שבבי כאן אנחנו בעצם כבר סוג של לי
יותר מורכבות מאשר שאנחנו צריכים.
בואו נסתכל.
אז בתכנית הארנב שלנו, אם אני להקטין את תצוגה כאן,
אני עושה חלק מאותם דבר שוב ושוב.
מה עליי לעשות זה סוג של אותו הדבר חזר פעמיים?
>> SPEAKER 32: הדפס הנקודות.
>> בריאן SCASSELLATI: כן אני להדפיס נקודות אלה פעמיים.
באמת, צריך להיות לי הערה זו כאן למטה.
אני להדפיס כמה נקודות ב מתחיל, ממש עד כאן.
ואז אני להדפיס כמה נקודות בסוף.
ואני עושה סוג של בדיוק את אותו דבר.
מה אנחנו הולכים להתחיל עובד על בשבועות הקרובים
הוא להיות מסוגל לקחת אותם בלוקים של קוד שאנו משתמשים בו שוב ושוב,
ודרך תהליך הפשטה נקראת,
אנחנו הולכים למשוך אותם החוצה ו לכתוב אותם פעם אחת, כך שלאחר מכן אנחנו יכולים
שימוש חוזר בהם שוב ושוב.
אז בואו ננסה את זה.
מוכן?
>> אנחנו הולכים לקחת את הבלוק הזה של קוד.
ואני הולך לקחת אותו משם.
ואני הולך define-- למטה בתחתית,
אני הולך לכתוב פונקציה חדשה.
זה לא הולך לחזור כל דבר.
ואני הולך לקרוא לזה printDots.
>> זה הולך לקחת אחד טיעון, מספר שלם ש
אומר howManyDots אני צריך להדפיס.
ועכשיו במקום להדפיס נקודות j, אני להדפיס לספר howManyDots אני צריך להדפיס.
>> ויש בעיה אחת קטנה כאן.
מישהו יודע מה זה?
מה יש לי שהוא מופיע כאן זה לא מוגדר?
>> קהל: [לא ברור]
>> בריאן SCASSELLATI: ובכן איך נקודות רבות מוגדרת ממש עד
כאן, אבל אני משתמש במשתנה שאני.
אז אני הולך לקחת משתנה ש ואני הולך להגדיר אותו כאן
במקום.
>> אז עכשיו זה הולך stay-- אופס, יש הכובעים לנעול על somehow-- אני
הולך לשמור אותי לכאן.
>> אז עכשיו הנה הפונקציה הקטנה שלי או תת-שיגרתי, וזה אומר,
כמה נקודות אני הולך להדפיס?
וזה ילך דרך לולאה זה ו להדפיס אותם שוב ושוב.
>> אז אני יכול לשנות את התכנית שלי עד כאן.
ומה אני קורא לפונקציה זו?
printDots.
אז אני אתקשר printDots.
כמה נקודות אני רוצה להדפיס בפעם הראשונה לפני הארנב?
קהל: י.
בריאן SCASSELLATI: י.
כמה נקודות אני רוצה להדפיס בסוף, אחרי הארנב?
10-J.
>> ויש דבר אחד שאני חסר.
כפי שראית בהרצאה היום, אנחנו הולכים להכריז printDots
למעלה לתת את אב הטיפוס.
אוקיי.
>> אז מה שעשיתי הוא שניסיתי לבודד את החלק בה שימוש חוזר של קוד
שעשיתי שוב ושוב.
וניסיתי למשוך אותו החוצה כדי ש כל זה כלול במקום אחד.
בדרך זו, אם יש לי טעות איפשהו, אני רק צריך לתקן את זה במקום אחד.
בסדר.
>> אז בואו לשמור אותו.
ובואו לוודא שזה עובד.
אז בואו נצא.
נלך שוב למסוף שלנו.
אנחנו להתקרב.
אנחנו נעשה את זה תהליך הארנב.
>> אה.
וזה נתן לי אזהרה.
מה זה אומר לי?
ובכן בכל אחד מאלה פעמים, אתה תמיד רוצה
כדי לגלול עד error-- הראשון עכשיו על זה, יש לי רק אחד.
>> זה אומר לי בbunny.c, על קו 8, 9 טור, יש בעיה.
זה אומר, שהכרזת זה אני משתנה ואתה לא השתמשת בו.
>> עכשיו בדרך כלל, זה לא השגיאה החמורה ביותר.
זה קל לתקן.
ולמעשה, אנחנו יכולים לחזור ב.
אנחנו יכולים לחזור לארנבת.
ובמקרה הזה, כולנו צריך לעשות הוא להיפטר מאני,
כי אנחנו לא משתמשים ב אני בתוך עיקרי יותר.
אנחנו רק להשתמש בו בתוך תת-השגרה שלנו.
>> אז בואו נשמור את זה.
אנחנו נחזור.
ולהתקרב.
אנחנו עוד פעם אחת לעשות ארנב.
ויש שוב 10 מסגרות שלנו.
אוקיי.
>> בכל פעם שאתה נתון procedure-- כן.
SPEAKER 33: יש לי זה-- אני מבולבל.
האם אתה יכול לחזור לקוד?
בריאן SCASSELLATI: כן.
>> SPEAKER 33: אז, כשאתה כתב אב הטיפוס שלך, את טענתך
שזה נקרא בשם howMany?
אבל, below--
>> בריאן SCASSELLATI: אה, כן.
>> SPEAKER 33: --called משהו שונה, אני לא מבין.
>> בריאן SCASSELLATI: מדוע הם שונים.
אז זה שאלה גדולה.
אז השאלה הייתה, עד כאן, כתבתי howMany,
ולמטה, כתבתי howManyDots.
>> הסיבה לכך היא שעד באב הטיפוס שלך, זה באמת לא שם לב
לשמות שאתה מכניס.
כל מה שבאמת אכפת הוא שזה מספר שלם.
היא רוצה לדעת את הצורה של מה שאתה מכניס.
>> עכשיו stylistically-- oops-- מה שאני צריך אל, הוא שאני רוצה לעשות משחק הבאים.
אוקיי.
מכיוון שתהיה לשמור אותו יותר קל לי לזכור.
אבל זה היה הטעות שלי כן.
>> SPEAKER 34: וכך ל אב טיפוס לעבודה, רק
כתיבת קו ש, כתיבת אב הטיפוס,
מאפשר פונקציה שמגיעה ממש מתחתיו ללכת עד הסוף
ולאחזר מה זה אומר?
>> בריאן SCASSELLATI: מה זה אומר כאשר המהדר עובר,
זה הולך מהחלק העליון של הקוד שלך לתחתית.
ומה הוא אב-טיפוס זה, זה בעצם הבטחה.
>> זה אומר, שיש הולך להיות פונקציה מוגדרת במקום כלשהו.
זה הולך להיות printDots נקרא.
וזה הולך לקחת טיעון אחד זה הולך להיות מספר שלם
וזה הולך לחזור שום דבר, סוג החלל.
אוקיי.
אני מבטיח לך שזה הולך להיות הגדרה איפשהו בהמשך הדרך.
אבל כל פעם שאתה רואה כי, כמו שאתה הולך במורד
דרך שאר פונקציה העיקרית, אני רוצה
לך לטפל בזה כפונקציה שלוקח קלט מספר שלם אחד.
>> ולכן כאשר המהדר יורד באמצעות זה, היא רואה שהבטחה.
וכאשר הוא יורד, שומר הולכים, הולך כל הזמן,
הוא מוצא בפעם הראשונה printDots מוזכר.
וזה אומר, אה, אתה נותן שלי j זה. j זה מספר שלם.
>> ובכן הבטיח לי שיהיה להיות שלם וזה נכון.
זה בסדר.
ולבסוף, במורד בתחתית מאוד,
לפני שאני מגיע לסוף שלי קובץ, אני עושה טוב על ההבטחה שלי
ואני מגדיר את זה.
אוקיי?
>> 35 דובר: אז, זה saves-- תכנית תחסוך חללים ריקים
שזה חוזר וממלא בסוף?
>> בריאן SCASSELLATI: זה לא על הקצאת הזיכרון.
זה בעצם רק על מה ש הסוג שאתה מצפה לראות.
צריך את הדבר הזה אחת ויכוח, או חמישה טיעונים?
זה צריך להיות שלם ולהיות שניתן לו, או מחרוזות?
זה כל מה שזה נראה לעשות הוא לבדוק,
אתה נותן לי את סוג נכון של טיעון.
אוקיי?
בסדר.
>> תן לי להשאיר אותך עם קצת אחד אחר להסתכל.
אמנות ASCII היא לא המודל הגדול של אנימציה כפי שהוא היום.
אבל יש אנשים שכמובן לקחת את הדברים והם דוחפים את זה לקיצוניות שלהם.
>> זה, כמו דוד הפגין בהרצאה, פיסת הקוד
שאתה צריך בשום פנים ו מנסה לשכפל את עצמכם.
בגלל זה הוא נורא סגנונית.
למעשה, הוא נועד להיות כ ככל האפשר לקשה לקרוא.
אוקיי.
>> אז, לעשות שוב, בואו להתמקד בכאן.
אני הולך עכשיו, שינוי ספרייה.
אני הולך לעלות אחד רמה, חזרה לסביבת העבודה שלי.
אז אני אשנה את הספרייה לזה ספרייה אחרת שיצרתי.
>> וזה בינלאומי תכנות C לטשטש תחרות.
אמצעים לטשטש קשה ככל האפשר כדי להבין.
אז בבקשה, אל תפחדו, אם אתה מסתכל בשלב זה וללכת, אני לא יכול לקרוא את זה.
זו הנקודה שלו.
אוקיי?
>> אבל, יש לנו את זה תכנית נפלאה שאני
הולך להסתכל רק על ידי הקלדה יותר.
ובואו נראה אם ​​אני יכול להקטין את התצוגה רק קצת, כך שאתה יכול לראות את זה
>> וזה התכנית.
זה שם endo.c.
וזה נראה כמו דלי זה עם סוג של האותיות F-L-U-אני-D בזה.
>> זה הוא למעשה תכנית.
זה כתוב במעורפל ביותר אופן שבו המחברים אולי יכלו
כתוב זאת.
אבל זה חתיכה קטנה נפלאה ש יוצר מודל של דינמיקה של נוזלים.
>> וכך אנחנו הולכים לתת לי מודל שקלט ש
נראה כך, של staired להגדיר מכולות
עם כמה נוזל, כמה נוזל, עד שבחלק העליון.
ואנחנו נצטרך אותו לדמות מה קורה לו.
>> אז אני אתקשר אל הפונקציה ש, אנדו.
ואני אתן לו ש קובץ קלט שהיה לי.
ויש ההתגלמות של אמנות ASCII שלנו.
סימולטור דינמי נוזל מלא פועל רק כמה שורות של קוד.
>> עכשיו מה בעצם באמת מדהים על תכנית זו קטנה
הוא שאני רוצה לעצור את זה עכשיו, אז אני הולך להשתמש במה שהפקודה?
>> קהל: בקרה-C.
>> בריאן SCASSELLATI: בקרה-C. אוקיי.
אז אני אשתמש בקרה-C. C זה יהיה לעצור את זה.
אני לנקות שוב.
ועכשיו אני הולך להפעיל את תכנית, לבצע את התכנית,
באמצעות עצמו כקלט.
>> ואנו רואים את דינמיקת הנוזלים סימולציה שלו נמסה.
אוקיי.
בבקשה אל תתנו לי תכנית ש להיות הדבר שמבלבל אותך.
זה רק כדי שנוכל לסיים ב משהו מגניב ומעניין.
אוקיי.
>> מיטב של מזל עם סטי הבעיה שלך.
נשמח לענות שאלות אחרי השיעור.
תודה רבה, חבר 'ה.