[Powered by Google Translate] [♪ ♪ זמזום]
אז כדי להכיר לך את מה שיש לי על המסך;
זה האחד הכלים שפתחנו במשך הקיץ;
זה נקרא CS50 Spaces,
וזה היישום שלנו שיתוף פעולת הקידוד
שאנחנו הולכים להשתמש בחלקים.
זה די מגניב.
האם מישהו מכם ראה CS50 טווח עדיין?
בואו ימשכו אותי שבכרטיסייה אחרת.
Run.cs50.net
כך
אם אתה הולך לrun.cs50.net,
אתה יכול לראות את זה בדרך שלך לדפדפן
למעשה קוד - לכתוב קוד C,
ולאחר מכן להפעיל אותו,
כך שזה גם הידורו, מנהל אותו, לאחר מכן מחזיר את הפלט אליך,
אז זה סוג של דרך מגניבה לניסוי
עם חלק מהקוד שעובר על דוד בהרצאות
ואנחנו נותנים לעל קבוצות בעייתיות
מבלי למעשה לפטר את המכשיר.
>> אז מה עושה Spaces זה שונה מזה
אם לחזור לכרטיסייה זו,
רווחים הם CS50 ריצה, כמו שאתה רואה כאן,
אם אנחנו לגלול שוב ומסתכלים על הצד השני של החלון, אבל,
אתם רואים נכונים שאני האדם היחיד במרחב הזה,
אבל מה שאני הולך לעשות הוא לשאול אתכם להצטרף אל החלל הזה איתי
וכולנו נגיע לקוד באותו החלון קטן,
לשתף קוד אחד עם השני,
ולדבר על ההבדלים בין הקוד שלנו.
אז זה סוג של דבר מגניב -
כך להצטרף, אם תבקר בקישור זה ממש כאן בראש
כי אני כבר מסומן,
אתה יכול פשוט להקליד apps.cs50.net/spaces/vqcspSnO.
>> בסדר, אז כדי להתחיל,
אני הולך לתת לך קצת מסיור זה.
אנחנו הולכים לעשות כמה קידוד קטן ומטופש עם זה בהתחלה,
רק כדי שכולם מקבל קצת תחושה של מה זה כאילו,
אבל מה שעשיתי -
או מה שאני עומד לעשות כאן הוא -
אני הולך לקחת את הקוד שכתבתי כאן,
וכפי שאתם רואים עכשיו הוא ריק;
זה לא עושה כלום.
זה רק קוד צלחת דוד, אנחנו קוראים לזה.
עם קצת כדי לעשות את התגובה.
אני הולך לשמור אותו על ידי להכות על הכפתור השמור הזה.
ומה שעושה זה
הדגיש אותו כאן בקצרה - שקופסה ירוקה הגרסה לשמור,
ועכשיו, אם אתה מחפש אותי בשטח,
אתה לוחץ על השם שלי,
אתה יכול לראות שיש לי גרסה זו ממש כאן,
אם תלחץ על עדכון ו,
זה יהיה לטעון קוד שלתוך החלל שלך, מדי.
>> אז יש כל טעון שקוד לתוך השטח שלהם?
בסדר, אם יש לך עדיין לא, אתם מוזמנים לעשות זאת,
ואז מה שאני רוצה אתם לעשות בזה קצת כדי לעשות את הסעיף
הוא כותב קצת באמצעות printf על עצמך,
כך למשל, הייתי כותב
printf ("קורא לי נייט");
ואז הייתי כותב
"סיימתי את הלימודים בשנת 2009
מסטנפורד "
ואני אשמח לשמוע על
באיזו שנה אתה בבית הספר,
בין אם אתה במכללה או בית הספר לעסקים
או אחר בבית ספר הרווארד,
מה אתה לומד אם זה ידוע עדיין;
אם זה לא ידוע, זה מגניב לגמרי.
אני לא אחליט עד שהייתי מאוחר בשנה השנייה שלי.
ואז גם אני אשמח לדעת
שום דבר מטורף שאתה רוצה לספר לי או
משהו על הכיתה או סתם כל דבר אחר.
לאחר שתסיים לכתוב את זה עם מעט printf שלך,
אם תוכל לחסוך את התיקון או יותר נכון
ודא תחילה שתוכל להפעיל אותו
ושזה מדפיס את בדיוק מה שאתה רוצה זה להדפיס,
ואז אם אתה הולך קדימה ולשמור גרסה כי
באמצעות הלחצן הגרסות השמורים, בחור הראשון וקטן זה כאן,
ואנחנו די נלך דרך ולעשות הקדמה קטנה ככה.
אז אתה צריך רק צריך ללחוץ על כפתור Play,
אשר עד כאן בצד השמאל למעלה,
כך כפתור Play זה בצד השמאל למעלה יהיה
לשלוח את הקוד שלך לשרת שלנו שבו היא מקבלת לוקטה ואז לרוץ.
אז מה זה די משוגע על זה
קוד זה ממש לא פועל במחשב שלך;
זה בעצם שנשלח אל מעבר לאינטרנט.
>> איך זה הולך, שרלוט?
>> אני - בסדר. אני - אני חושב שאני
לאחר קשיי שמירתו
בשרת כזה שהיא יכולה - אני יכול להפעיל את התכנית.
ואז כשאני מנסה להפעיל אותו, זה אומר שיש שגיאה.
הוכרז כוירוס, שהוא לא שם יותר.
אה, בואו נראים, אתה יכול להכות שוב על שמור?
אני רואה את זה על המסך.
עכבר >>, בסדר, אז זה מה שיש לי.
ואני לא יודע למה זה לא נותן לי לנהל אותה.
אה, אוקיי, מצטער.
האם אתה יכול להסביר למה - מה לא היה בסדר - מה שלא עובד איתו?
>> כן, כי אני לא רואה שיש שורה אחרונה בו יש עדיין משתנה
שלא הכריז, שאני לא מתכוון לזה להיות שם.
כן, מושלם!
>> עכשיו אם אני שומר אותו, אני חושב שזה צריך לעבוד.
עכשיו, לאחר שהצלת אותו, זה עובד; מדהים.
>> אז כן, כמו שאנחנו הולכים בדרך -
אז מה קורה,
אני רק הולך לחזור על זה למצלמה.
מה שקרה היה שזה משתנה זה
נשאר באחרי - אני מניח שמחקת כמה דברים אחרים
איפה אתה תוכרז כ,
וכך זה היה זורק את הדברים ולא נותן לך להפעיל אותו.
אז זה בדיוק מה שאנחנו רוצים לעשות בסעיף
הוא שאנשים ינסו לכתוב חלקים שונים של קוד,
הידורו, לראות מה עובד, מה לא לראות,
ואז די לדבר על הדברים האלה, כי אלה הם נקודות שמעד
אני עדיין נתקל,
אני עדיין - אני עושה המון דברים טיפשיים כל הזמן,
ואני לא יודע למה זה לא עובד,
אז בואו להרים את הגרסה של שרלוט 3,
ושנריץ את זה.
>> אז כשאני רצתי, עכשיו שיש לי הקוד שלה לכאן
אני יכול להתמקד ב, לחץ על כפתור ההפעלה,
העלאות אותו, בונה אותו, מנהלות אותו,
אומר שזה רץ בהצלחה, ואם אני לגלול למטה,
לראות שרלוט היא זוטרה באדמס הבית,
פסיכולוגיה, משנית בכלכלה; מדהימה.
נהדר לפגוש אותך!
מדהים.
אוקיי, ימשיך, בואו נלך לדניאל,
ללכת לגרסה 3,
לקמפל, לרוץ;
למה שלא תספרו לנו קצת על עצמך, דניאל?
>> מתקשר אליי דן.
אני הולך לבית הספר לעסקים על פני מכם,
ואני היה במארינס לפני כאן,
וכל זה חדש לי, אז כן.
אל תרגיש רע, אני בת 30 ואני לא יודע כל הדברים האלה.
מדהים; תודה, דן!
בסדר, יש לנו עוד דניאל.
אתה הולך לפי דניאל - יהיה לך להציג את עצמך, דניאל?
>> >> בטח, אני דניאל.
אני בכיתת י 'במאת'ר עכשיו.
כשאני מתרכז בממשלה,
אבל אני רוצה לקחת את CS50 כי שמעתי ביקורות מצוינות על המעמד
ואף פעם לא ניסיתי לפני CS.
גלול למטה ולהראות את זה - מגניב.
ההעברה ב, ג'ארד.
איך זה הולך?
>> טוב, מה שלומך?
כפי שאתה יכול לראות, אני concentrator פילוסופיה זוטרה באליוט,
במקור מדרום קליפורניה,
ואני מעוניין לקחת CS50 כי אני אוהב את ההיגיון שלה,
ונראה ממש מגניב לעשות דברים במחשב, ולכן.
מדהים; שם בדרום קליפורניה אתה?
>> כשעה מ[ לא ברור], עיר קטנה [לא ברור].
אה, כן, האבא שלי נולד Redlands.
דברים מגניבים.
>> בסדר, ג'ימי, איך זה הולך, ג'ימי?
>> טוב, מה שלומך?
עושה די טוב!
ספר לנו על עצמך.
>> אני בכיתת ט ', ואני לא לגמרי בטוח מה אני לומד בחוג
אבל אני די אני נוטה לכיוון כלכלה.
כמו דניאל לפניי, אף פעם לא עשיתי כל CS, אבל זה נשמע די מגניב.
אני במקור משיקגו.
מדהים. אז לבדוק את התדפיס שלו כאן.
רציתי לשאול, האם בהדפסה יצאה כפי שציפית?
>> לא, שכחתי להדפיס שורה חדשה.
אני באמת שכחתי שגם כשכתבתי את הקטע שלי
בפעם הראשונה, יותר מדי.
זה סוג של כאב לזכור לשים אותם באופן ידני.
זה יהיה נחמד אם הוא רק יודע שזה מה שרצית.
>> אוקיי, קלי.
וואו, יש לנו 2 Kellys; 2 דניאלס, 2 Kellys.
אז קלי - אתה הולך על ידי רן קלי?
אוקיי, מדהים.
או קלי, אני מתכוון.
>> אז כן, כך אני קלי.
אני בכיתת י 'בPfoho.
יש לי דואר אלקטרוני היום כי עדיין יש לי 7 שבועות להכריז על הריכוז שלי,
אז אני מנסה לא לחשוב על זה,
ואני אוהב אפייה, ריצה, וCraisins.
אין לי ניסיון עם רוב של CS;
למדתי את עצמי לבנות אתרי אינטרנט כשהייתי ממש צעיר,
אבל אני חושב שכנראה למדתי את עצמי טועה הרבה פעמים.
אני מקווה שאני אלמד קצת יותר
ו-- כן.
>> מדהים, טובה, תודה לך.
בואו נלך לקלי האחר;
אין לי שום דבר - לא אתה אומר משהו בפה?
>> [לא ברור]
הנה זה!
מתוק!
>> בסדר, אז אני קלי.
אני סטודנטית לתואר הראשונה שנה.
אני לומד בחוג שכל, מוח, וחינוך.
אני סיימתי את הלימודים במכללת פרנקלין ומרשל בשנת 2008
עם מגמות בפסיכולוגיה וסוציולוגיה
וקטין בצרפתית.
אני לוקח CS50
כי אני מעוניין לקבל דוקטורט במדעי המוח
ואני מרגישה שזה יעזור לי להבין את הטכנולוגיות בשימוש.
מדהים.
ההעברה ב, מיקאלה.
האם זה הגייה נכונה?
אוקיי, מדהים.
>> >> אני Mikhaila.
אני בכיתת י 'בבית קירקלנד,
וכשאני מתרכז בהנדסת מכונות.
אני באמת אוהב את הרכיבה על אופניים, שנבניתי על אופניים בקיץ הזה.
אני לוקח את CS, בעצם,
כדרישת ריכוז,
אבל אתה יודע, אני חושב שזה עדיין סוג מגניב של כיתת הנדסה.
מדהים - שנבנית על אופניים בקיץ הזה?
>> כן.
וואו, כמו מסגרת וכל זה?
>> אהה (חיובי).
וואו, זה ממש מגניב.
>> [שיחה בלתי נשמעת מחוץ למצלמה]
[שחוק]
כן, זה היה כל כך ארוך.
אתה אף פעם לא יודע, נכון?
ובכן, מגניב; תודה כן, Mikhaila.
>> בסדר, המסים.
מסי >> שמי; אני בכיתת ט ',
אז זה אומר שאני לא יודע כלום!
אני רוצה להתרכז באסטרופיזיקה.
בCS50,
אני מרגיש כמו בהחלט לעזור עם זה.
עובדה מוזרה לי היא שאני כבאי ארצי מוסמך.
וואו!
איך זה קרה?
>> אני השתתפתי אקדמיה
ועברתי גיהינום במשך הרבה שבועות
וקבלתי האישור שלי.
וואו, מזל טוב!
זה הישג לא קטן, זה בטוח.
אוקיי, אז עכשיו אנחנו נעשה אותי.
אני הבא בתור בשורה.
אני - להפעיל אותו.
>> אז השם שלי הוא נייט.
אני היה בכיתה של 2009 בסטנפורד.
אני היה במערכות סמלים גדולות,
בדומה למוח, המוח, ריכוז ההתנהגות כאן,
אבל זה סוג של שילוב של
מדעי מחשב, בלשנות, פסיכולוגיה ופילוסופיה.
סוג של - כן, הרבה דברים מוזרים, אבל זה היה נהדר,
ואז אני גם עשיתי את המאסטר שלי במדעי מחשב שם,.
אז אני חדש הרווארד השנה.
אני באמת רוצה להגיע להוראה.
אני ביליתי את 4 השנים האחרונות בשיעורי מדעי מחשב ת"א ing סטנפורד
וכן הדוד ירשה לי לבוא,
ואני אעזור בCS50,
אז אני עושה את זה כל זמן, אני לא בלימודים.
זה היה כיף.
אני מקווה שזה ימשיך להיות כיף, אני בטוח שכן.
>> בסדר, סם.
>> השם שלי הוא סם; אני תלמיד שנה השנייה במכללה, בחוק באופן ספציפי.
העיקרי שלי יהיה ההיסטוריה של מדע, מן הסתם, וVes משני,
והצבע האהוב עליי הוא צהוב.
אין צורך לשפוט או משהו, אבל זה צבע טוב!
וסטלה.
>> היי, אני סטלה; אני בכיתת ט 'באפור.
אין לי מושג מה אני כבר מרוכז בעדיין,
כך CS50 היה רק ​​סוג של אקראי,
וזה מעניין.
למעשה כיף, ג'ימי היה חבר הרווארד הראשונה שלי,
כי אנחנו משני שיקגו.
מגניבה, וגרייס - שאמור להיות אחד לא באמת נחמד, נכון?
>> חשבתי [לא ברור].
אה, כן.
[צ'אט מצלמה מחוץ לבלתי נשמע /]
אוקיי, אני עדיין לומד, עדיין לומד.
>> אז יש לנו משהו אחר זה די מעניין כאן.
כן, אני רק תוהה, האם יש לך רעיון שקורה כאן?
אתה יודע איך לפרש את זה?
>> אני היה אמור לשים פסיק אחרי כל שורה האחת.
זה סוג של כאב.
לפעמים הפסיק האלה יכול להיות כאב אמיתי לאתר.
אז מתברר כי
תכנית המיוחדת שאנחנו משתמשים בזה לשנה
לקמפל קוד C שלנו נקרא קלאנג,
והסיבה שהתחלנו להשתמש קלאנג השנה -
כי אנחנו לא השתמשנו בתכנית שבעבר;
אנחנו מנצלים אחד את השני בשם GCC זה באמת פופולרי -
קלאנג בעצם נותן לך הודעות שגיאה שהגיונית.
זה אומר "צפוי": "אחרי ביטוי",
והוא אפילו אומר לך את הביטוי לאחר שהיה זקוק לי פסיק.
אז אתה לתקן את זה?
>> כן, ממש עכשיו.
מדהים; תודיע לי ואנחנו למשוך אותו למעלה, ושנריץ את זה.
אבל כן, לשים נקודה ופסיק באלה הוא סוג של כאב.
>> אני סדרתי את זה, אז אני חושב שזה צריך לעבוד.
מדהים - 3 מהדורות.
זה נראה כמו זה.
בסדר, אז עכשיו אם אנחנו מפעילים את זה,
שם זה הולך.
דברים מגניבים.
>> בסדר.
אז תודה על עושה את זה.
זה נהדר לפגוש אתכם.
מה אנחנו הולכים לעשות עכשיו זה להשקיע קצת הבא
די לצלול לתוך בעיות הסעיף
שבאו מהבעיה להגדיר מהשבוע
ואנחנו נעשה את זה עבור רוב הסעיפים
לשאר הטווח,
ואז נחסוך 15 האחרונים, 20 דקות בערך
לדבר על הבעיה להגדיר את עצמו
ואז פשוט על כל שאלה אחרת שיש לך באופן כללי על הכיתה.
עם זאת, מה לעשות שאנחנו באמת רוצים
ראשון לדעת שהשתתפות
שימוש בחומר Spaces,
לזרוק בקוד, לזרוק בהצעות,
וכשמדבר על דברים כמו ההפסקה הזו,
או לא עובדים, רק בגלל שאלו דברים ש
אני יודע שאני נתקלתי
כשהתחלתי קידוד,
ובאמת היו די מתסכלים בזמנים
כי אם זה כמו 2:00 לפני סט הבעיה שלך נובע,
כך - רק בשביל גילוי,
אני לא התחלתי את תכנות עד שהיה בשנה שנייה במכללה.
זה היה סוג של דבר זה מוזר, לא ידוע
שמעתי שהיה די מגניב
ושמעתי גם שזה יכול להיות ממש קוץ בתחת
אם ברצונך להצטרף פסיק וזה הטעות היחידה שמחזיקה את התכנית שלך מעבודה
ומונע ממך ללכת לישון,
אז בהחלט,
אם יש לך שאלות כאלה,
אם יש לך חששות כאלה, תודיע לי,
בגלל שאני רוצה לעשות זה ניסיון טוב בשבילכם.
>> אז אתם חייבים להוריד את כל הבעיה להגדיר עדיין?
די יודע איפה זה? אוקיי.
אז תיסע לcs50.net, כי אין לי את זה על חשבון זה,
למשוך את הקבוצות הבעייתיות,
למשוך את קבוצת הבעיה 2, ואנחנו מסתכלים המהדורה הסטנדרטית כיום.
אנחנו נמשוך את המפרט כאן.
לגלול למטה.
אז אנחנו הולכים להתחיל לחפש בקטע זה של שאלות.
האם אתם צפיתם במכנסיים קצרים האלה עדיין?
אוקיי.
אז יש מכנסיים קצרים על לולאות,
אשר נעשה על ידי טומי, אחד מהחברים להוראת הראש.
יש אחת בהיקפו,
אני מאמין שנעשיתי על ידי עמית הוראה אחרת בשם דוד
ואז אחד על קיסר הצפנה גם נעשה על ידי דוד.
הם די מגניבים.
האם אתם כבר צופים את התחתונים שלהם עד כה?
מה נשמעו הם הייתם?
מועיל? אוקיי, טוב לדעת.
אם הם לא, אתה יכול לומר זאת.
אבל לפני שאתה עושה,
הייתם, אנשים הסתכלו על השאלות הללו
בכלל?
>> בואו נדבר על זה קצת.
אז אנחנו כבר הצגנו מעל בשבועות האחרונים
בהרצאה
מספר הלולאות שונות.
יש ללולאה,
לולאה בזמן, ואז עשה תוך הלולאה,
ובהרצאה, אנחנו כבר מדברים הרבה על
כמה הלולאות האלה הן כל
די דומה בהרבה דרכים,
ואתה יכול לעשות הרבה יותר מאותם דברים עם לולאה בזמן
שאתה יכול עם לולאה ל.
אתה פשוט צריך להשתמש בסוג של השילובים הנכונים של משתנים וכאלה.
וכך באמת
ההבדל האמיתי בין כל הלולאות הוא כי
לפעמים הם יותר שימושיים
כדי להשתמש בם בפעם אחת מאשר במועד אחר.
>> כך למשל,
הלולאה בזמן השונה מעשה תוך לולאה.
האם כולם מרגישים שהם צריכים לטפל טובים בכאשר
עשה תוך לולאה היא יותר
שימושי או מה ההבדל?
>> אני חושב שההבדל הוא עשה תוך לולאה
פועל - אני לא יודע בדיוק מה היא הטרמינולוגיה,
אבל הסדרה של פונקציות בתוך הלולאה.
הם באופן אוטומטי - זה עושים ריצות שלה לפחות
לפני שהוא בודק את מצבו, או הלולאה בזמן רק להפעיל אותו כש
זה פועל ברציפות - אם המצב הוא להיות מרוצה.
כן, האם זה הגיוני?
>> בואו נסתכל קצת קוד.
אז רק כדי לחזור על השאלה,
או בתשובה, ולא;
התשובה הייתה כי
בעוד לולאה תבדוק אם המצב
שציינתם הוא נפגש
לפני שהיא מפעילה את הגוף של הלולאה בפעם הראשונה,
אילו עשה תוך לולאה תפעל באופן אוטומטי בגוף של הלולאה,
זה מה שאנחנו קוראים לו - זה מוזר מינוח,
אבל אם אי פעם אמרתי שכל דבר שאינו הגיוני, יגיד לי -
גוף הלולאה הוא שדברים שאתה מכניס בין הסוגריים המסולסלים.
ועשה תוך לולאה,
שהגוף להידרס לפחות פעם אחת,
ואז מקבל את המצב נבדק לפני שהיא מפעילה כל פעם ברציפות.
>> כך שלמעשה, סם,
אכפת לך כתיבה פשוטה תוך לולאה
במרחב?
>> איך אתה די אוהב
להפוך חדש ...?
אני פשוט מוחק כל מה שיש לך בפנים.
כן, רק לנקות אותו.
>> ובכן, אני מאמין שיש לי זה -
איזה מהם אתה רוצה, בזמן, או שאתה רוצה ...?
כן, פשוט בזמן נכון, להדפיס משהו.
ובואו נראים.
אלכסנדר, הבין שמעולם לא הציג לך.
>> אה, זה בסדר.
האם אתה - אתה יכול לקודד את עשה תוך לולאה עבורנו?
>> כן, אני אנסה.
בסדר, אנחנו פשוט למשוך את אלה שעל המסך,
כך שיש סוג של ידית מהם ההבדלים.
>> אז הנה מה שסאם עשה.
יש לו מספר שלם הנקרא i
שהוא מאותחל ל 17.
ואז הוא אומר בזמן (אני int = 17)
printf ("קורא לי סם".);
אז מה קורה כאשר אנו מפעילים את הקוד הזה?
יש שגיאה, מה השגיאה אומרת?
בואו נמשוך אותו ולדבר על זה.
אירעה שגיאה, זה אומר.
בואו לגלול למטה.
אז זה נתן לנו את השגיאה, והיא אמרה,
"היי, אני מצפה ביטוי".
זה די מובן.
כן, בדיוק כך - ושוב,
יהיה עוד באג קטן שנתפוס בשנייה בלבד.
אבל זה עוד אחד מאותם סוג של דברי טרמינולוגיה מוזרים,
כך אני int = 17 זה
אין ביטוי.
מה זה נראה כמו שהוא עושה הוא שזה
הכרזה שלמה בשמי
והגדיר אותו שווה ל 17
או, לייתר דיוק, לשים 17 שבint בשם i.
וזה לא הגיוני
בהקשר של הלולאה בזמן הזה.
זה אכן הגיוני, כפי שנראה,
בהקשר של ללולאה, כי להצהרות לולאה אין להתחיל
עם זה לint i שווה משהו
וממשיך.
>> אז עשה לך -
לתקן משהו, בסדר.
הנה זה מתחיל; מדהים.
אז עכשיו דברים נראים קצת אחרים.
כמה דברים השתנו.
האם אתה יכול לספר לנו מה הדברים השתנו?
>> הוצאתי int, כך שאין הכרזה [לא ברור] במקום מטלה.
סימן שוויון אחד, שמתי 2 שלטים שווים, כלומר שווים.
מדהים.
כן, אז מה שסאם עשה היה שהוא הוציא את int
שהיה כאן קודם לכן,
כך שאם אני רק מסתכל על זה - זה מה שהיה קודם לכן, הוא אמר int,
שמצהיר על זה - אז לקחתי את הסוג.
יש, מחרוזת int, char, קצרה,
אלה נקראים סוגים.
אז אתה הוצאת את הסוג
ולאחר מכן בעבר,
היה לו רק אחת סימן השוויון
ומה שהוא אמר היה בעייתי בעניין הזה היה
כאשר יש לך 1 סימן שווה,
זה אופרטור השמה.
שלא בוחן את השאלה אם 2 דברים שווים.
כי בעצם זה הגדרת משהו שווה למשהו.
אנחנו מכניסים את המספר 17 אליי משתנה.
אז כדי לעשות את זה סוג של השוואה,
אתה צריך להשתמש כפול שווה,
וזה סוג של דבר מוזר
אך היא טעות נפוצה למדי.
אז דבר אחד אני מוכן להצביע, אם לא אכפת לך,
הוא שב
תפקידנו כאן בעיקרי int,
אתה רואה שהגוף של הפונקציה שלנו
מקוזז מהצד השמאלי
על ידי 4 ברווחים או בכרטיסייה.
הסיבה שאנחנו עושים את זה
רק לשם נוחות קריאה.
כפי שניתן לראות בלולאה בזמן של סם כאן,
הוא לא לשנן כלל,
וזה לא משפיע על הפונקציונליות של הקוד.
הוא יפעל בדיוק אותו הדבר.
>> כך למשל, אם אנו מגיעים לפסגה כאן
ולחץ על כפתור Play שלנו, זה יהיה לבנות אותו,
זה יהיה להפעיל אותו,
ומה יקרה?
למה זה עדיין אומר לרוץ?
>> כי זה ימשיך לחזור על היי.
בדיוק, ולמה זה ממשיך לחזור על היי?
מכיוון שלעולם לא משתנה >> השלם, כך שזה תמיד 17.
כן, בדיוק, ולכן
בואו נראים, אחרי - מזכיר לי שוב את שמך?
ג'ימי. אז ג'ימי אמר כי
מהסיבה זו חוזרת על היי שוב ושוב
בגלל המצב הזה הוא תמיד נכון.
אנחנו אף פעם לא משנים את הערך של i.
אנחנו אף פעם לא לשנות את התוכן של מה שמאוחסן באותו משתנה.
לכן בשלב זה יש לנו את השגיאה ש
התכנית שלך שנוצרה יותר מדי תפוקה,
אם אנחנו לגלול למטה וסוג של מבט במה שקורה כאן ו,
אתה יכול לראות שזה היי, היי, היי, היי, היי, היי, היי לכל אורך הדרך.
מדהים.
>> אז סוג של חזרה לנקודה המקורית
כי לאחר הכניסה כאן
בגוף הלולאה בזמן לא השפיע על כלום.
התכנית עדיין רצה בסדר גמורה.
באופן טיפוסי לסגנון טוב -
וזה משהו שאנחנו מחפשים בסטי הבעיה שלך -
אנו מבקשים ממך לשנן את זה על ידי 4 מקומות, שבו אתה יכול לעשות
רק על ידי לחיצה על מקש TAB
או על ידי הצבה ידנית ב 4 מקומות בעצמך.
מגניב, אוקיי אז בואו נלך אחורה ולהסתכל על
אלכסנדר יעשה-הזמן.
>> רק די התקשה קצת.
אוקיי, גם בואו לעבוד דרכו.
האם זה מגניב?
>> כן.
>> אוקיי, אז הנה זה בא.
זה קוד שכתב אלכסנדר.
האם אתה הולך על ידי אלכס - בסדר.
אז הנה הקוד שאלכס כתב.
אז, יש לנו ההכרזה הראשית שלנו כאן,
ולאחר מכן יש לנו משתנה השלם הזה שנקרא אני
הכרזה ממש כאן.
יש לנו משפט לעשות
ואז שוב את הגופה עם פלטות אלה,
אז זה הגוף של עשה תוך -
תנו לי להתמקד בזה בכך שזה יהיה קריא יותר -
ובגוף, שאנחנו מנסים להדפיס "זה הגוף",
אני + +,
כך להגדיל את התוכן שלי ולעשות את זה
עד שאני הופך להיות 3,
ואז התכנית שלנו מסתיימת.
>> אז מה קורה כאשר אנו מפעילים תכנית זו?
>> ציפיתי מזהה.
אוקיי, אז לבנות, להפעיל, מתרחשת שגיאה.
מה קורה?
אנו לגלול למטה כאן,
אנחנו מקבלים דבר, נראה קצת המסתורי הזה,
צפוי פסיק לאחר הכרזה ברמה עליונה.
זה קצת מוזר.
האם יש למישהו מושג על מה שאולי קרה?
דיי מוזר, כן.
>> [לא ברור] יוכרז מחוץ לסוגריים?
אז האם זה לא יחול אז כאשר אתה משתמש בסוגריים?
אז הוא הצהיר שהבחור הזה שמחוץ לסוגריים?
אה, החבר 'ה האלה - הסוגריים המסולסלים?
>> כן.
כן, בדיוק.
אז מתברר כי
אתה לא ממש יכול להצהיר על משתנה כאן ככה.
מה שאולי היה מנסה לעשות היה -
לחתוך אותו משם -
אתה יכול גם לשים אותו בתוך הסוגריים המסולסלים ממש כאן
או אלטרנטיבה אחרת
הוא לשים אותו מחוץ לחלוטין.
ולכן אלה - תלוי איפה אתה שם את ההצהרה למעשה
שממשתנים שלמים,
אתה יכול לקבל 2 סוגים מאוד שונים של משתנים;
כאשר זה מחוץ לראשי,
זה מה שאנו מכנים משתנים גלובליים.
זה מחוץ לתחום של כל אחת מהפונקציות -
זה לא בתוך פונקציה -
ואילו אם אנחנו שמים אותו בתוך ראשיים,
רוצים ממש כאן, אז זה נקרא משתנה מקומי,
בגלל שזה מקומי להיקף ראשי.
ונדברנו קצת יותר על מה ההבדלים
בין 2 סוגים ולמה אתה משתמש בסוגים שונים של משתנים,
אך לעת עתה,
אתה פשוט יכול לשמור את כל המשתנים מקומיים,
משום שאין לנו כל צורך במשתנים גלובליים.
>> אוקיי, אז זה דבר אחד ממש שם.
בואו ננסה לרוץ בזה שוב, לראות מה קורה.
הפעלה, מקבל את הודעת שגיאה אחרת.
קרב קצת, מה אנחנו מקבלים?
אנחנו מקבלים את זה אחרי הסוגריים צפויים לעשות / זמן.
יש לך רעיונות מה קורה? דן?
>> האם בזמן אז סוגריים ולאחר מכן -
אני לא יודע אם אתה צריך redeclare int,
אבל לעשות בזמן (i <3).
בדיוק, כן.
אז מתברר שדן זה בדיוק נכון.
אנחנו לא צריכים לשים סוג זה כאן שוב.
במקום זאת, יכול להרוג את הסוג
ופשוט לעשות את זה.
בסדר.
אני להתקרב בחזרה החוצה, לנסות את זה עוד פעם אחת.
תראה ש; הוא פועל בהצלחה.
אם אנחנו לגלול למטה, "זה הגוף" הדפיס 3 פעמים.
זה די מתוק.
כל הכבוד, כל כבוד, חבר 'ה.
כל הכבוד.
איך זה הולך כל כך רחוק?
קצב הגון?
אוקיי, מגניב.
>> אז, כפי שאנו סוג של חזרה לשאלה המקורית,
- ועכשיו אם אנחנו רואים את ההבדל,
אתה רואה את זה בעשה תוך הלולאה הזו,
המצב מגיע אחרון.
אז כפי שהמחשב קורא את התכנית
מאז תוכניות C מבוצעות סוג של בסדר עוקבים זה,
איפה הם, פשוטו כמשמעו, להתחיל עם השורה הראשונה של ראשי,
ואז להפעיל קו 6, קו 7, 8 קו, קו 9,
שורה 10, השורה 11,
את כל הדברים האלה בראש ממש כאן
הולך יתבצע פעם אחת
לפני שבכלל לבדוק את המצב הזה כדי לראות
אם לא אני - או את התוכן שלי, ולא -
הם פחות מהמספר 3.
ורק אם ברגע שאנחנו מגיעים לקו 12,
את התוכן שלי הם פחות מ 3
נעשינו בפועל לקפוץ חזרה לקו 7
ואז לחזור על התהליך,
ואז לבדוק את המצב שוב ושוב ושוב.
>> אז אנחנו יכולים לעמת את זה
עם - התקרבות בחזרה החוצה,
לגלול למטה לגרסתו של סם,
אנחנו הולכים להסתכל על זה, השתנה מעט, כך שזה כבר לא לולאה אינסופית -
היכן אם להתמקד,
אנו רואים כי מאחר שתכנית זו מתבצעת,
זה הולך להכריז אני int הראשון,
להגדיר את התוכן שלי להיות על 0,
ואז זה מכה את המצב תוך הלולאה הראשונה,
לכן במקרה זה, הגוף הזה, זה וprintf ("היי") אני + +
אפילו לא יבצע
אלא אם כן אני הוא למעשה פחות או שווה ל 2.
אז אם אני הוא 3, למשל,
אם להגדיר זאת כאן
שווה ל 4 - או שאני אעשה 3, כי אמרתי 3 -
ולאחר מכן להפעיל אותו,
זה יהיה לבנות, הוא יכול לרוץ בסדר גמור,
אבל זה לא ממש להדפיס כל דבר,
כי זה שנכשל במבחן למקרה הראשון.
אז בכיתה, אנחנו די דברנו על למה-תוך הלולאות האלה
שימושיים לפעמים
ומדוע אנחנו נשתמש בה בניגוד ללולאה בזמן.
>> האם יש - אין יש לכם הצעות כלשהן
למה עשה תוך לולאה עשויה להיות שימושית יותר?
>> ובכן, אני חושב לעשות, ואילו לולאות הן אם אתה רוצה קלט משתמש,
כי ככה אתה יכול לתת להם
לשים משהו בפעם אחת: אם זה נכון,
אנחנו יכולים לעבור לשאר התכנית,
אבל אם זה לא נכון, אז אתה ממשיך לשאול את המשתמש
עד שאתה שם את הקלט הנכון.
כן, בדיוק - בדיוק,
כך עשה תוך הלולאה שימושית
כי כאשר הנחיה לקלט מהמשתמש
כי אתה צריך לקבל הקלט של המשתמש לפני שאתה באמת יכול לבדוק את זה.
אז ב1 pset, בpset 2,
לאן אתה להציג עבור קלט משתמש הרבה,
זה דבר נוח לשימוש
בניגוד לרק בעוד לולאה פשוטה.
אם אתה משתמש בלולאה בזמן, אתה יכול לעשות את אותו דבר -
אתה יכול לעשות את אותו דבר עם לולאה בזמן
כפי שאתה עושה עם עשה תוך לולאה.
אתה פשוט צריך להיות סוג של תהליך כפול זה
בו אתה מקבל את הקלט ראשון ולאחר מכן להתחיל הלולאה בזמן שלך.
אילו עשה תוך לולאה, אתה רק צריך לכתוב את זה פעם אחת
וזה הרבה יותר נקי.
>> בסדר.
יש שאלות?
הגיוני?
>> התשואה 0 - זה פשוט סוג של דוכן או שזה -?
כן, כדי שנוכל -
ובכן, אנחנו נתחיל לכסות את זה קצת יותר מאוחר
אבל מתברר כי
0 תמורה זה שאנחנו מכניסים
בסוף העיקרי כל הזמן -
אתה די יכול פשוט לקחת את זה כדבר שאנחנו עושים
לעת עתה.
מה שהתחלנו לדבר על עם פונקציות
סוג של בסוף השבוע שעבר ולאחר מכן שוב השבוע
הוא שפונקציה
לוקח תשומות שהם הדברים האלה בתוך הסוגריים;
אלה הם 2 כניסות, הוויכוחים או פרמטרים שלנו,
מה הם גם קראו לפונקציה העיקרית שלנו,
ואז פונקציה מייצרת תפוקה
שאנו קוראים לי ערך החזרה.
ואת ערך ההחזרה במקרה של עיקרי הוא זה int,
השלם הזה,
וכמו שאתה אומר לי פונקציה, "היי, זה מה שהתפוקה שלך
הוא הולך להיות, "הוא במילה" שיבה ",
שמילת מפתח, ולא,
וכך חוזרים ראשי 0
או פלט עיקרי 0
מקובל בתוכניות C
בגלל חזרת 0 מ האמצעי עיקרי ש
"היי, הכל מבוצע עם התכנית שלי בסדר הגמורה."
אם היו עלינו לשים משהו אחר מאשר 0,
כמו 1, לדוגמה,
המשמש לתגיד מי שדרס תכנית זו
משהו שהשתבש.
אז כפי שאנו מקבלים יותר מעורבים עם חומר על הסמסטר,
אם אתה אי פעם תיאלץ לומר,
"אופס, אתה יודע, משהו השתבש בתכנית זו,"
ולא שיש התרסקות התכנית שלי, אני רוצה להודיע
הרץ של התכנית שלי שמשהו השתבש,
אתה יכול להשתמש בשווי תמורה,
כפי שאנו קוראים לזה, זה לא 0.
>> כך יהיה לנו כיסוי שקצת יותר
ברגע שאנחנו נכנסים לפונקציות.
זה סוג של היגיון?
אוקיי.
פונקציות הן סוג של מוזר -
אני חושב שלאנשים שיש להם הרבה רקע במתמטיקה,
זה מגיע קצת יותר בקלות,
במיוחד אם יש לך רקע מתמטי מופשט יותר קצת
ואתה רגיל לדבר על פונקציות
וכל הסוג כזה של דברים.
אבל אנחנו ננסה ולכסות אותם
וללכת לאט וברור כפי שהם באים.
כמו כן, argc int כל זה,
char * argv [],
לעכשיו, אתה יכול גם לקחת את זה כצלחת דוד.
אנחנו כבר התחלנו לכסות את אלה קצת בהרצאה
כאשר אנו מדברים על טיעונים שמקבלים שמועברים לתוכניות בשורת הפקודה,
אבל בסטי הבעיה שלך והתוכניות שלך,
זה לגמרי בסדר, רק כדי לכתוב מבוטל ולשמור את זה פשוט.
ומה החלל הזה פירוש הדבר הוא כי
"היי, עיקרי הוא לא הולך לקבל כל תשומות;
זו רק תכנית שאנחנו הולכים רק לרוץ.
אנחנו לא הולכים לתת לו כל מידע נוסף
בכל פעם שאנחנו מתחילים אותו בריצה ".
אז לעת עתה, אתה יכול לעשות את זה;
אתה גם יכול גם להשמיט את ה 0 התמורה
בסוף התוכניות שלך והם ירוצו בסדר גמורים,
אבל אני ממליץ פשוט לשמור שבי
בכמה שבועות, תתחילו לסוג של
למשוך בחזרה את המכסה קצת ולהבין יותר על
כל אותם החלקים נעים קצת שונים.
>> בסדר, עכשיו בואו נדבר על השאלה השנייה שלנו כאן.
אז מה זה "מזהה לא מוצהר" בדרך כלל מצביע
אם outputted ידי קלאנג?
אני חושב שאנחנו יכולים לראות שכבר היום.
מישהו יכול לתת סיכום של מה זה אומר?
בואו נראים, קלי - אחד ממשפחת קלי.
אז >> -
כן, מה עושה -
>> אני חושב שכשאתה, כמו, לא מצהיר את המשתנים ואתה מנסה להשתמש בו.
כן, בדיוק, בדיוק.
אז אם אי פעם תראה את הפלט הזה
כאשר אתה מנסה לקמפל את התכנית שלך,
בדיוק כמו קלי אמר,
זה אומר שאתה בשימוש במשתנה שלא הצהיר,
כך שאם אני חוזר לשטח שלנו,
ואני עושה משהו כמו
printf (
"שלום% s")
ולנסות ולמלא שב% s
עם משתנה של זה שלא הצהיר בכל מקום
ואני מנסה להפעיל אותו,
תראה למה אני יורד בתחתית זה ממש כאן:
"שימוש של" מזהה לא מוצהר ";
זה רק אומר שאתה לא הכרזת המשתנה שלך.
אותו דבר קורה אם
יש לך X ואתה מנסה ולאחסן אותו ב7
ואני לא הכרזתי X.
אני מקבל שאותה שגיאה:
"שימוש" x "מזהה לא מוצהר".
>> בסדר,
כך קיסר ההצפנה, לא להיות מאוד מאובטח,
אני אתן לכם לצפות, זה סוג של קצר הבין למה,
ובתקווה לאחר עושה בעית שבוע זה נקבע
שבו אתה בעצם לכתוב הצפנת קיסר, תוכל להבין קצת יותר
על מה זה אומר להיות מאובטח ובטוח -
או לא מאובטח, אני מניח - חוסר הביטחון הוא מעט שונה.
הדבר השני היה שיש לנו השאלות אחרות האלה כאן
על פונקציות
ומה תפקידו הוא,
ואנחנו סוג של דברנו על כך זמן קצר בעת שדברנו על ערכים לחזור;
למישהו שהייתי בהרצאה,
אתה יכול לסכם שהיה להרצות היום?
בסדר.
בואו נראים, בואו יש - מישהו יכול להגיד לנו מה היא פונקציה?
קלי?
>> >> בעיקרון משהו שאתה מצייר עליו משהו שכתוב בספרייה זה
מסובך יותר לשם, ואז אתה פשוט כותב טופס קצר שלה,
אז כמו שאת מתייחסת אל הספרייה, באמצעות
כל מה שהקוד ארוך ו[ לא ברור].
כן, בדיוק, ואז אתה רוצה להוסיף משהו לזה?
>> כן, אני חושב על זה כדומה לרעיון של נוסחה במתמטיקה
שבו אתה פשוט כותב נוסחה ואז אתה יכול לחבר במשתנים
וזה מה שפונקציה היא [לא ברורה].
>> כן, אז יש לנו כמה תשובות כאן
כי שניהם ממש טובים וממש על.
יש המתייחסים לקוד שכבר נכתב בספרייה במקום
זה יותר מסובך
ואז אתה יכול לשאוב כי קוד
ובעצם להשתמש בו רק על ידי כתיבת צורה הקצרה שלו -
או, לייתר דיוק, את שמו -
ואז יש גם השוואה זה לנוסחה במתמטיקה
או פיסיקה, כל דברים כאלה
שם יש לך נוסחה
ואז אתה יכול לחבר
המשתנים שלנוסחא
אז כדי לקבל את התוצאה של הנוסחא,
אז אתה חושב על זה כמו כמו המשוואה ריבועית.
תאר לעצמכם אם לא שיש ללמוד על
מה הנוסחא ריבועית היא בשיעור מתמטיקה,
אתה פשוט הייתה תכנית מחשבון קטנה שעשתה את זה בשבילך.
האם מישהו משתמש בתוכניות של מחשבון בלימודי מתמטיקה בבית הספר תיכון?
כן, שיעורי פיסיקה?
איפה אתה יכול פשוט לומר, "היי, נוסחה ריבועית.
אלה הם את המשתנים שאני רוצה קלט.
עכשיו תן לי את התשובה. "
זה סוג של מה היא פונקציה.
זוהי דרך עבורנו
סוג של כתיבה כגון תת תוכנה קטנה קטנה
במסגרת התכנית הגדולה שלנו
ולהשתמש בו שוב ושוב
כך שאין לנו להעתיק ולהדביק קוד,
אנחנו יכולים לתת לו כניסות שונות ולקבל תפוקות שונות,
זה סופר שימושי
כשאתה מנסה לכתוב תוכניות שונות בזמנים שונות.
>> כך למשל, פונקציה שאנחנו כבר משתמשים שוב ושוב ושוב
במהלך הקורס הוא printf.
Printf היא עצם פונקציה
ומתברר שזה בעצם די ארוך ומסובך,
נבזה, לתפקד לכתוב.
אז פשוט כמו שזה נראה לנו
להדפיס סחורה למסך,
משום שכולנו פשוט עשינו את זה בתחילה היום סעיף,
מתברר שזה בעצם, אתה יודע,
זוג טוב של 100 שורות קוד.
זה לא משהו שאני אי פעם ארצה לכתוב, זה בטוח,
אבל אנחנו מקבלים להשתמש בו בכל יום; זה די מגניב,
ולכן אנחנו מקבלים לחלוק אותו עם זה,
עם תוכניות שונות,
לכן אנחנו יוצאים לצלול יותר לפונקציות;
לעת עתה, אנחנו לא -
הפונקציה היחידה שאנחנו הולכים להיות כתיבה היא עיקרית.
ראשי עצמו הוא גם פונקציה,
ואתה יכול לראות שיש לו הפלט,
התשומות שלה כמו שדברנו עליו,
ולאחר מכן את שמה, שהיא מרכזית.
העיקרי הוא סוג של - היא פונקציה מיוחדת לשם.
בתכנית C שלך, שם צריך להיות פונקציה עיקרית,
ואז לעת עתה, יש לנו סוג של כתיבה הושמטה
אב הטיפוס, או הכרזה, העיקרי.
אנחנו נתנו לך את זה,
ויש לנו רק שאתה ממלא בסוג של את החסר.
>> >> אז לקבוצת הבעיה השנייה, אנחנו לא צריכים
לכתוב את זה בפונקציה השנייה?
אני לא מאמין בכך.
אני מאמין שהכול כאן.
כן, אז קיסר הצפנה,
אתה לא צריך, זה לא נראה כמו,
וVigenere, שגם אתה לא,
כך - ומתברר שאף פעם לא ממש צריך לכתוב
פונקציה, נכון?
אתה קורא תמיד לשים את כל הקוד שלך בתוך ראשי,
ומתכנתים רבים לעשות זאת.
ככל שאנו מתקדמים ב,
אנחנו מתחילים פונקציות מציגות כדרך
כדי לנקות את הקוד שלך,
כדי לעשות את זה יותר אלגנטי,
במקרה יש לך משימות - כמו סוג של כשדברנו על לולאות,
איך לפעמים יש דברים שאתה רוצה לעשות שוב ושוב ושוב,
ויש לך סוג של הדרך התמימה -
או מה שאנו מכנים לעתים קרובות פתרון "קש האדם",
פשוט להעתיק ולהדביק שוב ושוב -
אתה יכול לעשות את אותו דבר עם פונקציות שבו אתה פשוט להעתיק ולהדביק
את אותו קוד שוב ושוב,
אבל זה bloats הקוד שלך -
זה בסופו הופך את הקוד שלך באמת ארוך -
והוא גם מקבל קצת מבלבל,
ואז זה אומר שאתה לא מסוגל לאהוב -
אם אי פעם תרצו להשתמש בקוד הזה שוב בתכנית אחרת,
גם אתה תקוע העתקה והדבקה שלו שוב,
כך אחד הדברים שנדברנו עליו
סוג של עיצוב וסגנון של התוכניות שלך,
ולכן כאשר זה הגיוני סוג של
חבילת משהו ולשים אותו כפונקציה נפרדת,
אנו ממליצים לך לעשות את זה,
וזה משהו ששוב,
אין שלטון חזק ומהר.
לעתים נדירות אנו אומרים שאתה חייב לכתוב פונקציה שנקראת כך,
אבל זה יותר מאחד מהדברים האלה שאתה פשוט מתפתח עם זמן
כפי שאתה כותב יותר ויותר תוכניות.
>> עוד שאלות?
אוקיי, אז בואו עכשיו
עליי חזרה לבחור הזה ממש כאן,
לכן אני עדיין בחלק זה של שאלות.
דברנו על כל אלה שונים אלה,
מה פונקציה, למה לכתוב פונקציות,
כאשר אתה יכול פשוט להעתיק ולהדביק?
אני מקווה ששכנענו אותך שכתיבת פונקציות היא דבר טוב.
אז עכשיו בואו נעבור לתכנית מייספייס זה,
ונבלנו קצת זמן לעשות את זה.
>> אז, בואו תראו,
יש לי מישהו יכול לקרוא את זה בשבילי?
בואו Mikhaila - תהיה לך לקרוא את זה בשבילנו?
>> אתה מתכוון לחזור כשמייספייס -
בחזרה כאשר מייספייס היה מגניב.
>> "חזור כאשר מייספייס היה מגניב,
זה היה כל הזעם לסוג כזה.
אולי זה עדיין? אני לא ממש בטוח.
בכל מקרה, שימוש CS50 Appliance,
CS50 הפעלה, או CS50 Spaces,
לכתוב תכנית שמנחה את המשתמש להודעה
ואז פלט את ההודעה עם מהוון המכתב הראשון שלה,
עם כל מכתבים האחרים במקרה לסירוגין,
לפי פלט הדוגמא להלן,
טקסט boldfaced בי מייצג קלט מסוים של משתמש.
לשם פשטות, ניתן להניח שהמשתמש
רק אותיות וחללים קטנות קלט.
שקול בעיה זו הזדמנות להתאמן;
אתה לא תתבקש להגיש תכנית זו. "
>> מדהים, תודה לך.
אז כפי שאמר Mikhaila,
אנחנו הולכים לכתוב תכנית שMySpaces הקוד שלך.
אז האם מישהו מכם ישתמש ב-MySpace?
מישהו מכם יש חשבונות MySpace?
אה, כן, כן!
זה היה די מגניב.
[שחוק]
אני יודע.
כרויות בעצמי.
אז מה שאנחנו מנסים לעשות הוא לכתוב תכנית
שעובר דרך
ואת האות הראשונה
ואז כל מכתב ואילך -
או כל אות אחרת לאחר מכן, אני מצטער.
>> לכן - ואתה יכול לראות בדוגמה זו,
זה איך אנחנו מפעילים את התכנית,
ואז זה רק אומר, "אנחנו מפעילים תכנית בשם a.out.
הקלט שאנחנו הולכים לתת לו
הולך להיות יתבקש לעשות זאת.
אנחנו לא הולכים לספק את הקלט בשורת הפקודה ".
אם אתה עוקב אחרי כל ההרצאות
ושמע על טענות של שורת פקודה,
זה סוג של שם אלה - שתחביר פאנקי
בעיקרי מגיע עם argc int, כל הדברים האלה,
אז הנה אנחנו לא משתמשים בזה, אנחנו לא עוסקים בכל אלה.
אנחנו פשוט הולכים לקבל את זה שהוקלד על ידי המשתמש ב,
ואז שורה שנייה זה עם ייוון פאנקי
מה שאנחנו רוצים את התכנית שלנו לפלט.
>> אז במקום להשתמש במכשיר או הפעלה, יצטרך להשתמש ברווחים,
בגלל שיש לנו רווחים,
ולכן אם אתם הייתם
ולקבל קוד לנראה משהו כזה,
אז אני הולך להציל את גרסה זו
רק אז יש לך את צלחת הדוד ממש כאן
שנראה כמו זה, int הראשי (ריק), שום דבר בו.
למעשה, מה שאנחנו עושים הם שאנחנו נצטרך למחוק הכל ביחד.
אנחנו רוצים לוח חלק,
בגלל שאנחנו לא הולכים להתחיל לכתוב קוד;
ולא, אנחנו הולכים לנסות לכתוב כמה pseudocode
שבאמת רק אומר שאנחנו הולכים לכתוב משהו שאיני קוד
זה סוג של מתאר את מה שאנחנו רוצים לעשות,
שזה בערך כמו שעשה דוד ביום הראשון של הרצאה,
או שאני מניח שזה היה ביום השני של הרצאה כשהוא עשה את הדגמת גרביים השלמה.
אולי אתם זוכרים ש-- רואים את הגרביים?
יוסף היה שם למעלה סוג של הקלדה באנגלית?
אז אנחנו הולכים לעשות את אותו הדבר.
>> אז כשאני מתחיל לכתוב pseudocode,
אני רוצה להתחיל על ידי הסתכלות על מה הקלט הולך להיות.
ואני נותן את עצמי דוגמה אחת,
כל כך כמו "תודה על התוספת!"
ואז גם אני אכתוב מה שאני רוצה להיות הפלט,
אשר במקרה זה הוא משהו כזה.
וזה סוג של נותן לי מקום טוב, כמו, מתחיל לחשוב על,
"אוקיי, אני רוצה לקחת את הקו 1
ואני רוצה להפוך אותו לקו 2, "
וזה סוג של מסייע להנחות את החשיבה שלי.
זהו מקום טוב להתחיל בו.
דרך נוספת לחשוב על זה, יותר מדי, כפי שאנו kinda להמשיך הלאה
וכמו שאתה עושה את זה בתוכניות שלך, היא
לחשוב על סוג של כמו מה הם המקרים זה העוקץ?
מה הוא סוג של התרחישים המוזרים?
מה הן התשומות המוזרות שאנחנו עלולים לקבל?
ומה היציאות האלה צריכות להיראות?
לדוגמה, קלט אחד מוזר
יהיה זה אחד,
יצירה שום דבר,
כמו מה שיש לנו פלט במקרה זה?
משהו שאנחנו רוצים לחשוב על זה, יותר מדי.
>> אז בדיוק כמו שאלה,
מה שאולי אנחנו רוצים פלט?
אם אנחנו לא מקבלים שום קלט בכלל, מה צריך להיות פלט התכנית שלנו?
שום דבר. >>
שום דבר? נשמע נהדר.
אז אנחנו רוצים לוודא שאנחנו לא כותבים שום דבר
אם אנחנו לא מקבלים שום דבר פנימה
מגניב. אוקיי.
כך
אני מתכוון לקרוא לכמה אנשים כמו שאנחנו הולכים דרך
ופשוט להבין כמו סוג של מה האלגוריתם הכללי הוא
ואנחנו סוג נתחיל לעבוד דרך זה יחד.
>> אז, בואו נראים. מסים.
איך אתה חושב שתתחילו?
מה יהיה מקום טוב להתחיל בו כאן
אם אנחנו רוצים לשנות, למשל, קו 1
אל קו 2?
האם אתה סוג של רק תסביר לי, באנגלית, מה אתה חושב?
אל תדאגו לגבי קוד.
>> הדבר הראשון שאני אעשה יהיה
סוג של המשתמש הישיר כדי לספר להם מה שאתה רוצה.
אוקיי, אז, אומר,
"היי, משתמש. אני רוצה
מחרוזת "- מדהים.
אז בואו לכתוב את זה.
מנחה את המשתמש למחרוזת.
זה נשמע כמו התחלה טובה.
בסדר.
בואו נשאל קלי רן שלב זה.
מה היינו אז רוצה לעשות עכשיו?
מה סוג שלנו בא -?
>> איסוף הקלט שלהם ולאחסן אותו כמשתנה.
גדול.
אז אוסף את החוט,
לאחסן אותו במשתנה.
אז האם יש משהו מיוחד שאנחנו רוצים לעשות כאן?
האם אנחנו רוצים לבדוק את הקלט שלהם
לפני -?
>> כן.
מה שאולי אנחנו רוצים לבדוק?
>> כן, אמר שאין לנו כדי לבדוק אם זה מספר, נכון?
כי זה יניח שזה קטן?
כן.
>> אז מתברר ש-- כן.
אז getString מובטח להחזיר אותנו מחרוזת.
זה לא הולך לחזור מספר לנו או משהו כזה.
אולי יש תווים ספרתיים בתוך מחרוזת, אם כי.
ואלה, אנו יכולים להתעלם כמו שעשינו ייוון.
אבל מחרוזת ריקה היא בסדר גמורה,
לכן המקרה ממש כאן, על קו 4 ו 5,
ימין, שבו אין כניסה,
ויש לנו את הדבר כפלט שלנו.
אנחנו לא צריכים לדאוג ולוודא שיש משהו במחרוזת
או שהמחרוזת באורך של לפחות 4 תווים;
כל דבר הוא בסדר.
אז זה עומד בניגוד, למשל, בתוכניות כמו מטבעים שכתבו
שבו אתה צריך לוודא שאתה מקבל מספרים שאינם שליליים;
אתה צריך לוודא שאתה מקבל את המספר הנכון של ימים בחודש.
ואיך אתם עושים את זה?
איך תעשה את הבדיקה הזאת?
מה שמחייב אותך להשתמש?
>> האם-אילו לולאות.
עשה תוך לולאות; סוגים אחרים של לולאות, יותר מדי, כן.
אז מתבררים שאנחנו לא צריכים להשתמש בלולאה במקרה זה,
כשאנחנו להציג עבור מחרוזת, שהוא די נחמד.
>> בסדר, ימשיך הלאה.
אז, סטלה.
האם אתה יכול לספר לנו קצת על מה שאנחנו צריכים לעשות עכשיו?
אז עכשיו יש לנו את המחרוזת, יש לנו אותו מאוחסן במשתנה;
מה אנחנו צריכים לעשות עם החוט?
>> אנחנו צריכים -
לזהות 2 -
כן, רק אומר את זה באנגלית, זה מדהים.
זהה את >> [לא ברורות] בירות - או, באותיות גדולות.
כן, כך היית לזהות אילו הם אותיות גדולות וקטנים.
אנחנו לא יכולים רישיות או הקטנים עד שנזהה איזה מהן.
אז אני נשים את זה לכאן.
>> לכן, רק מלחשוב על התהליך הזה,
איך אנחנו עושים את זיהוי הזה?
אתה יודע, דן?
סוג של מה שאנחנו - מה כלי שהיינו צריכות להשתמש מארגז הכלים שלנו?
>> שהייתי מנסח זאת בדרך כלשהי במערך או כמו כל קו
היא קופסה הקטנה משלו,
ואז אותיות גדולות זה משם או לא.
אוקיי, אז כלי אחד שאנחנו יכולים להשתמש הוא מערך.
מה יש לנו לחפש במחרוזת,
אם כי, כדי להבין - היה לנו להסתכל על הדמויות.
>> אז יש לך להסתכל על האורך של המחרוזת?
כן, כל כך חלק, כי הוא מקבל את אורך המחרוזת.
רק מתוך סקרנות, מה אנו משתמשים כדי לקבל את אורך מחרוזת?
>> Strlen?
כן, strlen, אנחנו קוראים לזה "strlen"
כל פונקציות מחרוזת אלה, ולכן הוא פונקציה strlen,
וזה סופר נוח, משום שאנו יכולים להשתמש בו רק כדי להגיד,
היי, strlen: הנה מחרוזת, יגיד לי כמה זמן זה.
בהרצאה היום, דיוויד דבר הרבה על איך strlen מיושם,
מה באמת קורה מאחורי הקלעים.
אבל זה אחד מאלה מאוד הסופר השימושיים.
ישנם אלה אחרים שגם בספריית המייתר,
כמו strcmp, שאיית "strcmp",
המשמש להשוואת מייתרים אחד לשנייה.
האחרים יוכלו להשתמש כמו strstr,
וזה טוב למציאה תת מחרוזות וכן הלאה.
ברוב המקרים, כולם מתחילים עם str ואז ללכת על להיות משהו אחר.
הסיבה שהם לא באמת לאיית אותם כמו מחרוזת וכן הלאה
הוא כי עוד כבימים הראשונים של C,
כאשר אנשים היו כתיבה ראשונה וכל זה,
הם היו מגבלות על מספר התווים שאתה יכול להשתמש
לשמות פונקציות ושמות משתנים,
כך שכל הדבר הוא כמו סופר מרוכז.
אבל כל פעם שאתה רואה משהו שמתחיל ברחוב,
בדרך כלל אומר שזה משהו שקשור בחוט.
>> אוקיי, אז יש לך כדי לקבל את האורך של המחרוזת,
ואז, מה אנחנו עושים עם הדמויות?
אתה יודע, סם?
>> אין לי מושג, אני מנסה להבין את זה.
אני באמת לא יודע - הלוואי שהייתי דרך כלשהי -
אני מתכוון, אני חושב שאולי אוכל לעשות משהו עם סיכויים ומשתווה,
אבל אני לא יודע על שום תפקיד כזה.
כן.
>> אבל - זה לא בהכרח היה עובד,
כי אז היית מקבל את החללים להיות -
היית צריך להיות מקום כדי לקבל טיפים על איך -
אוקיי.
>> אני לא יודע - אני סוג של אבד בשלב זה.
כן - לא, לא, לא, אלה הם נקודות טובות.
אז מה שאנחנו צריכים לעשות הוא, כמו שאמר סם,
אנחנו צריכים לעקוב אחר שהאותיות הן האותיות המשונות,
ואלו הם אותיות אפילו.
אבל אנחנו רוצים לוודא שאנחנו לא רק מחפשים
במוזר ואפילו
מדדים במחרוזת,
אלא מסתכל על האותיות המוזרות ואפילו במחרוזת,
כך שאנחנו צריכים להיות קצת הבחנה זו בין
אותיות - כמו מה זה בעצם, B, C, D, או כן הלאה,
ומה הם דברים שלא מכתבים, אבל עדיין במחרוזת שלנו.
לדוגמה כאן, כמו סימן קריאה זה לא מכתב,
אבל זה עדיין חלק מהמחרוזת שלנו, זה עדיין char.
כמו כן, כל הרווחים האלה -
זה לא הגיוני לנצל שטח, נכון?
אז אנחנו רוצים לוודא שאנחנו איכשהו לדלג אלה
תוך מעקב ומאזן סיכויים.
>> אז סוג של ארגז הכלים בתכנות שלנו
עד כה, אם ארצה,
יש לנו מספר הכלים שונים שדברנו עליו.
אז אחת, למשל, הם משתנים,
כמו שדברנו עליו כאן.
כלי נוסף שדברנו עליו הם פונקציות.
אז אנחנו מדברים על משתנים בpseudocode כאן
כמו מה שאנחנו הולכים להשתמש לאחסון המחרוזת שלנו.
דברנו על פונקציות כדי לקבל את האורך של מחרוזת, כמו strlen.
אנחנו כבר מדברים על משהו אחר, ואנחנו לא מדברים על זה
להרבה קודם לכן בסעיף היום: לולאות.
>> מה אתם חושבים על שימוש בלולאה בתכנית זו?
ג'ארד, מה אתה חושב?
האם אנו משתמשים בלולאה בתכנית זו?
>> כנראה שלא, לא, כי אתה לא צריך לעבור את זה יותר מפעם אחת.
אוקיי, אתה לא צריך לעבור את מה שיותר מפעם אחת?
>> כל המחרוזת.
בסדר, אז אתה לא צריך לעבור את המחרוזת כל פעם.
מצטער שלא היה שום היגיון!
אתה לא צריך לעבור את כל המחרוזת יותר מפעם אחת.
אוקיי.
מה אתה חושב?
>> אני חושב שעדיף להשתמש בם
כדי שנוכל לעשות כמו להוון תוך
המיקום שלו הוא מספר [לא ברור].
גדול, וכך לנצל את מה?
אוקיי, אז אנחנו אומרים ש
אנחנו צריכים להשתמש בלולאה כי אנחנו רוצים
להוון מכתב בעוד שזה לא מספר.
אז - מצטער, לא ברצונך להוסיף?
>> אני עומד לומר שהדרך בה אתה מתייחס למחרוזת
וזה [לא ברור] נפרד [לא ברור] על הדמויות?
כן.
>> ואז תוכל להקצות את המספרים ל--
או המבוסס על המיקום של האותיות במחרוזת?
כן.
>> ולזהות אם זה מוזר או אפילו, ולמצות את המכתב עצמו
ואילו מיקומו של המכתב הוא [לא ברור] - מצטער.
גדול.
>> אז רק לסכם.
האם תוכל להזכיר לי את השם שלך שוב - אני מצטער.
>> שרלוט.
שרלוט, בסדר.
אז מה שרלוט אומרת,
אשר נכון לחלוטין - אלוהים, כמו זו לכניסה אוטומטית עליי -
הוא שאם אנחנו מסתכלים על מחרוזת
כמו זו בראש -
"תודה על הוספה" -
כרצף של תווים
איפה הוא בעמדה 0,
h הוא בעמדת 1.
הוא בשעת 2, אז יש לנו 3, 4, 5;
החלל הוא במיקום 6.
ואילו - מה העמדה של f?
7!
O? 8.
ר? 9.
ולאחר מכן יש לנו 10, ואז אני באמת לא יכול לכתוב את זה בלי זה
די מבולגן מקבל על המסך.
אבל זה בעצם מה שאנחנו יכולים לדבר על מחרוזות בזיכרון.
האם זה מחרוזת
הוא רצף של תווים,
כאשר אנו מתייחסים לאופי אישי ובמחרוזת,
לעתים קרובות אנו עושים זאת על ידי הפנייה לעמדה שהאופי של
בתוך המחרוזת,
כנראה באותה הדרך שאנחנו מדברים על ספטמבר
להיות החודש התשיעי של השנה
או ביום שני הוא היום הראשון בשבוע.
אז זה מספק אותנו לדרך
להבין אילו הם מוזרים אפילו לעומת
כי אתה יכול לראות כאן,
אם אנחנו משווים את זה עם T זה,
אתה יכול לראות שכל אלה שהוונו
הם אפילו בעמדות,
לפחות למילה הראשונה,
ואז דברים שהיינו נזרק מרגע שפגענו בחלל,
בגלל שאנחנו לא סופרים את החלל הזה כמכתב,
כך שזה כאילו התחלנו
ויצאתי 0, 1, 2, 3, 4, 5,
חלל, 6, 7, 8, מרחב,
9, ולאחר מכן 10, 11, 12, וכן הלאה.
>> מגניב, ולכן אנחנו בהחלט רוצים להשתמש בסוג מסוים של לולאה
כדי לעבור על כל אחת מהדמויות בתורו.
לכן בשלב זה,
אנחנו נחזור לpseudocode הישן שלנו כאן.
כחלק מהזדהות זו של אלה אשר
הם באותיות רישיות ואילו הם קטנים,
אנחנו רוצים לעשות את זה באיזה לולאה.
לולאה, במעי גס.
איזה סוג של לולאה, מתוך הסוגים של לולאות שיש לנו,
נראה שיש אחד טוב לשימוש במקרה זה?
>> חשבתי ללולאה.
ולמה אתה חושב ללולאה?
>> כי זה מתחיל באפס, ולאחר מכן
כאשר אנו מגיעים לאורכו של החוט,
ולאחר מכן כל איטרציה אתה יכול [לא ברור], מדי?
כן, בדיוק.
לכן, מתוך את הבחירות השונות של לולאות,
יש לנו ללולאות, בעוד לולאות, ולעשות תוך לולאות.
איפה ללולאה שימושית במיוחד
כאשר אתה רוצה לדעת
סוג שבו אתה נמצא בבית בלולאה,
כמה פעמי הלולאה בוצעה עד כה.
וזה בדיוק מה שאנחנו רוצים לדעת במצב הזה,
כמו אמר קלי,
מבוסס על ההנחה של ההערה הקודמת של שרלוט שאנחנו רוצים לדעת את המיקום
של הדמות בתוך המחרוזת,
ועבור לולאה ייתן לנו בדיוק את זה,
כי אם אנחנו מתחילים סוג של מבט לאחור על המחרוזת שלנו,
אם תתחילו הלולאה עבורנו ב0,
ואנחנו עולים לאורכו של כל החוט,
אז אנחנו יכולים לשייך את אות T
עם 0 בלולאה,
המכתב H עם 1 בלולאה, וכן הלאה,
הולך את כל הדרך עד לסוף המחרוזת.
>> אז בואו נתחיל קידוד זה רק קצת
פשוט כל כך אתם לקבל תחושה איך זה נראה.
אני הולך להציל את זה,
כך שיש לנו הקוד פסאודו כאן,
ואני הולך למחוק הכל.
אז יש לי לוח חלק.
אני הולך להתחיל על ידי כתיבה (void) העיקרי int
{
אני הולך לשים 0 בתמורה
ולאחר מכן}.
אז בדרך כלל כשאני מתחיל תכנית, זה מה שאני מתחיל איתו.
אני אשמור אותו כך שיש לכם את זה.
אז אחד הדברים הראשונים שדברנו עליו היה
מקבל קלט מהמשתמש
ולאחסן אותו בחוט.
כיצד תקבל קלט ממשתמש?
GetString. >>
GetString, בסדר.
אז אם אני מקליד GetString ()
ופסיק.
בואו ננסה לרוץ בזה; יהיה זה לרוץ, קודם כל?
ולמה זה לא פועל?
>> יש לך להצהיר על המשתנה.
אני חייב להצהיר על משתנה. אוקיי.
>> אז איך אני עושה את זה?
אכפת לך לכתוב משהו, לחלוק אותו?
ואז אנחנו יכולים למשוך אותו.
בואו נראים, דן, נכון, בסדר.
או דניאל. העתק שב, קלט מחרוזת = GetString ().
מדהים.
האם זה פועל?
בואו ננסה את זה.
הכה ריצה, קוד מקור העלאה, בניין, אירע שגיאה.
אוקיי.
אז מה חדש קורה כאן?
שימוש בביטויים 'המחרוזת' מזהה לא מוצהר.
>> יש לנו לכלול את הספריות?
כן, כל כך של דן אומר שיש לנו כדי לכלול את הספריות.
האם זה מה שאתה מתכוון לומר, סטלה? מדהים.
זה מדהים, כל כך סטלה, אתה יכול
העתק את הקוד הזה מתוך השטח של דניאל?
אם תלחץ על דניאל רולאן קי, להעתיק אותו,
ואז אתה שם את הקו כולל ב, ולאחר מכן לשמור אותו?
תודיע לי כשאתה מוכן.
אז תחביר כולל זה גם סוג של פאנקי;
יש כזה תג חשיש,
ויש לכלול, ואז יש הסוגריים האלה.
אתה זוכר איך זה עובד, או שאני צריך לשים אותו בקוד זה כאן?
>> אני טוב.
אוקיי.
>> שהדפסתי אותו - אני לא היה בטוח שספרייה, אם כי.
אה, בסדר - כן, כך שזה ספריית CS50.
>> אה, שמתי את ספריית stdio.
>> אה, יש את זה - כן, לא, כלומר -
כך מתבררת שהמחרוזת היא למעשה משהו שהוא מיוחד לCS50.
למעשה אין סוג מחרוזת אמיתית
כי ממש כאן, מחרוזת נמצאת במצב הסוג, -
אנחנו מכריזים קלט נקרא משתנה מסוג המחרוזת -
ואנחנו מציבים בתוך הקלט
הערך שמקבל חזר אלינו: הפלט של קריאה לפונקצית GetString זה.
אתה יכול להגיד את זה הוא קריאה לפונקציה כי יש בזה את הסוגריים, בדיוק כמו עושה printf,
בדיוק כמו strlen עושה.
אבל מחרוזת היא למעשה לא סוג אמיתי
בשפת C.
אנחנו הפכנו אותו לסוג, ואנחנו ניקח על יותר מה שהיא באמת
ב-C, משום שיש דרך לעבוד עם מחרוזות;
רק עשינו משהו כדי שזה ייראה טוב יותר במקצת.
>> אז הנה זה בא.
הנה הקוד של סטלה.
זה חייב לכלול # .
אנשים אחרים קוראים לזה כמו חשיש כולל לפעמים או חד כולל.
עכשיו אנחנו יכולים להתחיל אותו, להפעיל אותו,
ואנחנו עדיין מקבלים הודעת שגיאה.
בואו לראות מה קורה.
"'קלט' משתנה שאינם בשימוש".
אוקיי, אז זה מגניב, זה מגניב.
אני מתכוון, זה לא ממש מגניב,
בגלל שאנחנו מקבלים הודעת שגיאה וזה לא פועל,
אבל מה שזה אומר הוא ש
אנחנו לא השתמשנו במשתנה שלנו, וזה הגיוני.
אנחנו לא ניסינו לעשות שום דבר עם זה.
זוהי דרך ש
קלאנג מנסה לעזור לנו לוודא שאנחנו לא רק באמצעות משתנים
ואז בטעות קורא להם משהו אחר מאוחר יותר בקוד שלנו,
עוזר לנו להימנע משגיאות בדרך זו.
>> בסדר, אז יש לנו קלט ממשתמש,
אז אחסנו אותו במשתנה.
הצעד הבא היה אז
להתחיל לחפש בכל התווים במחרוזת
ואילו הם מזהים לאותיות רישיות
ואילו הם להיות באותיות קטנות.
וכמו קלי ושרלוט הביאו למעלה,
אנו עושים זאת באמצעות ללולאה.
אז מישהו בכלל זוכר את התחביר של לולאת for
והייתי רוצה לקחת דקירה בפשוט כותבים
השורה הראשונה של ללולאה, רק לקצת?
קלי, אתה רוצה לנסות את זה?
>> כן, אז אתה צריך לאתחל ראשון,
אז שם לי = 0,
ואז עשה לי <strlen ().
האם זה בשטח שלך - האם אני יכול למשוך את זה?
>> כן, אני דפוק קצת, אבל כן.
>> אוקיי, בואו להרים אותה.
מדהים.
>> אבל אז אני לא יודע אם הייתי לך את זה -
כן, בסדר.
אז הנה מה שיש לי קלי: בואו נסתכל עליו במהירות.
אז היא כללה cs50 הספרייה בחלק העליון.
היא כללה את ספריית IO הסטנדרטית בראש,
והתקן IO יש פונקציות כמו printf,
כך שאם אי פעם תרצה להשתמש printf, אתה צריך את הקו הזה.
ואז היא כללה מחרוזת ספרייה,
שאנו צריכים,
מפני שהספרייה יש מחרוזת strlen פונקציה,
אשר יגיע ל, רק קצת.
אז אם אנחנו מסתכלים על מה שקלי נעשה כאן,
אם אפשר ללכת דרכנו את מה שעשית?
>> כן, כן - אני מתכוון, יש לי טעויות, ולכן -
כן, לא, זהו -
>> אז אני רציתי לקרוא את המחרוזת שיש לי רק "מחרוזת".
אני רוצה להדפיס את המחרוזת
ואז -
רציתי רוצה להגדיר כמחרוזת כמו מערך של כל תו
להיות שונים [לא ברור], נכון?
ואז אני רוצה להתחיל בעמדה 0
ולאחר מכן כל 2 ברווחים,
אני הולך לנצל,
אז אני פשוט תארתי אותו כבן 23, כי אני מסתכל בטבלת ASCII.
אז זה מה שאני חושב - אני יודע שזה לא בסדר.
>> קבלתי את זה, אז זה התחלה מצוינת.
אני חושב שהרבה מהמסגרת הוא במקום כאן.
בואו נעבור סוג של שורה אחרת שורה ולראות מה קורה.
אז כמו שאני אוהב לעשות זה פשוט להתחיל על ידי ההידור של הקוד
ולתת למהדר יגיד לי כמו מה לא בסדר עם הקוד שלי,
כי המהדר הוא ממש טוב באומר לך מה לא בסדר עם הקוד שלך.
אז אם אנחנו משחקים אותה, בנייה, וזה לא לבנות.
זה אומר שהייתה טעות,
כך שאם אנו לגלול למטה ומסתכלים על השגיאה הראשונה,
זה אמר -
אנו לגלול חזרה לפסגה,
אנו יכולים לראות שיש 5 טעויות שנוצרו כאן למטה בתחתית.
אופס, זה באמת נותק.
אני מניח שפשוט לא הולך להיות יותר טוב.
>> הנה אנחנו מתחילים.
אז יש 5 שגיאות הכוללים שנוצרו.
כאן אני יכול לראות את 2 הראשונים בלבד,
אז אני יכול להעביר את זה קצת, ואז סוג של את הגלילה.
זו הפקודה שהופעלה כדי לקמפל את הקוד,
ולאחר מכן השגיאה הראשונה הייתה בfile.c כאן:
"צפוי לזהות או '('", וזה היה על הקו הזה
איפה אנחנו אמרנו מחרוזת = GetString ().
אתה יכול לראות כאן שזה היה על קו 8 של file.c,
ואז אני מאמין שזה אופי 12 - זה השגיאה.
אז מה השתבש בשורה 8 - קלי?
>> אתה פשוט צריך לקרוא לזה, כמו, מכתב או משהו,
כמו מחרוזת של או משהו?
כן, אז מתבררים ששמות סוגים מיוחדים אלה,
כך המחרוזת, int, char, קצר,
הם כל מילות המפתח מיוחדות,
ואתה לא ממש יכול להשתמש בם כשמות של המשתנים שלך,
כי המהדר מסתכל על זה ואומר,
"אה, אני יודע שזה סוג"
אז אתה לא יכול באמת יש משתנה מחרוזת נקראת מחרוזת,
כמו שאני מנסה לעשות כאן, זה לא יעבוד.
אבל במקום זה, אנחנו יכולים לקרוא לזה משהו כמו ים או ברחוב או ברחוב.
אנחנו גם לא יכולים לקרוא לזה int.
אנחנו לא יכולים לקבל מחרוזת בשם int.
אנחנו לא יכולים לקבל מחרוזת בשם char: אף אחד מאלה שיעבדו.
>> אז אנחנו פשוט קוראים לזה של לעת עתה.
מדהים.
אז מה עכשיו קורה בתחום הזה?
מחרוזת - קו זה נראה די טוב?
בואו לנסות עוד פעם, ובואו להפעיל אותו.
אוקיי, אז אנחנו עדיין מקבלים שגיאות.
הפעם, אנחנו למטה עד 4 טעויות.
אז יש לנו אחד מהם.
בואו לעלות.
"מחרוזת" סוג שם לא צפוי: ביטוי צפוי, "כן?
>> כן, זה משום שניסיתי שם את המחרוזת.
כן, כך זה נראה כאילו אנחנו עכשיו גם צריכים ללכת לתקן
כל ההפניות הללו למחרוזת.
אתה יכול לראות שיש התייחסות למחרוזת כאן, כאן, כאן,
כדי שנוכל להעביר את כל אלה לשל.
גדול. אוקיי, להפעיל אותו שוב.
בניין - שגיאה אחרת התרחש.
>> אוקיי, עכשיו אנחנו למטה לשגיאה אחת,
כך אני int = s ולאחר מכן את הסוגריים המרובעים.
אז אתה יכול לספר לנו קצת על מה שאתה עושה כאן, קלי?
>> כן.
זה היה בקו 10.
>> אני לא יודע אם אנחנו צריכים את כל זה,
אבל אני חושב שאני מנסה -
אני אשמור את זה, כך שתוכל לבצע יחד.
>> אני חושב שהייתי
ניסיתי להגיד לו כדי להתחיל בעמדה 0
בתחילתי ללולאה,
לכן אני חושב שאולי זה אומר שאין צורך.
אז רק כדי לסכם,
היית אומר שזה - היית מנסה להתחיל עם זה בעמדה 0
ולקבל את זה - כן,
לכן אני חושב שקודם לכן, גם כשאתה היה חוצה את הקוד,
אתה מדבר על זה שאתה רצית להתייחס למחרוזת כמערך
כדי שנוכל לגשת לכל תו בנפרד.
אני חושב שדן מערכים הוזכרו גם מנסה להמיר מחרוזות למערכים.
>> מתברר מסוג זה מתחת למכסת המנוע,
מחרוזת מאוחסנת בפועל כמערך כבר,
ואתה יכול לגשת אליו כמו מערך;
אין מרה שאתה צריך לעשות.
אין מחרוזת - כך -
מחרוזת היא לא באמת מערך,
אבל אתה יכול לגשת אליו כאמור, כי כל הדמויות מאוחסנים
זכות אחד ליד שני בזיכרון,
כך שאם אתה רוצה לקבל את התו הראשון של המחרוזת,
זה אותו הדבר כמו מקבל המספר השלם הראשון במערך של מספרים שלמים.
אז אנחנו לעתים קרובות - אנחנו נטפל
מתייחס ל 2 כמו
הו, כמחרוזת, כמו להיות מערך,
למרות שזה באמת - הם נוראים דברים שונים מאוד,
אבל אתה יכול להתייחס אליהם מאוד דומה.
אז מתברר שזה ממש קו -
אנחנו לא צריכים לעשות שום מרה,
ולמעשה,
זה למעשה אינו ביטוי תקף,
וזה מה שהמהדר שלנו אומר לנו.
זה אומר, "היי, זה צפוי ביטוי,
ומה יש לי כאן משהו שלא ביטוי ".
כדי להצהיר על מערך,
כל מה שאתה צריך לעשות הוא משהו כמו זה בנקודת פסיק,
ואז אומרים לי המערך כמה זמן אתה רוצה שזה יהיה,
כמו 5, אז זה קו 10
יכריז מערך התקשרתי עם 5 מספרים שלמים בזה.
>> זה בצד, זה לא הכרחי לקוד,
אבל זה - זה סוג של מה שנראית כמו ההצהרה.
>> איך היית לא להשתמש בעוזרת ש[ strlen (s)]?
עוזרת ש[ strlen (s)]?
>> Char i, ואז בתוך הסוגריים, strlen (הים).
כן, ולכן אנחנו יכולים -
אנחנו יכולים לעשות את זה,
וזה יכריז - מה זה עושה?
>> אני חושב שזה יהיה להצהיר על מערך
של, כמו - של -
הו, אתה לא צריך אותי - הו,
כן, אתה בהחלט לא צריך אותי.
אתה מצהיר מערך של תווים
אורכו של הים.
ואז מה סם של אומרים זה ש
קו זה 10 - הניח לי קצת מרחב בינו לבין השאר ולכן אנחנו יכולים לבודד אותו -
קו 10 זה הייתי להצהיר על מערך
של תווים, strlen שווה (ים) שלהם,
אבל אנחנו ממש צריכים אותי,
והסיבה שאנחנו צריכים אותי, משום שאנו צריכים לתת למערך שם;
אחרת, לא תהיה לנו דרך להתייחס למערך מאוחר יותר בקוד.
>> אז עכשיו זה משהו ששם המערך
ובתוכו האורך.
זה ייתן לנו מערך,
אבל זה - שוב, זה הוא הצהרה.
זה לא משימה, זה לא אתחול.
אם תכריזו על מערך זה ככה,
יש בעצם שום דבר בתוכן של המערך.
זה פשוט זבל - מה שנמצא שם.
וכמו שאמרנו,
אנחנו למעשה אפילו לא צריכים לעשות מרה זו,
כי אנחנו כבר יכולים להתייחס למחרוזת של כמערך.
אני יודעת שאנחנו פועלים קצת ארוכים על זמן,
אבל אני רוצה להגיע רק לזה מהר מאוד ללולאה
ואראה לך איך לגשת לתווים הבודדים במערך,
כי זה מפתח למשימה שלנו.
ואז ניתן לך ללכת משם.
>> אז הנה, יש לנו ללולאה
זה נראה כמעט טוב.
מה לא ממש כמעט שם?
ממה - מה אינה כשורה בעניין הזה ללולאה?
>> אין סוגריים מסולסלים?
אין סוגריים מסולסלים, לאחד.
רוצה לוודא שיש לנו את הגוף של הלולאה עם סוגריים מסולסלים.
אופס, לא הסד המרובע!
ומהו הדבר הבא שאנחנו צריכים לעשות עם זה לולאה?
אם אני מנסה ולהפעיל אותו,
מה חדש השגיאה הזאת שאני מקבל?
אני מקבל את כל השגיאות הללו - אני צריך לאתחלי.
גדול.
אז זה יהיה לולאה - זה לא ממש שם,
אבל זה מתחיל להיות ממש קרוב.
קוד זה אנו יכולים כעת לרוץ,
לבנות, שגיאה עדיין מתרחשת.
למה הוא עדיין מתלונן,
אומר הביטוי הוא בשימוש,
וזה בגלל הקו הזה לא עושה כלום.
לא לאחסן אותו בכל מקום, אנחנו לא לשמור את התוצאה.
איפה אנחנו צריכים להיות להציל את התוצאה הזאת?
>> של או i?
בדיוק, והתחביר יוצא הדופן הזה,
של זה עם סוגריים המרובעים
הפירוש לגשת אופי i-ה של הים.
זה הולך להיות משהו שבאמת חשוב לתפקיד.
למרבה הצער, אנחנו הולכים צריכים להפסיק כאן,
כך שסעיף סבסטיאן יכול לבוא ב,
אבל אני שמח להישאר אחרי בחוץ ואקח אותך שאלות.
אז תודה שבאתם.
זה צריך עכשיו להעלות, לבנות, להפעיל.
אנחנו יכולים להיכנס למחרוזת כמו "שלום"
והוא מדפיס "QOX".
[שחוק]
>> אז לא ממש שם, אבל מרגש, מקבל כיוון הלולאות האלה!
תודה שבאת, ואני אהיה בחוץ.