>> [השמעת מוסיקה]
DAVID מלאן: בסדר.
זה CS50, וזה הוא סוף השבוע 2.
אני כל כך מצטער שלא יכולתי להיות יש איתך את כל היום,
אבל אתה בידיים טובות מאוד.
הרשה לי להציג של רוב אודן של CS50.
ROB אודן: וכמובן, לאחר מכן אנחנו צריכים לעשות את הכיף של העובדה
שהוא שלח לנו אנכי וידאו ולהראות את זה.
>> [וידאו השמעה]
>> [השמעת מוסיקה]
>> [בעקבות]
>> וידאו -זהו לא צריך להסתכל בדרך זו.
זה היה יכול להימנע.
אומר לא לקטעי וידאו אנכיים.
>> קטעי וידאו -Vertical לקרות כאשר אתה להחזיק את המצלמה שלך בדרך הלא נכונה.
הווידאו שלך יהיה בסופו דבר נראה כמו זבל.
>> - [רטינה]
>> : רווחה הם יותר ויותר אנשים מכורים לביצוע קטעי וידאו אנכי בכל יום.
זה לא סדק או כלום, אבל זה עדיין ממש רע.
ישנם שני סוגים של שונים אנשים שסובלים מVVS.
הקבוצה הראשונה מתייחסת ל קטעי וידאו שהם יורים כמו תמונות.
הם לא מתכוונים לשום נזק.
הם פשוט לא מבינים ש בזמן שאתה יכול להפוך את תמונה,
אתה לא באמת יכול להפוך את וידאו.
>> [CRASH]
>> - [MONKEY צלילים]
>> בחור' קבוצה אחרת היא אנשים שלא נותן [בליפ].
>> תסמונת וידאו -Vertical היא מסוכנת.
יש לי קולנוע תמיד היה אופקי.
טלוויזיות הן אופקיים.
מסכי מחשב הם אופקיים.
העיניים של אנשים הן אופקיים.
אנחנו לא בנויים ל לצפות בקטעי וידאו אנכיים.
>> -אני אוהב את קטעי וידאו אנכיים.
>> -לא אכפת לך.
>> -אם של בעיה זו עזב, אתה גם לא בדוק
יתחיל להראות ארבעה קטעי וידאו בבת אחת, רק כדי לחסוך ברוחב פס.
>> קטעי וידאו אנכיים -Letterboxed היית להיות בגודל של בול דואר.
>> -ואז זה יתפשט בכל מקום.
יש מסכי קולנוע תמיד היה אופקי.
אם קטעי וידאו אנכיים הפכו תיאטראות מקובלים, סרט
יצטרך להיות גבוה ורזה.
>> -ואז כל בתי הקולנוע היית צריכה לקבל נהרסו ונבנה מחדש.
ועד שהם נבנו מחדש, המילה קוניס יהיה זקן ומכוער.
>> -Birds יתרסק לתוכם ולמות.
>> כל החדים לקבל נוקשה צוואר ממבטו.
>> -ואז אף אחד לא יושב ב השורה הראשונה אי פעם שוב.
>> -George לוקאס מחדש שחרור כוכבים מלחמות again-- המהדורה רזה.
>> -אני אף פעם לא היה באמת מסוגל להגיד לי הסיפור שאני רוצה לספר.
זו הייתה הזדמנות גדולה עבורי להתנסות בטכנולוגיה חדשה.
>> "אתה אידיוט.
>> ם בכל זמן מכשיר נייד משמש ל להקליט וידאו, הפיתוי הוא שם.
פשוט תגיד לא.
אומר לא לג'ורג 'לוקאס.
אומר לא למילת קוניס הישן.
אומר לא לקטעי וידאו אנכיים.
>> : ואם אתה רואה מישהו עושה את זה, אומר, "אתה לא יורה שדמה נכון!"
>> [השמעת מוסיקה]
>> [סוף ההשמעה]
>> [מחיאות כפות]
>> [AUDIO OUT]
ROB אודן: --simple צורה של הצפנה,
שהוא בעצם ההצפנה ופענוח של מסרים סודיים.
אז הנה יש לנו צעצוע פשוט מאוד.
והרעיון הוא הטבעת החיצונית מסתובב סביב הטבעת הפנימית.
ואתה יכול לראות, אולי אם אני זום ב, לראות-- זה קשה לראות.
אבל, כמו, המספר 1-- גם, שעבר.
>> מספר 1 מפות למכתב X, מספר 2 מפות למכתב
ג 'קשה מאוד לא לדלג קדימה.
מכתב 2 מפות לג ' מספר 3 מפות לד אז
בטבעת זו אתה יכול לתת לי מישהו הודעה 1, 2, 3.
מסיבה כלשהי אתה רוצה לומר להם XJD.
אבל אתה יכול לתת להם כמה הודעה של מספרים,
וכל עוד יש להם טבעת זו, הם יכול לפענח את מה שאתה מנסה לומר.
>> זה אז אתה יכול לראות דוגמא מסוימת של הצפנה
לפני אם סביב עונת חג המולד אתה כבר צפה סיפור חג המולד.
אם מעולם לא ראו את זה לפני, אז פשוט
להפעיל TBS באופן מילולי כל זמן בערב חג המולד,
כי הם פשוט להראות את זה גב אל גב לגב אל גב אל גב כל היום.
והווידאו הרלוונטי הוא זו.
[וידאו השמעה]
-Be זה ידוע לכל ומשונים שראלף פארקר הוא זאת
מינה את חבר של ליטל יתום אנני מעגל סודי
והוא זכאי לכל הכבוד והטבות המתרחשות בם.
חתמה היתומה הקטנה אנני.
בתשובה פייר אנדרה בדיו!
הצטיינות והטבות כבר בגיל תשע!
>> [צועק מהרדיו]
-בחייך.
בואו נגמור עם זה.
אני לא צריך את כל הג'אז הזה על מבריחים ופירטים.
מחר בלילה עם "תשמע ההרפתקה המסכמת
של שחור ספינת פיראטים.
עכשיו, זה זמן ל המסר הסודי של אנני
לחבריך מהמעגל הסודי.
זכרו ילדים, רק חברים של המעגל הסודי של אנני
יכול לפענח המסר הסודי של אנני.
זכרו, אנני תלויה בך.
הגדר הסיכות שלך לB2.
הנה ההודעה.
12.
11.
2.
'אני בפגישה החשאית הראשונה שלי.
>> -25.
14.
11.
18.
16.
>> אה, פייר הוא בערב קול גדול.
אני יכול לספר לי הערב של ש ההודעה הייתה באמת חשובה.
-3.
25.
זה מסר מאנני עצמה.
זכור, לא לספר לאף אחד.
>> שניות לאחר מכן -Five, אני ברק חדר בבית שבו ילד של תשע
יכל לשבת בפרטיות ולפענח.
אהה!
B!
הלכתי למשנהו.
א המילה הראשונה היא "להיות".
ס זה היה הקרוב יותר עכשיו.
ע '25.
זה ר '
-בחייך, ראלפי!
אני חייב ללכת!
"אני אקה להיות ימין למטה, אמא!
גאון גי.
ט O. "הקפד" - כדי להיות בטוח מה?
מה הייתה יתומה קטנה אנני מנסה לומר?
הקפד מה?
>> -Randy חייב ללכת!
אתה מוכן בבקשה לצאת?
>> נכון -All, אמא!
אני אהיה מחוץ נכון!
אני מתקרב עכשיו.
המתח היה נורא.
מה זה היה?
גורלו של כדור הארץ עלול להיתקע במאזן!
>> -Ralphie, רנדי חייב ללכת!
>> "אני אקה להיות תקין החוצה, בוכה בקול רם!
כמעט שם!
האצבעות שלי טסו.
המוח שלי היה מלכודת פלדה.
כל נקבובית רטט.
זה היה כמעט ברור!
כן.
הקפד לשתות השוקו שלך.
שוקו?
מסחרי עלוב?
בן זונה.
>> [סוף ההשמעה]
>> ROB אודן: אז ככה השוקו מתייחס להצפנה.
בעיקרון CS50 רק מפורסם שוקו, כדי שנוכל
להיות מסחרי עלובה לשוקו.
בסדר.
אז עכשיו מדעי מחשב בפועל.
זכרו ביום שני שעזבנו את צלילה עמוקה לתוך מחרוזות.
אז יש לנו עסק עם המחרוזת "Zamyla."
ואנחנו מכירים העובדה שאנחנו יכולים לטפל ב
"Zamyla" כרצף של תווים.
וזוכר שלמדנו סימון הסוגר.
אז אם זה היה מאוחסן במחרוזת "של", ולאחר מכן
אם אמרתי התושבת של 0, שהיית מצביע ז הון המכתב
ואם אמרו של התושבת 1, ש מצביע על כך שהאותיות קטנות הראשונה,
וכך הלאה עד לסוגר של 5, המצביע על כך שעבר.
>> עכשיו זוכר ש אורך של מחרוזת זו הוא 6,
אבל המדדים למחרוזת הם 0 עד 5, Z דרך שיימשך.
אז זה עכשיו מתאים לתמונה גדולה יותר של זיכרון המחשב שלך, זיכרון RAM שלך.
אז איפשהו התכנית ש אתה מפעיל את המחשב
צריך לזכור Zamyla אי שם בזיכרון.
אז יכול להיות שאני מתנדב?
כן בבקשה.
ומה שמך?
>> דיקן: דיקן.
>> ROB אודן: דיקן?
נחמד לפגוש אותך, דיקן.
אז לבוא לכאן, ו אנחנו הולכים יש לך לצייר
על הפריסה מגניבות נחמדה שלנו של זיכרון.
עכשיו אני רוצה לחשוב על זיכרון כרצועה אחת ארוכה של בתים,
אבל רק למטרות תצוגה שנציע ב פשוט משמאל לימין, מלמעלה למטה.
אוקיי?
>> אז אני הולך להראות לי program-- Getstrings.c.
וכך כל תכנית זו היא עושה מבקש ארבעה מיתרים
מהמשתמש עם הדפסת GetString ולאחר מכן
מה שהמחרוזת הראשונה נכנסה היה.
אנחנו מתעלמים משני בארבעה.
אוקיי.
אז כאן now-- כאשר אני S1 הבקשה הראשון.
אז אתה המחשב.
ואתה מיישם GetString.
אז אתה מבקש ממחרוזת שלי, ואני אומרים, אוקיי, דיקן.
תן את המחרוזת "דיקן".
>> אז אי שם בזכרונך צריך לזכור "דין".
אז לכתוב את זה לזיכרון למקום.
ללא רבב.
אוקיי.
אז עכשיו יש לנו S2.
וs2 הולך להיות בקשה לGetString.
אז אני הולך להיכנס מחרוזת.
אני הולך להיכנס "חנה".
אז להיכנס "חנה" אי שם בזיכרון.
כן.
-H.
>> אוקיי, אז עכשיו S3.
וזה הולך להיות אחר לבקש GetString.
ואז עכשיו להיכנס "מריה".
בסדר.
ואז יש אחד אחרון בקשה לGetString, S4.
אז, אני לא יודע.
מה אנחנו הולכים עם אנטי אי.
אז להיכנס לתוך זיכרון.
כן.
אז פשוט לעשות "רוב".
>> אוקיי.
אז עכשיו explain-- מדוע עשה אתה משאיר החללים האלה?
למה יש לך את זה ריק שטח כאן, כאן, וכאן?
כן.
אז שם לב כשאני הולך להדפיס s1-- כך שאם אנחנו
הייתה ריצה "חנה" ממש עד לצד "דיקן,"
איך אנחנו יודעים מתי המחרוזת "הדיקן" מסתיים?
אז הדפסת S1 המחרוזת עשויה להיות רק מודפס "DeanHannahMariaRob"
אם אין לו כל מושג כאשר "דיקן" מסתיים למעשה.
>> בסדר.
אז בזיכרון הדרך בה אנו למעשה מייצג סוף זה של מחרוזת
הוא עם קו נטוי אפס.
אז המרחב הזה הוא בדיוק מה שרצינו.
זה צריך להיות קו נטוי אפס.
זה יהיה קו נטוי אפס, וזה יהיה קו נטוי אפס.
ואתה יכול לקבל פרס מדהים על היותו מתנדב מושלם.
קח כדור מתח!
>> אוקיי.
אז קו נטוי דמות הזאת הוא אפס איך אנחנו מציינים את קצה חוט.
זה איך כאשר כל תכנית נתונה רוצה להדפיס מחרוזת,
זה how-- אנו זוכר שלמדנו פונקצית strlen בשבוע שעבר?
אורך מחרוזת?
זה איך אורך מחרוזת הוא מסוגל לקבוע כמה זמן מחרוזת היא.
זה פשוט ממשיך iterating על הדמויות
עד שהוא מוצא קו נטוי אפס אופי.
אז הדבר חשוב להבין על אופי הקו הנטוי אפס
הוא זה מיוצג על ידי כל האפסים בביטים.
אז שם לב שזה הוא מובהק מהאופי אפס.
אז האופי אפס, אם אתה זוכר בדוגמא שהוא נתן בסוף
הרצאה שבי תווי המפה צריכה-- כמו מפות הון ל -65.
אותיות קטנות מפות עד 97.
ב אותיות קטנות יהיו 98.
אז מספר 0 המפות צריכה-- אני לא יודע את החלק העליון של הראש שלי.
44 או 45.
אי שם באזור זה.
>> אז הדמות 0 הוא מספר אמיתי.
אבל אפס קו נטוי מפות לכל אפס הביטים.
אז יש הבחנה בין הקו הנטוי אפס,
שנתקשר אל שליחות קטלנית null.
יש הבחנה בין קו נטוי אפס והאופי אפס.
>> בסדר.
אז דיבר קצת יותר על מיתרים.
אז אנחנו רואים כאן זה איך זה יהיה ערוך בזיכרון.
אז הרעיון הזה של מחרוזות כרצף של characters-- כך המחשב הרשמי
טווח sciency לרצף הוא מערך.
אז היינו קורא מחרוזת מערך של תווים.
ולמעשה יש נתונים אחרים סוגים שאנחנו יכולים לעשות את המערכים מתוך.
>> אז להניע זה, תסתכל על דוגמא.
אנחנו קוראים לזה ages0.c אני יהיה להעתיק ולהדביק התבנית שלנו.
אוקיי.
אז בתכנית זו מה ש רוצה לעשות הוא לתפוס את הגיל
של שלושה סטודנטים בקורס.
אז אנחנו יודעים int age-- ועכשיו אני הולך להגיד 0.
אז אולי כדאי לך לומר AGE1, אבל למטרות שנראה בקרוב מאוד,
אני אגיד age0 int שווה GetInt.
אז אותו השיחה לGetInt שכבר משתמשים אני
לא יקרה לך להיות שגרם אומר, "תן לי את הגיל."
אבל רק מבקש אותו.
>> וAGE1 שווה GetInt.
וAGE2 int שווה GetInt.
אז, שוב, שלושה תלמידים, אבל סופו של דבר המדדים משתנים
הם age0 דרך AGE2.
אוקיי.
אז התכנית הזאת תעשה כל מה אנחנו רוצים עם age0, AGE1, וAGE2,
אך תכנית זו סופו של דבר עובד לשלושה תלמידים.
>> אוקיי.
אז עכשיו מה אם אני רוצה ארבעה תלמידים?
ובכן, אני הולך צריך לחזור לתוך הקוד שלי, לשנות את התגובה,
ועכשיו יש לנו int age3 שווה GetInt.
אוקיי.
אז מי רואה את הבעיה כאן?
מה הבעיה עם סוג זה של התקנה?
כן.
אז אנחנו יוצרים משתנה לכל תלמיד.
עכשיו זה עובד, אבל סופו של דבר מה אם אני עכשיו
אומר, "אני רוצה לתפוס את גיל שמונה תלמידים או 16 תלמידים
או הסטודנטים אולם רבים מן מאות תלמידים בCS50
או אלפי סטודנטים בקמפוס או מיליארדי אנשים בעולם?
אז בסופו של הדבר אינו בר-קיימא.
כל פעם שאתה רואה את עצמך העתקה והדבקת קוד כזה,
אתה צריך בדרך כלל מרגיש שיש דרך טובה יותר.
>> אז זה המקום שבו אנחנו מציגים הכרזת מערך.
לכן, כאשר אתה להצהיר על מערך, זה מה הפורמט הכללי
הוא הולך להיראות.
אנחנו הולכים להגיד את הסוג.
ואז אנחנו הולכים ל לתת את שמו של מערך זה,
בדיוק כפי שאנו מגדירים כל משתנים נתון.
ואז סוף סוף אנחנו משתמשים סימון הסוגר זה שוב
אבל בהקשר שונה מ איך אנחנו משתמשים בזה קודם לכן.
>> אז הנה זה נראה כמו רגיל הצהרה משתנה שראינו.
אז ראינו int x למחצה מעי גס לפני.
ובכן עכשיו אנחנו יכולים לראות משהו כמו int סוגריים x 5.
ולשים את הרעיון הזה ל תכנית GetInt שנו--
כדי שנוכל ליישם זה באותה הדרך.
>> בואו נגיד בCS אנו נוטים להשתמש n כמספר משהו.
אז הנה אנחנו הולכים לאחסן ארבעה תלמידים.
ועכשיו אנחנו יכולים להגיד גיל int תושבת n-- לא ממש מבינה את זה yet--
להכריז מערך של ארבעה תלמידים.
אז איך זה ייראה ב הזיכרון יהיה דומה לזה.
נקה זה.
ואנחנו הולכים להיות במקום כלשהו בmemory-- אני אשים את זה שם למעלה.
>> אז אי שם בזיכרון.
אחד שתיים שלוש ארבע.
יש לנו ארבעה מספרים שלמים ברציפות למערך זה של ארבעה מספרים שלמים.
אז, ברגע זה, מה הוא גודלו של אחד מהקופסות האלה?
כן.
זה ארבעה בתים.
זה 32 סיביות.
אז עכשיו זה שונה מהמערך ש
ראה קודם לכן, המערך של תווים.
במחרוזת כל תיבה הייתה רק בית אחד, בגלל אופי הוא רק בית אחד.
אבל עם מערך של מספרים שלמים, כל תיבה צריכה להיות ארבעה בתים על מנת
כדי להתאים כל מספר שלם.
אז זה מה שמערך של ארבעה ints ייראה.
>> ולאחר מכן חזרה לקוד.
עכשיו אנחנו רוצים בעצם חנות מספרים שלמים למערך זה.
אז עכשיו זה מאוד, מאוד, מאוד משותף דפוס שיהיה בשלב מסוים
הפך זיכרון שריר.
אז int i שווה 0.
אני פחות מ n.
אני פלוס פלוס.
קבוצת הגיל אני שווה GetInt.
>> אז זה ללולאה, בפורמט זה, אתה צריך לקבל מאוד בעבר.
אז זה בדרך כלל איך אנחנו לחזר על כמעט כל מערך.
עכשיו שם לב זה סוג של מסביר מדוע מההתחלה
לא היה לנו ללולאות הולכים לint אני שווה 1, אני פחות או שווה ל -10.
להיות כי החל מהסיבה אפס עושה את העבודה הזאת גם עם מערכים.
אז מערכים הם אפס באינדקס.
אם מערך זה הוא באורך 4, המדדים 0 עד 3.
>> אז הדרך הראשונה איטרציה של לולאה זה ל
אנחנו הולכים להיות הגדרת גיל תושבת 0 שווה לקריאה לGetInt.
אז כל מה שאני קרה להיכנס במקלדת.
במעבר השני, אנחנו הגדרת AGE1 שווה לGetInt.
לעבור שלישי, AGE2.
age3 לעבור סופי.
אז אם במסירה הראשונה של הלולאה אני נכנסים למספר 4 במקלדת,
אז להכניס 4 כאן.
אם במסירה השנייה שאני נכנסתי 50, שנשים 50 כאן.
בהרצה השלישית אולי אני הזן 1 שלילי, שלילי 1,
ולבסוף, אם אני נכנסתי 0-- ו עכשיו זוכר שזה היה מדד שלושה.
>> אחרי שחזרנו לולאה, הוא אני הולך להיות מוגדל עד 4.
אני כבר לא פחות מ n, אשר הוא 4.
ואנחנו לפרוץ את הלולאה.
אז מה יהיה בסדר עם זה?
[לא ברור]?
קהל: [לא ברור]
>> כן.
אז המערך יש רק ארבעה מקומות, מה שאומר שמדדים 0 עד 3.
אז אם זה היה המקרה, הייתי לקחת על עצם את הערך 4 בשלב מסוים.
קבוצת הגיל 4 תהיה הגדרה כל מה שקורה להיות כאן
מה יש לי לומר, להיכנס 6.
שתהיה הגדרה זו עד 6.
>> אבל אנחנו לא יודעים מה נגמר כאן.
זה לא זיכרון שהיו לנו גישה ל.
אז אם אתה זוכר מ ההרצאה הקודמת,
הוא הדפיס את ערכים של Zamyla ו בשלב מסוים הוא הכה פילוח זה
דופי. אז אתה בטח יהיה לראות תקלות פילוח רבות ככל ש
ליישם חלק מקבוצות הבעיה.
אבל זה אחד מהדרכים שבהן אתה יכול להיתקל פילוח
דופי, כאשר אתה מתחיל גישה זיכרון בדרכים שאתה לא צריך להיות.
אז לא היה לנו גישה ל מיקום זה ומדובר בבאג.
>> אז זה טוב יותר.
עכשיו יש עדיין קטן בעיה עם קוד זה.
וזה בעצם שאנחנו עדיין תקוע בארבעה תלמידים.
עכשיו, אם אני רוצה להשתמש בשמונה תלמידים, על אישור.
זה לא כזה עניין גדול.
אני יכול ללכת ב, לשנות את להגיב, ולשנות את n.
עכשיו זה יעבוד עם שמונה תלמידים.
אם אני לקמפל ולהריץ זה, זה ייראה me--
זה יהיה לבקש מספרים שלמים לשמונה תלמידים וזה פשוט יעבוד.
אבל זה פחות אידיאלי לצריך להדר מחדש את התכנית בכל פעם
אני רוצה לשנות את מספר התלמידים שאני רוצה להיכנס לגילים ל.
>> אז השיפור הסופי ב זה, כפי שנראה כאן-- אנחנו
הולך לבקש את מספר האנשים.
כאן יש לנו מספר אנשים בחדרים
או כל גילים של אנשים בחדר.
אבל אנחנו הולכים לבקש את המספר אנשים בחדר מהמשתמש.
אז זה אותו הדבר-לעשות בזמן המדויק לולאה שלא ראו קודם.
זה אותו הדבר בדיוק עשה תוך לולאה ש
ניתן ליישם על סט הבעיה.
אז כל עוד הם כניסת n פחות מ 1,
כך שיש חייב להיות ב אדם אחד לפחות בחדר.
כל עוד הם כניסת n פחות מ 1,
אז אנחנו הולכים להמשיך לשאול שוב.
נא להזין את המספר אנשים בחדר.
עכשיו, ברגע שיש לנו את המספר אנשים בroom--
אז אני יכול להיכנס כי יש 200 אנשים בחדר הזה.
אז כאן אנחנו הולכים לבוא ולהצהיר על מערך בגודל 200.
אנחנו מכריזים מערך זה גדול מספיק כדי להכיל 200 גילים.
יורד, זה ללולאה כי יקבל מאוד בעבר.
אז iterating על מערך זה, הקצאה לכל מיקום
במערך שמספר שלם, ו אז בסופו כאן אנחנו
פשוט מקבל דוגמא של iterating על מערך ש, שלא להקצות ערכים,
אבל כדי לגשת לערכים.
>> אז כאן אנחנו רואים שאנחנו אומרים, שנה מעכשיו,
% אדם שאני יהיו% ישנים ששנים, בי% הראשונים שהוא אני ועוד 1.
אז הוא שמשתנה מדד זה.
ואני% השני הולך להיות הערך המאוחסן במערך הגילים בתוספת 1.
אז בתוספת זו 1 היא רק בגלל שאנחנו saying-- תוספת זו 1, גילים אני בתוספת 1.
תוספת זו היא 1 רק בגלל שאנחנו אומר, שנה מהאדם
יהיה זה בן.
>> אז למה הוא אני זה פלוס 1?
למה יש לנו בתוספת 1 לשם?
כן.
אז לזכור מערכים אפס אינדקס.
אז אם אנחנו מדפיסים את זה ל מישהו רק כדי לקרוא את הפלט,
אז כנראה שהם רוצים לראות משהו כמו אדם אחד, מספר אדם אחד,
יהיה בן 20.
מספר האדם שני יהיה בן 15.
הם מעדיפים לא לראות את האדם מספר אפס הוא בן 15 שנים.
>> אז קומפילציה זה ופשוט לראות מה זה נראה like-- צור קצת מרחב.
הפוך הידור גילים.
ריצת גילים.
אנו רואים מספר האנשים בחדר.
אז אני אגיד יש שלושה אנשים בחדר.
גיל של מספר אדם אחד, נניח 15, 20, 25.
ועכשיו אני אגיד שנה מ עכשיו הם יהיו 16, 21, 26.
בואו לראות שזה עובד עם n שאינו שווה ל -3.
אז אם אני אומר מספר האנשים הוא 5, אחד, שתיים, שלוש, שתיים, אחת, שנה מעכשיו
הם יהיו שתיים, שלוש, ארבע, שלוש, בן שנתיים.
אז אני יכול רק כ בקלות n להיות 10,000.
עכשיו אני אשב כאן די בעת כניסת גילים, אבל זה עובד.
>> אז עכשיו בזיכרון איפשהו יש מערך בגודל 10,000,
כך סופו של דבר 40,000 בתים, כי יש
ארבעה בתים לכל אחד מהמספרים שלמים אלה.
אז יש מערך של גודל 10,000 שבו אנחנו יכולים
לאחסן את הגילים של 10,000 האנשים האלה.
בסדר.
שאלות על כל זה?
כן.
מה אם נתן מספר שלילי?
בואו לראות מה קורה.
אז במספר case-- המסוים הזה אנשים בחדר, אחד שלילי.
זה דחה את זה, כי כאן אנו לקרות
לטיפול בעובדה שאם n הוא פחות מאחוז אחד אנחנו הולכים לשאול שוב.
אם תנסה להכריז מערך של גודל שלילי,
זה בדרך כלל לא עובד.
>> אז בואו ננסה.
בואו להתעלם מה ערכם קלט עבור n
ורק אומר גילים int שלילי אחד.
בואו אראה אם ​​זה אפילו הידור.
אני לא בטוח.
מס '
אז גילים הוכרז כ מערך עם גודל שלילי.
אז מראש היא מכירה מערך לא יכול יהיה בגודל שלילי ודוחה אותו.
עכשיו, אם אנחנו לא להתמודד עשה תוך לולאה זה בצורה נכונה,
אם לא היינו בודקים אם n הוא פחות מ 1--
נניח שאנחנו פשוט לא היה לי זה בכלל
ובמקום זה אנחנו פשוט לתפוס שלמים.
לא משנה מה הוא מספר שלם ש, אנו מצהירים מערך של גודל ש.
>> אז המהדר לא יכול אולי להתלונן עכשיו.
אם אני לקמפל זה-- כך שזה לא יכול להתלונן,
כי זה לא יכול לדעת שאני הולך להזין מספר שלילי,
אשר עשוי להיות לא חוקי.
לכל זה יודע, אולי אני להזין מספר חיובי,
שהוא חוקי לחלוטין.
אז אני מתאר לעצמי אם אני נכנסתי שלילי 1 אנשים בחדר, פילוח אשמה.
>> אז, בסדר.
אז בואו נוסיף את זה בחזרה רק לשמור אותו מה זה היה במקור.
אז להפוך את הגילים.
עכשיו, אם אני רוצה לנסות שלילי age-- אז בואו
אומר שיש חמישה אנשים בחדר.
גיל של מספר אדם אחד הוא 4 שליליים, אדם שלושה
הוא אפס, אדם לוש-- אישור.
אז הנה, מחברה, מספר אדם בשנה אחד יהיה שלילי בן 3 שנים.
אז כנראה לא הגיוני.
אבל זה רק בגלל שמחפש בקוד כל מה שאנחנו עושים
מבקש GetInt.
>> עכשיו, אם היו לנו פונקצית GetPositiveInt
או שהיו פשוט עשה את זה סוג של אותו תוך לולאה שם למטה,
אז זה יעבוד בסדר גמור.
אבל בזה בפרט מקרה, שאנחנו עושים פשוט לא
במקרה טיפול בערכים שליליים.
שאלות אחרות על מערכים?
אוקיי.
>> אז עכשיו שראינו מערכים.
ואנחנו הולכים צריכים להשתמש זה לטיעוני שורת הפקודה.
אז בבעיה להגדיר two-- אני יודע שרבים מכם
אולי עדיין עובד על סט בעיה אחד, אבל בעיה להגדיר שני מתקרבות.
בבעיה להגדיר שתי, אתה הולך צריך להיות התמודדות עם מחרוזות, מערכים,
וטיעוני שורת הפקודה.
>> אז מה הם טיעוני שורת הפקודה?
עכשיו, אתה יכול לראות כאן למטה טיזר קטן בדיוק מה
הולך להיות קורה.
אנו רואים argc העיקרי, Inc int, סוגריים argv המחרוזת.
אז בואו ראשון ננסה לפרש מה שמנסה להגיד.
עכשיו בסדר.
>> אז בשורת הפקודה אתה צריך להיות להתרגל לחלק מפקודות אלה
עכשיו, ויש לך כנראה לרוץ CD במסוף לפני.
אז אם אנחנו אומרים pset1 CD, אתה יודע שזה צריך
להיות שינוי לתוך ספריית pset1.
>> עכשיו שם לב שיש לך אף פעם לא נכתב תכנית כמו זו לפני.
כל תכנית שכתבת, היית רץ, למשל, נקודה לקצץ מריו,
הנקודה לקצץ חמדנים, ואז זה אולי יבקש ממך הקלט.
עכשיו, זה לא מה ש שינוי הספרייה עושה.
כאשר אתה מפעיל את התקליטור, זה לא אומר אז, איזו ספרייה שאתה רוצה CD ל?
במקום זאת, אתה פשוט אומר, pset1 CD, ו זה פשוט הולך לספריית pset1.
>> אז באופן דומה יש לנו דוגמאות נוספות.
לעשות שלום.
כאשר אתה מפעיל לעשות, זה לא אומר אז, איזו תכנית היית רוצה לעשות?
אתה פשוט אומר, ב שורת הפקודה לעשות שלום.
>> מהלך הוא דוגמא נוספת.
אחד זה אנו נעים mario.c להגיש את מדריך אחד.
אז עכשיו אנחנו יודעים עם דוגמא זו אנחנו באמת עוברים שתי טענות.
יש mario.c כטענה הראשונה, ונקודת נקודה היא הטענה השנייה.
ואז כאשר אתה מפעיל לעשות, אתה רואה שפקודה באמת ארוכה line--
שפקודה באמת ארוכה מודפס בשורת הפקודה.
אז כל כך הרבה זמן command-- זה הוא רק חלק קצר שלו,
אבל עכשיו יש לנו שלוש שורת הפקודה טיעונים.
מקף דוט אפס, שלום, וhello.c.
>> אז אלה הם שורת הפקודה טיעונים, נימוקים
שאתה עובר ב שורת הפקודה כדי שזה
לא צריך שתתבקש כאשר אתה מפעיל את התכנית.
זה יהיה מתסכל אם כש אתה רץ מצלצל זה אמר, "בסדר,
שprogram-- ש קובץ אתה קומפילציה?
Hello.c.
מה הדגלים היית רוצה להיכנס? o מקף.
מה תרצה הקובץ שייקרא?
שלום.
לא, אתה פשוט להפעיל צלצול מקף o שלום hello.c.
>> אז במבט לאחור בשלב זה.
עכשיו argc argc-- הוא ספירת הטיעון.
זה המספר של שורת הפקודה טיעונים נכנסו בשורת הפקודה.
ובכן, מבחינה טכנית argv-- v מייצג וקטור,
אשר בעצם אומר מערך.
אבל אתה יכול להתעלם מכך.
Argv-- יש לנו argv מחרוזת, כך argv מחרוזת בסוגריים.
אז זה עוד צורה של בסוגריים שלא ראה בעבר.
הסוגר אז שראינו סימון כאשר אנחנו כבר אמרו,
כמו, מחרוזת של שווה Zamyla.
הסוגר של 0 כניסות ז האופי
>> כן, אנו רואים בסוגריים כש אמרנו גילאי int סוגרים 5.
שהכריז מערך של גודל 5.
אז הנה גרסה של סוגריים שלא ראו בעבר.
אז זה סוג של argv מחרוזת ש יהיה מוכר לחלוטין
שזה יהיה רק ​​מחרוזת.
עכשיו סוגריים מציינים כי זה הוא מערך.
אז אמצעי סוגריים argv המחרוזת argv שהוא מערך של מחרוזות.
עכשיו מבחינה טכנית מחרוזת הוא מערך של תווים.
אז זה עכשיו מערך של מערך של תווים.
אבל זה הרבה יותר קל לחשוב על זה כמו רק מערך של מחרוזות.
>> אז למה סוגריים עשויים להיות ריקים?
כמו, למה אנחנו לא יכולים לומר, תושבת 5, n הסוגר?
כן.
אנחנו לא יודעים כמה תשומות יש הולכים להיות.
אם אנחנו מסתכל על דוגמא הצלצול אז, אנחנו אומרים מצלצלים מקף o שלום hello.c.
במקרה הספציפי הזה, יש לקרות להיות שלושה טיעוני שורת הפקודה.
וכך brackets-- נראה בשנייה שזה לא יהיה שלושה.
זה מבחינה טכנית יהיה ארבעה.
אבל בסוגריים, שהיינו למשל, יש שלוש.
אבל עכשיו אם הסתכלנו מהלך mario.c נקודת נקודה, סוגריים
היינו רוצה לשים את שני בהם.
>> ויש הרבה פקודות ש יש מספר משתנה של שורת הפקודה
טיעונים.
אז מה גרסה זו של סימון התושבת מציין
הוא שargv הוא מערך של מחרוזות.
אבל אנחנו לא יודעים כמה מחרוזות במערך ש.
ואיך אנחנו יודעים איך אז מחרוזות רבות במערך?
זה כל argc הנקודה.
argc אומר לנו כמה זמן argv הוא.
>> אז הדבר האחרון שכדאי דעה היא ש, מבחינה טכנית,
הפקודה עצמו נחשבת כאחד טיעוני שורת הפקודה.
אז pset1 CD, יש שני שורת הפקודה טיעונים.
התכנית בעצמו, CD, ולאחר מכן החלק בפועל הטיעון שלו, pset1.
כל תכנית שכתבת עד כה יש לו נקודת argument-- שורת הפקודה אחד
לקצץ מריו.
זה הטיעון של שורת הפקודה בלבד.
>> מחפש אז עכשיו בצלצול מקף o שלום hello.c.
אז מה הוא argc?
4.
אז argc הוא 4.
צלצול, תושבת כך argv 0 היא צלצול.
תושבת argv 1 היא מקף 0.
argv תושבת 2 היא שלום, ו argv הסוגר 3 הוא hello.c.
אוקיי, אז שאלות על זה, ואז תסתכל על כמה דוגמאות תכנותית.
>> אוקיי.
אז אנחנו נסתכל על hello3.c.
אז זה צריך להיות מוכר מ אחת דוגמאות הראשונות ג
היו לנו איפה אנחנו היינו אומרים רק, שלום עולם, אבל עכשיו זה הוא כללי יותר.
אז הנה אנחנו אומרים שלום % s תושבת argv n הלוכסן 1.
Notice-- כך עד נקודה זו, זה הוא מה קובץ התבנית שלי נראה.
היה לי int הראשי (void), ולאחר מכן הייתי לעשות משהו בפונקציה העיקרית.
עכשיו במקום, ברגע שנתחיל התמודדות עם טיעוני שורת הפקודה,
אנחנו צריכים להצהיר צורה שונה של עיקרי.
>> אז מסתכל על hello3 שוב, העיקרי הולך
לקחת שני טיעונים now-- argc int, מספר טיעוני שורת הפקודה,
ומחרוזת argv סוגריים, בפועל מחרוזות נכנסו בשורת הפקודה.
אז אני הולך לשנות את זה תבנית כדי לשקף עובדה זו.
עכשיו בכל פעם שאתה כותב תכנית, אם לא
צריך לקחת כל שורת הפקודה טיעונים, ואז פשוט להשתמש int הראשי (void).
אבל עכשיו כשאתה כותב תוכניות טיעון שורת הפקודה, ש
אתה הולך לעשות לבעיה להגדיר two-- אז עכשיו שאתה מפעיל
תוכניות שצריכות לקחת שורת הפקודה טיעונים,
אתה צריך שתהיה לי עיקרי של צורה זו.
>> אז כאן-- זו היא השימוש הגדול של הטיעון של שורת הפקודה.
אז הדפסת argv 1.
אישור אז בואו לקמפל ולהפעיל את התכנית.
הפוך hello3.
הידור.
דוט לקצץ hello3.
ונניח, "רוב".
שלום רוב.
אם אני אומר, "שלום מריה," שלום מריה.
שלום מריה.
חנה עדיין אומרת, "שלום מריה, "כי אני לא
עושה שום דבר עם argv 2.
Argv 2 עכשיו יהיה "חנה".
Argc יהיה 3.
מה אם אני עשיתי את זה?
אז שלום null.
>> הוא נגע בקצרה על העובדה כי, מבחינה טכנית, GetString
אולי תחזיר null, אבל אנחנו נגיע הרבה יותר למה שnull הוא למעשה.
אבל לקחת את זה כעניין של עובדה שאין הוא בדרך כלל רע.
עשינו משהו לא בסדר אם זה הדפסה "שלום null."
והסיבה שעשינו משהו לא בסדר הוא-- גם,
כשרצתי hello3 נטוי נקודה, argc היה 1.
אז זה אומר האורך של argv היה 1.
אם מערך הוא באורך 1, המדד תקף רק הוא אפס.
ואז הנה argv 1 הוא מחוץ מגוון של מערך זה.
זה היה דומה ללפני כשניסיתי לאחסון 6 מחוץ לסוף המערך.
אז אני מנסה לגשת למשהו מחוץ לספירת argv,
ואנחנו מקבלים אפס.
>> אז גרסה טובה יותר של זה, שיפור,
הוא במפורש בדיקת argc.
אז אם argc שווה 2, זה אומר שאנחנו רצים משהו כמו hello3 לוכסן נקודה רוב.
וזה יהיה להדפיס "שלום רוב."
אם argc לא שווה 2, אז זה רק הולך
להתעלם מה אתה שם בטענה של שורת הפקודה
כטיעונים שורת הפקודה.
או אם אתה לא שם בכלל, זה רק הולך להתעלם מכך ורק אומרים,
"שלום אתה."
>> אז קומפילציה זה.
הפוך hello4.
ופועל hello4.
מפעיל אותו בדרך זו, מה צריך להיות מודפס?
"שלום אתה."
שלום אתה.
מה לגבי hello4 רוב?
"שלום רוב."
ולבסוף, שלום רוב מריה רק "שלום לך" שוב,
כי אתה לא באמת להיכנס משהו שציפה.
אתה נכנס יותר שמות ממה שהוא יכול להתמודד,
כך שזה רק ברירת מחדל ל שלום לך ההתנהגות.
אז שאלות על זה?
או טיעוני שורת הפקודה?
>> אוקיי, אז לקחת מבט עוד כמה דוגמאות של שימוש
שורת הפקודה arguments-- הראשונה יש לנו argv מקף 1 הנקודה ג.
אז ההערות לתת מה צריכה לעשות תכנית זו.
אבל שם לב now-- זה ללולאה, זו תואמת את התבנית המדויקת
אני אומר לפני.
אנחנו פשוט להיות באמצעות argc במקום n.
עכשיו argc הוא באמת n.
זה האורך של מערך argv.
אז הם iterating על argv כל ערך argv ing-printf מערך.
>> אז אם אני עושה את זה.
הפוך argv 1.
זה הידור.
דוט לקצץ argv 1.
פשוט רץ זה, זה הדפסי נקודה argv הנטוי 1
מאז שהייתה שורת הפקודה בלבד argument-- את שם התכנית.
תמיד יהיה בleast-- argc לא יכול להיות פחות מ,
מאז תמיד יהיו לפחות להיות שם התכנית לפעול.
אז argv 1 רוב יודפס argv 1 ואז על הקו החדש "רוב".
>> אז באיטרציה הראשונה של לולאה זה, אני הוא 0.
Argv 0 הוא שם התכנית.
דוט לקצץ argv 1.
ולאחר מכן argv 1 הוא ראשון שלי שורת הפקודה טיעון, שהוא רוב.
בשלב זה, אנו שווים לargc.
אנו לפרוץ את הלולאה ואנחנו נעשו.
אז זה יעבוד עבור שרירותי מספר טיעוני שורת הפקודה.
שים לב שזה מדפיס argv 0, argv 1, 2 argv, argv 3, argv 4.
ואין argv 5.
argc הוא שווה ל 5.
אז בargc-- באני שווה 5, אנחנו לפרוץ את הלולאה.
אוקיי.
אז שאלות על זה לפני ש תתבונן בדוגמה מורכבת יותר?
>> אז argv 2.
בסדר.
אז אנחנו עדיין הדפסה טיעוני שורת הפקודה.
אבל עכשיו שמתי לב שיש לנו מקונן ללולאה.
אז מה הוא עושה את זה?
אז הלולאה הראשונה הוא עושה בדיוק מה שעשה בעבר.
אנחנו עדיין לולאה מעל כל טענה של שורת הפקודה,
אבל עכשיו loop-- השני זה יש לנו גם ראה משהו כזה בעבר.
כשiterating על Zamyla להדפיס את Z--M-Y-L-.
אז הלולאה שנייה לj int שווה 0, n שווה strlen של תושבת argv אני.
>> אז בואו נחשוב ראשון ל כל-- בואו ללכת דרך.
בואו נחשוב מה היית עושה במחשב לעשות אם אני רץ תכנית זו כנקודה רק
לקצץ argv מקף 2.
אז אם רצתי את הקוד הזה, אז argc הולך להיות שווה ל 1.
ומחרוזת argv-- יש רק הולך להיות מדד אחד בargv,
וזה הולך להיות שווה לנקודה לקצץ argv 2-- את שם התכנית.
>> אוקיי, אז עכשיו אני שווה 0, אני פחות מ 1, אני בתוספת בתוספת לj int שווה 0,
n שווה strlen של תושבת argv 0, כך ב איטרציה הראשונה של לולאה זה. argv
תושבת 0 היא הקו נטוי נקודת argv 2.
אז מה הוא אורך המחרוזת ש?
ובכן, נקודה לקצץ-R-G-V מקף 2.
אז strlen של שיהיו 8.
אז j שווה 0, n שווה 8.
כל עוד j הוא פחות מ 8, ++ j.
ועם זה אנחנו הולכים להיות הדפסת תו בודד, אשר
הוא argv הסוגר אני סוגר j.
>> אז הוא רק אפס.
עדיין יש לנו רק אחד שורת הפקודה טיעון.
שבאיטרציה הראשונה של ללולאה, אנחנו
הולך להיות הדפסה תושבת argv 0 הסוגר 0.
ואז j הולך להגדיל.
ואנחנו הולכים להדפסה תושבת argv 0 תושבת 1.
ולאחר מכן argv הסוגר 0 התושבת 2.
>> אז זה המפגש הראשון שלנו מערכים רב-ממדיים.
זכור קודם לכן שאמרתי argv שהוא מבחינה טכנית
מערך של מערכים של תווים.
אז הנה אם אמרתי משהו כמו מחרוזת של שווה תושבת argv אני,
ואז אמרתי, של י הסוגר, זה יהיה להשיג את אותו הדבר.
עכשיו, אתה כבר ראית של j הסוגר לפני.
זה פשוט לגשת לי-ה אופי של מחרוזת זו.
אז עם זה, אנחנו מקבלים אופי י-ה מargv i-ה.
>> אז מה צריך סופו של דבר תפוקה זה?
הפוך argv 2.
זה הידור.
דוט לקצץ argv 2.
"רוב מריה חנה," ולתת לנו קצת מקום.
כך אנו רואים שזה פלט נקודה על קו משלו וקו נטוי
בשורה הנפרדת ובשורה הנפרדת.
זה להדפיס את כל דמות בודדת
כל טענה של שורת הפקודה.
ולאחר מכן ביניהם, בגלל הקו החדש
אנחנו מדפיסים כאן למטה, ב ביניהם זה יהיה להדפיס קו חדש.
>> אז זה דומה ל מקף argv לפני 1,
שהודפס בכל שורת הפקודה טיעון,
אבל עכשיו אנחנו הדפסה טיעוני שורת הפקודה
ולאחר מכן iterating דרך כל אופי של כל טיעון של שורת הפקודה
כדי לקבל פלט זה.
אוקיי?
אז שאלות על זה?
>> דבר אחד שיש לציין הוא ש arguments-- שורת הפקודה
כך הם מופרדים על ידי רווחים כ אתה באופן טבעי היה מצפה מהם להיות.
אז מחרוזת יכולה להיות רווחים בזה.
זה לא סופר חשוב, אבל אם אני רציתי את טענת שורת הפקודה השלישית
יש מקום בו, אז אני אפשר לומר משהו כזה.
אוקיי?
אז זה עדיין עכשיו יש שלוש בלבד שורת הפקודה היטב arguments-- 4.
דוט לקצץ argv מקף 2, רוב, מריה, וחנה בלומברג.
אוקיי.
שאלות על זה?
>> אין שום דבר מיוחד על אופי החלל.
זה פשוט קורה להיות ש שורת הפקודה מתייחסת לאופי החלל
איך אתה להפריד כל ויכוח.
בסדר.
אז סט הבעיה two-- אתה הולך להיות
מסתכל על הצפנה סודית-מפתח.
אז, בדומה לדוגמא ש ראינו מסיפור חג המולד,
אתה הולך להיות יישום מסוים אלגוריתמים ש, ניתנו הודעה,
אתה הולך להיות מסוגל כדי להצפין הודעה ש
שמישהו רק עם סוד ש מפתח, עם שטבעת המפענח,
צריך להיות מסוגל לפענח.
>> כך שהיא המהדורה סטנדרטית.
אתה הולך להיות יישום שתי גרסאות שונות.
אם יקרה לך תסתכל במהדורת ההאקר עכשיו,
אנחנו הולכים לתת לי אתה מחרוזת כמו זה,
המייצג את סיסמא מוצפנת.
אז המטרה שלך היא להבין מה היא הסיסמה המפוענח.
עכשיו זה בעצם הוא איך סיסמאות מאוחסנים בהרבה מחשבים,
וזה רק מאחסן זה מחרוזת אקראית של תווים.
יש לך להבין איך להגיע ממחרוזת האקראית של תווים
למה הסיסמה המקורית הייתה.
>> ולבסוף, אחרי זה סט בעיה, אתה צריך
להיות מסוגל להבין מה זה אומר.
כך תוכל ללמוד כיצד לפענח סוג זה של מחרוזת אקראית.
באופן דומה, אם אתה זוכר משבוע 0, אתה יכול לראות את כתובת אתר.
ואתה אמור להיות מסוגל לפענח סופו של דבר זה.
אתה לא יכול להיות מאושר כשאתה לפענח אותו ולחץ על הקישור.
בסדר.
זהו זה להיום.
אז תתראה בשבוע הבא!
>> [השמעת מוסיקה אלקטרונית]