[Powered by Google Translate] הדוד Malan: זה CS50, וזו תחילת השבוע, 1.
מה שחשבנו שאנחנו היינו עושים היום היא לקחת מבט לאחור על
משהו שרבים מכם כנראה עבר לחלק
זמן עכשיו ואולי נראה קצת מוכר.
זה כאן, זה, כמובן, הוא ב--
קהל: מדע.
הדוד Malan: מדע המרכז.
אז זה בעצם אחד מהמחשבים המוקדמים
לגבות מ 1940.
זה היה אחד ממחשבי אלקטרו 1
שהיה מסוגל ארוך במיוחד,
חישובים עצמיים מתמשכים, ומה שאנחנו בעצם רואים ב
מרכז המדע הוא רק חתיכה קטנה של הדבר הזה.
מה שחשבנו שאנחנו היינו עושים אז הוא מעיף מבט לאחור בוידאו
שנעשה לפני כמה זמן, זה מציג
דבר לעולם.
ותראה ממוסיקה והקול שאכן אלה
היו זמנים מאוד שמחים.
>> [השמעת וידאו]
-נצחון של מיומנות מתמטית ומכאנית הוא זה
מחשבון גדול חדש אוטומטי באוניברסיטת הרווארד.
בעיות סבוכות במתמטיקה, והיא הוכנסה
מכונה בצורה מוצפנת בקלטת, נפתרת באופן מדויק
חלק זעיר מהזמן דרוש לאדם
חישוב.
נועד לזרז את כל הצורות מתמטיות ומדעי
מחקר, המוח המכאני הענקי שיפעל לארצות
צי אמריקאי עד לסוף המלחמה.
>> הדוד Malan: אז מה שאתה אולי לא יודע הוא שזה היה ב
אותו מכשיר שזה מונח שכולנו עכשיו תיקח די הרבה
כמובן מאליו נטבע, זה של הבאג.
אז אחת מהמהנדסים עובד במחשב זה
מצא עש קטן במכונית שהביא פשוטו
בכמה חישובים שגויים.
וכסיפור הולך כך העש היה מודבק ליומן זה
כתב עת כאן, חזרה מ9 ספטמבר בשנת 1940 ומשהו,
וכך נולד "באג" המונח לעולם.
אז מכאן ואילך אנו רואים באגים להיות כל סוג של טעויות ב
תוכניות, בין אם מעשה ידי אדם או, במקרה זה, חרקים.
>> אז כמה הכרזות, ככל שנתקדם.
אז CS50 יש מסורת של מציעים ארוחות צהריים של מינים על
רוב ימי שישי במהלך הסמסטר, שבו אנחנו לוקחים 30 עד
40 סטודנטים לאש וקרח בכיכר למזדמנת
פטפוטים, דיבורים על מדעי מחשב,
לדבר על העתיד.
אנו מזמינים את בוגרים וידידים מהתעשייה לשוחח עד
תלמידים גם כן.
ממש לקראת סוף עושה מה שכיתה גדולה למדי
כל אינטימי יותר, לפחות פעם האחת ובאילו עבור
תת קבוצות של תלמידים.
אז אם אתה רוצה להצטרף אלינו ביום שישי הקרוב, בשעת 1:15, ללכת ל
CS50.net/lunch לRSVP.
ואנחנו נעשה את זה recurringly, אז שלא ידאג אם אתה לא
בין ראשוני 30 או כך השבוע.
>> אז הערות סופר.
מילה על המשאבים שעכשיו תתחיל להיות זמין
לתלמידים בכיתה.
כך שהראש שלך לא צריך להיות למטה במהלך הרצאות
ורשם את כל מה שאני אומר וכן הלאה, מה שאנחנו עושים
במקום זאת היא מספק מסגל ההוראה
סט הקנונית של הערות.
אז יש לנו אחד מחברינו להוראה, אנדרו Sellergren,
שמתיישב בכל שבוע, סוקר את קטעי וידאו, ולאחר מכן
כותב את מה שאנחנו חושבים למדי
סט סמכותי של הערות.
וחיבתו של אנדרו, גם, של לשים את ההערות שוליות במתחכמות
התחתון.
אז אתה מקווה שתיהנה אלה כהתייחסות לספר
כיף, וגם, בואו חידון זמן, כהזדמנות לסקור
מה שקרה בהרצאות בודדות.
אז אלה מקושרים בדף ההרצאות.
>> סט הבעיה 0, בינתיים, הוא החוצה.
ובמונחים של המשאבים העומדים לרשותך -
ההדרכה.
מילוא הוביל הראשון ביום שישי.
הוא צולם, לשים באינטרנט על ידי שבת.
וכך להבין, שאם אתה לא ממש בטוח מאיפה להתחיל,
לזה או עתיד P-סדרות, תמיד לפנות תחילה ל
הדרכה או ממנו הווידאו.
החתך הוא בהתקדמות; בcs50.net/section הוא בך
צריך להגיש את ההעדפות שלך, אם יש לך לא
כבר, על ידי היום.
בגלל סעיפים יתחילו ביום ראשון הקרוב, יום שני,
ויום שלישי.
אנחנו עושים את אותם קטעים השלושה ימים, כל שבוע של
סמסטר על פי רוב.
ואנחנו גם מציגים, שוב, מסלולים שונים.
אז תתבקש על צורת החתך הזה, אם אתה
לא ראה אותו כבר, אם אתה בין אלה שפחות
נוח יותר, נוח יותר, או איפשהו באמצע.
ואם אתה סוג של על הגדר, בדרך כלל אי ​​שם ב
בין מה שרוב התלמידים בסופו של בדיקה.
שעתי עבודה מתחילות הלילה.
>> אז גרד הוא מפתח נמוך למדי, למרות שזה די טבעי
לנתקלו בבאגים שונים, או להיות בטוח לגבי איך
ליישם משהו.
אז תבין שאנחנו נתחיל שעתי עבודה בשבוע.
הם יהיו באננברג יום שני, יום שלישי, יום רביעי,
יום חמישי, 20:00-11:00 בהפסקת המוח.
classmen העליון יכול להיכנס, ואם אי פעם יש לך בעיה להגיע
בדלת, כי הם יהיו swiping, פשוט דברים בדרך שלך
ובלהסביר אתה איתי CS50.
בדרך כלל 20 עד 30 מתוכנו בצוות תהיינה שם כדי לעזור
אתה אחד על אחד.
>> עם הגעת הרעיון הוא כזה: אתה תביא את המחשב הנייד שלך,
יהיה לך המטען שלך, יהיה לנו כבלי חשמל נוספים,
במיוחד לאורך הקיר הדרומי של אננברג בי
יש המון שקעי חשמל.
ונקודת הכניסה העיקרית לשעתי המשרד Q & A היא ללכת
cs50.net/discuss ולפרסם
השאלה שלך שם.
ולתייג אותה עם pset 0 או pset 1, מה השבוע
שעלול להיות.
ואז מה שאנחנו הולכים לעשות זה יש טבלה של עמיתי הוראה
ועוזרים כמובן, בדרך כלל 8 או 10 או משהו כזה שלנו,
עובר, שמירה על עין על הלוח, ו
תלש שאלות ממש מהר ככל שאנו יכולים,
בהתייחסו לך הודעות הקשורות אם לא מצאת מי
עצמכם, הפניות לאינטרנט, כנדרש.
ואז, אם יש בעיות, כמו שיש באופן בלתי נמנע
יהיה, או שזה פשוט יותר הגיוני לשבת אחד על אחד,
לעבוד דרך בעיות עם מישהו.
>> או שאתה רק נכנסת לשעתי עבודה באמת
צורך החשיבה ש.
אתה לא רוצה לעבור את הצורה האלקטרונית, אתה
ממש רוצה להיפגש עם מישהו.
לתקשר כי לנו, ומה יקרה כאשר
השאלה כבר ראה ע"י חבר צוות, ואנחנו
לקבוע, כן, זה אמור להישלח לאחד 20 או
30 חברי צוות כאן ברמה אזורית, תוכל לראות בפינה שמאלית עליון זה
קצת הזן את תור הלחצן מתחיל להבהב בcs50.net /
לדון בו.
וזה אומר לך שעכשיו כבר הוזמן, כך
לדבר, כדי להזין את התור.
ועל ידי לחיצה על הכפתור הזה, השם שלך יופיע על
האייפד שמברך CS50, אחד מראשיו של הקורס, יהיה
להיות מחזיק ליד הכניסה של אננברג, שאז יהיה
רואה כמתואר כאן, את התלמידים שיש להם שאלות על
מהשמאל, חברי צוות שנמצאים בצד ימין.
ועם לחץ על ימין ועל שמאל, דפדפן האינטרנט שלך
תתחיל להבהב בהקדם, למשל, פרופ 'McGonnagal
הוא מוכן לראות אותך בשולחן מסוים באננברג.
>> אז עשיתי כמה מהשנה שעברה.
אנחנו כבר אתחלנו שעתי עבודה ו
מחדש יישם הרבה של התוכנה.
אז הבין שזה יהיה לחמם את זה שבוע.
אבל גם מבין יותר מדי, בשנים האחרונות, כפי שאולי שמע
מחברים, שעתי עבודה היו 50 עד אכן
150 תלמידים בו זמנית.
וזה פשוט לא אפשרי עבורנו להתמודד עם זה
למעשה, אחד על אחד, לאורך כל הערב.
וכך מה שאנחנו בעצם הולכים לנסות לעשות את זה שנה היא
לנצל את העובדה שהרבה שאלות הן
נפוץ ולעתים קרובות יכול להיות טוב יותר ענה
באופן אסינכרוני.
אז אתה יכול כאילו לחשוב על התגובה של צוות,
ואנחנו יכולים לחשוב על הקוד שלך, בלי מחומם
לחץ נאבק בהכרח
דרך זה לצד זה.
אז אנחנו מעריכים שבערך מחצית שלישית או מהשאלות
יהיה שגר באופן אישי, ואנו ננסה למרוט את כ
רבים כמחצית או יותר באופן אלקטרוני,
בשעתי עבודה.
ואנו נמשיך להשתמש בדיון
במהלך השבוע גם כן.
>> ולבסוף, להבין כי קורס זה ניתן לקחת עובר / נכשל.
אז אם אתה על הגדר, או פשוט לחשוב שאתה באמת
לא בטוח אם זה העולם בשבילך, או שזה באמת
די זר לך, להבין שזו דרך נפלאה
מצובר קצת ביטחון שבי להיכנס
כיתה, כמו שאני עשיתי כנות, לפני שנים.
ואז יש לי חמישה שבועות כדי למיין של דמות בשביל
את עצמך אם אתה רוצה להישאר עובר / נכשלת, לעבור למכתב
כיתה, או כמו.
ובדרך כלל מה עובר / נכשל אין, לדעתי, לתלמידים הוא
שאם אתה מכניס כי 10 שעות, 20 שעות, מה שזה
יכול להיות בכמה בעיות, ואתה דופק את הראש שלך
על הקיר,
ואתה באמת לא יכול לרדוף אחרי משהו, ועליך
יש כל כך הרבה דברים אחרים שאתה צריך לעשות, בכנות, מה אני
חושב עובר / נכשל היא, זה לוקח את העוקץ של
מצבים כאלה.
איפה שצלמת את הדבר 90% מהדרך.
אתה יודע, זה לא ממש מושלם.
אבל יש לך הרבה ממנו, בכל זאת.
אז לשקול עובר / נכשל כנותן לך
מודל מנטלי, אולי.
>> כל כך בשבוע שעבר הנכון, צלל אל גרד, ואנחנו
דבר על תכנות ברמה גרפית גבוהה למדי.
והיום אנחנו עושים את המעבר לשפה
בשם C, שפת תכנות ברמה נמוכה יותר בחלק העליון של
ששפות מודרניות רבות כיום בנויות, כוללות חלק
מאלה שאנחנו משתמשים בי לקראת סופו של המונח.
ותחבירי, איך שהם נראים
כל די דומה.
אז בואו נתחיל לעשות את המעבר הזה כאן.
אז זו הייתה תכנית בשבוע שעבר שהיה פשוט ביותר
שלום תוכניות בעולם.
זה פשוט הדפיס לשלום עולם המסך, עם
בועת דיבור קטנה שיוצאת מהחתול.
ובכן, אם אנחנו מתחילים עכשיו לתרגם את זה למשנו
שפה, מבין שרעיונות היום וביום רביעי
זהים, אבל התחביר מתחיל להשתנות.
אז אילו בשבוע שעבר היה לנו, כשהדגל ירוק לחץ, אומר
שלום עולם.
היום אנחנו הולכים להיות, חלל int, ראשי, printf,
תמורה, עם חלק אחר בתחביר גם שם.
סוגריים מסולסלים וסוגריים, וציטוטים, ומה לא.
אבל מבין שהליבה של הרעיון כאן היא ההדפסה,
וסופו של דבר העובדה שעיקרית עכשיו הוא הולך להיות
שם נרדף להתחלה של תכנית.
העיקרי הולך להיות בו הדגל הירוק בעיטות מחוץ דברים.
>> אז עכשיו בואו להקניט מלבד כמה מאבני הבניין כאן
לפני שנצלול לתוך כמה דוגמאות קונקרטיות.
אז קרא את זה בשבוע שעבר הצהרה לפיה זה רק
הוראה ולמידה.
לעשות את זה - במקרה זה, אומר שלום עולם.
ובכן ב-C, אם נסתכל רק כי קו, זה איך אנחנו
תתחיל להביע שפיסת הפאזל מסוימת:
printf ("hello world");.
ועכשיו אנחנו נתגרה אלה בהפרש של יותר ויותר עם זמן,
אבל להבין שיש כאן דפוס.
אז אחד, יש לנו הדבר הזה שנקרא printf, שהוא
למעשה מקביל למילה יגיד.
זה מה שהוא הולך לעשות.
Printf, וf כאן פירושו "מעוצב".
אז זה רק אומר שאתה יכול להוסיף
פרטים אסתטיים שונים.
סוף הציטוט אז הוא תחילתו של מה שאנחנו הולכים
כדי להתחיל לקרוא מחרוזת.
מילה, משפט, משפט.
מחרוזת בשפת תכנות היא רצף של אפס
תווים או יותר.
אז h-E-l-l-o, פסיק, וכן הלאה היא,
סוף הציטוט, מחרוזת.
ועכשיו קו הנטוי n, קצת מוזר מבחינה תחבירית, אבל אנחנו
כבר הגדיר כי בשבוע שעבר כלמה התכוון?
זה רק קו חדש.
זה פשוט דרך של העברה למחשב שאתה רוצה
מקבילה של להכות הזן שם, אבל אתה לא
רוצה בעצם על Enter ולכן בלגן כל
עיצוב של התכנית שלך בפועל.
עכשיו הסוגריים מצרפים מחרוזת זו, פתוח וסוגר
paren הקרוב, ובתוך כך היא המחרוזת שלנו.
כי זה משום שבג' ותכנות, אחר
שפות, דברים כמו printf לקחת טיעונים, או לקחת
פרמטרים.
>> אז להתחיל לחשוב עכשיו על הבלוק הזה הסגול כיגיד
פונקציה, כשיטה, כנוהל.
אתה באמת יכול לקרוא לזה איך שתרצה לעת עתה, אבל
זה סוג של תכנית מיניאטורי שעושה אחד בלבד
דבר, בשורה אחת, לא פחות.
אז printf הוא גם מה שאנחנו הולכים להתחיל לקרוא
פונקציה, ופונקציות לעשות משהו - במקרה זה
מדפיס מחרוזת מעוצבת למסך -
אבל גם לקחת פונקציות טיעונים או פרמטרים.
ועל ידי טיעונים או פרמטרים, תודה לך, אנחנו מתכוונים
שהתנהגותם יכולה להיות מושפעת ממה שעובר ב
בתוך הסוגריים.
אז במקרה הזה, צרכימי printf יגידו לי מה להדפיס, ואנחנו
רק לעבור ב, במרכאות כפולות כאן, מחרוזת שאנו
בעצם רוצה להדפיס.
והפסיק בסופו של קו זה הוא פשוט
מטרד הסטורי לפיה בסופו של רוב שורות קוד,
אתה שם את פסיק לעשות סופר ברור למחשב
כי הקו הזה של קוד מסתיים כאן.
עכשיו זה טוב, כי כפי שנראים כתוכניות לקבל יותר
מורכב, הפסיק יעשה בני אדם סופר ברור לנו,
וגם במחשב, שבו שורות של קוד התחלה והסוף.
מבין שחלק מהשפות אין חלק
באותם פרטים אלה.
ואכן, ב-JavaScript, שאתה לא תמיד צריך משהו
כמו נקודת הפסיק.
אבל גם על זה שיבוא.
>> אז לולאות.
היו לנו משהו כזה, מאוד אינטואיטיבי, ברור, לעשות
משהו שוב ושוב ושוב.
כמו ללבוש גרביים, או אמירת שלום, במקרה זה.
ובכן, החל מיום ב-C, אנחנו יכולים להביע את שריטה זה
לחסום כבזמן (אמיתי) printf ("hello world").
אז שם לב שאנחנו מתחילים לבנות באופן מילולי את הפאזל
חתיכה מקודם.
יש לנו את אותו בלוק סגול, אבל זה בתוך זה
בצע בלוק סוגריים, והדרך הטובה ביותר לתרגם את זה
לC היא כדלקמן.
אין תמיד מילת מפתח.
אתה לא יכול פשוט להקליד f-o-r-e-V-e-R ב C.
אז האנלוגי הקרובה ביותר הוא זמן.
>> עכשיו, בזמן (נכון) נראה קצת טיפש, כי עושה את הערך
שינוי האמיתי אי פעם?
יש להניח שלא.
זה כמו להגיד בזמן אחד, ואילו ב, תוך נכון.
זה הכל אותו הדבר, נכון שתמיד קורה.
אז זה לולאה היא למעשה גרימה איזה סוג של לולאה?
פשוט לולאה אינסופית, נכון.
לולאה לתמיד או כפי שכינינו זאת בשבוע שעבר,
רק ללולאה אינסופית.
אז לפעמים זה רע.
לפעמים זה באג, לפעמים זה למה שאתה מקבל
כדור מסתובב החוף או שעון חול או כמו.
אבל במקרה הזה, אנחנו בכוונה, מכל
סיבה, רצתה להדפיס את אותו הדבר שוב
ושוב ושוב.
או במקרה של כמו שעון, אתה רוצה לעשות
משהו שוב ושוב ושוב.
כך לולאות אינסופיות אולי הגיונית.
וכך ב-C שאפשר לתרגם לתמיד לקוד.
>> אז עכשיו זה קצת יותר ספציפי.
היינו לנו לחזור 10 פעמים את המשפט הבא.
אז בזמן (אמיתי) לא ממש עובד שם, כי האמת היא
תמיד נכון.
אז אם אנחנו במקום להסתכל על גרסת C, עכשיו התחביר מקבל
קצת יותר מסתורי.
אבל אם להיות כן ברגע שתתחיל לראות את זה, את כל זה מקבל
די מוכר במהירות.
אז זה מה שנקרא ללולאה.
ללולאה הולך לספר את המחשב כדי לעשות משהו
שוב ושוב ושוב במשך זמן רב ככל
הדברים האלה הם אמיתיים.
עכשיו למה אנחנו מתכוונים בכך?
ובכן, יש שלושה חלקים ללולאה, ואנחנו הולכים
תחזור לזה בהקשר של ממשי
דוגמאות ברגע.
אז אל תדאג אם זה לא די לשקוע בהכל בבת אחת.
אבל אני int = 0 הם, סיפור ארוך קצר, ואמרו לי
משתנה זה מסוג המספר שלם, אז תן לי מספר
קרא לי, ולאתחל אותו ל 0.
זה נותן לי כמו x משתנה אלגברית ו
לאתחל אותו ל 0.
אבל במקרה הזה שקראנו את זה אני.
ואז באמצע, זה אומר שאני פחות מ 10.
שאומר את המחשב לעשות דברים כל כך הרבה זמן הבאים
כפי שהוא פחות מ 10.
וכמובן, הוא מתחיל פחות מ 10 כי
זה מתחיל ב 0.
אז לבסוף, אתה יכול אולי לנחש מה + + אמצעים.
זה קצת תחביר שרק אומר לי להגדיל.
אז להוסיף 1 ל i, שוב ושוב ושוב.
>> וכן, ככל שנראה לולאה זה, תחביר זה, אלא מיישם
בדיוק אותו הדבר, כי, בכנות, בגרד היה פשוט כל כך
הרבה יותר קל לבטא.
חזור על 10, וסיימת.
ב-C, וברוב שפות תכנות, אנחנו צריכים להיות
קצת יותר מאלף למחשב ולמעשה
לציין משהו כזה.
אבל אנחנו עוד נחזור לזה ותחביר אחר.
>> מה לגבי משתנים?
בשריטה שהיינו לנו משהו כמו בלוקים הכתומים האלה,
איפה אני יכול להצהיר על משתנה.
בואו נקרא לזה באופן שרירותי דלפק.
בואו לאתחל אותו ל 0, ולאחר מכן
בואו לנצח לעשות משהו.
במקרה זה בסריטות שאני אומר לדלפק, ולכן
החתול הולך להיות בועת דיבור קטנה שמדברת
המספר זה במשתנה זה.
ואז יש לנו נגד שינוי על ידי 1.
אז כל זה עטוף בתוך מנעול לנצח.
אז אנחנו כבר עכשיו יש את אובניים הבניין בC עם
אשר לתרגם את זה.
>> אחת דרכים שאנחנו יכולים לעשות את זה הוא זה.
תן לי מספר שלם, קורא לו דלפק.
לאתחל אותו ל 0
בשורה הראשונה שם.
אמנם (נכון), אז אני גונב מרעיון שרק לרגע
לפני, ללכת ולעשות את הדברים הבאים.
הדפס את הדלפק, ולאחר מכן להגדיל את הדלפק,
שוב, ושוב, ושוב.
או שוב, + + רק אומר להוסיף 1 למשהו.
אבל יש קטע חדש של תחביר כאן.
מה קופץ החוצה ברגע לא בין הדוגמות הקודמות שלנו?
כן, ד% זה.
אז אתה אולי יכול להסיק מה זה עושה, בכנות, על הבסיס
על מה לחסום סריטות הוא עושה.
אבל שוב ב-C, אנחנו רק צריכים להיות קצת יותר ספציפיים
כשזה מגיע לביטוי לעצמנו.
>> אז printf ("% d \ n").
ובכן רוב שאנחנו יכולים לזרוק כמוכרים.
הציטוטים רק אומרים שזה מחרוזת, הקו הנטוי n
רק קו חדש.
אז הדבר החדש היחיד כאן הוא ד%.
וכל מה שהוא מציין.
ד% הולך לציון מספר עשרוני.
ו% מחשב אמצעי ד, לשים מספר עשרוני כאן.
ובכן, מה מספר שאתה רוצה לשים שם?
ובכן, כפי שאתה אולי יכול להסיק, אחרי הפסיק אנחנו אומרים
מונה, זה השם של משתנה שהוכרזנו או
יצר כמה שורות קודם לכן.
אז זה פשוט הדרך של C של חיבור משתנה לתוך
מחרוזת באופן דינאמי.
כי לעומת זאת, אם הייתי עושה משהו במקום כמו
זה, printf ("נגד"), מה יעשה זה
תכנית במקום לעשות, כנראה?
זה ממש ידפיס "נגדי".
וזה לא האפקט שאני רוצה.
אני צריך להחליף בחלק הערך מספרי.
כך אוכל לראות כי פונקציות אז, כמו printf, לא יכול לקחת
רק טענות בודדות בלבד, כמו
"שלום עולם".
הם יכולים לקחת פסיק סוף הציטוט, ולאחר מכן כמה משתנים
שיקבל להתחבר אליה, כפי שנראים במחרוזת הקודמת
באמצעות מצייני סימן% אלה.
>> ובכן מה עם ביטויים בוליאניים?
ביטויים בוליאניים היו הערכים האלה, אמת או שקר.
כן או לא.
1 או 0.
או ביטול.
אז בגרד הם נראים כמו זה, ולהבחין כי
בלוק תחתון כאן הוא למעשה שיתוף
של שני רחובות קטנים יותר.
אז אני סוג של גררתי והורדתי שלושה חלקי פאזל
יחד כדי להפוך את חתיכת הפאזל כבר לא שם כדי שאני
יכול להעביר את הרעיון שאני רוצה x להיות פחות מ Y ו
y להיות פחות מ z.
וכך אני יכול לתרגם שני קווים נפרדים אלה כך.
הדף אחד יכול להיות מתורגם trivially מאוד ל-C,
רק עם x <y.
אולי עם סוגריים מסוימים למען סדר טוב.
ולאחר מכן ב-C, אתה לא כותב ולציון
שילוב של משהו.
אתה במקום לכתוב &&.
וכפי שסופו של דבר יראה, אמפרסנד אחת קורה
התכוון למשהו אחר.
אז && פשוט מציין את הרעיון ו.
>> אז שוב, למרות שזה מתחיל להיראות מורכב למדי,
אחת המטרות של החדרת סריטות, מלבד
רק שיש סוג של כיף על רמפה שבו אתה יכול לעשות
משהו שמאוד גרפי, ואנימציה, ו
shareable וכדומה, גם להעביר את הרעיון כי
כל הרעיונות שאנחנו מתחילים לצלול להיום ואילך
כבר מגולם באפילו כך פשוט
ממשק מאז יום אחד.
מה דעתך על זה כאן?
>> אז תנאים.
אז בלוק השריטות בצד השמאל יש נראה
קצת יותר מורכב.
אבל זה רק חלק והגרירה
נשירה של חלקים מוכרים.
אם x קטן מ-y, אז תגיד.
אחר אם x גדול מ-y, אז תגיד.
אחר, אנו יכולים להניח שזה הגיוני להסיק כי
הם חייבים להיות שווים.
אז להגיד שהם שווים.
עכשיו ב-C באותו הדבר הנכון, מדויק.
ושים לב שהסוגריים המסולסלים הולכים להיות
תכונה של C ושפות אחרות שלא עושות סוג זה
של אנקפסולציה.
בדיוק כמו אם בלוק הוא הדבר הצהוב הזה זה סוג של
תופס בלוק הסגול בתוכו.
כמו כן הן סיכות אלה -
סיכות אלה מסולסלים -
נועד להעלות באוב את אותו רעיון של אימוץ אחד או יותר
שורות קוד שמסוכסך בתוכם.
אז בצד הימני כאן, אם x קטן מ-y, printf
("X קטן מ-y").
אחר אם x גדול מ-y, להדפיס אותו.
אחר להדפיס שהם שווים.
>> אז בקיצור, יש מיפוי או תרגום ישיר למדי
בשפה שראינו עד כה, כולל לחלק
מהתכונות המתוחכמות יותר.
אז אתה לא יכול להיות באמצעות זה לפרויקט שלך, ואולי גם לא
להיות באמצעות זה לפרויקט שלך השבוע.
אבל יש לנו את הדברים האלה קראו במערכי ג בלגרד,
הם נקראים רשימות.
וראינו את אלה עם Fruitcraft RPG בשבוע שעבר.
הבחור הקטן והכחול שהסתובב, להרים
דובדבנים ותפוזים וכדומה.
ובכן בלגרד, שיושם עם זה כתום
לחסום המכיל מילים, במקרה זה, אנחנו ממש
הוספה "כתום" כדי
משתנה בשם המלאי.
אז ב-C, תחביר זה הולך להיות קצת יותר מסתורי.
ואנחנו נחזור לזה בשבוע הבא ולעשות יותר
דברים מעניינים בעולם של קריפטוגרפיה עם זה.
אבל כאן בתחתית, שתי שורות אלה למעשה
לתרגם את מה שאנחנו עושים בשריטה אחת לחסום שם למעלה.
אבל גם על זה שיבוא.
>> כדי לשים את זה ביחד, כאן הוא תכנית ב C. אז בואו
להקניט את המהירות מלבד כמה חתיכות של תחביר כאן, אבל
אז בואו באמת תתחילו לכתוב קצת קוד, להכיר
אתה עם כמה מהכלים שאנחנו משתמשים, ולראות אם אנחנו
יכול לבנות על עכשיו כמה מאבני הבניין הבסיסיים אלה מ
בשבוע שעבר, עכשיו מבחינה תחבירית בC. אז בראש כאן, זה
היא אולי האחת התוכניות המשעממות ביותר שאתה יכול
לכתוב בכל שפת תכנות ביותר.
אבל היא איכשהו יש משמעות מיוחדת בגלל שזה
תכנית קנונים שכל מדען מחשב כותב כש
ללמד מישהו שפת תכנות -
תכנית שלום עולם.
>> אז בחלקו העליון, אנו רואים את הרעיון הזה של # כולל
ולאחר מכן, בסוגריים הזוויתיים, stdio.h.
אנחנו הולכים לחזור לזה, אבל באמת מה ש
פירוש דבר הוא כי קיים קובץ בעולם הזה שנקרא סטנדרטי
I / O, stdio נקודת שעות, וזה רק קובץ טקסט ה
מישהו כתב לפני שנים.
ובתוך קובץ טקסט שהם קבוצה שלמה של
פונקציות, או בשיטות או בנהלים, שמישהו אחר
כתב שהם מקבלים, כי אנחנו
כעת תוכל להשתמש בקוד של אותו האדם.
את הפונקציות שהוא או היא כתבה.
במקרה זה, printf זה לא משהו שאני כתבתי, זה
לא משהו שCS50 כתב.
זה משהו שמישהו כתב לפני שנים ולשים
קובץ שנקרא stdio.h ואז, כבדרך אגב, לשים
חלק אחר של הפונקציה בקובץ אחר.
אבל אנחנו נגיע לשם.
>> אז # כולל הוא פשוט הדרך שלנו לומר, ב
C, לתת לי גישה לפונקציות שמישהו אחר כתב.
ובמקרה זה שאכפת לי כי אני רוצה printf.
עכשיו אנחנו מקבלים int main (void).
אז זה אחד מהדברים האלה, בכנות, כי ביום 0,
די לי לסוג של את האיזור, כי זה פשוט
לא מעניין
מבחינה אינטלקטואלית, חלק מהתחביר.
אבל לעת עתה יודע כי פונקציות, הידוע גם בכינויו
נהלים, או שיטות, בדרך כלל לייצר איזה שהוא ערך.
הם עושים משהו.
הם באים עם תשובה.
הם מייצרים פלט.
אז int ליד עיקרי היא רק דרך הקיצור שלנו אומרים
שפונקציה זו, הליך זה, סופו של דבר הוא הולכת
כדי לתת לך חזרה מספר.
ולמה שהוא, אנחנו נחזור אליו.
העיקרי הוא הסטנדרט העולמי לברירת מחדל ברירת המחדל
פונקציה שהולכת לקבל להורג בתכנית C כש
אתה מפעיל את זה.
החלל רק אומר את הדבר הזה, עיקרי, לא לוקח
טיעונים, במקרה זה.
אז אני סופר להיות מפורש.
אין שום התחייבויות בשם, אין שום פסיקים.
Void אומר שאין טיעונים לראשיים.
>> עכשיו לבסוף, למרבה המזל, שתי השורות האחרונות הן מוכרות.
בתוך הסוגריים המסולסלים יש לנו printf
ויש לנו תמורה.
והתמורה היא סוג של מזל שיש לנו כדי
הכניס אותו לשם, כי במקרה הזה זה לא עושה את כל מה ש
חלק גדול מעניין.
אבל בתוכנת מחשב, כאשר פונקציה מחזירה 0,
זה אומר שמכיל בסדר.
שום דבר לא השתבש.
לעומת זאת, אם פונקצית המחזירה 1, או 1 שלילי, או
1337 שליליים, או כמה מספרים אקראיים כמו ש, כי
בדרך כלל אומר שבעצם התרחשה שגיאה.
אז אם אתה ב-Mac או במחשב האישי שלך, אם אי פעם ראית
מסר כלשהו מעצבן כי המחשב שלך התרסק או
קפוא, ויש הודעת שגיאה סתומה,
ועוד קצת קוד, כמו קוד מערכת
1,2,3,4, חלק מספר,
כי בדרך כלל הוא פרט מיותר לספר
רובנו בני האדם, אבל זה מה שאיזה אירוע כלשהו
תכנית בעצם חזרה, ערך שאינו אפס.
והיתרון של זה הוא ש0 פירוש כל, כמו גם, ו
אז אתה בעצם יש מספר אינסופי של דברים ש
יכול להשתבש.
זאת הסיבה שהם בחרו 0 לטובים וערך שאינו אפס עבור
רע, כפי שמייד תראו.
>> אז בואו נלך קדימה ולכתוב את זה.
אז זוכר שלפני כמה הימים הייתי מק להיפתח
חלון מסוף, ולאחר מכן פתחתי את תכנית טקסט, כמו
TextEdit, והתחלתי לכתוב קצת קוד.
טוב, זה בסדר גמור.
אבל הניסיון שלך הולך להיות שונים במקינטוש, או
על Solaris מחשב, מחשב לינוקס, מה הפעלה
מערכת יקרה לך להיות באמצעות.
וכן בקורס, מה שבמקום להשתמש במשהו
קרא CS50 Appliance.
אז CS50 המכשיר הוא חתיכה להורדה של תוכנה
שמאפשר לך להריץ מערכת הפעלה שנקראת לינוקס,
במיוחד פדורה לינוקס, ב-Mac או במחשב האישי שלך.
ואתה עושה את זה על ידי הורדת משהו שנקרא hypervisor.
אז כל זה יהיה מתועד בסט בעיה 1.
ואתה תהיה הובלת לכיוון מה שאתה צריך להוריד.
אבל התוצאה הסופית, בין אם יש לכם מק או PC, היא
להוריד כמה תוכנות חופשיות.
לאחר מכן עליך להוריד את מכשיר CS50, ואתה אומר ש
תוכנה חופשיה - hypervisor -
כדי להפעיל את מכשיר CS50 בחלון במחשב שלך.
ומה שקורה הוא זה.
>> יש לי עכשיו, שים לב כאן, מה שנראה כמו שולחן עבודה
הסביבה.
ותנו לי באמת מתכווץ החלון הבודד הזה.
אז זה כרגע הוא Mac שלי, עם חלון קטן כאן, ובתוך
בחלון זה קורה להיות לחלוטין
מערכת הפעלה אחרת.
ואכן יש תפריט התחל זה כאן למטה, מזכיר
חלונות, שיש לו חבורה שלמה של תפריט משנה, לרבות
קישור לCS50 הידני, Dropbox, וכמו.
ומה סביבה זו כרגע היא סביבה סטנדרטית
שכל אחד מאיתנו יכול כעת להשתמש, כך שלא משנה מה שלך
מחשב הוא, מה יש לך ולהתקין עליו, איזו גרסה
של Mac OS או Windows שאתה מפעיל, כולנו עכשיו יש את
אותה הסביבה.
ועכשיו בסביבה זו אנו יכולים להתחיל לכתוב קוד כלשהו.
>> אז אני הולך קדימה, לפתוח בתכנית בשם gedit.
זה דומה לnotepad.exe, או
TextEdit על מק.
וזו רק תכנית לעריכת טקסט פשוטה סופר
שנראה כך במבט הראשון.
עכשיו בחלק עליון, יש לי לוח לבן, בתחתיתי
יש חלון השחור הזה שאומר @ מכשיר jharvard.
וזה משום שחשבון המשתמש שנוצרנו מראש,
לכולם נקרא ג'ון הרווארד.
יש לו תיקייה שבה כל הקבצים שלו הולכים לעבור, ו
כאן מקום שבו אנחנו יכולים להתחיל לכתוב קוד כלשהו.
אז תן לי ללכת קדימה פה ולהתקרב קצת, ואני
הולך לעשות # include , int main (void), ו
אז אני הולך לעשות printf ("hello world")
, להחזיר 0.
עכשיו כל זה ממש שחור ולבן.
>> תן לי ללכת קדימה ולעשות דבר אחד ללמד gedit מה אני
בעצם עושה.
תן לי ללכת לשמירה בשם.
אני הולך לבחור בצד השמאל כאן jharvard.
אז שוב, גם אם מעולם לא השתמש בלינוקס לפני, בכנות
בימים אלה, כולם צללו לתוך המהות
אותו סוג של ממשק -
Mac OS, Windows ו-Linux.
אז בחרתי תיקיית הבית של jharvard כאן.
ואני הולך לשמור קובץ זה כhello.c.
אז בחלקו עליון, שהקלדתי hello.c; שמות ג
תכנית עם. הארכת ג היא
מה מנהג נפוץ.
ואני מכה על שמור.
ועכשיו מה שיפה הוא שאני כבר למדתי ביעילות gedit,
כי מדובר בתכנית C.
שימו לב שהטקסט השחור ולבן שלי עכשיו מקודד לפי צבע, או
התחביר הדגיש, שפשוט מושך את תשומת הלב ל
חלקים סמנטיים שונים של התכנית.
בחלק שמאלי העליון שם, כמו התוכניות שלי מורכבות יותר ויותר, אני
הולך להיות סיכום של כל הדברים שכתבתי.
אז זה אותו שם.
אז תן לי עכשיו להתרחק ולרדת לחלון מסוף זה.
>> אז זה אולי חדש לאנשים רבים.
אם מעולם לא השתמשתי בסביבת שורת פקודה, אתה אף פעם לא
שימוש DOS, או שמעולם לא השתמש לינוקס, או שמעולם לא נפתח
חלון מסוף Mac OS שלך, יש הרבה דברים שאתה
יכל לעשות עם GUI, כגון הצבעה, ולחיצה, ו
גרירה ושחרור, וכדומה, אבל באופן כללי -
בוודאי בעולם של מדעי מחשב -
שימוש בשורת פקודה, שבו אתה לא צריך עכבר
בדרך כלל, יש לך מקלדת שלך בלבד, הוא למעשה הרבה
חזק יותר מממשק, ברגע שתתרגל ל
פקודות שונות.
ואתה בעצמך סוג של תשלום של צורך להצביע וללחוץ
בכל דבר.
אז בgedit נטפלנו בליהנות מהטוב שבשני העולמים.
אנחנו יכולים לגרור ולשחרר את הטקסט, אנחנו יכולים לראות את זה
נחמד וצבעוני.
אבל כאשר זה מגיע זמן להפעיל את התכנית שלנו, לפעמים
פשוט להשתמש בחלון הקטן הזה כאן.
>> אז אני הולך קדימה ולעשות את זה.
בחלון השחור ולבן התחתון, אני הולך קדימה
ולכתוב קלאנג.
וצלצולים, הוא השם של מהדר.
מדובר בתכנית שממירה את קוד המקור שלי
ל, ולכן, קוד אובייקט.
0s ו 1s, שראינו בשבוע שעבר בקצרה.
כזכור משבוע שעבר, הבטחתי שאנחנו הולכים
ללכת ממשהו כזה - שהיינו צריך להיות
משהו כמו זה -
וזה בהחלט לא משהו שאדם הולך
לעשות באופן ידני.
אז במקום שאנחנו הולכים להשתמש בתכנית, וכי התכנית ב
מקרה זה נקרא קלאנג.
והשם של התכנית שלי הוא hello.c.
אז כדי לקמפל מקוד המקור hello.c אל
קוד יעד, או 0s ו 1s, זה צריך להספיק רק לעשות
זה ולחץ על Enter.
>> אוקיי, נראה כאילו כלום לא קרה.
אבל אני יודע עכשיו, או משבוע שעבר, ששם ברירת המחדל של
תכנית, כאשר כתבו ב-C, נקראת טיפשות a.out.
שם לא מעניין ביותר שאתה יכול לבוא עם.
היא האות הראשונה של האלפבית, את מה שהיה
outputted, אבל ניחא.
זו התכנית שלי, ועכשיו נקודת לוכסן, כפי שנראה, הוא
למעשה רק סוג של תכונת אבטחה, כי
a.out הוא תכנית שכתבתי.
זה לא בא עם המחשב שלי, זה
לא בProgram Files.
זה לא בתיקיית היישומים של Mac OS.
אני צריך להיות סופר מפורש עם המחשב, ואומר
תכנית זו, a.out, היא בתיקייה הנוכחית,
ספרייה נוכחית.
והדרך שאתה מייצג זה בסביבה כזאת
היא הנקודה מייצגת כל מה תיקייה שנמצאת כעת פנימה
וכך. / רק אומר a.out לרוץ
בתיקייה הנוכחית.
ואני רציתי בזה עם זן, וזהו, התכנית הראשונה שלי.
>> עכשיו בואו תיקחו אותי צעד אחורה.
החלון זה קצת קטן, ולהבין שהתחתית
השאיר במכשיר כאן הוא סמל אחר.
אחת הוא כרום, שאמור להיות די מוכר, רק באינטרנט
דפדפן הפנימי של המכשיר.
וסמל שחור ולבן זה רק
חלון מסוף גדול יותר.
אז אם זה נעשה קצת מעצבן למיין של יש פשוט
פרוסה זה קטנטן של חלון שבאינטראקציה
עם תוכניות, אנחנו יכולים לעשות את זה במקום.
ועכשיו הרשה לי להתחיל להקליד כמה בקרוב
להיות פקודות מוכרות.
ls.
אז ls הוא הפקודה לרישום.
אז ב- Mac OS או Windows, שהיית בדרך כלל ללחוץ פעמים
תיקייה ולאחר מכן, וזהו, אתה רואה את כל קבצים השונים
ותיקיות.
בסביבת שורת פקודה, שבו אתה יכול להקליד רק
פקודות או טקסט, ls היא שווה הערך.
אז תראה לי מה שיש במדריך זה.
>> עכשיו יש כאן חבורה של דברים, שהוא גם קטן
מוכר וקצת לא מוכר.
אבל שים לב שבדיוק כמו Windows ו-Mac OS, jharvard
יש תיקיית שולחן עבודה.
אז סמלים כלשהם שנמצאים בשולחן העבודה שלי יקרו
להיות באותה תיקייה.
יש תיקיית הורדות, דברים ש
כרום יכול לשים שם.
Dropbox.
אז המכשיר מגיע עם תמיכה מובנית לDropbox
כך שבמשך הסמסטר, אתה יכול לסנכרן עם Dropbox
חשבון, כך שכל התוכניות שלך מגובה.
הם נגישים במחשב האחר שלך.
אם משהו משתבש עם המכשיר, אתה יכול
מאוד בקלות להתאושש מDropbox.
אז התיקייה שנמצאת שם בשביל זה.
יש שני קבצים שנעשיתי - hello.c
וa.out.
ואז לימין יש כמה תיקיות אחרות שעוד
להגיע לקראת הסוף הסמסטר, באינטרנט
תכנות.
אז כשאני עושה. /, A.out, Enter, זה אומר ללכת
בספרייה אני ב, הספרייה הנוכחית, ולהפעיל את
תכנית בשם a.out ממש שם.
>> בסדר, כך שזה נחמד וטוב, אבל זה לא כל כך
משכנע לכתוב תכנית בשם לעזור a.out.
אז אנחנו באמת יכולים לעשות את זה קצת אחר.
אז במקום סתם צלצול ריצה, hello.c, בואו נוסיף
מה שנקרא ארגומנט שורת פקודה.
אז טיעון של שורת פקודה, או מתג במקרה זה, הוא פשוט
עוד מילה או צירוף מילים שהקלדתם בשורת פקודה לאחר
התכנית שאתה רוצה לרוץ.
אז במקרה הזה, צלצול הוא התכנית אני רוצה לרוץ,-O
פלט באמצעות קובץ שכבר לא נקרא a.out.
פלט קובץ בשם השלום, ולעשות זאת על ידי איסוף
המילה אחרונה בשורה, hello.c.
אז בקיצור, זה שיפור מאוד שולי, לפיה
במקום שיש a.out קובץ בשם זה בטיפשות,
עכשיו אני יכול לעשות צלצול-o שלום, אז hello.c, ו
לאחר מכן על Enter.
שום דבר לא נראה שיקרה, אבל שוב הרבה כמו עם 0 - כאשר
נדמה ששום דבר יקרה זה אומר ששום דבר רע שקרה -
אז בואו נעשה ls עכשיו, זן, ואכן אני עכשיו
יש תכנית שלום.
אז אם אני מקליד שלום עכשיו, פקודה לא נמצאה.
בסדר,. /.
אז בדיוק נכון.
לכן, מכיוון שהתכנית שכתבתי, וזה לא בא עם
המחשב,. / שלום, Enter, אומר
עכשיו אני רץ שלום.
>> אז זה מה שיש.
עכשיו מה שנעשינו בסופו להגיע לשורת פקודה יותר ויותר
טיעונים שמאפשרים לנו לעשות יותר, אבל רק לאלה ל
מי זה יכול להיות כובע ישן, תן לי למעשה להיכנס
ספרייה כאן ורק לתת לך טיזר של כמה אחר שאנו
אפשר ללכת על יישום שלום העולם.
תן לי ללכת לכאן, ואני הולך לפתוח אותו.
כך שלמעשה, אני הולך להסביר מה אני עושה, ולכן
זה שימושי.
תן לי בחזרה למעלה.
>> אז אני עושה את זה כבר זמן רב.
אז שם לב מצד ימין יש כמה
ספריות הנקראות בשמות מוזרים source1m וsource1w.
זוהי רק מוסכמה המטופשת אנו משתמשים.
מקור רק אומר שקוד מקור, 1 פירוש זה הוא שבוע אחד, ו
מ 'אומר שזה יום שני, וw אומר שזה יום רביעי.
כך ששום דבר מסתורי שם.
זה פשוט סימון מקוצר.
הדברים הכחולים האלה הם תיקיות, הידוע גם בכינויו
ספריות.
אני רוצה להיכנס לתיקייה שעכשיו, ועל מחשב רגיל
אני יכול פשוט ללחוץ לחיצה כפולה על סמל תיקייה ו
יש את כל הקבצים שלי.
אבל בסביבת שורת פקודה, אני לא ממש יכול לעשות
ש, אז במקום זה, אני צריך לשנות ספריות באופן ידני.
אז אם אני מקליד CD ולאחר מכן source1m, Enter, תבחין כי
הפקודה, הדבר בלבן בצד שמאל, פשוט השתנה.
וכך אכן, כאשר הוא רק אמר סוגריים ולאחר מכן את
שרבוט קטן, סמל טילדה, שנועד רק לי היה
בספריית הבית של ג'ון הרווארד, מסמכיו שלי,
הקבצים האישיים שלו.
אבל עכשיו בסוגריים זה אומר ~ / source1m.
זה רק אומר שאני בתיקייה בשם source1m
זה בספריית הבית של ג'ון הרווארד.
אז אם עכשיו אני רוצה להציג את הקבצים בתיקייה זו, קל
שאלה, אני פשוט מקליד ls.
ועכשיו אני רואה את כל קבצים שנוצרתי מראש להיום
הרצאה, שכל, או רובם, תקרה
לסיים ב. ג.
>> אז תן לי ללכת קדימה עכשיו ולהפעיל gedit של תכנית בשם
holloway.c, אשר נכתב על ידי כמה האקר אקראי
באינטרנט, שנראה קצת כמו זה.
ואנחנו לא מתכוונים לעבור על זה בכל
פרטים, אבל עבור אלה נוחים יותר, בפרט, אם
אתה רוצה לקחת ניחוש מה התכנית הזו עושה כאן.
היה סמוך ובטוח, בין אם אתה פחות או יותר בנוח,
אנחנו אפילו לא להגיע לדברים מהסוג הזה עד סוף
בסמסטר הזה.
זה מה שדוגמה של תחרות עורפלה C, ה
אמצעי לכתוב תכנית מחפשת המסתורית ביותר שאולי
יכול לעלות על אנשים חכמים אחרים, שהם באופן דומה
מנסה לכתוב את הדברים ולהראות לעולם שהם יכולים לכתוב
דברים נסתרים יותר ממך.
אז זה לא דוגמה לתכנית כתובה היטב מ
פרספקטיבה של סגנון, זה היא דוגמה לתכנית ש
זוכה בתחרות, לאנשים שמנסים
להיות מעורפל ומופשט.
>> אז אם אנחנו מנהלים את הדבר הזה, תן לי ללכת לחלון המסוף שלי,
אם אפשר לומר כך.
אז סביבת שחור ולבן זה נקרא
חלון מסוף באופן כללי.
תן לי ללכת קדימה ולעבד אותו.
אני לא מתכוון להשתמש בצלצול, כי תכנית זו היא
לא ברור מספיק ושהוא צריך שונה
מהדר, אחת בשם GCC.
אבל זה עושה את אותו דבר.
זה לוקח קוד מקור לקוד יעד.
ועכשיו אם אני מפעיל a.out, תכנית שבה
פשוט ראיתי שעושה זאת.
כך שהבחור שזכתה בתחרות בשנה ש.
בכל אופן, אנחנו לא הולכים בכיוון זה, כשלעצמו.
>> אז בואו ננסה דווקא עכשיו להקניט בנפרד מה אנחנו יכולים לעשות
עם אובניים הבניין הבסיסי אלה כדי להפוך יותר ויותר
תוכניות מעניינות.
אז כתבתי תכנית, נגמר לנו תכנית.
עכשיו אנחנו באמת יכולים לפשט וכבר לא צריכים לכתוב
מילת הצלצול בשורת הפקודה.
מתברר שהתוכניות שלנו מקבלות יותר מסתוריות, שאנחנו יכולים, או
יותר מורכב למדי, אנו יכולים למעשה מפעילים את הפקודה הזו.
אז תן לי לחזור לספריית הבית שלי, אם אפשר לומר כך, הרשה לי
להסיר - RM הוא פקודת ההסרה - אני הולך להסיר
את הקובץ שנקרא a.out ושלום.
ועכשיו שם לב בסביבת שורת פקודה, כמו ב
GUI, אתה מקבל תתבקש לעשות זאת. אני לא יכול ללחוץ על כפתור ש;
צריך להקליד y עבור כן, y עבור כן.
ועכשיו אם אני מקליד ls שוב, שים לב שאלו ירוקים
תוכניות - a.out ושלום -
הם נעלמו.
היזהר rm.
הוא יכול לעשות דברים רעים, בדיוק כמו שתוכל על ידי גרירה
דברים לזבל שלך.
>> אז עכשיו בוא נלך קדימה - ואני יכול לעשות את זה - צלצול-O
הלו, הל -
אני כבר משועמם הקלדת פקודה ש.
למרות שהקלדתי אותו קצת מהירות.
אז אנחנו יכולים לעשות במקום לעשות שלום.
אז להפוך אינו מהדר.
זה רק תכנית ידידותית שמגיעה עם לינוקס, בזה
מקרה - מערכת ההפעלה -
שממכן את תהליך קומפילצית תוכניות.
אז במקום לזכור את שם קובץ ומצלצל-O
אז כן הלאה, במיוחד ברגע שהקווים האלה מקבלים יותר ו
יותר, אני יכול רק לכתוב לעשות.
וזה הולך לו לפלוט את כל חבורה של דברים ש
סופו של דבר יראה בסמסטר הזה.
אבל שם לב עכשיו אם אני ls הסוג, שלום הוא חזרה בספרייה שלי.
ואכן אני יכול להפעיל אותו עם. / שלום.
אז לעשות רק לאוטומטי את התהליך של ריצה מה שהיה,
במקרה זה,, פקודה מורכבת יותר עוד הרבה זמן.
אז אנחנו הולכים להתחיל להשתמש באיפור, רק בגלל שזה הרבה
יותר ידידותי למשתמש.
>> אבל עכשיו בואו נעשה את תכנית מעניינת יותר
מסתם להגיד שלום.
לכן, בתוכניות שכתבנו עד כה יש ראשי.
זה בדיוק הדבר שברירת מחדל בעיטות מחוץ הכל.
אבל יש תפקידים אחרים שם בחוץ, כמו גם, ו
stdio.h הוא הדבר שאותו ראה בראש שלנו
קובץ לפני, וזה מה שנקרא ספרייה הסטנדרטית.
בתוך הספרייה הסטנדרטית היא חבורה שלמה של פונקציות
שמישהו אחר כתב, ואנחנו יכולים להתחיל באמצעות אלה
פונקציות לכתוב יותר
תוכניות מעניינות את עצמנו.
>> אז תן לי לחזור למכשיר.
אני הולך לסגור את חלון מסוף זה.
אני הולך לסגור את הדברים שכתבנו קודם לכן, ופשוט ללכת
לhello.c, ושם לב עכשיו שאני יכול לעשות את הדברים הבאים.
שלום העולם הוא לא כל כך מעניין, שהייתי רוצה
אישית התכנית הזאת לעצמי.
אז במקום לומר עולם, אני הולך
קדימה ואומרים -
אני יכול להקליד דוד - אבל זה באמת סוג של
ביסוד.
אבל בואו ננסה את רעיון מציין מיקום זה.
יזכיר כי ב-C, ולא בprintf, היו לנו אלה
מצייני מיקום, ויש יותר מסתם ד%.
אז% ד היה, לבדוק את השפיות מהירה.
אוקיי, מספר עשרוני, זהו זה.
ספרות אחרי נקודה עשרונית, זה הכול.
אז ג%, כפי שאנו נתקלים, הולך להיות אופי.
שים את דמות כאן, מכתב דרך z,
או סימן פיסוק.
מישהו תו בודד,% f, יודע משפות אחרות?
אז ערך נקודה צפה.
מספר אמיתי.
אז לא מספר עשרוני - זה הוא למעשה מספר אמיתי עם
נקודה עשרונית, וחלק מספר הספרות לשמאל
וזכותו שלו.
% s, מייתר.
שבו אנחנו הולכים לראות לעתים קרובות למדי.
מחרוזת, שוב, היא רק מילה, ביטוי, רצף של
תווים בודדים.
ולבסוף, LLD?
אז זה יותר ממקרה פינה.
ארוך, ארוך עשרוני.
אז אם אתה רוצה לא רק מספר שהוא גדול, שזה
רוצה מספר גדול יותר, אתה הולך צריך לציין ל
המחשב שהוא בגודל מסוים.
>> אז בואו לצבוט זה קצת.
במקום קוד קשה רק בדוד, תן לי קצת
דינמי אומרים% s.
אז שם% s כאן, שהוא מציין מיקום עבור מחרוזת.
אז תן לי לעשות פסיק, ולאחר מכן "דוד" כאן.
עכשיו זה לא כל כך מעניין מבחינה אינטלקטואלית,
בגלל כל מה שעשיתי עכשיו הוא באמת ליצור יותר עבודה בשביל
המחשב.
במקום להגיד למחשב לעשות את זה בבת אחת, אני עכשיו
אמר לעשות את זה ולהכניס מחרוזת כאן סופו של דבר, פסיק,
כאן היא מחרוזת ש.
אז זה לא שיפור טוב יותר, אבל זה לפחות
צעד לקראת תכנית מעניינת יותר.
כי עכשיו, תן לי ללכת קדימה ולעשות חלון זה קטן
גדול יותר, תן לי להמשיך ולרוץ לעשות שלום.
ועכשיו,. / A.out לא עובד, למה?
בסדר, עכשיו זה נקרא שלום.
אז שוב לעשות, וגם עם צלצול-O, שם
תכנית להיות משהו יותר מעניין.
וזהו: עכשיו זה אומר שלום דוד.
>> בסדר, עדיין תכנית מטופשת.
אז עכשיו בואו באמת נחזור לכאן ולהציג את הרעיון
של משתנה.
האם לא יהיה זה נחמד אם אני יכול להצהיר על משתנה
הסוג שלו היא מחרוזת?
והערך של המשתנה מגיע דווקא מהמשתמש
או את עוצמה.
אז באופן שרירותי, אני הולך לקרוא למשתנה שלי, שהיא
פשוט כנס משותף כאשר יש לך משתנה אחד בשם
המחרוזת.
אני הולך לעשות את סימן שוויון, ואז אני הולך לקרוא
פונקציה שנקראת GetString.
אז GetString זה לא משהו שמגיע מובנה בתוך ג זה
פונקציה שצוות CS50 כתב, באמת רק בשביל
אלה הזוג הראשון של שבועות, כדי לפשט את התהליך של
מקבל קלט ממשתמש וצובר קלט משתמש בצורה
של מחרוזות או מספרים, וכאלה.
אז GetString הוא כמו printf, אבל ברור שלא
להדפיס זה הולך לעשות את מה שהשם שלה אומר, מקבל מחרוזת.
אבל להשתמש GetString, אנחנו הולכים צריכים לעשות שינוי
כאן, מעבר לזה.
אז באופן אינטואיטיבי, תכנית זו, בתקווה, הוא הולכת איכשהו
מקבל מחרוזת מהמשתמש, ואז מה זה הולך לעשות
עם מחרוזת, בשם של?
זה רק הולך להדפיס אותו, נכון?
עדיין לא תכנית מגרה כי כל מה שקורה
לעשות הוא תקע שבערך לתוך בי% s
אומר שהוא צריך ללכת.
>> אז בוא לפחות לראות את זה בפעולה.
בואו להציל אותי ולהקטין את התצוגה.
עכשיו בחלון המסוף, פה למטה, פרוסה הקטנה של אחד,
תן לי שוב לעשות לעשות שלום.
אוקיי, ואה, לעזאזל, יש לי חבורה שלמה של טעויות.
בואו לגלול אותי, ואנחנו רואים אותנו ראשון -
אז בוא באמת לעשות את זה בחלון גדול עוד יותר, כך שאתה
יכול לראות איך פשלתי -
עד לשלום.
אוקיי, זה אסון, נכון?
כתבתי שלוש שורות של קוד, ו
זה נתן לי 12 שגיאות.
אז למה זה?
אז למרבה המזל, לעתים קרובות כשאתה רואה הרבה, הרבה שגיאות
יורק החוצה בבת אחת, זה באמת רק בגלל שיש לך
מבולבל המחשב עד כאן.
והוא נשאר מבולבל עד שזה יגיע לכאן.
וכך זה רק מתחיל למעוד, וכושל, ו
לירוק מפחיד יותר מדווקא חל.
אז באופן כללי, תמיד להתחיל עם העליון.
>> אז רוב למשל מאוד העליון של אדום,
הודעת שגיאה היא זו.
שימוש במחרוזת זיהוי לא מוצהרת, לא אני
מתכוון סטנדרטי ב?
אני לא עשיתי זאת.
התכוונתי מחרוזת, אבל זה בגלל שגם מילת המחרוזת
שאני שומר את השימוש מילולי למעשה
לא קיים ב-C גם.
זה משהו שאנו נשתמש רק בשבוע הראשון או שתיים
כאן, אבל זה קיים בקובץ בשם cs50.h.
אז לעת עתה, יודע שיש ספרייה אחרת זה כי
צוות כתב, כך שזה נכתב בתקופה מאוחרת יותר מאשר
stdio.h.
אבל בתוך cs50.h הוא הגדרה, מילה נרדפת של
מינים, שיוצרים מילה במחרוזת זו.
>> אז עכשיו תן לי לחזור לחלון המסוף שלי.
אני הולך לנקות את כל הבלגן הזה על ידי Ctrl-L. עכשיו פשוט
למחוק הכל נקי, ואני מתכוון להמשיך ולעשות
הלו שוב, לחץ על Enter.
אז מה קרה עכשיו?
עכשיו כל השגיאות האלה הלכו משם.
אז מה באמת עשיתי?
פשוט אני כבר למדתי את המחשב שמחרוזת קיימת, וזה
שבקובץ שנקרא cs50.h.
אז להפסיק להתלונן, כי עכשיו אתה יודע איפה למצוא את
ההצהרה כי הפונקציה של כביכול.
איפה זה קיים בעולם.
>> אז עכשיו אני הולך קדימה ולרוץ שלום.
נראה לי ללולאה אינסופית, שום דבר לא קורה.
אז אני צריך להקליד משהו כאן, נכון.
שורת הקוד הראשונה בתכנית שלי הייתה GetString.
אז זה ממש מחכה לי כדי לקבל מחרוזת.
אז במובן הזה, כן, זה הוא לולאה אינסופית.
כנראה בGetString היא התנהגות ברירת מחדל שאנו
כתב - צוות -
שפשוט אומר לחכות ולחכות ולחכות ולחכות ולחכות,
עד שהמשתמש נותן לך על ידי הקלדת מחרוזת משהו פנימה
אז תן לי ללכת קדימה וסוג ב D-v-- i-D, Enter.
וזה מה שיש, שלום דוד.
>> עכשיו האם זה נראה כאילו זה רק מעשה?
תן לי ללכת קדימה והקלד בטומי.
הזן, בסדר, נראה שזה עובד.
עבודות עבור רוב, עבודות לZamyla, עובדות - בסדר.
אז זה הולך לעבודה, סביר להניח.
אז זה צריך להדפיס את כל מה שאנחנו בעצם נותנים לו,
ואנחנו יכולים להיות קצת קשים כאן.
בואו נראה אם ​​אנחנו עושים משהו כמו שלום.
יכול ללכת לכאן, בואו נראים, להעתיק, להדביק.
אני לא הולך להיות מסוגל להדביק את זה כאן פעמים רבות.
דבק, בסדר, Shift + Ctrl + V. אז מה יכול
קורה שרע כאן?
>> אוקיי, אז, segfaults.
אז כמה מכם עם רקע קודם ישמח לדעת כי
בדרך כלל, נותן מחשבים המון כניסות כשהם
כנראה לא נועד לקבל שמות ארוכים כמו זה - רעים
לדברים לקרות.
אכן, בעולם של האינטרנט, גם זה קורה לא מעט,
לפיו כאשר אתה מעצב אתר, כשאתה
העיצוב פייסבוק, יש לך לקבל החלטות שרירותיות עד
קדמי, כמו כמה זמן יהיה של מישהו
פייסבוק שם המשתמש יהיה?
או כמה זמן יהיה שמו הפרטי של מישהו להיות?
כמה זמן את מספר הטלפון של מישהו יהיה וכדומה.
ואם מתכנתים עושים הנחות רעות, תוכניות לשבור
מפני שאתה מנסה לתת להם יותר תפוקה, יותר קלט
לייתר דיוק, ממה שהם צריכים זיכרון.
או הזיכרון RAM שהוקצה עבורו, ולכן אם עכשיו אני על Enter,
תכנית שעבדה בפועל, מכיוון שהיינו בספרייה
ואנחנו בכלל צפינו מקרה הספציפי הזה.
אבל אין ספק שהסמסטר הזה, תוכל לכתוב אחד לפחות
תכנית שאומרת את המילים הללו.
זכור את זה שבועות מהיום, אולי ימים מעכשיו.
אשמת פילוח היא דבר רע.
זה יתייחס ליעשה משהו שהמחשב
לא ציפה.
ובמקרה כזה, אתה, המתכנת, לא ציפתה.
הרבה כמו מה זה ערימה של גרביים, הייתה שונה
מקרים פינתיים היינו יכולים נתקלו.
כמו כן בתוכניות אם אתה לא צופה כמה זמן הוא
השם של מישהו הולך להיות.
או מה אם יש לי משתמש זדוני, ואת השם שלו או שלה הוא
למעשה די קצר, אבל הם רק מנסים
להתעסק איתי?
מה הולך להיות ההתנהגות של התכנית שלי?
ובכן, במקרה זה, משהו באמת עשוי לקרוס.
>> אז בואו לעשות את זה.
ב 90 דקות, זה המון זמן
לעשות מדעי מחשב.
למה שלא להיכנס להרגל של לקחת חמש דקות
לשבור כאן, וכשנחזור, אנחנו לצלול לתוך חלק
תוכניות מורכבות ומשכנעות יותר?
חמש דקות.
>> בסדר.
אז תגובה אחת מהירה.
נאמרתי לי שלמרות שזה היה על המסך לפני, מה
יצא לי מהפה היה cs50.net/rsvp.
זה נכון. cs50.net/lunch.
אז עכשיו אתה יכול לנסות RSVPing לזה ב/ ארוחת צהריים.
אבל בואו נעשה את זה עכשיו.
אז זה היה סופר מהיר, סופר חדש להרבה אנשים.
כובע ישן לאנשים מסוימים.
אז בואו אחורה לרגע, ולראות איך הגעתי ל
פלט זה שלום עולם רק לפני רגע.
>> אז קודם כל, יש מכשיר CS50 זה.
שוב, חלק מהתוכנה, בעיה להגדיר 1 עומד לספר
לך איך להוריד אותו, שבו כדי להוריד אותו, מה ללחוץ
וכן הלאה.
ואז ברגע שאתה פעלת בהתאם להוראות אלה, תוכל
כדי למקסם את החלון שלך, ו-Mac או במחשב האישי שלך ייראה
משהו קטן כזה.
רקע שחור, בתיקייה ראשית בחלק העליון שבו כל
הקבצים שלך ללכת, פח אשפה בפינה השמאלית העליונה,
תפריט בתחתית.
אז שוב, די דומה ברוח ל-Mac OS או Windows,
למרות שזה קורה להיות לינוקס.
אז מה אנחנו עושים הבאים?
ובכן, התחלנו לכתוב תוכניות.
וזוכרים משבוע שעבר שכל מה שנדרש לכתוב
תכנית היא עורך טקסט פשוט,
כמו פנקס רשימות או TextEdit.
למען אמת, אתה יכול גם להשתמש ב-Word של מיקרוסופט.
אבל סופו של דבר דברים רעים יקרו, כי זה מאוד
פתרון מגושם לכתיבת תכנית, בתוספת המדבר
לשמור אותו בפורמט השגוי.
אבל זה רק בעורך טקסט, במעבד תמלילים, הוא כל מה ש
צורך לכתוב את תכנית.
>> אז בCS50 המכשיר, אנחנו יכולים לעשות את זה בדרך פשוטה אחת.
אנחנו יכולים פשוט ללחוץ על סמל זה בצד שמאל למטה.
ושוב, בעיה להגדיר 1 יהיה לייעץ לך על כך, והנה -
אתה מקבל ממשק השחור ולבן הזה שבו אנחנו יכולים להתחיל
כתיבת קוד.
אז בואו נתחיל לכתוב תכנית סופר פשוטה שוב.
אני מתכוון ללכת לקובץ, שמור, ואני הולך לקרוא
זה, יניח, hello2.c.
ואני רק אומר לו על ידי לחיצה על jharvard, לשים אותו
בספרייה הביתית שלו, אני לא ממש אכפת
שם זה הולך.
ואז שמור.
ועכשיו אני יכול להתחיל לכתוב את התכנית שלי.
ואני זוכר מקודם שאני צריך לכתוב int
עיקרי (void).
קרב על שמאלי עליון.
ואז אני רוצה לומר printf, קח שניים.
ועכשיו ציטוט שורה חדש, קרוב, קרוב
סוגריים, פסיק.
ואז אני יורד כאן לחלון מסופי זה
מוטבע בgedit, רק מטעמי נוחות.
ואני מתכוון להמשיך ולכתוב לעשות שלום, אך לא
שלום לבד, hello2.
>> אז הקובץ שלי נקרא hello2.c. הקובץ שלי ולכן
צריך להיקרא hello2, במקרה זה.
לעזאזל, מה אני עושה לא בסדר?
בסדר, אז ברור שהשמיט קו, אם אתה זוכר מה
תוכניות קודמות להיראות.
אבל בואו נראה אם ​​אנחנו לא יכולים להקניט זה לגזרים.
למרבה הצער, רוב האנשים שכותבים את התוכניות שבי
אנחנו כותבים תוכניות לא לפשט את הדברים כל כך טובה.
אז יש לנו לסוג של רפרף על מה שלא עושה די
לחוש כאן ולראות אם אנחנו יכולים להבין מה לא בסדר.
השורה הראשונה שם אומר בעקיפין הכרזת C
פונקצית printf עם הסוג int ספרייה.
בסדר, הבנתי חלק מזה.
אבל נראה שזה רומז לעובדה שנהגתי printf
בסדר, איכשהו.
ומה תחושה הוא שגוי זה?
אני פשוט לא למדתי את המחשב שהוא בקובץ
קרא stdio.h.
עכשיו יש לי רק לשנן עכשיו שprintf הוא
בstdio.h, ואכן יהיה אחר
פונקציות באותו קובץ שנתרגל אליהם.
>> אז עכשיו תן לי ללכת קדימה ופגע Ctrl-L שלרק לנקות
משם, שידור חוזר להפוך hello2, וזהו.
ופקודה שוב, מורכבת יותר ממה שאנחנו נסביר ל
המטרות של היום.
אבל זה לא להפעיל צלצול, והצלצול לוקח קוד מקור ו
יורק את 0s ו 1s.
ואלה 0s ו 1s במקרה זה נקראים מה?
אוקיי, מתנגד קוד.
ואת הקובץ שהם בנקראים, כך,
hello2, במקרה זה.
מאחר שקובץ הטקסט שלי היה hello2.c, Enter.
ועכשיו יש לי לקחת את שתי נקודתי קריאה, קריאה
נקודה, סימן קריא.
בסדר, אז יש לנו את היכולת לקבל מחרוזות עכשיו,
כנראה.
ובכן, מה עוד אנחנו יכולים לקבל ממשתמשים?
>> ובכן בCS50 הספרייה, יש פונקציות נוספות ה
הולכים לפשט את חיינו בימים הראשונים האלה.
Getchar, GetDouble, GetFloat, GetInt,
GetLongLong, GetString.
ובכן, בואו לתלוש מעל הקל ביותר של אלה ראשונים.
GetString ממש עושה את זה.
זה פשוט יושב שם, מחכה למשתמש להקליד משהו ב,
וברגע שאני מקליד משהו ובמקיש על Enter, זה
עושה משהו עם ערך זה.
אז בואו נחזור לדוגמה שכדי לראות בדיוק מה
GetString עושה.
תן לי ללכת קדימה ולפתוח בgedit, hello.c, ולהיזכר
כי ממש לפני ההפסקה, זה המקום שבו הפסקנו.
>> אז בואו עכשיו להקניט זה לגזרים בפירוט רב יותר.
אז ב 6 בשורה, יש שני דברים
קורה באותו הרגע.
סימן השוויון הוא הפרדת המחצית ראשונה ומחצית שנייה.
אז בצד השמאל של סימן השוויון, אנחנו
אומר מחרוזת s.
ואז, רק המונחים של ההדיוטות, מה הוא מחרוזת של
עושה, אתה חושב?
זה יוצר את מה?
אז זה יוצר מחרוזת בשם זה.
אז מה זה באמת אומר?
טוב, זה להזמין מקום למחרוזת בשם זה.
זה לא לגמרי נכון.
מה זה עושה?
מחשבים ובכן, כפי שאתה יודע, יש כוננים קשיחים; זה מקום שבי
הקבצים שלך מאוחסנים.
מחשבים יש זכרון RAM, וזה מקום שבי תוכניות נטענות
זמן שהן פועלות.
לכן, כאשר אתה לוחץ פעמים על סמל ו-Microsoft Word פותח
עד, Microsoft Word פועל, כביכול, בזכרון RAM, שהוא
חלק האלקטרוני של המחשב.
לא, חלק הפיזי המכאני שהוא מסתובב, בי
נתונים מאוחסנים בדרך כלל לטווח ארוך.
אז מחרוזת של די הרבה אומר לי את המחשב
מספיק RAM כדי להתאים מחרוזת.
עכשיו זה קצת פשטני, כי
כמה גדול המחרוזת הוא הולך להיות?
ובכן אנחנו באמת לא יודעים עדיין, ולכן בשבועות הקרובים
אנחנו בעצם נוכל למשוך בחזרה את השכבה שהיא מחרוזת ו
אנחנו נגיד לך מה שהוא באמת.
מייתרים, לעת עתה, הוא רק פישוט נחמד של עולמנו.
אבל מחרוזת s מצהירה מחרוזת בשם של, לעת עתה.
מצהיר מחרוזת.
זה שומר קצת מקום בזכרון RAM עבור מחרוזת המשתמש הוא
על להקליד.
>> עכשיו בואו נסתכל בצד ימין של סימן השוויון.
אז זה אומר GetString ().
ושפיות קצת לבדוק.
העובדה שאין שום דבר בתוך הסוגריים
מרמז על מה GetString?
זה לוקח אין ויכוחים.
כלומר, אתה לא יכול להשפיע על ההתנהגות שלו בכל דרך.
בכל פעם שאתה משתמש בו, הוא יקבל מחרוזת וזהו זה.
לעומת זאת, printf, בתקווה ההתנהגות שלה עושה
לשנות בכל פעם.
אחרת, זה תפקיד די חסר תועלת אם הדפסה
היא עושה את אותו דבר.
אם זה תמיד מדפיס דוד או משהו
השרירותי כל הזמן.
אז printf הגיוני יש ויכוח.
GetString לא ממש צריך את טיעון, כי רציתי
כדי לקבל מחרוזת מהמשתמש וזה המשתמש שקורה
כדי לספק את הדינאמיות בהקלדה באותיות שונות
כל פעם במקלדת.
>> אז מה עושה GetString סופו של דבר?
תחשוב על זה כקופסה השחורה הקטנה הזה.
קופסה שחורה וזה לוקח לא קלט, אבל כשאתה דופק על
זה, זה יורק את מחרוזת שהמשתמש הקליד פנימה
והעובדה שיש סימן שוויון יש משמעות לקחת
מה לירוק על ימין ולאחסן אותו בתוך
מה בצד השמאל.
אז סימן שווה כאן, זה ממש לא אומר
שוויון, זה לא אומר שמשימה טכנית.
קח את הערך בצד ימין, ולשים אותו ב
משתנה בצד השמאל.
כך שכל מה שקורה שיש.
>> עכשיו בקו 7, אנחנו קוראים printf.
אז printf תקווה הוא מקבל קצת משעמם עד עכשיו.
אז להדפיס מחרוזת מעוצבת.
מה חוט?
להדפיס, "h-E-l-l-o,% s
! \ N ".
בסדר, אז מה אני רוצה תוסף עבור% s?
פשוטו כמשמעו, כל מה שמאוחסן בים.
אז במקרה הזה סימון, קצת שפיות כמה טיעונים, עושים
printf לקחת?
אוקיי, שמעתי את אחד.
שמעתי את אחד שוב.
שניים שמעו שניים.
ומה בנוגע לשלוש?
אוקיי, שלוש?
מצוין.
שלוש תשובות אפשריות, רק אחת מהן נכונה.
אז טיעונים שוב להשפיע על ההתנהגות של פונקציה.
בעבר, printf לא לקחת את הטיעון אחד בלבד.
"שלום העולם" היה ויכוח אחד.
עם זאת, כעת, שים לב איפה פסיק זה.
פסיק זה מחוץ לציטוט / סוף הציטוט, מה שאומר
היי printf, הנה מגיע טיעון שני.
>> אז פסיקים ברוב שפות תכנות
ויכוחים מרובים נפרדים.
אז התשובה כאן היא בהחלט לא אחד, כי
יש פסיק זה.
אז מינימאלי, printf הוא כנראה לוקח שניים
טיעונים הפעם.
אבל את ההזדמנות לשאלה מה טריק כאן היא
על הפסיק הזה?
האם זה מרמז על כך שיש בעצם שלוש טענות?
זה, זה, זה ו.
אז לא, בגלל הפסיק שנמצא בתוך המרכאות, אשר
כלומר, זה באמת רק אסתטי של שפה אנגלית.
אין לזה שום קשר למספר
טיעונים בתכנית זו.
אז פסיק זה הוא מחוץ למרכאות הכפולות.
ואז להחזיר 0.
רק מיון עבור עכשיו בואו ניקח את זה של באמונה ל
כיום, ורק יודע שכאשר פונקציות נעשות ביצוע
שורות של קוד, הם בדרך כלל צריכים להחזיר ערך כלשהו.
במקרה זה, רק בגלל שעיקרי חייב להחזיר int,
זה בדיוק כמו השפה C עובד.
>> לכן, מכיוון ששום דבר לא השתבש, מרגיש כמו התכנית של זה
בסדר, אני מקודד פשוט קשה בתמורה 0.
אבל בניגוד לכך, ואני הולך לכתוב את זה בקוד פסאודו
עכשיו, ממש כמו יוסף עשה כשעשינו את הגרב
למשל בשבוע שעבר.
אם משהו ישתבש - זה לא קוד עצמו - הלך
לא בסדר, ואז לחזור, יניח, 1.
אחר יחזירו 0.
אז זה המקום שאנחנו הולכים עם זה.
זה לא קוד C בפועל, רק pseudocode.
אבל עד כדי כך שאולי תחזרו
ערכים אפשריים שונים.
אבל נכון לעכשיו אני רק הולך קדימה ולהחזיר 0.
בסדר, כל שאלות עד כה בתחביר, פונקציונלי,
או אוהבים?
כן, מאחור.
>> קהל: [לא ברור]
הדוד Malan: האם אתה יכול לדבר קצת יותר חזק?
מדוע 0 תמורה לתכנית זו, ו?
קהל: [לא ברור]
הדוד Malan: אה, זה בגלל שנהייתי עצלנית, מצטער.
אין תגובה אקדמית טובה, להחזיר 0.
אני יכול להציל את מין זה, באומרו הטכני C, אם עיקרי
לא במפורש להחזיר ערך, 0 יוחזרו
באופן אוטומטי עבורך.
וזה נכון, אני לא רק לטשטש את העקבות.
אבל, הייתי צריך לעשות את זה ככה.
לא takeaway מעניין מאשר שמלבד הטעות שלי.
כן?
>> קהל: לרוב בעת ההקלדה בחלל, זה אומר שאתה
לא מחזיר משהו.
הדוד Malan: נכון.
אם במקום זאת, עליך לציין לפני שם של פונקציה, עבור
למשל כאן, הריק, אז הפונקציה
לא מחזיר שום דבר.
ולכן אני פשוט אומר, שיבה או לא כלום,
ושיהיה עקבי.
ואנחנו נחזור לזה.
ורק לידיעתך, אחד מהתופס עם הלמידה
תכנות בעולם שיש לו מאה ספרים ו
מאה אתרי אינטרנט שם בחוץ, הם שיהיה תמיד
לראות תחביר שונה בספרים שונים
על ידי אנשים שונים.
מבין אנו נעשינו כמיטב יכולתנו בסעיפים והרצאות להיות
עקבי.
אבל לפעמים אתה תראה תחביר סותר.
אז בכל פעם בספק, פשוט לשאול.
ובכלל, אנחנו נדאג בהרצאות ובקטעים שיש
כמעט תמיד להציג את זה בדרך הנכונה.
ואני אומר כמעט תמיד, כי דוגמה טובה.
שאלות אחרות?
>> קהל: האם% s קיימת מחוץ למכשיר?
הדוד Malan: האם קיימת% s החיצונית של המכשיר?
כן.
אז% s יש לעשות עם ג עובדה שאנחנו משתמשים בו ב
מכשיר מיסוד יש מה לעשות עם
תכונות של השפה שאנו משתמשים.
ואכן, בשבוע שעבר כאשר השתמשנו Mac שלי, כתב
קוד C ב-Mac שלי.
הייתי יכול להשתמש ב-Mac של% שלי, ואתה יכול להשתמש בו על
מחשב Windows שלך, אם אתה מתקין מהדר, כמו
של Visual Studio של מיקרוסופט.
אז% s.
כל מה שאנחנו עושים בתוך של חלון זה היום יש
לעשות עם ג והיסוד ולא כלום עם
מערכת הפעלה בשאלה.
לעומת זאת, חלון המסוף השחור ולבן - כש
אני מקליד דברים כמו ls, וrm ו cd -
שיש לעשות עם מערכת ההפעלה ו
ניווט בסביבה.
כן.
קהל: אני מתכוון לספרייה, CS50 הספרייה.
הדוד Malan: אוקיי, אז אם אתה מתכוון למחרוזת של מילות המפתח, ה
קיים רק בCS50 הספרייה, נכון.
זה לא מקיים ב-C עצמו, ואכן בזוג
שבועות אנו לזרוק ספריית CS50 ולהתחיל
עושים דברים מהתחלה את עצמנו, אם אפשר לומר כך.
שאלות אחרות?
כן.
>> קהל: [לא ברור]
הדוד Malan: שאלה טובה.
האם מקרה הפקודות רגישות?
ותן לי לעשות כאן הבחנה.
אז פקודות הן בדרך כלל דברים שאנחנו כותבים ב
חלק תחתון של החלון, בחלון המסוף.
כל דבר עד כאן יהיה הצהרות או קוד C.
אבל בשני המקרים, התשובה היא אותו הדבר, כן.
שתי הסביבות הללו, קוד C בראש ו
שורת פקודה של מערכת הפעלה ב
תחתון, הוא עניין רגיש.
אז אתה חייב לנצל GetString עם ההון G,
ההון ס אתה חייב לכתוב printf בכל האותיות קטנות.
עליך להקליד ls בכל האותיות קטנות.
אז כמעט בכל סיטואצית סמסטר, במקרה זה יובא בחשבון,
למעשה, עניין.
כן.
>> קהל: [לא ברור]
הדוד Malan: אה, אז בסדר, מה אם היה לנו קובץ
קרא hello.d.
אז מתברר D היא שפת תכנות.
וכך, במקרים מסוימים, נוכל בעצם לכתוב בתכנית
קובץ ושהרכיב שבאופנה.
אנחנו יכולים, ובעצם, תשובה הקצרה היא, אני לא יודע.
אז אנחנו הולכים לעשות את זה.
תן לי ללכת קדימה וליצור קובץ חדש.
והספין כאן, בכנות באופן כללי, הוא בכל פעם לכל ספק
בסמסטר הזה, ויש לך מכשיר או המחשב שלך
לפתוח, קדימה ולנסות משהו.
אז אני הולך להציל את קובץ שנקרא hello.d.
שמור את זה.
ואני הולך לרוץ לעשות שלום Enter.
זה נראה להסיק שג היה סביר יותר
מ ד, במקרה זה.
שאלות אחרות.
כן.
>> קהל: [לא ברור]
הדוד Malan: אוקיי, יגיד את זה עוד פעם.
קהל: [לא ברור]
הדוד Malan: איך היית הולך על אבחון זה או
פתרון זה?
כל כך סביר, כי רוב הם שפות שונות,
סביר להניח שהיית מקבל לחלוטין
תכנית אחרת outputted.
היית מקבל הודעות שגיאה שונות לחלוטין.
וגם רק במונחים של עיצוב, זה יהיה ללא ספק להיות
החלטת תכנון לקויה צריכות הייתה לכתוב שתי שונים
שפות עם קבצים בשמות זהים כמעט, ב
אותו מדריך המדויק, תוך שימוש
כלי אוטומטי כמו לעשות.
אז אני יכול גם לדחוף חוזר ואומר ב15 שנים עושים את זה,
אף פעם לא עשה את הטעות הזאת.
יכול לקרות.
אבל יש רק שונה, אני חושב,
הגנות לוגיסטיות במקום.
בנוסף הודעות השגיאה שתבואנה בעיקבותיה, שהייתן
סופו של דבר לחשוף את מה שהוא הנושא.
אבל מקרה פינה אפשרי.
>> בסדר, אז בואו להציג רק כמה אחרים
תכונות כאן עכשיו, כדי שנוכל להתחיל לבנות את ליותר
ותכנית מורכבת יותר.
אז קודם כל, מתמטיקה.
אז דוגמאות מתמטיקה הן רק סוג של קל בשבוע הראשון.
זה לא אומר שכל תכנות הוא כ
מתמטיקה.
אין ספק, להבנת תכונות שונות של
מתמטיקה, אלגברה בפרט, היא
די רלוונטי כאן.
בכיתות גבוהות יותר ברמת CS, אלגברה ליניארית,
תחשיב, וכמו.
אבל מבין שרוב מה שנעשינו בסמסטר הזה לא מפחית
למתמטיקה, ובוודאי שלא לחשבון, כשלעצמה, אבל באמת
רק היגיון וחשיבה זהירה.
וכן את הקשר הזה שיש לו מדעי מחשב ארוך,
במיוחד ברמת בית הספר התיכון, במתמטיקה, הוא
קצת מטעה.
מכיוון שברוב התוכניות שאנחנו כותבים, באמת, הם
סוג של רמה גבוהה יותר והתמקדות בפתרון בעיות ש,
בטוח, אולי להשתמש בחלק חיבור, חיסור, ושונה
נוסחות מתמטיות או כדומה,
אבל בסופו של היום, זה על חשיבה ולא
רק יישום מה שאולי עשה על כמו TI
מחשבון בבית הספר תיכון.
>> אז עם זה אמר, בוא עכשיו יעשה משהו עם אלה
אופרטורים מתמטיים שכן קיימים, כך שאנו יכולים להכשיל
על כמה היבטים הבסיסיים של תכנות, או ב
במקרה זה ג אז יש, כCS50 הספרייה הציעה,
והיום אנחנו משתמשים רק GetString - וברגע
אולי תפקיד אחד אחר -
אבל יש סוגי נתונים שונים במחשב.
בסופו של היום, מחשבים יודעים רק 0s ו 1s.
אבל זוכר ששבוע שעבר דברנו על המערכת הבינארית
בייצוג מספרים, כמו המספר 0, ו 1, ו 2,
כל הדרך בעד 8, כמו בווידאו של נייט.
ואז אנחנו יכולים לסמוך הרבה יותר גבוהים כפי שאנו
עשה על במה כאן.
אבל אם אתה רוצה לייצג לא רק מספרים, אלא מכתבים,
אנחנו, בני האדם, צריכים לבוא עם קצת שרירותי
מוסכם, שלפיו אם בסופו של היום את כל המחשב שלי
כבר היא היכולת להביע 0s ו 1s, גם אנחנו היינו טובים יותר
להתחיל תקנון דפוסים של 0s ו 1s שמייצגים
דברים שונים.
דפוס של 0s ו 1s שמייצג את האות.
דפוסים של 0s ו 1s המייצגים את אות Z.
דפוסים של 0s ו 1s המייצגים את הצבע הכחול, או
אדום, או כמו.
אנחנו צריכים להשתמש בכל אלה 0s ו 1s לבטא את עצם ב
הקשרים שונים, בדרכים שונות שאינן
בהכרח מספרי.
>> אז במונחים של ייצוג, C יש סוגי נתונים שונים,
וראינו אחד מהם עד כה.
ראינו int, והודעה על מה שלא מופיע על המסך
עכשיו היא מחרוזת.
מחרוזת אינה, למעשה, קיימת בג שוב, זה
פישוט אנו מגישים ל1
כמה שבועות.
Char הוא אופי אישי.
ציפה היא מספר אמיתי, עם נקודה ומספרים לעשרוניים
שמאל וימין שלו.
כפול הוא מה, לבעלי רקע חזרה מוקדם?
אז כפול הוא כפול משהו.
מוסיף כמות כפול של דיוק.
אז מה זה אומר?
אז בכל אחד מהמקרים הללו, בעולם יש סוג של טופל
כמה חתיכות משמשים כדי לייצג
כל אחד מהדברים האלה.
אז אם ראית וידאו ASCII של נייט כבר לחלק
של pset 0, או בהמשך השבוע אתה, אתה בטח יודע
שASCII -
ייצוגי דמויות -
להשתמש בכמה חתיכות?
ואולי אפילו אתם זוכרים מההדגמה שלנו בשבוע שעבר באופן
הרבה אנשים היו על במה.
אז 7 או 8, בדרך כלל.
אז בדרך כלל 8, ויש משהו שנקרא כמו הוארך
ASCII שמשתמש בכל 8 הביטים, במקום 7.
אבל באופן כללי, אנחנו מדברים בחזקים של 2, ולכן במקרה זה, 8.
אז דמות בשפת תכנות היא בדרך כלל 8 סיביות.
אז int הוא בדרך כלל 32 סיביים.
מצוף הוא בדרך כלל 32 סיביים.
כפול הוא בדרך כלל 64 סיביים.
ומה זה אומר?
זה אומר שאתה יכול לייצג מספרים גדולים יותר, או במקרה
מספרים אמיתיים, אתה יכול לקבל הרבה יותר מספרים אחרי
מקום עשרוני.
הרבה יותר דיוק, במקרה זה.
עכשיו זמן ארוך נקרא על שמו, למרבה הצער.
אז יש int שהוא 32 סיביים.
יש זמן שהוא, לא, 32 סיביים.
וארוך ארוך שהוא 64 סיביים.
עם זאת חלק מאלה רגישים להיקשר, היא תלויה
איזה סוג של מחשב יש לך.
אז באופן כללי, אנו נציין בשיעורי בית או בחידון כש
זה באמת חשוב.
אבל הנקודה היא שיש כל אלה שונים
ייצוגים כאן.
>> אז בואו באמת לצלול לתוך תכנית.
במקום לכתוב את זה מהתחלה, תן לי ללכת קדימה
ולפתוח מקוד המקור של היום - כל אשר הוא
באינטרנט - אם אתה רוצה להתעסק באינטרנט, או תשואה על
יום רביעי, עם המכשיר במחשב שלך, הוראות
שליחבר בעמוד הבית של הקורס.
הנה תכנית סופר פשוטה.
אבל יש לה משהו חדש קטן בראש ש
לא הייתה לנו בעבר.
המון קווים כחולים של טקסט.
אז הקווים הכחולים האלה מייצגים הערות.
אז זה די שימושי בתכנית כדי להיות מסוגל לכתוב
כמה הערות לעצמך, או לעמיתים לעבודה, או חברים, או
עמיתי הוראה, מסוג לתאר את מה שקורה ב
קובץ זה, אבל אין לי מה לעשות עם קוד C עצמו.
אין מה לעשות עם התכנית פונקציונלית, זה רק
אסתטיקה.
אז כמו שאתה עושה את זה ב C הוא שאתה בדרך כלל מתחיל
הערות עם / *, ואתה בסופו ההערות שלך עם
* /.
אם אתה באמת אנאלי ואוהב לצייר ומיון של תמונות,
אז אתה רוצה לשים המון כוכבים, היית יכול
קופסה קטנה כמו זה.
אבל זה בכלל לא משנה.
הדבר היחיד שחשובים הוא ראשון
ואחרון.
זה מה שנקרא תגובה מרובה שורות.
וזה רק מוסכמה אנושית לעתים קרובות לעשות את הכוכבים והתיבה
דברים בסוג הזה, אם יש לך הרבה זמן פנוי.
>> אז אחרי שכתבת בהערות מסוימות, בדרך כלל, באים
האומץ בפועל של התכנית.
הנה המוכר שלנו # כולל .
ולא מהיר, זה נחוץ או לא נחוץ?
קהל: צורך.
הדוד Malan: אז זה ממש לא הכרחי.
אז מדוע, אם כי, הוא שזה לא הכרחי?
כך שאין printf.
ואכן.
כל מה שאנחנו עושים בתכנית זו היא מתמטיקה.
אז אני באמת יכול למחוק את זה.
אז אתה לא תמיד צריך לכלול כל דבר ב
החלק העליון של תכנית.
>> אז בואו נפשט את זה קצת.
ועכשיו שים לב למה התכנית הזו עושה.
לא הרבה של עניין.
int x = 1.
ובכן, מה זה עושה?
ובכן, תחשוב על מודל מנטלי מקודם.
צד השמאל של ביטוי זה עושה מה?
יצירת מרחב למספר שלם.
אז כמה מקום?
ובכן, אנחנו יודעים במקרה עכשיו שזה 32 סיבי.
בעבר, הייתה מחרוזת טכנית 32 סיביות, אבל יותר
על כך שבעתיד.
אבל int הוא 32 סיביים.
לכן הביטוי הזה כאן מהשמאל, int x רק אומר היי
מערכת הפעלה, תן לי 32 ביטים של זכרון RAM -
הידוע גם 4 בתים של זכרון RAM -
כך שאני יכול לשים את המספר שלם שבחלל.
מה עשית שלם שאתה רוצה לשים?
ובכן, רק המספר 1.
int y מקבל 2, עושה בדיוק את אותו דבר למרות
המספר גדול, במונחים של גודלו.
המספר עצמו הוא עדיין רק 32 חתיכות.
זה פשוט הדפוס של ביטים שונים כדי
לייצג 1 מול 2.
int z עכשיו אומר לי עוד 32 חתיכות, קורא לזה z, ולשים
סיכום של 1 ו 2 לשם.
כך שעכשיו יש להניח z לאחסון הערך 3,
ולאחר מכן להחזיר 0.
>> עכשיו תכנית זו, הוא עושה משהו מעניין?
אז זה בעצם לא עושה שום דבר מעניין, בכל
תחושה, כי למה? זה עושה קצת מתמטיקה.
אבל זה לא חוזר תשובה, נכון.
זה חוזר 0.
זה לא מדפיס את התשובה.
אז התכנית הזאת היא יסוד חסרת ערך, כפי שהוא
עומד עכשיו.
זה עושה קצת עבודה.
זה הולך לקחת קצת מספר השניות, או מייקרו, כדי
לרוץ, אבל זה לא ממש עושה משהו
שימושי לאדם.
>> אז בואו ממש עכשיו לפתוח math2, שם עכשיו אני ממש
להדפיס את התוצאה.
אז גם את זה ניתן להסיק מהדוגמות הקודמות שלנו.
אם אני רוצה לעשות קצת מתמטיקה פשוטה, int x = 1, y
= 2. z הוא 1 ועוד 2 עכשיו.
מה זה הולך להדפיס ברור?
רק 3.
אז שפיות מהירה לבדוק.
בואו להעביר אותי לספרייה זו.
אז cd source1m.
תן לי ללכת קדימה ולעשות הקלד math2.
אין הודעות שגיאה יצאו, אז תן לי לרוץ -
לא a.out-תן לי לרוץ math2. Enter.
ואכן, אותו הדפיס 3.
ובכן, הבה נסתכל על וריאציה של זה.
בmath3.c, עכשיו יש לנו דוגמה זו כאן.
>> אז די מעניין של אדם זה.
אז בספר הזה, תשובה הוא הולך לקבל 1 חלקי 10,
ושימו לב שהכרזתי עליו כמצוף.
למה אני רוצה שזה יהיה מצוף?
טוב, זה חלק קטן.
זה הולך להיות מספר אמיתי.
אז זה הולך להיות 0.1, בתקווה - 10%, במקרה זה.
ומה אז אני רוצה להדפיס?
ובכן, זו תשובה.
ובכן, בואו להקניט אלה מלבד ראשונים.
אז בצד השמאלי, מצהיר
לצוף, קוראים לזה תשובה.
בצד ימין, אל 1 מחולק 10 ולשים את זה
לענות בתוך משתנה.
עכשיו, הקו הזה נראה קצת יותר מסתורי.
אבל שם לב שחלק ממאפיינים מוכרים. % פירושו כאן מגיע
מציין מיקום.
f אומר הנה ערך נקודה צפה, רק אמיתי
מספר, משהו עם נקודה עשרונית.
0.2 מה זה אומר?
מישהו יודע מניסיון קודם?
שני מקומות אחרי נקודה עשרוניים.
אז לא ראיתי את זה בעבר, אבל זה רק דרך
פעילות גופנית יותר שליטה קצת יותר וprintf
פתגם אל תשאיר לי 30 נקודות לאחר הנקודה העשרונית,
במקום לתת לי רק 2.
>> ואז בואו נלך קדימה ולהפעיל את זה.
אז להפוך את המתמטיקה 3, ועכשיו תן לי לרוץ במתמטיקה 3, Enter.
וזה לא בסדר.
נדמו לי שנתקלנו בבאג האמיתי הראשון שלנו.
טוב, אולי אני פשוט לא מחפש מספיק קרוב.
אז בואו תעלו אותי לכאן, ותן לי לשים 20 עשרוניים
מקומות בזה משהו.
ותנו לי לקמפל את זה, יגרום math3, לרוץ.
די בטוח 1 חלקים 10 היא לא 0.
אז מה קורה פה?
ובכן בסדר, אז למעשה אין לו מה לעשות עם זה.
זו מחשבה טובה.
זה באמת רק צירוף מקרים
שאנחנו עושים את זה.
אבל רק כדי להוכיח שזה לא זה, אני
להחזיר משהו אקראי.
אל תעשה את זה בבית, כי זה פשוט לא נכון.
אבל להפוך את math3, תן לי לרוץ אותו.
אז יש מה לעשות עם מה שאני חוזר, צריך רק לעשות
עם מה שאני מדפיס.
אבל שמעתי אותו כאן למטה.
מה?
קהל: אז אנחנו צריכים לכתוב את המספרים ב
חטיבה כ--
>> הדוד Malan: אוקיי טוב.
אז אנחנו צריכים לכתוב את המספרים המשתתפים ב
חלוקה כאן כנקודה צפה מעריכה את עצמם.
אז הבעיה כאן היא כמו קודם: C, כמו בהרבה
שפות, יש סוגי נתונים שונים.
וסוגי נתונים אלה, למשל, הם אלה כאן.
ואת סוגי הנתונים בשאלה כאן, כשאני סוג 1 ואז
סוג 10, הם כנראה סוגי נתונים מה?
אז זה כנראה int, נכון?
זה בהחלט לא לצוף כי אין עשרוני
נקודה או משהו כזה.
אז באמת, יש לי int מחולק int.
>> אז מה המעניין במתמטיקה ובמחשב הוא ש
אם אתה עושה את החלוקה באמצעות מספרים שלמים -
1 מחולק 10, כן עומד על 0.1.
עם זאת, כאשר אתה חלוקת מספר שלם במספר שלם,
תשובה יש גם להיות שלם רק בגלל, לעת עתה.
ומה ההשלכות אם כך?
ובכן, אם התשובה היא 1 חלקים 10 שווים 0.1, מה
המחשב הולך לעשות הוא אין לי מושג איך
מייצג 0.1, כי זה ערך נקודה צפה, לא
שלם; זה הולך לכרות את הכל אחרי
נקודה עשרונית ורק להראות לך את ה 0 בהתחלה.
ועובדה שזה מדפיס כנקודה צפה
ערך, זה רק עניין אסתטי.
זה בגלל שאני מכריח את המחשב כדי להדפיס זה כ
צף ערך נקודה.
ואכן אני כבר הכרזתי עליו כמצוף, אבל המתמטיקה היא
קורה כאן.
>> אז תן לי לתקן את זה ממש בדרך זו די קלה.
למה שלא פשוט לעשות 10.0 ו 1.0, למרות
מבחינה טכנית אני יכול לברוח עם רק עושה אחד מאלה.
עכשיו תן לי ללכת קדימה ולעשות math3.
תן לי ללכת קדימה וכעת להפעיל math3, Enter.
ועכשיו, אוי ויי.
עכשיו יש לנו בעיה חדשה לגמרי.
אז טוב יותר, נכון, אנחנו קרובים יותר ל -0.1, אבל מה שברור הוא
כאן לא בסדר?
אם אנחנו כבר שוכבים לך במשך שנים, נכון?
חלק 1 ב 10 הוא למעשה לא ממש 0.1, אז מה
באמת קורה כאן?
ובכן אתה יכול סוג של היגיון בתוך זה בהיגיון.
אם מחשב יש כמות מוגבלת של זכרון RAM כדי להתחיל רק
עם, ואכן מחשב רק באמצעות 32 סיביים עבור
צפתי ערך נקודה, זה הגיוני שעם
מספר סופי של ביטים, 32 במקרה הזה, כן, אתה יכול
מייצג הרבה דברים.
זה באמת הוא 4000000000 ערכים שונים יכולים להיות
מיוצג עם 32 סיביים, 2 עד 32, אבל זה עדיין סופי.
אז הבעיה היא שיש מספר אינסופי של אמת
מספרים, נכון.
אם תיתן לי מספר אמיתי, אני תמיד יכול למצוא לך אחד
מעט יותר גדול, קצת פחות, רק על ידי tweaking
מספרים שאחרי הנקודה העשרונית.
אז אם אין לך מספר אינסופי של ביטים, אתה
אולי לא יכול לייצג אינסופי
מספר של מספרים ממשיים.
>> אז יש חוסר הדיוק הזה טבוע במחשבים, ו
זה מקבל מעד על כל הזמן, אפילו בפשוט של
תוכניות כמו זו.
אבל גם בכמה בעיות, כמו גם בעולם אמיתיות מאוד.
למעשה, בואו ניקח רגע רק כדי להעיף מבט על
משהו שבאמת קרה במציאות.
אנחנו נסתכל רק הזוג הראשון של דקות, ולאחר מכן
אנו לכתוב באינטרנט הקישור.
אבל זה מעיד על בדיוק מה שיכול להשתבש, די
בכנות, באופן מאוד טרגי שבו הדברים האלה הם לא
מוערך או רק אנחנו, בני האדם עושה טעויות כשמדובר
אלו סוגים של פרטי יישום של מחשבים מודרניים.
>> [משחק וידאו]
-כעת אנו חוזרים לאסונות הנדסיים על פלאים מודרניים.
מחשבים.
כולנו כבר למד לקבל את הבעיות לעתים קרובות המתסכלות
שילכו איתם.
באגים, וירוסים ותקלות תוכנה הם מחירים קטנים ל
לשלם עבור הנוחות.
אבל בצבא גבוה טק ומהירות גבוה וחלל
תיכנות יישומים, הבעיה הקטנה ביותר יכולה להיות
מוגדל לאסון.
ב -4 ביונים 1996, מדענים מוכנים לשיגור מאויש
5 רקטות אריאן.
הוא נשא לווינים מדעיים שנועדו
לקבוע בדיוק איך השדה המגנטי של כדור הארץ
אינטראקציה עם רוחות סולריות.
הרקטה נבנתה עבור סוכנות החלל האירופית ו
המריא מהמתקן שלה בחוף הצרפתי גיאנה.
>> -בערך כ 37 שניות לתוך הטיסה, הם 1
משהו שם לב שהשתבש, כי החרירים היו
מסתובב בצורה שהם ממש לא צריכים.
כ 40 שניות לטיסה, ברור שהרכב
היה בצרות, וזה כשהם עשו את ההחלטה
להרוס אותו.
קצין בטיחות באומץ אדיר לחץ
כפתור, התפוצץ הרקטה לפני זה יכול להיות
סכנה לביטחון ציבור.
>> -זו הייתה הפלגת הבכורה של אריאן 5, ו
חורבן התרחש בגלל הפגם המוטבע ב
תוכנה של הרקטות.
>> -הבעיה באריאן הייתה שלא הייתה מספר ש
דורש 64 סיביים כדי לבטא והם רצו להמיר אותו
למספר 16 ביט.
הם הניחו שהמספר לא היה
הולך להיות מאוד גדול,
שרוב הספרות אלה במספר 64 הביט היה 0s.
הם טעו.
>> -חוסר היכולת של תוכנה מי שיקבל את
סוג של מספר שנוצר על ידי אחר היה בשורש
הכישלון.
פיתוח תוכנה הפך להיות חלק מאוד יקר של
טכנולוגיה חדשה.
4 רקטות אריאן היו מוצלחות מאוד.
כל כך הרבה מתוכנות שנוצרו לזה היה גם בעבר
באריאן 5.
>> -הבעיה הבסיסית הייתה שאריאן 5 היה מהיר יותר,
האיץ מהר יותר.
והתוכנה לא היוותה בשביל זה.
>> -ההרס של הרקטות היה כספי עצום
אסון, והכל בשל שגיאת תוכנת דקה.
אבל זו לא הייתה הפעם הראשונה שהיו בעיות המרת הנתונים
הטריד טכנולוגיית טילים מודרנית.
>> הדוד Malan: נשאיר את זה ככה.
אבל זו היא עדות לעד כמה ישים אפילו חלק מ
פרטים אלה ברמה הנמוכים ביותר שאנחנו כבר החלנו
לחקור היום.
אז גם כמו שאתה מקבל קצת לא מרוכז אולי על ידי כמה
התחביר וarcaneness כאן, מבינים שמעל
נהיה ממוקד רק בטווח איך זה ישים הוא
עולמות הרבה מעבר CS.
אנחנו רואים אותך ביום רביעי.