>> ROB: בסדר.
ברוכים הבאים לחלק הראשון.
אני רוב.
>> יוסף: אני יוסף.
>> ROB: כך תהיה לנו לצלול ישר פנימה
דבר ראשון שיש לדבר על הוא Appliance.
אז אני מקווה שרובכם יש לי הוריד את זה כבר.
אבל אתה יכול לראות את ההוראות בcs50.net/appliance.
אוי אלוהים, עכשיו אני מודע לעצמו.
אני עדיין שומע אותו.
>> יוסף: וואו, זה נשמע כמו זה מבולבל.
>> ROB: אז כמה אנשים כבר יש בעיות עם זה, אז לא לחכות עד
הרגע האחרון של הבעיה מוגדר לנסות ולפתור את המכשיר ו
לגלות שזה לא עובד.
>> יוסף: ואם משהו לא עובד ואתה צריך עזרה, אתה יכול ללכת
cs50.net/discussion איפה אנחנו יש פורום שבו אתה
יכול לפרסם השאלות שלך.
ואנחנו נגיע אליהם בסופו.
>> ROB: בסדר.
אז זה מה שAppliance נראה.
שוב, זה רק נפרד לחלוטין מערכת הפעלה שרצה בתוך
מהי מערכת הפעלה אתה פועלים על המחשב הנייד שלך.
והדברים העיקריים שאתה יהיה אשתמש הם gedit.
אז אני מקווה שזה כבר הפך לאתר מוכר.
המסוף.
>> ואתה גם יכול להריץ כרום בתוך המכשיר.
היו כמה אנשים שדיווח באינטרנט
לא יעבוד במכשיר.
וחלק מהם פשוט הנחתי שיש לא אמור להיות
אינטרנט במכשיר.
אבל כן, יש אמורה להיות באינטרנט.
>> אני אגיד את זה עכשיו, אבל זה לא באמת אומר שום דבר.
אם האינטרנט לא עובד, זה מה שאתה נוטה צריך
לרוץ כדי לתקן את זה.
אם אתה נתקלת בבעיות באינטרנט, לא זוכר את זה, רק לכתוב את זה על
דיון, ואנו אומרים, להפעיל את זה.
אבל האינטרנט צריך לעבוד.
>> אז הדבר היחיד האחר - כן, שום דבר השאר הוא באמת רלוונטי.
אבל אני רק רציתי לציין ש--
רואה בפינה ימנית תחתון זה.
אז כל אחד ממכשירי חשמל שלך צריך יש כתובת IP.
ומאוחר יותר בסמסטר, IP זה כתובת תהפוך לרלוונטית יותר כאשר
אתה עובד על p-סט האינטרנט, כי תוכל לגשת
אתר שאתה עובד על משלך Chrome המקומי באמצעות כתובת ה-IP הזה.
>> אבל מה שאני רוצה להשתמש בכתובת ה-IP ל-- ואתה לא חייב לעשות את זה, אני
רק רוצה להצביע עליה -
הוא כאן.
אז זהו חלון מסוף ב Mac שלי, זה לא ב
מכשיר בכלל.
ואתה יכול לחפש את מה פקודה זו עושה.
אבל אני הולך לSSH ישירות למכשיר שלי.
אני לא יודע מה ה-IP.
>> יוסף: 168 -
>> 168.224.1.0.
>> ROB: אז ברגע שאני גומר עם זה, להיכנס פנימה
עכשיו, בעצם, זה זהה ל חלון מסוף בתוך המכשיר שלי.
אז אף פעם לא עבדתי די הרבה בעצם מתוך המכשיר עצמו.
אני פשוט תמיד אותו פועל ברקע ממוזער
וSSHed לתוכה.
>> הבעיה עם זה הוא שאתה לא הולך כדי להיות מסוגל להשתמש gedit בקלות
ישירות מזה.
אבל אם אתה רוצה להיות מגניב אמיתי האקר, אז אתה צריך להתרגל ל
עורך פקודת שורת טקסט בכל מקרה.
אז Vim ו Emacs וננו, כל אלה חלופות שונות.
ננו נוטה להיות הקל ביותר.
ואני חושב שאין לה הדגשת תחביר.
אה, לא, זה לגמרי עושה.
אז אתה יכול להשתמש Nano, כי כי אחד די קל.
>> אתה רואה את כל הפקודות הללו בתחתית.
סמל גזר הקטן הזה.
אם לא ראה את זה קודם, תוכל כנראה רואה את זה הרבה עכשיו.
זה בדרך כלל אומר את גזר השליטה, כמו החלק התחתון השמאלי של מקלדת
אופי שליטה.
אז הנה זה אומר לי כאן למטה -
אה, זה לא נותק אם אני זום פנימה
אז בקרה, X הוא איך אני הולך לצאת.
וזה אומר שאני יכול לפגוע Y עבור כן, לחיסכון, N למס
אז זה נאנו.
>> Vim ו Emacs נוטים להיות מעט יותר מסובך ומכריע.
אבל אתה יכול להתרגל לזה, ואז אתה תאהב את זה.
אז זהו זה.
>> יוסף: אין צורך לעשות את זה.
>> ROB: כן.
אתה חופשי להשתמש gedit עבור שארית הסמסטר.
אז כל שאלות הקשורות למכשיר?
או האם יש לך מחשבות על מה עוד צריכה להיות דיבר על כ
המכשיר?
כן.
>> SPEAKER 1: כאשר אתה SSHed אליך דבר, היה Crimson הסיסמה?
>> ROB: כן.
הסיסמה לכל דבר די הרבה במכשיר הוא הולך
להיות הארגמן.
>> SPEAKER 2: התקנה כמו IDE אמיתי על המכשיר, זה יעבוד?
>> ROB: אני מתאר לעצמי Eclipse עושה לי גרסת פדורה, ובמקרה כזה, כן,
אתה יכול לעשות את זה.
זה כנראה לא ממש שווה את זה.
>> SPEAKER 2: אישור.
אז זה כנראה קל יותר אם אני רוצה להשתמש באקליפס, פשוט להשתמש היליד ו
לאחר מכן להעלות ל--
>> ROB: אה, זה הוא גם כנראה יותר קל.
אבל אתה יכול לקבל את זה עובד בתוך המכשיר.
>> יוסף: ולמצלמה, השאלה היה, אתה יכול להתקין עוד
IDE הפנימי של המכשיר?
>> ROB: Eclipse להיות דוגמא של IDE.
כל שאלות מכשיר אחרות?
בסדר.
>> אז אנחנו עכשיו נעבור לשורת הפקודה דברים הקשורים לממשק, כך CLI.
ושוב, אני רק הולך לעבודה ב כאן, כי זה זהה ל
עובד בתוך חלון מסוף בתוך המכשיר.
כיצד גופן שמחפש?
האם זה גדול מספיק?
בסדר.
>> אז יש הרבה פקודות ש אתה צריך לקבל די נהג
במהלך הסמסטר.
שני הגדולים לניווט הם ls, רשימה הקבצים בספרייה זו, ו
cd, אז לשנות את הספרייה.
אז אני יכול לשנות לשולחן עבודה ולאחר מכן דפוס נפוץ מאוד הוא cd כדי
ls ספרייה ומייד מה במדריך.
>> אנשים גם לפעמים לא מבינים שהשלמת Tab היא דבר.
cd אז כמו, VH, ואז הקש על Tab.
אני כמעט אף פעם לא להקליד את את הדבר כולו.
ואז אם אני ממשיך להכות Tab שוב, זה באופן אוטומטי
להתחיל רישום בשבילי.
אז אני יכול vhosts cd, מארח מקומי.
וזה רק הולך -
במקרה שלא שמע את המושג לפני כן, בספרייה היא רק מילה אחרת
לתיקייה.
אז עכשיו אם אתה רואה -
בואו להביא את זה לראש.
>> אז עכשיו אם אתה רואה בסוגריים, אתה לראות קצת טילדה, הלוכסן, vhost,
לוכסן, מארח מקומי.
אז טילדה, שמתייחסת בספרייה הביתית שלי.
זה מדריך שאתה בעת SSH פנימה
זה המדריך שאתה בכאשר אתה פותח את מסוף.
זה המקום שבו אתה מתחיל.
ואז אני פנימי של ספריית הבית שלי, ואני בתוך vhost
בתוך ספרייה של ספריית הבית שלי.
ולאחר מכן אני פנימי של מקומי תארח ספרייה הפנימית שלו.
>> אז כמה דברים שימושיים אחרים עם דיסק -
או גם, באופן כללי, כך שנקודה תמיד מתייחס לספרייה הנוכחית.
Cd, נקודה היא פקודה די חסרת ערך.
אבל זה משתנה ל ספרייה נוכחית.
שימושי יותר אחד במונחים של cd הוא נקודה, נקודה, שהיא
רק לעלות ספרייה אחת.
>> ושים לב כי אלה -
אני רוצה להגיד שמות בדויים, אבל אלה סמלים, נקודה, ונקודה, נקודה, עבודה אלה
לכמעט כל פקודה שאתה הולך לחשוב על הריצה.
cd אז כמו הוא כנראה איפה אתה אהיה שימוש ביותר, אך אלה אינם
דברים שפשוט cd מבין.
זה פחות או יותר משהו כולו שלך שורת הפקודה מבינה.
הרבה תוכניות להבין נקודה ונקודה, נקודה.
>> אז שימושיים אלה אחרים - cd, המקף.
כך שהוא הולך להביא לי הספרייה האחרונה שהייתי בה
אז לפעמים אני אעשה משהו כמו, הו, אני עובד כאן.
ואני רואה את שגיאה מסוימת עם משהו, ו אני אלך לחקור אותו על ידי לחיצה על
כמה ספרייה אקראית במקום כלשהו.
ואני לא יודע אם זה יהיה תן לי שם.
זה יהיה.
אז אני עושה מה שאני רוצה במדריך זה.
בלה, בלה, בלה, בלה, בלה.
ואני הייתי כמו, בסדר, אני רוצה כדי לחזור למקום שהייתי.
cd, מקף, וזה מביא אותי ישר בחזרה.
>> אז אני הולך לזרוק הרבה אלה עליך היום.
אני לא מצפה ממך לשנן את כולם.
זה סוג של פשוט יודע שהם קיימים.
ואז מאוחר יותר כאשר אתה כמו, הממ, אני רוצה לחזור ל
ספרייה שהייתי רק ב, הו, חכה, משהו כמו מה שקיים.
אתה לא צריך רק להקליד בכל המדריך שוב.
>> יוסף: וסופו של דבר אתה פשוט להשתמש בם שוב ושוב, ו
זה יהפוך זיכרון שריר.
>> ROB: כן.
אז איך שאמרתי קודם, שטילדה היא ספריית הבית שלך.
אז אני יכול cd, טילדה.
אבל גם אין לי ל לעשות את זה אם אני רק -
אני אחזור לספרייה ולכן זה לא דוגמא חסרת טעם.
אבל אם אני רק עושה cd, זה גם זהה, ללכת לספריית הבית שלי.
אני עושה את הפיקוד, ק
>> יוסף: אתה יכול גם להקליד ברור, מילה, ואת זה צריך לנקות אותה.
>> רוב: ואני חושב שגם בקרה, L גם עושה את זה.
אז הרבה דרכים שונות.
אני חושב שיש כמה הבדלים שבו ברור ובקרה, L יהיה פשוט
באמת לדחוף את זה לראש ו אני עדיין יכול לגלול אחורה.
פיקוד, K הורס, פשוטו כמשמעו, כל דבר, ואתה
לא ניתן לגלול בחזרה למעלה.
לכל הפחות, זה איך זה עובד בiTerm2.
אני לא יודע איך דברים אחרים -
הו.
>> עם SSHing, כך שאם אתה ב-Windows, אתה הולך צריך להוריד מרק
כדי SSH מאז Windows לא יש לי כמו כלי מובנה SSH.
ממחשבי מקינטוש, אתה יכול פשוט SSH ישירות מחלון מסוף.
על אישור.
שאלות?
>> עם ls, אז משהו להתרגל עם רוב של פקודות אלה היא -
כן, אני פשוט עושה אחד.
Ls, מקף, אני.
אז המקף, l הוא מה אנחנו הולכים לקרוא לדגל לls.
והרבה פקודות אלה יש דגלים שאתה יכול לעבור אליהם.
אז במקרה הזה, מקף, l הוא דגל שאומר לו שייתן לי מלא
רישום של כל המידע של קבצים אלה.
>> אז אנחנו רואים כאן ששולחן העבודה הייתה הותאם יום 30 ביולי בשעה 12:54.
הורדות שונה ב -6 בספטמבר.
אלה הם גודלו הנוכחי ו בתים של ספריות אלה.
אתה לא צריך להבין את כל זה.
>> החומר הזה בצד השמאל, drwx של אלה, שיהפוך להרבה יותר רלוונטי
מאוחר יותר, כאשר יש לך להתמודד עם -
כי יש לעשות עם מי שיש לו הרשאות להסתכל על קבצים אלה.
ולכן אם לא היית משתמש רק ב מחשב זה, אתה יהיה מסוגל
נניח, בסדר, אני צריך להיות רק אחד מותר להסתכל על קובץ זה או אני
הולך כדי לאפשר לכולם להסתכל על קובץ זה.
אז מישהו אחר במחשב שלי יכול להסתכל בקובץ זה.
אני אפילו לא יודע מה זה - מה זה עושה?
>> יוסף: אני לא ממש בטוח, בעצם.
>> רוב: אין לי מושג.
>> יוסף: אבל אם אתה לא יודע, יש הפקודה מועילה שאתה יכול להשתמש
להגיד לך מה הפלט אומר.
ואם תקלידו באדם לפני הפקודה -
כך M--N. ROB: אדם.
אז איש הוא עוד אחד כי הוא מאוד שימושי.
ואדם, ls.
אז הדפים בנאדם, יש להם שני פקודות שאתה הולך להיות באמצעות
בשורת הפקודה, ויש להם גם פונקציות שתהיינה רלוונטי
עם ג אז אתה יכול אדם -
ואני התעלמתי 3.
אבל איש printf 3 הוא הולך להביא את גרסת C של printf.
אבל אם אני פשוט עושה את printf איש, זה הולך להביא את printf הפקודה
זה קורה בשורת הפקודה.
>> אז גבר, ls.
דפי האדם יכולים להיות די מכריע.
כאן, לעומת זאת, תוכל לראות רשימה זו של כל הדגלים הללו שls
מבין.
אז אם אנחנו הולכים למקף, l, ו--
אני רק הולך לזרוק את זה עליך.
אבל, לשם חיפוש, אתה רוצה לראשון פגע בשאלה
סימן או על לחצן קו נטוי.
אז לחתוך.
>> ואז אני יכול לחפש לכל מה שאני רוצה.
אז אני הולך לקצץ למקף, אני.
והוא היה שם.
אז להשתמש בפורמט רישום ארוך.
זה לא עוזר לי להבין מה עמודה מסוימת שהתכוונה, אבל אני
מניח במקום כלשהו בכאן זה יכול להסביר את זה.
אז להשתמש בדפי האדם לכל פקודה כי אתה לא מבין מייד.
>> אני די בטוח שאתה יכול אפילו גבר, גבר.
ממשק לאינטרנט מדריכים.
אה, האחרון אחד זה אולי מעט ls הרלוונטי הוא, מקף,.
אז שם לב אם אני פשוט עושה את ls, אני מקבל את חמשת הקבצים הללו.
אם אני עושה ls, מקף,, אני תקבל הרבה יותר קבצים.
אז הדבר במשותף בין כל אלה קבצים חדשים הוא הנקודה מראש.
>> אז האמנה היא שקובץ ש מתחיל עם נקודה נסתרת.
כך שאתה לא רוצה לראות קובץ זה, אתה לא רוצה שיהיה לו להתעסק עם
הרישום בספרייה שלך.
זה רק כאשר הבקשה המפורשת שלך, בסדר, ls, המקף,, תראה לי.
מייצג את כל הקבצים, כולל אלה מוסתרים.
אז כמה פקודות אחרות.
אה, שאלות בשלב זה?
כן.
>> SPEAKER 3: כאשר אתה עושה ls, , מה זה הנקודה, הנקודה?
>> ROB: אוה.
אז זה מה שאני מדבר.
זה אותו הדבר שבו אני יכול כמו CD, נקודה, נקודה.
אז מבחינה טכנית, נקודה ונקודה, נקודה הן קבצים שקיימים בכל אחד
ספרייה שבה קובץ הנקודה מתייחס לספרייה הנוכחית.
אז אם אני cd, נקודה, אני רק הולך כדי להישאר בספרייה.
ונקודה, נקודה תמיד מתייחסת רמה מעלה קודם במדריך אחד.
אז אם אני נכנסתי ליומנים וls, מקף, אל, אני תראה את הנקודה, נקודה. cd לנקודה, נקודה
מביא אותי לספרייה הקודמת.
כן.
על אישור.
>> אז עוד די חשוב הפקודה rm.
אז זה מה שאנחנו הולכים כדי להשתמש בו כדי להסיר.
ותן לי בעצם לעשות עוד הפקודה ראשונה.
אז mkdir.
Mkdir הוא איך אתה יכול יצירת תיקיות.
ואני ליצור ספרייה זמנית ונכנס לזה בספרייה זמנית.
וכצפוי, זה ריק.
אבל אם אני ls, מקף,, עדיין יש לי נקודה ונקודה, נקודה, כי נקודה מתייחסת
הספרייה הנוכחית.
ונקודה, נקודה מתייחסת ספרייה קודמת.
ואלה תמיד יהיו קיימים לא משנה הספרייה בו אתה נמצא
>> וזו היא מיותרת לחלוטין הפקודה, אבל מגע.
אני רק משתמש בו, כי זה דרך קלה ליצור קבצים.
אז לגעת, לגעת b, c הוא רק לגעת הולך ליצור שלושה קבצים שנקראים,
b, ו-c הם ריקים לחלוטין.
אז הנקודה שלי יצירת אלה ב המקום הראשון הוא פשוט כל כך rm שהוא
איך אנחנו יכולים להסיר אותם.
אז rm,.
זה הולך לשאול אותי, להסיר קובץ ריק רגיל?
ואז אני אגיד כן.
>> אז אם אני יודע בודאות שאני רוצה למחוק את הקובץ שמבלי להיות
תתבקש לעשות זאת, להסיר את הקובץ ריק רגיל?, אז rm, מקף, ו הולך להיות
דגל שאומר, לכפות להסיר ללא גם מה שגרם לי, אה, אתה
בטוח שברצונך למחוק את הקובץ?
כן, אני בטוח.
אז rm, מקף, fb פשוט יהיה לעשות את זה בלי לשאול.
>> אז בואו נעשה כמה מדריכים יותר.
mkdir, tmp2, CD, tmp2, לגעת, לגעת ב.
על אישור.
אז עכשיו אני רוצה להסיר tmp2 כמדריך.
tmp2 אז rm.
לא ניתן להסיר tmp2, זה מדריך.
אז הבעיה כאן היא שrm לא עובדים באופן מיידי על ספריות.
זה נועד רק עבור קבצים כמו קבצים שאינו בספרייה.
>> ואז מה אנחנו יכולים לעשות כאן הוא rm, מקף, r.
שעומד, לאופן רקורסיבי אשר עשויים לא אומר לך משהו עדיין.
אבל כשאתה מגיע לרקורסיה, זה יהיה מתכוון יותר.
אז rm, מקף, r, tmp2 הולך באופן רקורסיבי להיכנס לספרייה זו.
ירידה לתוך tmp2 ספרייה?
כן, בואו ניכנס לזה.
האם אנו רוצים להסיר tmp2 /?
כן.
האם אנו רוצים להסיר tmp2 / b?
כן.
עכשיו אנחנו רוצים להסיר tmp2 הספרייה?
כן.
ואז עכשיו הספרייה והכל בפנים
שלו הוסר.
>> יש מבחינה טכנית rmdir הפקודה כי אתה יכול להשתמש בו כדי להסיר את
ספריות, אבל זה עובד רק על ספריות ריקות בכל מקרה.
ולראות את זה, בוא פשוט לעשות mkdir, tmp2 שוב.
Tmp2, לגעת.
על אישור.
אז אם אני מנסה להסיר dirtmp2, זה יהיה אומר, ספרייה אינה ריק.
אז אני פחות או יותר לא להשתמש בהסרה פקודת dir כל מקרה, כי rm, מקף,
r יעבוד על ספריות ריקות וספריות שאינן ריקות.
>> וגם, אם אני לא רוצה צריך לעבור את כל תהליך של
יורד לתוך הספרייה ו הסרת כל קובץ בודד, RM,
מקף, RF, tmp2.
ועכשיו זה נעלם.
>> משהו להיות זהיר עליו הוא rm, מקף, RF.
וזה מפחיד אותי אפילו להקליד את זה, כי אם אני בטעות
על Enter או משהו.
אז rm, מקף, RF, טילדה היית, ללא מה שגרם לי, ו לא ינחה
לי, זה יהיה באופן אוטומטי להסיר ספריית הבית כולו שלי ו
כל אשר בו.
אז אתה עשוי לחשוב כי זה דבר טיפשי לעשות.
וכן, זה הוא.
>> אבל זה יכול לקרות בקלות רבה על ידי תאונה אם, נניח, אני רוצה להסיר
הקו הנטוי שלי, ספריית vhost.
ורק בהקלדה מהירה, אני עושה את טעות הזאת.
כי יסיר באופן רקורסיבי שני ספריית בית והספרייה vhost
בספרייה המיוחדת הזה שרק קורה שלא קיים כרגע.
אבל זה הייתי עדיין להסיר ספריית הבית כולו שלי.
לפחות בכך שלא f, זה יביא אותי קודם.
ואני אהיה כמו, אה, לא, אני לא רוצה לעשות את זה.
אבל אנשים, לוכסן, ובכלל זה שלי נוטה להיכנס
הרגל תמיד RF-ing.
אפילו קבצים רגילים שאני רק יכול RM, ג, אני נוטה פשוט rm, מקף, RF, ג.
רק להיזהר כשאתה RF-ing.
>> 4 SPEAKER: מה C עושה?
>> ROB: C הוא אני מדבר על שקובץ C מדבר במדריך זה, rm ש, ג.
>> יוסף: ויותר מסוכן, אם אתה משתמש כוכב, הוא מתייחס לכל דבר ב
המדריך.
אז מה שאני בדרך כלל נוטה לעשות הוא אני להיכנס לספרייה ואני רוצה
להסיר את כל הקבצים שם.
אז rm, מקף, RF, כוכב.
>> ROB: כן.
Rm, מקף, RF, כוכב.
>> יוסף: אם אתה לא זהיר ו מה בספרייה אתה ב--
אני לא היה בזמני, אבל אני היה בטעות בספרייה הבית שלי,
אז אני להסיר את כל מה בספרייה הבית שלי.
ובאמת עשיתי את זה בעבר, ו אני חושב שעשית את זה לפני או
ג'יי עשתה את זה בעבר.
>> ROB: אני כבר הוסר בטעות -
כך להתעלם מפקודה שקצת.
>> יוסף: לא כיף.
>> ROB: אז בספריית bin הקו הנטוי הוא חבורה של קבצים בינאריים שבו יש עוד
יהיה מוכרים אלה כמו צלצול.
ובכן, מצלצל ובעצם כל אלה דברים שאני מפעיל בפקודה
קו הוא בספרייה bin קו נטוי זה.
>> יוסף: כמו ls הוא כאן.
>> ROB: אז נקודה, לוכסן, ls הייתי רשימה בספרייה זו.
>> יוסף: חדר גם הוא בספרייה זו.
>> רוב: יש לי RM טעות, בן RF-ed, אשר הסיר כל פקודה שאני יכול
אולי אי פעם תרצה.
אשר לאחר מכן אני פשוט להתקין מחדש מכשיר חדש בשלב זה.
>> יוסף: אז להיזהר מאוד בעת שימוש בפקודה זו.
>> קהל: [לא ברור]?
>> ROB: כן.
זה גם הרגל רעה להיכנס.
אם תשימו לב, אני עכשיו -
כן, אתה לא יכול להבחין בכך, אבל זום בי אולי יכול.
אז אני עכשיו @ שורש מכשיר.
אז jharvard הוא המשתמש שאנחנו רוצים לך להיות תמיד משתמש בה.
שורש הוא המשתמש שיש לו הרשאה לעשות כל דבר.
>> אז שם לב כשאני jharvard, אם אני מנסה cd -
מה במדריך זה?
אה, שורש הוא דוגמא טובה.
אז cd, שורש.
הרשאה נדחה.
כי אם אנחנו מסתכלים על רשימה זו -
ושוב, אין לך לגמרי מבין את זה.
אבל שלושת המקפים האלה אומרים שלא נותנים לכל דבר אחר
משתמש לתוך ספרייה זו.
והספרייה שקורה לי להיות בבעלות שורש משתמש.
>> אז העובדה שאני jharvard ולא זה שהוא לא שורש מותר ל
במדריך זה, זה אומר שאני הולך לקבל רשות נדחתה כש
אנסה cd לתוך זה.
לכן, כאשר אני שורש, יש לי אישור לעשות שום דבר, כוללים
למחוק קבצים חיוניים למכשיר ו
להרוס את הדבר כולו.
>> כך שזה הרגל רע להיכנס רק שיטוט שלך
מערכת הפעלה כמו שורש.
אני עושה את זה בכל מקרה.
שאלות?
ואני לצאת שורש, להישאר כjharvard.
על אישור.
>> פקודות רלוונטיות יותר.
אז חוזר לטמפ 'שלנו, MV הפקודה עומדת על מהלך.
באפשרותך להעביר.
עכשיו אנחנו רוצים לקרוא לזה ב, אז עכשיו קורא לזה ב.
או שאולי אנחנו רוצים לעבור ב מדריך אחת.
אז עכשיו ריק של ספרייה זו.
אני אחזור לספריית הבית שלי, ו אנו רואים כי ב הוא בפה, כי
ספריית הבית הייתה ספרייה אחת מעל הספרייה שב הייתה פנימה
>> יש גם cp.
אז cp הוא להעתיק קטע סופר, נקודה, טקסט.
אני יכול לקרוא לזה, נקודה, טקסט.
עכשיו יש לנו שני הסעיף סופר, נקודה, טקסט; וים, נקודה, טקסט.
זה עובד גם בספריות.
אני RF-ed קובץ יחיד.
אז cp -
טוב, קודם בואו ננסה cp, tmp, tmp2.
אז השמטת tmp ספרייה.
כל כך דומה ל RM, התנהגות ברירת המחדל הוא לא לעבוד בספריות.
>> ושוב, בדומה ל RM, ברירת המחדל התנהגות - טוב, מקבל אותו לעבודה
עם ספריות הוא, מקף-r משם.
אז להעתיק באופן רקורסיבי הזמני מדריך לtmp2.
וכך יש לנו עכשיו שני tmp וtmp2, וזה לא שמועיל מאז tmp
היה ריק במקום הראשון.
Tmp2.
>> עכשיו בואו להעתיק tmp לtmp2.
ואנחנו רואים שtmp2 יש גם את הקובץ , כי הספרייה ו
הכל בתוך כי מדריך הועתק.
וזה יכול להיות מועיל במידה מסוימת אם, תניח שאתה עובד
על בעיה להגדיר אחד -
או בעצם, ערכות בעיה מאוחר יותר הן אפילו יותר חשוב, כי יש
תהיה כל חבורה של קבצים ודברים.
>> אבל אתה רק רוצה, לשבריר שני, אתה כמו, בסדר, אני
הולך לנסות משהו אחר.
תן לי רק להעתיק כל pset1 מדריך לגיבוי pset1 כך שאם
אני בסופו של דבר דופק את דברים, אני יכול לחזור לספריית הגיבוי שלי.
ישנן דרכים מתאימות יותר של גרסאות גיבוי הקוד שלך, אבל
זה תמיד דרך מהירה רק כדי להפוך את בטוח שיש לך עותק של משהו
שאתה עומד לשנות.
>> אז הד הוא גם פקודה חד פעמית ש סוג של sillily פשוט להדפיס
שורת הפקודה בדיוק מה אתה רוצה להדהד.
אז הד היי.
אנחנו פשוט להדפיס היי.
הד שלום עולם.
אנו נדפיס hello world.
שנכנס לשימוש בעת להתחיל שילוב פקודות.
>> ושוב, לא מצפה ממך לגמרי מבין את זה עדיין, אבל זה
משהו לראות.
ואז אם אתה Googling עבור דוגמאות או שאתה מבין שאתה רוצה לעשות
משהו, זה יכול להיות מועיל.
אז בואו, כדוגמא, כך ls, מקף, אני.
אז הנה אני רואה את הפלט של ls, מקף, אני.
ואני אומר, אוקיי, אני רוצה לאחסן את זה בקובץ.
כל פלט זה כאן, אני רוצה לשים לקובץ נפרד.
>> אז זה קצת יותר מאשר סמל זה מה שאנחנו הולכים לקרוא.
אנחנו הפניית פלט לקובץ.
בואו לקרוא בלה הקובץ, כי זה מה שאני נוטה תמיד קורא לזה.
אז עכשיו אנחנו רואים שיש לנו להגיש בלה ממש כאן.
ואם אני פותח אותו, אני תראה את זה הפלט בדיוק מהפקודה
כי אני פשוט רצתי.
ובאופן דומה, אתה יכול -
אם זה היה פלט לקובץ, זה הוא לקבל קלט מקובץ.
מהי הפקודה שאני -
>> יוסף: אני חושב שאתה יכול להשתמש פחות או יותר, כנראה.
>> רוב: אבל מה לגבי רק פחות בלה?
אני לא יודע.
אם אתה בא לתרחיש זה, כמו יש psets שזה שימושי ל.
>> יוסף: אתה יכול צינור אותו להד.
צינור את הקובץ להד לראות את זה.
>> רוב: זה צינור.
>> יוסף: מצטער.
>> ROB: בסדר.
אז זה פלט לקובץ.
זה הוא מקבל את הטקסט מהקובץ ולמסור אותו לתכנית.
ותראה גם את הבחור הזה.
אז זה עושה את שניהם סוג של בבת אחת.
ובעצם, אני אציג את שני חדש פקודות רק כדי לעשות בו שימוש.
>> ההיסטוריה היא פקודה שימושית שהיא רק הולך להדפיס את הרשימה של
כל דבר שאי פעם להריץ שורת פקודה.
אז אנחנו רואים כאן את כל מה שיש לי כבר פועל כל הזמן הזה.
הרבה ls של.
>> ועוד פקודה שימושית היא grep כי מטרתו היא לחפש מעל
טקסט מחפש דפוסים, טוב, מחפש את מה שאתה
רוצה אותו לחפש.
וכן שימוש שימושי כאן הוא, למשל אנחנו רוצים לתפוס את ההיסטוריה.
ואני רוצה לחפש את הפקודות איפה אני - מה
שימושי אחד לחפש?
>> יוסף: [לא ברור]?
>> רוב: או בואו נחפש את כל נוגע, מכל סיבה שהיא.
אז זה מה שזה ייראה.
ואין לך לחלוטין מבין את זה.
אבל הרעיון הוא כאן, ההיסטוריה נותנת את אותו הפלט שהוא עשה כאן
איפה זה מדפיס את כל ההיסטוריה של כל מה שאי פעם לרוץ.
לאחר מכן, אנו עוברים את זה -
אז במקום להדפיס אותו למסך, אנחנו רוצים להעביר את זה ל
grep פיקוד המחפש כל המופעים של מילת המגע.
>> וזאת באמצעות השילוב הזה של היסטוריה כלים וgrep, אני יכול לראות, בסדר,
הנה כל הפקודות יש לי אי פעם לרוץ, והנה אחת משותף במקצת.
אנחנו בתחתית.
וזה גם נותן לי את הפקודה אני פשוט רצתי כי הייתי לי
מילת מגע בו.
אבל הצינור הוא דבר די שימושי לשילוב מספר רב של תוכניות.
ובעצם, זה קיצור לבואו שלי היסטוריה פלט להגיש בלה, ו
תן לי grep באמצעות בלה הקובץ כמו מה שאני רוצה להסתכל למעלה.
אז הצינור הוא פשוט קיצור דרך לשתי פקודות אלה.
כן.
>> 4 SPEAKER: [לא ברור]?
>> ROB: כן.
מה הוא -
אה.
בואו לבדוק.
אז חתול, כלב, דגים.
אז אני רוצה grep.
דאש, r, שוב, הולך להיות באופן רקורסיבי, כך אני רוצה לרדת למטה
כל הספריות.
אני רוצה grep באופן רקורסיבי לכל - ותן לי באופן זמני לקבל
את זה בדרך.
להתעלם ממני.
על אישור.
>> אז אני רוצה grep באופן זמני עבור כל המופעים של מילת הדגים.
ואז הנה מה שאני עושה הוא grepping באופן רקורסיבי למילה הדג.
וכוכב אומר על כל אלה קבצים בספרייה זו.
ואז זה נתן לי הרשאה נדחתה, משום שהוא אינו רשאי לקרוא את זה
קובץ מסוים.
אבל זה מצא דגים בקובץ, המבחן.
>> גם אני יכול לומר, באופן ספציפי, אני רק רוצה להיראות בבלה הקובץ, ב
ומקרה זה לא מצא שום דבר.
אני רוצה רק להסתכל בקובץ, המבחן.
זה יהיה למצוא דגים.
כלומר הפקודה די שימושית לדעת באופן כללי.
יש כמה חלופות לgrep שאמורים להיות יותר
מתכנת ידידותי, אבל אני נוטה עדיין ליפול על גב grep.
שאלות?
על אישור.
>> האם יש פקודות אחרות?
אה.
רק אחד חד פעמית שאני תמיד מוצא להיות כיף קאל.
אז שם לב כשאני בזה יפה מצב של מסך מלא, אין לי דף כמו
סרגל כלים או כל דבר.
אז קאל רק נותן לי קטן ונחמד לוח שנה זה נכון
החברה מנותקת, אני מניח.
אבל פקודה קטנה ונחמדה.
>> יוסף: זה [לא ברור].
פקודות אחרות שאולי יש לך ראיתי כולל צלצול ולעשות.
אנחנו נלך עליהם ב פירוט בהמשך.
אבל אם אתה כבר עובד על PSET, אתה צריך להיות
מכיר את אלה.
>> ROB: בסדר.
שאלות על דברים שורת הפקודה?
בסדר.
אז בואו נעבור לכמה דברים הקשורים ל-C.
מתמטיקה משתנים.
על אישור.
אז בדיוק כמו שהיו לנו במתמטיקה בגרד, אתה יכול גם להשתמש במתמטיקה ב C.
>> לפני שנגיע לזה לגמרי, כל כך משתנה.
זכור כי כל פעם שמצהיר משתנה כמו int x או y לצוף, אתה
צריך לתת לו להקליד לפני השם המשתנה.
אז סוגים שראינו עד כה הם int, לצוף, כפול, ארוך ארוך, שבו אני
לא ממש יודע אם יש לנו ראה את זה עד כה.
>> יש כמה כאלה אחרים.
אנחנו כבר רואים את התו.
יש קצר, שזה כמו שזה ההפך מארוך ארוך שבו זה
קטן יותר ממספר שלם.
ראינו גם מחרוזת.
אז מה מיוחד במחרוזת?
למה אני הייתי אומר שזה לא בדיוק כמו int?
>> 4 SPEAKER: זה לא באמת קיים.
>> ROB: כן.
אז הסיבה היחידה שיש לנו מחרוזת משום שכאשר אתה עושה
חשיש, כולל cs50.h.
ואנו רואים דוגמאות לכך בהמשך - אה, זה לא להתמודד עם זה היטב -
בי cs50.h עושה משהו לאורך הקווים מסוג
def, כוכב char, מחרוזת.
>> ואז זה אומר שאנחנו אפילו לא יודע מה כוכב char הוא עדיין.
אבל זה אומר שאנחנו רוצים מחרוזת.
כל מקום שאתה כבר משתמש מחרוזת, אתה ניתן היה באמצעות כוכבים char,
אשר למעשה הוא סוג ש קיים בשפת C.
אבל אנחנו עוד נגיע לזה.
אה, וזה הולך ימינה בחזרה.
מסודר.
>> אז אותו דבר עם bool שבו אמת ושקר.
כי הוא לא באמת סוג מובנה בג במקום זאת, זה פשוט, זה צריך
ערך אפס?
אז אנחנו פשוט רואים זה יהיה שקר.
האם יש לזה ערך -
כן, זה צריך כל ערך שאינו אפס?
אז נשקול את זה כדי להיות אמיתי.
אז אחד הוא נכון, שתי נכון, כל דבר שאינו אפס הוא נכון.
אז מי הם אותם.
שאלות על משתני הכרזה ו סוגים משתנים וכל זה?
כן.
>> 4 SPEAKER: במשך זמן רב זמן רב, בספר, הוא אמר שזה היה צריך להיות int הארוך ארוך.
אבל רק ארוך ארוך יעבוד?
>> ROB: אז מכפילי סוג אלה.
אז int x.
אז אנחנו גם יכולים להגיד x int חתום.
אנחנו יכולים לומר x int הקצר.
אנחנו יכולים לומר ארוכים ארוכים int x.
אבל פחות או יותר את כל הדברים האלה אני רק אמר, int חתום, int הקצר,
ארוך ארוך int, אתה יכול להיפטר int וזה יהיה פשוט להניח
שהתכוונת int.
x אז לא חתום, שרק אומר -
אתה יודע איך בדרך כלל עם int, אתה יכול להגיד x שווה 3 שליליים?
עם int חתום, אתה לא יכול.
>> יוסף: ושוב, למצלמה, השאלה הייתה, מה ההבדל
בין int הארוך הארוך ורק ארוך ארוך?
>> ROB: כן.
אז אני כמעט אף פעם לא לכתוב ארוך int הארוך.
אני אכתוב עוד ארוך.
>> יוסף: יש שאלות?
>> רוב: אישור.
תזכורת קטנה כל כך מטופשת של ככה אנו מכריזים על משתנה ולאתחל
משתנה ולהכריז אחר משתנה ולאתחל
את כל זה בצעד אחד.
אז ההכרזה על משתנה ו משתנה האתחול אין לי
לאבל יכולה להיות באותה השורה.
>> אז יש לנו מפעילי מתמטיקה סטנדרטיים שאתה רגיל -
פלוס, מינוס, חילוק, פעמים.
יש גם מודולו, שבו אנו נראה.
אין, לפחות ב C, מתח מובנה
מפעיל קארה העלאה בחזק.
ובכן, יש מפעיל קארה, אבל זה לא כוח.
>> יוסף: אבל זה לא העלאה בחזקה, כן.
>> ROB: אל תשתמש בסימן הכניסה להניח שזה אומר
כמו בריבוע או משהו כזה.
אז כמה דברים שכדאי חשוב על החלוקה.
אני אעמוד.
אז הכריז תשובה לאתחל.
אז אנחנו אומרים תשובה לצוף שווה 1 מחולק ב10.
הדפס תשובה לשתי ספרות אחרי נקודה עשרונית.
>> וזה מסוג הדברים שאני יאייש printf כדי להבין כי
מה לעזאזל עושה%, נקודה, 2f אומר?
וזה רק אומר, טוב, התעלמות 0.2.
ו%, f היא מה שאנו משתמשים להדפיס לצוף.
0.2 אומרים, הדפסה ש לצוף לשני מקומות אחרי נקודה עשרונית.
אז תכנית זו יש באג, ואתה עלול ראיתי את זה בעבר בכמה
כמובן CS קודם.
אבל מה הוא באג ש?
>> SPEAKER 5: אפס.
>> ROB: כן.
לכן, כאשר אנחנו אומרים, תשובה שווה 1 מחולק ב10, אנחנו רוצים
תענה להיות 0.1.
אבל 1 מחולק ב10, הוא 1 מספר שלם, 10 הוא מספר שלם.
וכך, כאשר אנו עושים מספר שלם מחולק שלם, אנחנו הולכים לחזור
מספר שלם.
אז 1 מחולק ב10 הוא 0.1.
>> מאחר שהוא צריך לתת לנו מספר שלם, זה רק הולך לזרוק כי
מקום עשרוני ולומר כי התשובה היא 0.
ולכן כאשר אנו עונים כאן להדפיס, זה הולך להדפיס 0.00.
>> יוסף: ולא רק כהערה, זה ממש זורק מה שאחרי
נקודה עשרונית.
אז אם אתה במקום היה 6 מחולק ב10, אולי אתה חושב שזה היה נותן לך
0.6 ואז היית לעגל כלפי מעלה ל -1.
אבל בעצם, מה קורה כאשר הוא מקליד משימותיו היא שהוא יורד מה הוא
לאחר הנקודה העשרונית.
אז 0.6 הופכים להיות 0.
>> ROB: כן.
ואנחנו נגיד חתוכים לזה.
אז בכל פעם שאתה מטיל לint, העשרוני מקוצץ.
אז את התיקון לזה - יש בעצם שתיים.
ואני הולך לעשות את השנייה, כי זה אחד הוא תיקון הרבה יותר קל.
>> אז תיקון אחד הוא להשתמש צף בחטיבה.
ובאמת, יש לך רק כדי להפוך את אחד מהם לצוף.
אבל זה ברור יותר במידה מה רק כדי להפוך את שניהם צף.
אז 1.0 מחולק 10.0 הוא חלוקת שני מצופים.
אז התשובה תהיה בסופו של דבר להיות לצוף, וכך תוכלו
נכון להדפיס 0.10 כאן.
>> משהו שלא עובד כל כך טוב על זה הוא, ובכן, בטח, זה היה קל
מספיק כדי להמיר 1 עד לצוף בכך שהוא 1.0.
אבל מה אם במקום שהיו לנו שני מספרים שלמים כמו int x שווה y 1 ו int
שווה 10, ולאחר מכן אנחנו רוצים לעשות x מחולק בy?
כך שזה לא קל פשוט לעשות x.0 או משהו.
>> אז את התיקון לזה הוא ליהוק.
אז ליהוק הוא דרך ב-C להמיר מסוג משתנה אחד למשנו.
אז הנה, 1 הוא מספר שלם.
ועל ידי הצבת מצוף זה מול את זה, אנחנו מטילים 1 למצוף.
ואז זה יהיה להמיר 1 עד 1.0.
וזה יהיה להמיר 10 ל10.0.
>> ואז דברים מתנהגים באופן דומה ל גרסה קודמת רק הראינו
שבו, כצפוי, אנחנו מקבלים 0.10 וזה יהיה להדפיס את זה.
ואנחנו יכולים לעשות את זה עם משתנים, יותר מדי.
אז אנו יכולים לומר, x לצוף מחולק על ידי y לצוף.
>> יוסף: יש שאלות?
>> ROB: אז בדיוק כמו במתמטיקה רגילה, יש לנו עדיפות על מפעיל.
אז בשיעור מתמטיקה, אתה צפוי לקרוא לזה סדר פעולות.
כאן, המונח הרשמי הוא קדימות מפעיל.
אבל קדימות המפעיל, או רוב מפעילים, הוא כפי שהיית מצפה.
>> אז בדיוק כמו במתמטיקה, 2 פעמים 10 הוא הולך להיות מקובצים באופן הדוק יותר מאשר
10 זה מחולק על ידי 2 ולאחר מכן 2.
סדר פעולות, הוא יעשה 2 פעמים 10, 10 מחולקים לפי 2, ולאחר מכן
זה יעשה 20 עוד 5 ועוד 2.
אז זה כצפוי, ואתה יכול להשתמש בסוגריים כדי ביטויי קבוצה.
אתה לא יכול להשתמש בסוגריים מרובעים לביטויי קבוצה.
כן?
>> SPEAKER 5: האם אתה יכול באמת פשוט לחזור שנייה אחת?
האם אתה יכול להטיל int למחרוזת?
>> ROB: אז ב-C, אתה יכול להפיל כל דבר אתה רוצה מה שאתה רוצה.
זה לא אומר שזה דבר טוב לעשות.
לכן, כאשר אתה מטיל int כדי מחרוזת, שפירושו -
ואנחנו נגיע לזה הרבה יותר ביסודיות -
>> יוסף: הרבה יותר מאוחר.
>> רוב: אני לא רוצה להגיד הרבה יותר מאוחר, אז ניסיתי לשנות את המשפט שלי.
אנחנו נגיע לזה הרבה יותר ביסודיות מאוחר יותר שבו באמת כאשר יש לך
משתנה מחרוזת -
כך מחרוזת יכולה להיות באופן שרירותי ארוך, נכון?
ואנחנו אומרים את זה כבר int הוא ארבעה בתים וארוכים ארוך הוא שמונה
בתים ולצוף הוא ארבעה בתים.
אז מחרוזת, בדיוק כמו int, רק יש מספר מסוים של בתים אליה.
ושיהיו ארבעה בתים.
>> אבל מחרוזת יכולה להיות די ארוך באופן שרירותי, נכון?
אז שלום עולם כבר, אם זה 10 תווים או משהו כזה, זה כבר
הולך להיות מעל 4 הבתים אני יכול להתאים למחרוזת.
ואז איך מיתרים באמת עובדים הוא כי הם שבו בזיכרון מחרוזת
נשמר.
>> וכן כאן, כשאני אומר x המחרוזת שווה עולם שלום, חלק פנימי של x הוא
רק אומר, הו, שלום העולם מאוחסן במקום המסוים הזה בזיכרון.
אז אם אנחנו מנסים להפיל שלמים כדי מחרוזת, אז אנחנו מנסים לפרש
כמה חלק מזיכרון אקראי כמחרוזת.
וזה כמעט תמיד שובר דברים.
>> יוסף: אבל אם מבלבל כי לך, אנחנו נהיה כיסוי זה
יותר לעומק מאוחר יותר.
>> ROB: כן.
זה מקום בו אתה הולך להיכנס למצביעים.
וזה הוא נתח משמעותי שבועיים של קורס זה.
>> SPEAKER 6: האם זה עובד כמו אובייקטים בשפות אחרות, או לא ממש?
>> ROB: אז בשפות, חפצים אחרים יהיה מיוצג על שימוש במצביעים.
למרות שזה לא אותו הדבר,.
כל מחשבות?
>> יוסף: לא.
לא מחשבות.
>> רוב: אישור.
>> יוסף: בשלב הבא.
>> ROB: פשוט ללכת עם זה.
בסדר.
אז מודולו.
בדיוק כמו שיש לנו בתוספת, מינוס, לחלק ולהכפיל.
אז מודולו הוא אחד שאתה יכול לא ראה בעבר.
וזה רק אומר, תן לי שלי את יתרת.
אז 55% 10.
שארית עושה 55 מחולקת על ידי 10 יהיו 5.
אז 55% 10 הוא 5.
ו -3% 5 יהיו 3.
8% 8 יהיו 0.
16% 15 יהיו 1.
>> יוסף: דבר אחד לציין עם זה, גם זה זה לא יכול לעבוד כצפוי
אם אתה משתמש במספר שלילי.
5% אז שליליים 4, חלק מאנשים עלול לחשוב שהוא -
מה היית חושב שלילי 5% 4 יהיו?
>> SPEAKER 5: אחד.
>> יוסף: אז יש אנשים שאומרים אחד, יש אנשים שאומרים שלילי אחד.
אבל מה -
>> ROB: אני אפילו לא צריך אמר אחד מהם.
>> יוסף: שני, מצטער.
יש אנשים שאומרים -
>> ROB: שלוש.
>> יוסף: שלוש?
>> ROB: שלילי -
מה שהיה - חמש שלילי -
>> יוסף: שלוש, שלוש, שלוש.
סליחה.
בגלל מודולו, בדרך כלל, כאשר יש לך ראיתי את זה במקומות אחרים, זה בדרך כלל אומר
להחזיר מספר חיובי, נכון?
>> ROB: לכן, כאשר אנו אומרים במתמטיקה, 10% ב, הם נוטים רוצים לתת לך -
אם אנחנו mod ידי 10, אז אנחנו מצפים מקבל מספר בין 0 ל 9.
בפה, שזה לא המקרה, כי אתה יקבל חזרה מספרים שליליים.
>> יוסף: 5% אז שליליים 4 יהיו שליליים 1.
>> רוב: אבל זה נדיר שאתה mod-ing מספרים שליליים מלכתחילה.
דלגתי על זה.
>> יוסף: כן.
>> ROB: Meh.
על אישור.
אז דבר אחד אחרון כדי להצביע על צף הוא זה התנהגות מסוכנת,
אבל צף לא מדויק ייצוג.
אז חוזר לבתים שוב, זכור כי int הוא תמיד ארבעה בתים ו
מצוף הוא תמיד ארבעה בתים.
אז הדוגמא של לוקאס היא די טובה.
>> אז תחשוב על 1 חלקי 3.
אז .3333333.
אם יש לי רק 32 ביטים, איך יכול אני מאחסן .33333 בדיוק?
ואולי, מכל סיבה שהיא, אתה אומר, בסדר, טוב, בואו נגיד
ש1011001 מסוימים הזה, בואו רק אומר שצריך להיות .333333.
ובכן, יש לך רק מספר סופי של ביטים אלה, כך שזה בלתי אפשרי
מייצג כל אחד ונקודה צפי הערך נתון רק 32 סיביות.
>> ובכן, אי אפשר לייצג את כל נתן ערך נקודה צפה אינסופי -
כן, בהתחשב בכל מספר סופי של ביטים.
אז הבעיה כאן היא, ובכן, כאשר אנו משמשים כדי להדפיס על שני מקומות אחרי נקודה עשרונית,
אנחנו בצורה נכונה לא לקבל את התשובה 0.10.
אבל מתחת למכסת המנוע, זה ממש יאוחסן קרוב ככל האפשר ל
0.10 כמו פיסות אלה יכולים לייצג.
האם זה בשקופית הבאה?
או שזה לא?
>> יוסף: כן, זה עד כדי כך.
>> ROB: Blegh, blegh.
>> יוסף: כן, אתה יכול פשוט למשוך את ההערות קצת.
>> ROB: אני רק הולך לזום על שעבר על זה.
אוי ואבוי, זה [לא ברור].
אז את המספר הזה.
זה מה שיודפס אם אנו מפעילים תכנית זו.
ושים לב שזה לא ממש ביג דיל אם אנחנו אכפת רק כמו
02:58 מקומות אחרי נקודה עשרונית.
כמו שרק נדפסו במקור 0.10, ובגלל זה אנחנו לא ראינו שום דבר לא בסדר.
אבל ברגע שאנחנו מתחילים להיכנס מדויק, מספר מדויק שזה
מייצג, אנו רואים כי אין בו בדיוק מייצג 0.1.
>> וחלק מהבעיה כאן הוא כמו, בסדר, זה בסדר, אבל, טוב,
ראשון, מה אם מה שניסינו לעשות, תשובה שווה שווה 0.1?
האם זה הולך להחזיר אמת או שקר?
ולכן קשה לומר.
אני חושב שזה ממש יכול לחזור נכון.
זה יהיה ראשון -
אני לא יודע.
התשובה היא ברגע שאתה מתחיל התמודדות עם ערכי נקודה צופה, אתה די
הרבה לא צריך להיות באמצעות שוויון בגלל חוסר הדיוק הזה.
>> ולכל מה שאתה יודע, זה מאית מקום עשרוני כי
נקודה צפה לא הייתה מסוגלת כדי להתמודד בצורה נכונה.
וכך השוויון יהיה פשוט להיכשל אפילו למרות המספר - אם היית
שימוש במספרים מדויקים, המספרים צריכים היה בדיוק אותו הדבר.
זה במהלך 50 כמו חישובים באמצעות צף אלה
ערכי נקודה, השגיאה יכולה לבנות מעלה מעלה ומעלה, ו
דברים פשוט לא נכונים.
>> יוסף: והיו באמת דוגמאות המפורסמות של זה קורה.
כמו מהנדסי נאס"א מקבלים את זה רקטות הלא נכונות, וגרמו להתפוצץ ב
האוויר אחרי שהם כבר יצאו לדרך.
והרבה נושאים כאלה.
אז כן.
>> SPEAKER 6: כשאתה אומר 0.3 f, זה לחתוך את השאר?
או שהיא לעגל כלפי מעלה או כלפי מטה?
>> ROB: האם printf בסיבוב זה?
>> יוסף: אני חושב שחותך printf.
>> רוב: אישור.
אז אנחנו יכולים ללכת באופן דומה את ההפך כיוון שבו זה, במקרה הזה,
הכי קרוב זה יכול לייצג 0.1 היו עם מספר זה.
הכי קרוב זה עלול להיות מסוגל מייצגים 0.2 הוא בהפך
כיוון, .199999996356 או משהו.
אז אם הלכנו בכיוון זה של דברים, אז f 0.3 printf יחזרו
1.99 במקום 2.00.
>> יוסף: ואני לא לגמרי בטוח בזה.
אולי אתה רוצה לכתוב קטן, קטן תכנית רק כדי לבדוק את זה.
>> ROB: אמנם, מה שאנחנו בטוחים כי אם ניסית להטיל של
int, והליהוק לint הולך לגרום לו לחתוך העשרוני, אם
אתה מנסה להטיל 1.9999999 לint, תקבל 1.
ואז אתה צריך בדרך כלל להשתמש פונקציה עגולה בספריית המתמטיקה.
שאלות?
על אישור.
>> יוסף: אז נע על תנאים וביטויים בוליאנית.
אז שראית אלה בעבר.
ובאמת, תן לי לעשות את שלי בטוח מחשב הוא בפורמט הנכון כאן.
חלל.
מצטער, אנחנו הולכים צריכים להתמודד קצת עם חיתוך בקצוות.
>> אבל כן, אתם ראיתם זה לפני בגרד.
אז זכות זו כאן היא ביטוי אשר משמש
הצהרה על תנאי.
אז תענה גדול מאפס רצון להגיד לך אמת או שקר.
ואלה הם באמת חשובים, כי הם מאפשרים לנו להציג את
היגיון לקוד שלנו.
>> כך למשל, מדובר בתכנית נכתב בסריטות ששואלת את המשתמש
למספר שלם ואומר להם אם השלם שהם נתנו לך היה
מספר חיובי או שלילי.
והמרה כאן כדי לראות היא תדפיס ראשון מתוך ההצהרה,
תן לי את מספר שלם.
ואז אתה שואל אותם למספר שלם.
>> ולאחר מכן אתה משתמש בהיגיון מותנה מעל כאן כדי לבדוק אם המספר הזה
היה ממש גדול מאפס או לא.
אז הנה יש לנו ביטוי בוליאני בתוך מותנה אם הצהרה.
האם יש שאלות?
האם יש שאלות על זה?
על אישור.
>> אז יש יותר מסתם גדול יותר מאשר, כמובן.
אתה יכול לבנות ביטויים בוליאנית באמצעות רוב מיני דברים שאתה
היה חושב במתמטיקה.
אז גדול יותר.
זה צריך להיות פחות מ.
סליחה.
ואת המרווח.
>> ROB: החס וחליל שאתה עוזב אותו.
>> יוסף: בסדר.
אז גדול יותר, פחות מ, גדול יותר מ, או שווה, פחות
מ, או שווה ל.
אנו משתמשים בשווים כפולים כדי לבדוק שוויון, משום שאחד שווה לאמצעי
משימה, נכון?
כן.
ואז אנחנו יכולים גם לא שווים על ידי שימוש בסימן קריאה, שווה.
>> וסמל סימן קריאה זה יכול להיות גם מורחב, כך שאם אתה רוצה
כדי להפוך כל סוג של בוליאנית ביטוי, אתה יכול לעשות את זה.
אז זה יהיה TRUE רק אם התשובה היא פחות
או שווה לאפס.
כל שאלות על זה?
על אישור.
>> אז אתה יכול גם לשלב הבאים ביטויים באמצעות הגיוני ו
לוגי או.
אז זה רק הסמל ו, שאמור להיות Shift, 7.
וזו היא סמל הצינור, שהוא לא באותיות קטנה ל 'זה אחד
זה ממש מעל מקש Enter שלך.
אז אתה משתמש בשני אלה כדי לסמל הגיוני והלוגי או.
>> אז זה רק יחזיר true אם תשובה אחד, שתיים, שלוש, או ארבעה.
וזה רק יחזיר true אם תשובה הוא מעבר לזה משני הצדדים.
כך שזה לא אחד, שתיים, שלוש, או ארבעה.
והדרך היית להשתמש כי בביטוי -
>> ROB: או אפס או חמש.
>> יוסף: אפס או חמש.
סליחה.
כן, כן, כן.
על אישור.
והנה עכשיו, באותה הדרך שאתה הייתי להשתמש בביטוי זה, קטן יותר
ביטוי בצד של אם מותנה הצהרה, שהיית גם להשתמש בו
אותה דרך רק על ידי לשים את זה בתוך הסוגריים של ההצהרה אם.
אז printf זה יהיה רק ​​אש אם תשובה אחד, שתיים, שלוש, או ארבעה.
כל שאלות על שילוב ביטויים?
>> אז יש עוד תנאי לבנות האנחנו קוראים אם / אחר.
כך שלמעשה, זה עכשיו פירושו, אוקיי, אם משהו שאני רוצה לבדוק שלא היה
נכון, ואז ללכת לעוד ו לבצע את אותה פעולה אחרת.
אז במקרה הספציפי הזה, שאלתי את המשתמש למספר שלם.
האם השלם גדול מאפס?
כן?
טוב, אז הם הרימו מספר חיובי.
אם לא, אז זה חייב להיות היה שלילי או אפס.
אז בחרת מספר שלילי או אפס במקרה זה.
כן.
או אפס.
>> ולאחר מכן יש לנו גם אם / אחר, אם ואלזה.
אז זה מאפשר לנו לבצע רצף של דברים רק אם הראשונים להיכשל.
אז במקרה הזה, עכשיו אנחנו עושים האחרון שאתה בוחר לאפס.
אז אם הם לא הרימו חיוביים ולא מספר שלילי, אז הם חייבים
יש הרים אפס.
אז זה פשוט יורד שרשרת כמו זה.
>> אז דוגמא לאופן אם הוא שונה מ--
אם / אחר שונה מ רק רצף של IFS.
וזו היא שאלה נפוצה ש אנשים שואלים אותו, כן, אם אתה מקבל כמו
95 בCS50, מה יהיה זה תכנית אומרת לך?
>> SPEAKER 5: יש לך א
>> יוסף: כן.
יש לך כל אחד אחד מאותם הנכונים.
יש לך, יש לך ב ', יש C ו D, נכון?
אז כל אלה מקבלים מוערכים לפי סדר.
אז בזמן ש95 גדול מ 90, זה גם גדול יותר מ80, זה גם
יותר מ -70, וזה גם גדול יותר מ60.
אז יש לך את כל הציונים האלה.
ואני מניח שהיית עושה רק רוצה א
>> הדרך לתקן את זה היא להחליף בעלי / של אם אחר.
אז בתרחיש זה, שהוא רואה ש95 הוא יותר מ 90, ולאחר מכן הוא עושה
לא להעריך את שאר של הדוחות.
כל שאלות על זה?
>> אז יש עוד סוג מותנה של מבנה שיש לנו כאן שאנחנו
קורא לשמירה על מתג.
אז זה מאפשר לך בעצם לבדוק מה הערך של מספר שאתה מכניס
לשמירה על המתג.
אז בתרחיש זה, אנחנו מיתוג על n, ושאנחנו אומרים, או, אם n הוא
אחד, ולאחר מכן להדפיס את האמירה הזאת.
ואז לשבור, מה שאומר שיציאה מתוך שמירה על המתג.
>> אם זה לא היה אחד, אז, טוב, רק סופו של דבר לבדוק את כל המקרים הללו.
וכך הוא בודק אם זה אחד או שתיים או שלוש, והיא מדפיסה בהתאם.
ומה מילת המפתח ברירת מחדל זה כאן למטה אמצעי הוא אם הם לא להיכנס לכל
של אלה, ולאחר מכן אומרים לא חוקיים.
אז בואו נגיד שאני שואל עבור n ו המשתמש נותן לי ארבעה.
ובכן, זה תואם אף אחד מהמקרים האלה, כך שזה יהיה להדפיס את מה שיש ב
סעיף ברירת מחדל.
כן, שאלה?
>> SPEAKER 5: האם אתה יכול להשתמש בוליאנית ביטויים במקום
אחד, שתיים, או שלוש?
>> יוסף: אז השאלה היא האם אתה יכול להשתמש ביטויים בוליאנית במקום אחד,
שני, ושלוש?
ובC, אני מאמין לך לא יכול לעשות את זה.
אבל בשפות אחרות, שאולי לך נתקל בסוף
סמסטר כמו JavaScript, אתה יכול.
ובכן, היית צריך לחשב ראשון ערך זה ולאחר מכן להשתמש בו ב
לעבור הצהרה.
כן?
>> ROB: אז חלק מהיתרון של מתג ההצהרות היא לחשוב על אם אתה עשית את זה
כאם / אחר, אז כמו שאם n שווה שווה לאחד או משהו כזה.
אחר / אם n שווה שווה שתיים, שיהיה.
אחר / אם n שווה שווה שלוש.
לכן דרך התכנית תרוץ זה רצף היה יורד רשימה
ולבדוק, הוא n אחד?
לא ולא.
האם n שתיים?
לא ולא.
האם n שלוש?
כן.
לעשות את זה.
>> ואילו עם הצהרות מתג, זה תוכל למעשה לקמפל את זה כדי להיות
ממש מהר.
וברגע שזה אומר מתג, זה אומר, בסדר, n הוא שתיים, אני
מייד הולך לקפוץ למקום שבי אני אמור להתחיל בביצוע.
אני לא הולך לבדוק תחילה, הוא n אחד, הוא n שניים?
זה מייד יכול להתחיל לעשות מה שהוא אמור לעשות.
>> ובגלל זה, זה לא יכול לקחת תנאים בוליאני.
או אחר זה היית צריך לעשות רציף, כמו, בסדר, הוא n
גדול מאפס?
השאר הוא n גדול מ 10 או משהו כזה.
>> יוסף: במקרה זה, אם השתמש אם / אחר,, ולאחר מכן את המתג היית אם של
לרוץ שלוש פעמים כ מהר יותר, אם אם / אחר.
אנחנו יכולים לארגן את המתג בכזה אופן שבו אנחנו לא לשבור
לאחר כל אחד מהמקרים.
אז במקרה הזה, אני מחיצות מספרים שאנו בוחרים לאחד ו
שני לא להיות מספרים גבוהים ו שלושה להיות מספר גבוה.
>> אז במקרה הזה, אם n הוא אחד או שתיים, זה יפגע במקרה ואז זה יהיה
נופל דרך, כי אין הפסקה.
וזה יהיה סופו של דבר כאן.
אז אם אנחנו בוחרים אחד, הוא יעשה printf ואז לשבור כל כך שאף אחד
זה מבוצע.
וכמובן, אם הם נכנסים בשלושה או משהו אחר, ואז הוא ידלג
אלה ולא ללכת לשם, וזה יבצע במקום
מתאים קו.
האם יש שאלות על זה?
כן?
>> 4 SPEAKER: האם אתה מקבל הודעת שגיאה אם ​​אתה הייתה הפסקה אחרי מקרה אחד, אבל זה
לא היה לי משהו בשביל לעשות את זה?
>> יוסף: אז השאלה היא שאתה מקבל שגיאה אם ​​יש לך הפסקה לאחר
מקרה אחד, אבל אין מה לעשות?
והתשובה היא לא.
אתה לא ממש מקבל שגיאה.
כן, מ"מ הממ.
>> אז כמו סוג של שינוי קטן כאן, אני הולך לשים את printf כאן.
אופס.
אז מה זה הייתי להדפיס אם שמתי אחד כבקלט?
כן.
זה הייתי אומר לך שזה לא לקח מספר גבוה פי שתיים, נכון?
כי זה יפגע שבמקרה הראשון, זה לא ישבור, וזה היה נופל
עד למקרה השני.
כל שאלות על זה?
>> ROB: האם יש לך עוד שאלה?
>> יוסף: אוקיי, מגניב.
בסדר.
אז יש עוד משהו שאנחנו קוראים מפעיל משולש שהוא בעצם
תחביר חלופי לעושים אם ולאחר מכן אחר.
וזה מאפשר לך לעשות את כל זה בשורה אחת.
אז בתכנית מסוימת זו, אני שואל את המשתמש עבור n.
ואם n הוא גדול יותר מאשר 100, אני אומר לי שלהם הם בחרו מספר גבוה.
אחר אני אומר להם שהם הרים מספר נמוך.
>> אז אנחנו יכולים להשתמש בתחביר באמת הארוך הזה, מחרוזת, S, ולאחר מכן בדוק אם n הוא
יותר מ 100 ולהקצות אותו בהתאם.
אבל אנחנו יכולים לעשות את זה הרבה יותר תמציתי על ידי שימוש בתחביר מפעיל משולש זה
הכולל שאלה סימן ומעי גס.
אז סימן השאלה הוא במהותו שואל שאלה, נכון?
>> ROB: הגדלה אולי על זה.
>> יוסף: כן.
נקודה טובה.
אז זה המפעיל המשולש.
אני ראשון ששואל את השאלה, הוא n גדול מ 100?
אם כן, אז אני מבצע ראשון חלק לפני המעי הגס.
אם זה לא, אז אני מבצע חלק שני אחרי הנקודתיים.
אז אם n הוא גדול יותר מאשר 100, אז זה מרים גבוה ומעמיד
כי למחרוזת s.
אם n הוא פחות מ 100, זה מרים נמוך ואז מכניס את זה לתוך מחרוזת s.
אז זה יהיה לעבות נתח הגדול הזה למטה לתוך בדיוק את זה בשורה אחת.
>> SPEAKER 5: האם זה פופולרי?
>> יוסף: כן, זה הוא די פופולרי עבור דברים בו בעצם אתה רוצה
אין משימה המבוססת על איזה מצב.
ובמקרה הזה, אנחנו מנסים כדי להקצות ערך למחרוזת s.
זה לא כל כך -
אני מניח שאני לא באמת מעדיף שלה במקרים אחרים.
אבל זה שימושי במיוחד למשימה הזאת.
>> רוב: זה דפוס די נפוץ שבו יש לך קצת משתנים כי
אתה הולך לומר, אם משהו, להגדיר משתנה זה לערך אחד; אחר, שנקבע
משתנה זה לערך אחר.
וזה התרחיש שבו ישתמש משולש.
>> יוסף: ואתה שומר המון קווים, נכון?
וזה רק גורם קוד שלך לטעון קצת יותר קריא.
כן, שאלה?
>> SPEAKER 6: למשולש, אתה יכול ללכת, שווים של מחרוזת s, סימן שאלה?
ואז אתה יכול להיות, למשל, חמש אפשרויות שונות.
ותלוי מה מספר n היה, היית בוחר אחד מאותם?
>> יוסף: אז השאלה היא, האם יש סוג של תחביר שבו אתה יכול לעשות את המחרוזת
ים שווה n, ואז יש להם יותר משני אפשרויות לאחר שסימן השאלה?
ותשובה פשוטה היא לא, אין באמת דרך טובה לעשות את זה, אלא אם כן
אתה רוצה משולש מרובה קן מפעילים פנימיים של כל אחד אחר.
>> אתה יכול לעשות כמו n גדול מ 100, סימן שאלה, ואז עוד אחד
מפעיל משולש, n גדול מ 50, סימן שאלה, וקן זה ככה.
אבל בתרחיש זה, הקוד שלך הוא מקבל סוג של בלתי קריא ומבולגן,
וזה יכול להיות טוב יותר רק כדי ללכת ל הצהרה אם / אחרת בשלב זה.
>> רוב: וגם, כהערה צדדית, PHP באופן שגוי מיישם המשולש
מפעיל כזה שternaries המקונן אפילו לא עובד כמו שצריך.
>> יוסף: כן.
אז זה נהיה קצת מבלבל, במיוחד כשאתה הולך
לשפות שונות.
>> ROB: זה מבלבל מספיק, כי שפות טועים בקשר לזה.
>> יוסף: אז בעצם, רק כדי להבהיר, יודע כל מה ש
% S עושה כאן?
כל שאלות על זה?
אני מניח שרק בשביל המצלמה,% s בעצם מאפשר לנו לשים מציין מיקום
למחרוזת.
ואז בסוף, אנו מציינים כי משתנה שאנחנו רוצים לשים לזה
בעל מקום הוא ים.
אז זה לוקח ים בעצם וזה מכניס אותו לכאן.
ואז זה יהיה להדפיס, בחרת גבוה או שבחרת מספר נמוך.
על אישור.
>> אז לולאות נאפשר לך לבצע דברים בתנועות מעגליות, נכון?
ייתכן שנתקלת בכך ב שריטה בצורה של Forever לולאות
או חזור על הפעולה עד או חזור בפרט מספר פעמים.
אז למה זה טוב לנו?
ובכן, ב-C, נניח שיש לנו את זה שיר בוצע בגרד ש
שרה, זה השיר כי אף פעם לא נגמר.
זה פשוט נמשך ונמשך ו לעולם ועד.
ובכן, אתה לא באמת יכול לעשות את תכנית שיש מספר אינסופי של printf
הצהרות בזה, נכון?
>> אז בתרחיש מסוים זה, בדרך זו כי אתה יכול לעשות את העבודה הזאת ו
כדי להפוך אותו להדפיס לנצח הוא במקום להשתמש בלולאה בזמן.
אז לולאה בזמן שתבצע מה בגופם של שתי פלטות ה
שייך לזה על סמך מה התנאי הוא.
אז בדוגמא זו בפרט לפני, אם אנחנו רוצים להדפיס לנצח זה, מה
אולי אנחנו עושים?
טוב, ברור, נכון?
>> אז זה סוג של משלב את הרעיון של כמה ביטוי בוליאני
יחד עם לולאה.
ולמדנו על וליאנית ביטויים קודם לכן.
אז בכל פעם שמצבו הפנימי של בעוד שנשאר נכון, לולאה זו
יבצע על ועל ועל.
ובמקרה זה, אם אנחנו רק מספקים אותו עם זה נכון, זה גורם אינסופי
לולאה שמדפיסה את השיר הלאה וכן הלאה ועל כמו שאנחנו רצויים לפני בלי
יש תכנית שיש לי אינסופי מספר הצהרות printf, שהוא
לא אפשרי.
>> כך יותר משכנע, אם כי, אתה יכול להשתמש בזה עם
משתנה ומצבו.
אז בואו נגיד שאנחנו רוצים לחזור ביטוי, מסוחרר לחלוטין, 10 פעמים.
אז מה אתה יכול לעשות עם לולאה בזמן שהוא ראשון שאתה יכול לאתחל דלפק
מחוץ משתנה של בעוד לולאה עד 10.
ואז בעצם, בכל פעם שאתה הולך דרך הלולאה בזמן, אתה מדפיס
המשפט, ואז אתה מקטין דלפק משתנה עד שבסופו של הדבר,
בשלב מסוים, ברגע שאנחנו לחסרי מספיק פעמים, 1 מ מספיק פעמים -
ורק כדי להבהיר, אני מינוס מינוס אומר שאני שווה אני מינוס 1.
>> שבעצם יביא אותי ל נקודה שבה ברגע שאני מכה אפס, זה
מצב הוא כבר לא נכון ו כך שזה יוצא מחוץ לעניינים.
אז לגמרי מסוחרר רק מדפיס 10 פעמים.
כל שאלות על לולאה בעוד?
על אישור.
>> אז יש דרך שאנחנו יכולים לעשות את מה שאנחנו פשוט עשה בצורה תמציתית יותר עם
מה שאנחנו קוראים ללולאה.
אז לולאה למורכבת אתחול, מצב, ו
עדכון, בדיוק כמו שהיו לנו לפני בבעוד לולאה זו.
אז בואו נסתכל.
בבעוד לולאה זו, הייתה לנו אתחול, ולאחר מכן היה לנו
תנאי שבדקנו.
ואז היה לנו עדכון צעד בראש.
>> עם לולאה ל, זה בעצם לוקח שלושת הדברים האלה ומתעבה אותו
למטה לתוך שורה אחת.
אז הדבר הראשון שהיא עושה ב ללולאת האתחול.
ואז אתה עושה פסיק, ולאחר מכן אתה עושה את מצבו, שהוא אני
גדול מאפס הולך לשם, ואז שלב העדכון.
אז זה מקבל בוצע ב הסוף של גוף הלולאה.
אז שתי תוכניות אלה הן למעשה שווה ערך.
>> כל שאלה?
אז מה הוא הבדל אחד בין שני אלה?
האם מישהו יכול להצביע עליה?
זה יכול להיות קצת עדין.
זה פשוט הבדל קטן מאוד.
כן?
>> SPEAKER 5: אתה לא תוכל להשתמש אני משתנה מחוץ ללולאה
[לא ברור]?
>> יוסף: בדיוק.
אז זה משהו שאנחנו נתחיל את מאוחר יותר נקרא היקף משתנה.
אבל בעצם, זה int אני חיי מחוץ ללולאה בזמן הזה.
אז ברגע שבעוד לולאה זה נעשה ביצוע, אני אהיה מסוגל להשתמש מאוחר יותר
בתכנית.
>> ואילו עם זה ללולאה, אני int זה הוא scoped בתוך זה ללולאה.
ובגלל זה הוא חלק פנימי של חלק זה של לולאה לקבלת, שמתחיל
בסוגריים ומסתיים עם הסד המתולתל שם.
כל דבר שהוא הצהיר בתוך כאן לא ניתן להשתמש בחוץ.
אז אם אני מנסה להשתמש אני בחוץ, זה יהיה תגיד לי, סמל הבלתי מוכרז.
ובעצם, לא הייתי תוכל להשתמש בו.
>> ROB: וכן, לפני 10 שנים, ב פשוטו כמשמעו, בכל המקרים, סוגריים מסולסלים הם
מה שאתה משמש לקביעה היקף משתנה.
אז לשם, int אני שווה 10 הוא הצהיר בתוך זה
קבוצה של סוגריים מסולסלים.
וכן לאחר מכן, כל עוד אתה מנסה להשתמש אני לפני סד מתולתל זה, זה בסדר.
ייתכן שאתה רואה כשאתה מקליד לעשות, אתה תראה את המקף, מקף, STD, שווה, C99.
>> אז זה הוא גרסה מתקדמת יותר של C כי GCC יישם שגם נותן לי
קיצור זה.
אז זה היה אמור לא להיות מותר בג ו אתה יכול להבין למה, כי זה int
אני הוא מחוץ לסד המתולתל הזה, אבל זה עדיין נחשב ב
היקף הסוגריים המסולסלים האלה.
אבל זה דבר מאוד נוח, ואז זה סיומת טובה.
>> יוסף: יש שאלות?
על אישור.
אז מה יותר שימושי הוא שלפעמים אתה רוצה סוג של דינמיות ב
הלולאה שלך, נכון?
אתה לא רוצה רק בהכרח להדפיס לגמרי מסוחרר כל הזמן, אתה
רוצה לספור למטה מ 10 או משהו.
ואז אתה יכול להשתמש במשתנת counter כמו גם בתוך הלולאה ש.
ובמקרה הזה, תכנית זו רק סופר לאחור מ10 כל הדרך למטה.
ומה זה לא מדפיס?
זה לא מדפיס אפס, צודק, משום שכאשר -
כן, זה גם לא מדפיס 11.
>> אז זה לא מדפיס אפס, כי כאשר אני הוא אפס, זוכר, זה מעריך
המצב לפני שהוא ממשיך כדי לבצע את גוף הלולאה.
וכשאני הוא אפס, זה שקר, ולכן זה לא להדפיס את הספירה לאחור
אפס, זה פשוט מדפיס את הספירה למטה 10 כל הדרך למטה עד 1.
אם אנחנו באמת רוצים אותה כדי להדפיס אפס, אז היינו לשים סימן שוויון
אחרי זה גדול יותר משלט.
על אישור.
>> אז דרך אחת לעשות את אימות קלט, אשר הוא כשאתה שואל את המשתמש לעשות
משהו, אתה רוצה להפוך אותם בטוחים עקבו אחר ההוראות שלך, הוא להשתמש
הלולאה בזמן, נכון?
אז במקרה הספציפי הזה, אני מבקש למספר חיובי ואז אני
מחכה לקלט.
>> ואז בדקתי בזמן שהקלט הוא פחות מאפס, כל זמן שואל אותם.
אז כל עוד הם נותנים לי מספר זה לא חיובי, להמשיך לשאול,
כל זמן שואל, חוזר ושואל.
אבל מה הוא סוג של מוזר על זה?
או מה שלא נראה אופטימלי על מבנה זה כאן?
אף אחד?
כן?
>> SPEAKER 6: אתה חוזר ההדרכה פעמיים.
>> יוסף: נכון.
אז יש לנו שתי הצהרות printf כאן, נכון?
אז יש דרך בה אנו יכולים לקבל את זה רק עד אחד שיגרום לנו
קוד קל יותר לקריאה ו קצת יותר נקי.
ואז אנחנו לא נצטרך יש קבל בפעמים גם כן.
ודרך אחת אתה יכול לעשות זאת היא באמצעות לולאת Do-אמנם.
>> ולולאת Do-אמנם היא בעצם צורה שונה של לולאה בזמן שבו
כל מה שבתוך הסוגריים המסולסלים מקבל להורג לפחות פעם אחת.
אז הנה, אני מצהיר, int קלט, מחוץ ראשון.
ואז אני פשוט אומר, לעשות את זה הוראות תוך קלט
הוא פחות מאפס.
אז הוא פוגע בלעשות קודם.
זה תמיד יהיה לבצע את זה לפחות פעם אחת, כך שזה תמיד לשאול את המשתמש
עבור קלט לפחות פעם אחת.
ואז זה מעריך את הקלט ש, וזה ממשיך במעגל.
כן, שאלה?
>> SPEAKER 6: האם יש דרך לעשות את זה [לא ברור] סוגים, כמו שאם אתה אומר,
GetString, ומישהו [לא ברור]
האם יש דרך ל[ לא ברור]
>> יוסף: אז השאלה היא, האם יש דרך לעשות אימות קלט אם המשתמש
לא לשים בצד הימין סוג משתנה?
אז אם אנו מבקשים int והם לתת לנו מחרוזת במקום.
ובפונקציות שאנו מקיימים בשבילך, GetInt, GetString בכל
פונקציות אלה, הם למעשה כבר לעשות סוג כזה של קלט בסיסי סוג
אימות מתחת למכסת המנוע.
אז אם אתה משתמש בפונקציות שאנחנו נתתי לך, לא באמת שיש לך.
>> אבל אם אתה רוצה להיראות יותר לתוך כיצד אתה באמת יכול לעשות את זה, אתה יכול להסתכל
מתחת למכסת המנוע בקובץ I/O--
לא הגיש, פונקציות קלט / פלט הסטנדרטי כמו לקרוא מקלט סטנדרטי ו
פלט סטנדרטי.
ואתה יכול לקבל תחושה טובה יותר איך אתה יכול לעשות את זה.
>> ROB: נושא אחד, אם כי, הוא במיוחד עם הדוגמא אתה
אמר, אתה מצפה מחרוזת ואני נכנסתי int.
איך היית לראות את ההבדל בין בכוונה רוצה
מחרוזת 123 לעומת רוצה 123 int?
אז מחרוזת, זה פחות או יותר אין אימות, זה רק מה שהם
נכנס לך תפרש כמחרוזת.
>> Int הוא קל יותר, כי לא משנה קלט שאתה לוקח מהמשתמש, אתה
תמיד לוקח את מחרוזת.
וכן מחרוזת כי אז אתה יכול לבדוק, הם כל אלה
ספרות מספרית בעצם?
>> יוסף: על אישור.
כל שאלות על לולאת Do-אמנם?
>> ROB: אה, וזה גם -
חוזר לההיקף, נפוץ למדי טעות מנסה להשתמש בכמה מקומי
משתנה מתוך Do-אמנם זה לולאה הפנימית של מצב זה.
ובעצם, אם רק נפטרתי מ וזה אמר, קלט int שווה
GetInt, אז המהדר צועק על לנו, כי קלט אינו קיימת
מחוץ להיקף של הסוגריים מסולסלים האלה.
>> יוסף: ובגלל זה אנחנו צריך מערך זה כאן.
על אישור.
אז אתה גם יכול לפרוץ את הלולאה מוקדם אם אתם רוצים.
אז זו דרך של שונה יישום מה שאנחנו פשוט ליישם.
ובמקום להשתמש במצב בתוך הסוגריים, אנחנו משתמשים
אם הצהרה הפנימית של הגוף של Do-בעוד הלולאה.
>> ובעצם, כאשר הקלט סוף הסוף גדול מאפס, נעשינו את זה
לפרוץ את הלולאה.
וכך אנחנו נלך כל עד לכאן.
ואתם יכולים לראות שהיית עושים את זה כנראה העדיף בזה
תרחיש, כי זה קצת מנקה קצת וקצת
קצת יותר קל לקריאה.
ואילו זה, אתה סוג של יש קווים נוספים בו.
זה רק קצת יותר מכוער, אני מניח, במובן מסוים.
כן, שאלה?
>> 4 SPEAKER: אשבור רק לקבל אותך מקבוצה אחת של פלטה?
>> יוסף: נכון.
אז השאלה היא תשבור רק להוציא אותך מלולאה אחת?
והתשובה היא כן.
אז אם יש לך מקונן ללולאות, עבור דוגמא, אם יש לי לint אני שווה 0
עד 10 ולאחר מכן לInt J שווה 0 עד 10, אם אני לפרוץ את פנימי
לולאה, אני עדיין הולך ללולאה החיצונית.
אז זה ישמור את ביצוע פעולות בצד החיצוני.
כל שאלות על זה?
כן?
>> SPEAKER 5: אבל לשבור פונקציות בלבד לסוגריים מסולסלים, ולא לאחרים
הצהרות?
[לא ברור]
>> יוסף: אז השאלה היא תשבור רק פונקציה עבור לולאות לעומת
הצהרות אחרות כמו אם?
וכן, זה המקרה, כי אתה שבירה מתוך לולאה, ימינה,
במובן מסוים.
>> רוב: ברוב המכריע של המקרים, זה זה הסוג של משהו אם,
לאחר מכן הפסקה.
אז אתה לא צריך לשבור לחול אם כי הוא כורך סביבו.
וגם, זה לא הרבה של לולאה, אך יש לזכור כי בוררים הם גם
פרץ על ידי הפסקות.
ראינו בשימוש הפסקות עם מתגים בעבר.
>> יוסף: ואתה יכול גם להשתמש בם בלולאות בזמן וללולאות.
כל שאלה?
על אישור.
אז עד הבא הוא פונקציות.
אז ייתכן שהשתמשת באחד מאלה BYOB בלוקים בפרויקט Scratch שלך.
וזה בעצם מאפשר לך להגדיר סט של
הוראות להיות אחריו.
>> ומה שאני מתכוון זה בואו נחשוב בחזרה למתמטיקה, נכון, אלגברה.
יש לך מה שאנו מכנים פונקציה של x, כמה משתנים, ובואו נגיד את זה
פונקציה היא f של x שווה X ועוד 5.
אז אתה יכול לחשוב על f של x כמו זה שחור תיבה שלוקחת 15 ובאז
מייצר 20.
>> אז באופן כללי יותר, פונקציה היא משהו שלוקח כמה כניסות ו
לאחר מכן מייצר כמה יציאות.
ולמה פונקציות הן טובות?
הם טובים עבור מספר הסיבות.
אז מישהו רוצה לקחת לדקור במה שארגון אומר?
במונחים של הסיבה פונקציות מועילות?
כן?
>> 4 SPEAKER: זה גורם לך קוד קריא יותר.
>> יוסף: נכון.
אז אחד הדברים הוא שהוא עושה הקוד שלך קריא יותר, נכון?
במקום שיש כמו int x שווה x פעמים x פעמים x, אני יכול לקבל את קובייה של x,
שהוא יותר קריא ויותר מובן לקורא.
>> ארגון גם הוא במונחים של פיצול הקוד שלך לניהול
מנות, כך שבמקום לנסות ליישם את כל זה בקטע אחד ארוך
בעיקרי, אתה יכול סוג של לפצל אותה למעין, אוקיי, בואו לכתוב פונקציה
לקוביית משהו, בואו נכתוב לתפקד לרבע משהו.
ככה אתה יכול לפצל אותו לקטנטן, חלקים קטנים שאתה יכול להתמודד
בניגוד למנסה להתמודד בעיה גדולה בבת אחת.
>> חלקים או אפילו זעירים, קטנים ש: ROB אתה ושותף יכולים להתמודד.
>> יוסף: כן.
>> ROB: אז במקום שניהם אתה מנסה להשתיל אחד
לתפקד באותו הזמן.
>> יוסף: פישוט.
כל מי שרוצה לקחת ניחוש?
כן?
>> SPEAKER 5: עוד חזרות.
>> יוסף: נכון.
אז דבר אחד שאתה יכול לעשות עם פישוט הוא שזה סוג של על
אותם הקווים כמו מחדש שימושיות הוא כי ברגע שאני כותב פונקצית קובייה, שאני יכול
פשוט להשתמש בזה שוב ושוב ושוב שוב בתכנית שלי במקום הקלדה
x פעמים פעמים x על x ו שוב ושוב.
ופישוט כאן גם פשוט אומר שזה עושה סוג של הקוד שלך
קל יותר לאתר באגים ברגע שאתה לפצל את זה לפונקציות.
כי אז אתה יכול למקם בי הבעיות שלך הן סוג של.
כל שאלה?
>> אז רעיון אחר הוא הפשטה, נכון?
הקופסה שחורה הזאת.
כמו שאתה יודע מה עושה GetInt כדי לקבל קלט מהמשתמש?
יש לנו לא ממש אמרתי לך, נכון?
כל מה שאמרנו לך הוא GetInt עושה בדיוק מה שזה אומר שהיא עושה.
אז גם אם אנחנו לא אגיד לך איך זה עובד, אתה עדיין יודע.
>> אז במקרה הספציפי הזה, זה הוא פונקציה מרובעת שעושה
דברים שונים לקלט כדי לייצר תפוקה.
ואתה יכול לרבע מספר ידי הכפלתו ארבע.
או שאתה יכול מה שאנו מכנים קצת להזיז אותו על ידי שתיים.
ואנו לכסות את זה קצת מאוחר יותר.
ואין צורך לדעת איך זה פונקציה באמת עובדת כל עוד זה
עובד כאמור.
>> אז מתחת למכסת המנוע, אני יכול להיות כמו, לחזור קלט פעמים
שמונה מחולקים על ידי שתי.
ולא היית יודע, נכון?
כל מה שאתה צריך לדעת הוא הוא עושה מה שהוא אומר.
אז זה הדבר שימושי על הפשטה.
>> ועוד דבר הוא סוג של הרעיון הזה ללוקליזציה של הקוד שלך לאחד
סעיף מסוים.
אז אם יש לי בעיה שאתה, אתה לא צריך ללכת בכל רחבי את הקוד שלך מנסה
כדי לתקן את הבעיה שבה הייתה.
אז במקרה הזה, אני יישמנו קובייה הלא נכון.
חשבתי שהקובייה הייתה הכפלה על ידי שלוש.
>> אז במקרה הזה, זה תכנית אחת כי רק הכפלה בשלוש
בכל מקום.
ויש תכנית אחרת שיש לו קובייה בחשבון אל פונקציה.
ואז עכשיו אם אני רוצה לתקן טעות שלי כאן, אני חייב לתקן את כל קו
של קוד בתכנית זו.
ואילו מהצד השני, אם אני משתמש פונקציה, אני רק צריכה לשנות
מה לא בסדר במקום אחד.
>> אז במדעי מחשב, אנחנו קוראים לכניסות ויציאות.
תשומות נקראות פרמטרים או טיעונים, ותפוקות נקראים
מחזיר ערכים.
ואנו רואים איך זה עוזר לנו סוג מלהגדיר פונקציה בשנייה.
אז זו הגדרת פונקציה לעקוב.
אז זה לוקח קלט, ולאחר מכן היא מחזירה את זה פעמים מספר
עצמו שלוש פעמים.
אז בואו לשבור את זה.
>> אז יש לנו כותרת פונקציה, אשר בעצם מורכב משלושה דברים.
אז יש לנו את הפרמטרים, אשר הם, כפי שאמרתי קודם,
תשומות לפונקציה זו.
ואז אנחנו נותנים את הפונקציה שם.
במקרה זה, זה נקרא קובייה.
ואז לציין מה הסוג של ערך ההחזרה הוא.
>> אז במקרה הזה, פונקצית הקובייה שלי לוקח במספר שלם וזה גם
מחזיר מספר שלם.
אז אם אני עובר בשניים, שתיים הוא מספר שלם, היא מחזירה לי שמונה, אשר
הוא מספר שלם.
אז להחזיר את שם פרמטרים סוג.
שאלות על זה?
>> ולאחר מכן את ערך ההחזרה הוא למעשה צוין בסוף באומר תמורה
ולאחר מכן חוזר כל מה מכיל את הערך המוחזר.
אז במקרה הזה, אם אנחנו שמים את כל זה יחד, פונקציה לוקחת ב
פרמטרים, זה נקרא משהו, ו היא מחזירה משהו שהוא הסוג
שאנחנו אומרים שזה הולך להיות.
כל שאלה?
>> אז איך אנחנו משתמשים בפונקציה?
ובכן, אנחנו כותבים פונקציה ולאחר מכן אנחנו משתמשים בו בתכנית שלנו, נכון?
אז קראתי לו קובייה, ו אז אני יכול להשתמש בקובייה.
>> אבל מה שחשוב לציין הוא שענייני הסדר.
אם יש לי קובייה מתחת עיקרי, זה הולך לרוץ לתוך קובייה.
ובשלב זה, אין שום דבר נקרא קובייה בתכנית, וזה
פשוט הולך להיות כמו, יש לי אין לי מושג מה הוא קובייה.
>> אז הוא יגיד לך, משתמע הכרזה על הפונקציה.
זה השגיאה שמופיעה.
ולכן במקרה זה, קובייה היא מתחת עיקרי, כך שזה לא הולך
לדעת על זה.
>> SPEAKER 5: אז עיקרי הוא בדרך כלל הפונקציה האחרונה מוגדרת?
>> יוסף: אז השאלה היא, הוא עיקרי בדרך כלל שעבר
דבר שהיית מגדיר?
ולא.
זה בגלל שאנחנו בדרך כלל אוהבים עיקריים כדי להיות בראש, נכון?
כי זה הדבר הראשון שאתה רוצה מתכנת הפתיחה
תכנית כדי לראות.
ואז איך אנחנו פותרים את הבעיה שלנו רוצה עיקרי להיות בחלק העליון, אבל
פונקציות שאנחנו רוצים, אנחנו רוצים אותם להיות מתחת עיקרי עדיין תוכל להשתמש
אותם בתוך עיקרי?
>> ובכן, אנחנו משתמשים במה שאנו מכנים אב טיפוס פונקציה.
אז מה בעצם אב טיפוס פונקציה הוא שזה לוקח את מה שראשון
החתימה או כותרת הפונקציה ממה שאנחנו רוצים ליישם את
כאן, ואנחנו שמים את זה ב החלק העליון של תכנית.
>> אז במקרה הזה, אנו אומרים כי, טובים, מאוחר יותר בתכנית שלנו, אנחנו הולכים
כדי להפוך את ההבטחה ליישם את זה פונקציה שנקראת קוביית int, אשר לוקחת
קלט מספר שלם.
אז עכשיו, בגלל שהוא מעל עיקרי, עיקרי, זה הולך לומר, נו, טוב,
מאוחר יותר בתכנית, שהולך להיות יש כל כך שאני יכול להתייחס אליו, אז אני
פשוט תנו לזה לעבור לעת עתה.
>> ולאחר מכן בתחתית, אנו ליישם קובייה.
ואז ראשי יהיה פשוט לומר, טוב, זה יהיה למיין של קישור
שני הסמלים האלה ביחד.
ואנו לכסות את מה ש משמעות בהמשך.
וכך תדע שזה הוא פונקצית קובייה שהוא צריך להשתמש.
>> ROB: [לא ברור] על רצון עיקרי בתחתית או
עליון, ראיתי את שניהם.
יש דברים שפשוט אוהבים לשים ראשי בתחתית.
אבל ברגע שפרויקט מקבל במיוחד גדול, בדרך כלל עיקרי הוא ב
קובץ כולו שלו.
ובנקודה זו, כמו שורת קוביית int היית -
בתוך stdio.h הן חבורה קווים בדיוק כמו int כי
שורת קלט int הקובייה.
>> וכך אב טיפוס אלה הם דברים שאתה נוטה לשים לקבצי כותרת, ב
ונקודה, זה לא משנה.
ובכן, זה לא משנה.
אלה תמיד הולכים בראש.
ואם עיקרי הוא לא קובץ כולו שלו, אתה לא צריך לדאוג לשים
אבות טיפוס לפונקציות בודדים בקובץ.
>> יוסף: ואנחנו נגיע לזה קצת קצת מאוחר יותר, כאשר רוב מתחיל לדבר
על העריכה.
וכך יש גם הבדל בין פרמטר וויכוח.
ופרמטר הוא בדיוק מה אנחנו קוראים לתשומות אלה כאשר
אנו מגדירים את הפונקציה.
ואנחנו קוראים לזה טיעון כאשר אנו למעשה להעביר אותו לפונקציה.
>> אז במקרה הזה, מדובר בפרמטר, כפי שאמרנו קודם.
וכאשר אנו למעשה להשתמש בו לשם, קובייה של x, אז x עצמו הוא
מה שאנו מכנים טיעון לקוביית הפונקציה.
>> ROB: אז את טענותיו של הפרמטר הן -
יש הבחנה זו, מאוד מבולבל לסירוגין.
בשלב זה, לי, זה כמו אחד המילים האלה, שכשאני רואה את זה ב
פרא, אני לא יכול לעזור, אבל באופן מיידי שאלה אם הם משתמשים בו ב
ההקשר הנכון, כי ההבדל הוא דק מספיק, כי רק
כולם נוטה -
כמעט תמיד אני אומר טיעון בלי קשר למה אני מתכוון.
>> יוסף: ופונקציות שימושיות גם למה שאנו מכנים תופעות לוואי.
אז פונקציה יכולה לקחת לא תשומות, ו זה גם יכול לייצר שום פלטים.
אז במקרה הספציפי הזה, אני הגדרת שגרה שאין לי
להחזיר ערך.
וכדי לציין את זה, אנו משתמשים מה שאנו מכנים חלל לכאן.
וכך תופעת הלוואי של פונקציה זו הוא שזה פשוט מדפיס דברים
לדף.
זה לא ממש לקחת כל תשומות, וזה לא
למעשה לייצר כל תפוקות.
>> אבל זה יכול להיות שימושי במובן אם אתה רוצה, למשל, ניפוי שגיאות
משהו בתכנית שלך, אם אתה רוצה לכתוב קצת שגרה כי
מדפיס את, נניח, את התוכן של זיכרון או משהו.
וכן תופעות לוואי אלה הן לפעמים שימושי מחוץ להקשר
רק רוצה כניסות ויציאות.
כל שאלה?
>> ולסיום קטע המסוים הזה, מה התכנית הזו עושה?
אני אתן לך חבר 'ה כמה שניות לקרוא את זה.
ברמה בסיסית מאוד, מה שאנחנו רוצים לומר הוא שזה מחליף x ו-y, נכון?
>> אז כמה מכם באמת חושב זה יהיה להחליף x ו-y?
הרם את ידך.
אף אחד.
על אישור.
מי שחושב שזה יהיה לא להחליף x ו-y?
וסכום שהיה לא את כל החדר.
אז יש אנשים שהם לא בטוחים.
על אישור.
זה סביר.
>> אז בואו לעבור את מה שקורה כאשר אתה בעצם קורא לפונקציות הראשונות ב
כדי לענות על שאלה זו.
אז זה מה שזיכרון סוג של נראה.
זה כמו סוג של מודל פשוט של מה שנראה כמו זיכרון כאשר
אתה מפעיל את תכנית.
אז יש משהו שנקרא הערימה כאן למטה ו
משהו שנקרא הערימה.
ולגדול אלה כלפי האמצע של זיכרון.
>> אז במקרה הספציפי הזה, כש אתה קורא לפונקציה, היא
מקבל לשים על הערימה.
ואז כל מה שכלול בזה פונקציה נשארת במה שאנחנו קוראים לזה
מסגרת המחסנית של הפונקציה.
ולכן כדי לקבל הדמיה יפה של זה, בואי - למשל, היה לנו
עיקרי תכנית קודם לכן.
ובתוך ראשיים, שקראנו קובייה.
אז עיקרי היינו הולך ראשון במחסנית מסגרת, כי זה הפונקציה הראשונה
זה נקרא.
>> ולאחר מכן, כאשר הקובייה נקראת פנימית של עיקרי, הוא מקבל לשים על גבי עיקרי
בתוך הזיכרון.
אז מה תוכל להבחין כאן הוא קובייה ש יש פרמטרים משלו ושלה
המקומיים עצמו.
לכן, כאשר אתה באמת עובר משהו פונקציה, הפרמטרים שהיא
מקבל הם עותקים של מה שהיה עבר מראשי.
>> וכדי להסביר סוג של זה, בוא ללכת דרך תכנית.
אז יש לנו את הערימה, זה רק את חלק המחסנית.
ומה שאנו עושים זה לאתחל ראשון x ו-y לאחד ושתיים.
אז יש לנו קופסות קטנות האלה.
הם יושבים בערימה של עיקרי למסגר בערימה.
הם מכילים אחד ושניים.
>> עכשיו אנחנו קוראים להחלפה.
מה שקורה הוא שאנחנו עוברים x ו-y ל החלפה, והחלפה יוצרים עותקים שלו
של משתנים אלו לשימוש בתוך של מסגרת הערימה שלה.
אז עכשיו לשם, יש לנו, אשר מכיל את הערך שהיה לי x; ו-B,
שמכיל את הערך שהיה לי y.
אז אחד, שתיים.
>> ותשים לב שזה הוא נפרד מx ו-y בתוך ראשי.
אז עכשיו אנחנו יוצרים זמניים משתנה להכיל.
אנו קובעים שווים ל-B, ולכן שינויים מאחת לשתיים.
ולאחר מכן הקמנו B שווה לטמפ ', שהוא אחד.
>> ואז עכשיו אנחנו יוצאים החוצה של פונקציה זו.
כשאתה יוצא מחוץ לפונקציה, מסגרת מחסנית מקבלת התפגרה הערימה.
אנחנו קוראים לזה לדחוף.
אתה דוחף את מסגרת מחסנית על המחסנית ואתה קופץ אם את המחסנית.
ואז מה שקורה הוא שכל מה ש היה שבסוג מסגרת ערימת רק
עולה בלהבות.
וכדי שכבר לא קיים.
>> אבל מה שאנחנו שמים לב?
אנחנו אף פעם לא באמת השתנו ערכים של x ו-y, נכון?
אז מי נשאר מקומי לראשי.
ועל ידי העברת דברים להחלפה, אנחנו למעשה מעולם לא שינה את הערכים האלה.
ומה שאנחנו קוראים לזה?
אנחנו קוראים לפטירתו זאת על ידי ערך.
>> אז ב-C, כאשר אתה עובר דברים לתוך פונקציות, הוא עובר אותם לפי ערך ו
יוצר עותק של אותם עבור הפונקציה לשימוש.
ואנחנו תלמדו על משהו שנקרא עובר על ידי עיון מאוחר יותר, אבל זה
דרך בה אתה יכול לפתור את הבעיה הזו.
אבל אנחנו לא לדאוג כי רק מאוחר יותר.
>> רוב: ולמעשה, מונח זה, דרך אגב על ידי התייחסות, אפילו לא צריך כל כך C
עובר על ידי התייחסות.
C באופן בלעדי כבר עובר ליד ערך.
לא משנה מה אתה עושה, אתה תמיד עובר העתק של משהו.
זה בדיוק את זה, כמו שאני סוג של הזכיר כי לפני שעם מצביעים
ושמחרוזת היא באמת רק ארבעה ביטים והצביעו על מקום בזיכרון.
>> ובכן, אם יש לי מחרוזת זו וזה אומר לי שהמקום שבו המחרוזת -
טוב, אם יש לי מצביע זה לזה מקום בזיכרון, ואז אני יכול לעבור
עותק של מצביע שלפונקציה, ו פונקציה שעדיין לא יודעת איפה ב
זיכרון זה.
אז שניהם של מצביעים אלה מצביעים לאותו המקום בזיכרון, ו
ככה אנחנו הולכים להיות מסוגלים כדי לשנות את הדברים שמעבר
מסגרת מחסנית נוכחית.
>> יוסף: האם אתה רוצה לעשות קומפילציה?
>> רוב: לא, זה 5:30.
>> יוסף: על אישור.
זה 5:30.
על אישור.
אז אנחנו יכסו קומפילציה אני מניח ב בסעיף הבא, או בסעיף שלך
מנהיג יהיה בשלב זה.
ו--
>> רוב: יש שאלות?
>> יוסף: יש שאלות?
כן?
>> SPEAKER 5: שימוש במחרוזות מCS50, כל פונקציות שאנחנו רוצים להשתמש עבור
אלה, שנהיה כמו פונקציות C.
CS50 לא נעלם וב עשה כל נוסף.
>> ROB: נכון.
כל אחד מC כמו [לא ברור], אתה ישתמש באלה על המיתרים שלנו.
>> יוסף: ועוד דבר אחד אחרון שאני רוצה להזכיר הוא שיש לנו מדריך סגנון
למעמד הזה.
>> ROB: הו, כן.
>> יוסף: אז אם אתה כבר בא תכנות רקע לפני, אתה
אולי יש מוסכמות מסוימות כאשר אתה כותב קוד כמו לשים
פלטה באותה השורה או מסוימת דרכים של זחה
או שמות המשתנים שלך.
במעמד הזה, אנחנו רוצים לעקוב מדריך לסגנון מסוים רק בגלל,
ובכן, אם אתה יוצא לעבוד ב בתעשייה, אתה הולך להיות צפוי
כדי לבצע את מדריך הסגנון של חברה שבה אתה הולך.
>> כמו למשל, אני חושב שפייסבוק יש סוג מסוים של שמות
אמנה.
ויש הבדלים בין הגמלים משתני מעטפת ובדיוק כמו
מפריד אותם עם קו תחתון.
וגם, אני חושב שהכי חשוב, כמו לדוגמא, כניסה, נכון?
>> אנו סוגריים מסולסלים מתחילים בי התנאי הוא, והם
הם בשורה הבאה.
ואנחנו גם לשים סוגריים מסולסלים ב אפילו אם זה רק שורה אחת.
והרבה פעמים, יש דרכים לעשות זה שבו אתה יכול להשאיר את הפלטה אלה
את אם זה רק שורה אחת תחת ההצהרה אם.
אבל במעמד הזה, אנחנו רוצים לעקוב מדריך לסגנון מסוים רק כדי שתקבל
משמש לדברים מהסוג הזה.
>> ROB: כן, ו50 סגנון הולך לאכוף מדריך הסגנון הזה, ואנחנו
הולך להשתמש בסגנון 50 לקוד שלך בכיתה.
אז זה עושה את הדברים קלים יותר עבורנו ו אני מקווה שלא צריך לעשות דברים ש
הרבה יותר גרוע בשבילך נתת סגנון סטנדרטי לא צריך להיות כי
לא מציאותי.
>> יוסף: ולבסוף, כדי למצוא את הסגנון מדריך, ללכת לmanual.cs50.net/style.
וכן.
>> 4 SPEAKER: האם אתה הולך לאכיפה כל תווים בכל שורה?
>> ROB: כן.
>> יוסף: מצטער, חבר 'ה.
>> רוב: זה כמו אחד מהיחידים.
בשלב זה, אני בסדר עם 120.
אני בסדר עם אומר 120 תווים בכל שורה.
אני מבין שיש להיות גבול מסוים.
אני חושב 80 הוא כל כך קטן, אבל אנחנו אוכפים את זה.
>> יוסף: באופן אישי, אני חושב שעם C, 80 תווים הוא בסדר יותר.
ברגע שאתה מתחיל לקבל לאחר שפות כמו JavaScript ו-PHP, לא
כך סביר רק כדי להגביל את זה 80 תווים.
על אישור.
ובכן, זה היה הקטע סופר.
האם מישהו רוצה ממתק?
>> 4 SPEAKER: כן.