1 00:00:00,000 --> 00:00:03,000 [Powered by Google Translate] [שבוע 4] 2 00:00:03,000 --> 00:00:05,000 [הדוד י מלאן] [אוניברסיטת הרווארד] 3 00:00:05,000 --> 00:00:08,000 [זה CS50.] [CS50.TV] 4 00:00:08,000 --> 00:00:12,000 >> בסדר, זה CS50, וזו היא ההתחלה של שבוע 4, 5 00:00:12,000 --> 00:00:16,000 וזה אחד מאלגוריתמי המיון האיטי ביותר האפשריים. 6 00:00:16,000 --> 00:00:19,000 מה זה היה שאנחנו רק הסתכלנו שם? 7 00:00:19,000 --> 00:00:24,000 זה היה סוג של בועה, בהזמנה הגדולה של O (n ^ 2) + סכום, 8 00:00:24,000 --> 00:00:28,000 ואכן אנחנו לא היחידים בעולם הזה להיראות לדעת 9 00:00:28,000 --> 00:00:30,000 מה הוא מיון בועות או זמן הריצה שלו. 10 00:00:30,000 --> 00:00:33,000 ואכן, זה היה ראיון עם אריק שמידט של גוגל 11 00:00:33,000 --> 00:00:45,000 והסנטור לשעבר ברק אובמה רק לפני כמה שנים. 12 00:00:45,000 --> 00:00:48,000 >> עכשיו, סנטור, אתה כאן בגוגל, 13 00:00:48,000 --> 00:00:54,000 ואני רוצה לחשוב על הנשיאות כראיון עבודה. 14 00:00:54,000 --> 00:00:58,000 כעת, קשה למצוא עבודה כנשיא, ואתם עוברים את התלאות היום. 15 00:00:58,000 --> 00:01:00,000 קשה גם לקבל עבודה בגוגל. 16 00:01:00,000 --> 00:01:05,000 יש לנו שאלות, ועלינו לשאול שאלות המועמדים שלנו, 17 00:01:05,000 --> 00:01:10,000 ואת זה הוא מלארי שווימר. 18 00:01:10,000 --> 00:01:14,000 אתם חושבים שאני מתלוצץ? זה ממש כאן. 19 00:01:14,000 --> 00:01:18,000 מה היא הדרך היעילה ביותר כדי למיין מיליון מספרים שלמים של 32-bit? 20 00:01:18,000 --> 00:01:21,000 [שחוק] 21 00:01:21,000 --> 00:01:24,000 ובכן 22 00:01:24,000 --> 00:01:26,000 אני מצטער. >> לא, לא, לא, לא. 23 00:01:26,000 --> 00:01:34,000 אני חושב שמיון הבועות יהיה בדרך הלא הנכונה ללכת. 24 00:01:34,000 --> 00:01:39,000 >> קדימה, שאמר לו את זה? 25 00:01:39,000 --> 00:01:43,000 בשבוע שעבר זוכר שלקחנו הפסקה מקוד, לפחות ליום אחד, 26 00:01:43,000 --> 00:01:46,000 והתחיל להתמקד בכמה רעיונות גבוהים יותר ברמה ופתרון בעיות באופן כללי יותר 27 00:01:46,000 --> 00:01:49,000 בהקשר של חיפוש ומיון, 28 00:01:49,000 --> 00:01:53,000 והצגנו משהו שאנחנו לא סטרנו על שם זה בשבוע שעבר, 29 00:01:53,000 --> 00:01:56,000 אבל סימון אסימפטוטי, ביג O, האומגה הגדולה, 30 00:01:56,000 --> 00:02:00,000 ולפעמים הכיתוב הגדול תטא, ואלה היו פשוט דרכים 31 00:02:00,000 --> 00:02:02,000 לתאר את זמן הריצה של אלגוריתמים, 32 00:02:02,000 --> 00:02:05,000 כמה זמן לוקח לאלגוריתם לרוץ. 33 00:02:05,000 --> 00:02:08,000 >> ואולי זכרו לך שדבר על זמן הריצה במונחים של הגודל 34 00:02:08,000 --> 00:02:11,000 של הקלט, שאנחנו בדרך כלל קוראים n, מה שעשויה להיות הבעיה, 35 00:02:11,000 --> 00:02:13,000 כאשר n הוא מספר האנשים בחדר, 36 00:02:13,000 --> 00:02:17,000 מספר עמודים בספר טלפונים, והתחלנו לכתוב את הדברים 37 00:02:17,000 --> 00:02:21,000 כמו O (n ^ 2) או O (n) או O (n log n), 38 00:02:21,000 --> 00:02:24,000 וגם כאשר המתמטיקה לא ממש הסתדר כל כך מושלמת 39 00:02:24,000 --> 00:02:28,000 וזה היה n ² - n / 2 או משהו כזה 40 00:02:28,000 --> 00:02:31,000 אנחנו במקום פשוט לזרוק כמה מונחים מסדר הנמוכים יותר, 41 00:02:31,000 --> 00:02:34,000 והמוטיבציה שיש שאנחנו באמת רוצים 42 00:02:34,000 --> 00:02:37,000 סוג של דרך אובייקטיבית של הערכה 43 00:02:37,000 --> 00:02:39,000 ביצועים של תוכניות או את הביצועים של אלגוריתמים 44 00:02:39,000 --> 00:02:42,000 כי בסופו של היום יש מה לעשות, למשל, 45 00:02:42,000 --> 00:02:45,000 עם המהירות של המחשב שלך היום. 46 00:02:45,000 --> 00:02:47,000 >> לדוגמה, אם אתה מיישם את מיון בועות, 47 00:02:47,000 --> 00:02:50,000 או שתיישם למזג מיון מיון או בחירה במחשב של היום, 48 00:02:50,000 --> 00:02:53,000 2 GHz מחשב, ואם מפעילים אותו, 49 00:02:53,000 --> 00:02:56,000 וזה לוקח קצת מספר השניות, בשנה הבאה יש 3 GHz 50 00:02:56,000 --> 00:02:59,000 או 4 מחשב GHz, וייתכן שלאחר מכן טוענים כי "וואו, האלגוריתם שלי 51 00:02:59,000 --> 00:03:03,000 עכשיו היא במהירות כפולה, "כאשר במציאות זה כמובן לא המקרה. 52 00:03:03,000 --> 00:03:06,000 זה רק החומרה קבלה מהר יותר, אבל המחשב שלך 53 00:03:06,000 --> 00:03:10,000 לא, ואז אנחנו באמת רוצים לזרוק דברים כמו 54 00:03:10,000 --> 00:03:13,000 כפולות של 2 או כפולות של 3 כשמדובר מתאר 55 00:03:13,000 --> 00:03:17,000 כמה מהר או לאט איך אלגוריתם הוא באמת ולהתמקד רק בי 56 00:03:17,000 --> 00:03:20,000 על n או כל גורם ממנה, 57 00:03:20,000 --> 00:03:24,000 כמה הכח כמו במקרה של המיני משבוע שעבר. 58 00:03:24,000 --> 00:03:27,000 וזוכרים שעם העזרה של מיון מיזוג 59 00:03:27,000 --> 00:03:31,000 היינו יכול לעשות כל כך הרבה יותר טוב ממיון בועות ומיון בחירה 60 00:03:31,000 --> 00:03:33,000 ואפילו סוג כניסה. 61 00:03:33,000 --> 00:03:36,000 >> ירדנו אל n log n, ושוב, 62 00:03:36,000 --> 00:03:39,000 זוכר שהיומן n בדרך כלל מתייחס למשהו שצומח 63 00:03:39,000 --> 00:03:43,000 לאט יותר אז n, אז n log n עד כה היה טוב 64 00:03:43,000 --> 00:03:45,000 כי זה היה פחות מ ² n. 65 00:03:45,000 --> 00:03:47,000 אבל כדי להשיג n להתחבר n עם סוג המיזוג 66 00:03:47,000 --> 00:03:51,000 מה היה החיידק הבסיסי של רעיון שהיו לנו למנף 67 00:03:51,000 --> 00:03:54,000 שגם אנחנו ממונפים לאחור בשבוע 0? 68 00:03:54,000 --> 00:03:58,000 איך הייתי להתמודד עם הבעיה בחוכמה עם סוג מיון מיזוג? 69 00:03:58,000 --> 00:04:04,000 מה הייתה תובנה המרכזית, אולי? 70 00:04:04,000 --> 00:04:07,000 מישהו בכלל. 71 00:04:07,000 --> 00:04:09,000 אוקיי, בואו ניקח צעד אחורה. 72 00:04:09,000 --> 00:04:11,000 תאר למזג מיון במילים שלך. 73 00:04:11,000 --> 00:04:15,000 איך זה עובד? 74 00:04:15,000 --> 00:04:17,000 בסדר, לחתור חזרה ל0 שבוע. 75 00:04:17,000 --> 00:04:19,000 בסדר, כן. 76 00:04:19,000 --> 00:04:22,000 [לא ברור לתלמיד] 77 00:04:22,000 --> 00:04:26,000 אוקיי, טוב, אז אנחנו מתחלקים מערך המספרים לתוך 2 חתיכות. 78 00:04:26,000 --> 00:04:29,000 אנחנו מסודרים כל אחד מהחלקים האלה, ואז מזגו אותם, 79 00:04:29,000 --> 00:04:33,000 ושראינו את הרעיון הזה לפני נטילת בעיה שזה גדול 80 00:04:33,000 --> 00:04:36,000 ותקצוץ אותו לבעיה שזה גדול או בגודל כזה. 81 00:04:36,000 --> 00:04:38,000 >> זוכר את דוגמא ספר טלפונים. 82 00:04:38,000 --> 00:04:42,000 היזכר באלגוריתם עצמו משבועות לפני הספירה, 83 00:04:42,000 --> 00:04:45,000 מין כל כך למזג סכם pseudocode זה כאן. 84 00:04:45,000 --> 00:04:48,000 כאשר אתה נתון אלמנטי n, בהתחלה זה היה שפיות לבדוק. 85 00:04:48,000 --> 00:04:51,000 אם n <2 אז לא עושים שום דבר 86 00:04:51,000 --> 00:04:55,000 כי אם n <2 אז n הוא כמובן 0 או 1, 87 00:04:55,000 --> 00:04:57,000 ולכן אם הוא או 0 או 1 אין מה למיין. 88 00:04:57,000 --> 00:04:59,000 אתה עשית. 89 00:04:59,000 --> 00:05:01,000 הרשימה שלך כבר מסודרת trivially. 90 00:05:01,000 --> 00:05:04,000 אבל חוץ מזה אם יש לך 2 או יותר אלמנטים קדימה ולחלקם 91 00:05:04,000 --> 00:05:06,000 ל 2 חצי, ימין ושמאל. 92 00:05:06,000 --> 00:05:09,000 מיין את כל אחת מהמחציות הללו, ולאחר מכן למזג את החצאים הממוינים. 93 00:05:09,000 --> 00:05:13,000 אבל הבעיה כאן היא שבמבט ראשון זה מרגיש כאילו אנחנו חתירה. 94 00:05:13,000 --> 00:05:17,000 זו הגדרה מעגלית שבאם שאלתי אותך כדי למיין n האלמנטים הללו 95 00:05:17,000 --> 00:05:22,000 ואתה אומר לי "בסדר, בסדר, אנחנו נטפל אלה n / 2 ואלו n / 2 אלמנטים", 96 00:05:22,000 --> 00:05:27,000 אז השאלה הבאה שלי הולכת להיות "בסדר, איך אתה למיין את n / 2 אלמנטים?" 97 00:05:27,000 --> 00:05:30,000 >> בגלל המבנה של התכנית הזו, אבל, 98 00:05:30,000 --> 00:05:33,000 כי יש מקרה בסיס זה, אם אפשר לומר כך, 99 00:05:33,000 --> 00:05:39,000 המקרה המיוחד הזה שאומר שאם n הוא <ערך קבוע מסוים כמו 2 תשואה באופן מיידי. 100 00:05:39,000 --> 00:05:42,000 אל תגיב באותה תשובה מעגלית. 101 00:05:42,000 --> 00:05:46,000 תהליך זה, מחזוריות זו סופו של דבר בסופו. 102 00:05:46,000 --> 00:05:50,000 אם אני שואל אותך "מיין אלמנטי n אלה," ואתה אומר, "בסדר, למיין n / 2 אלה", 103 00:05:50,000 --> 00:05:53,000 אז אתה אומר, ", מיין משובח הללו n / 4, n / 8, n/16" 104 00:05:53,000 --> 00:05:56,000 סופו של דבר תוכל לחלק במספר מספיק גדול 105 00:05:56,000 --> 00:05:59,000 שתהיה לך רק 1 שמאל אלמנט, ובשלב זה ניתן לומר, 106 00:05:59,000 --> 00:06:02,000 "הנה, כאן הוא אלמנט יחיד מסודר". 107 00:06:02,000 --> 00:06:06,000 אז הזוהר של אלגוריתם זה עד כאן הוא נובע מהעובדה 108 00:06:06,000 --> 00:06:09,000 כי ברגע שיש לך את כל הרשימות הללו לחוד, 109 00:06:09,000 --> 00:06:12,000 כל אלה הם בגודל 1, שנראה כחסרים תועלת, 110 00:06:12,000 --> 00:06:15,000 ברגע שתתחיל ממזג אותם וממזג אותם 111 00:06:15,000 --> 00:06:19,000 אתה בונה את סוף הסוף כמו רוב עשה בוידאו רשימה לבסוף מסודרת. 112 00:06:19,000 --> 00:06:22,000 >> אבל הרעיון הזה חורג הרבה מעבר למיון. 113 00:06:22,000 --> 00:06:26,000 יש רעיון זה מוטבע בתכנית זו המכונית רקורסיה, 114 00:06:26,000 --> 00:06:29,000 הרעיון לפיו אתה נמצא תכנית, 115 00:06:29,000 --> 00:06:32,000 כדי לפתור בעיה כלשהי אתה קורא לעצמך ו, 116 00:06:32,000 --> 00:06:36,000 או לשים בהקשר של שפות תכנות אתה פונקציה, 117 00:06:36,000 --> 00:06:39,000 ועל מנת לפתור את הבעיה, אתה קורא לעצמך פונקציה 118 00:06:39,000 --> 00:06:42,000 שוב ושוב ושוב, אבל אתה פונקציה 119 00:06:42,000 --> 00:06:44,000 לא יכול לקרוא לעצמך אינסוף פעמים. 120 00:06:44,000 --> 00:06:47,000 סופו של דבר יש לך למטה אותו, כביכול, 121 00:06:47,000 --> 00:06:49,000 ויש מצב בסיס קבוע בקוד שאומר 122 00:06:49,000 --> 00:06:53,000 בשלב זה להפסיק לקרוא את עצמך כך שהתהליך כולו 123 00:06:53,000 --> 00:06:56,000 סוף הסוף עושה למעשה להפסיק. 124 00:06:56,000 --> 00:06:58,000 מה זה באמת אומר, לרקורסיבית? 125 00:06:58,000 --> 00:07:01,000 >> בואו נראה אם ​​אנחנו יכולים לעשות את דוגמה פשוטה, טריוויאלי, למשל, 126 00:07:01,000 --> 00:07:03,000 3 אנשים עם אותי כאן על במה, אם מישהו נוח. 127 00:07:03,000 --> 00:07:06,000 1, בואו ניכנס, 2 ו 3. 128 00:07:06,000 --> 00:07:09,000 אם אתה רוצה 3 שתבואו לכאן. 129 00:07:09,000 --> 00:07:12,000 אם אתה רוצה לעמוד ממש לידי כאן בשורה, מניח שבעיה ביד 130 00:07:12,000 --> 00:07:15,000 מאוד trivially הוא לספור את מספר האנשים שנמצאים כאן. 131 00:07:15,000 --> 00:07:18,000 אבל בכנות, אני עייף מכל הדוגמות הללו הספירה. 132 00:07:18,000 --> 00:07:21,000 זה הולך לקחת קצת זמן, 1, 2, ונקודה, נקודה, נקודה. 133 00:07:21,000 --> 00:07:23,000 זה הולך להימשך לנצח. 134 00:07:23,000 --> 00:07:25,000 אני מעדיף פשוט דוגית בעיה זו לחלוטין עם העזרה של-מה השם שלך? 135 00:07:25,000 --> 00:07:27,000 שרה. >> שרה, הכל בסדר. 136 00:07:27,000 --> 00:07:29,000 קלי. >> קלי ו? 137 00:07:29,000 --> 00:07:31,000 >> ווילי. >> וילי, שרה, קלי, ווילי. 138 00:07:31,000 --> 00:07:34,000 נכון לעכשיו אני כבר שאלתי את השאלה במישהו 139 00:07:34,000 --> 00:07:37,000 כמה אנשים נמצאים על הבמה הזאת, ואין לי מושג. 140 00:07:37,000 --> 00:07:40,000 זוהי רשימה ארוכה באמת, ואז במקום זה אני הולך לעשות את הטריק הזה. 141 00:07:40,000 --> 00:07:43,000 אני הולך לשאול את האדם לידי לעשות את רוב העבודה, 142 00:07:43,000 --> 00:07:46,000 וברגע שהיא נעשית עושה את רוב העבודה 143 00:07:46,000 --> 00:07:49,000 אני הולך לעשות את הכמות המינימאלית של עבודה האפשרית ופשוט להוסיף 1 144 00:07:49,000 --> 00:07:51,000 לכל התשובה שלה, אז הנה זה באנו. 145 00:07:51,000 --> 00:07:54,000 אני כבר שאלתי כמה אנשים על במה. 146 00:07:54,000 --> 00:07:57,000 כמה אנשים על במה משמאלך? 147 00:07:57,000 --> 00:08:00,000 השמאלי שלי? >> בסדר, אבל לא לרמות. 148 00:08:00,000 --> 00:08:04,000 זה טוב, זה נכון, אבל אם אנחנו רוצים להמשיך את ההגיון הזה 149 00:08:04,000 --> 00:08:08,000 בואו נניח שאתה רוצה באופן דומה דוגית בעיה זו בצד השמאל שלך, 150 00:08:08,000 --> 00:08:11,000 כך, במקום תשובה ישירה קדימה ופשוט להעביר את האחריות. 151 00:08:11,000 --> 00:08:14,000 הו, כמה אנשים נמצאים בצד השמאל שלי? 152 00:08:14,000 --> 00:08:16,000 כמה אנשים מהשמאל? 153 00:08:16,000 --> 00:08:18,000 1. 154 00:08:18,000 --> 00:08:27,000 [שחוק] 155 00:08:27,000 --> 00:08:30,000 אוקיי, אז 0, אז מה עכשיו וילי עשה 156 00:08:30,000 --> 00:08:33,000 הוא שחזר התשובה שלך כיוון זה אומר 0. 157 00:08:33,000 --> 00:08:36,000 עכשיו, מה אתה צריך לעשות? >> 1. 158 00:08:36,000 --> 00:08:39,000 אוקיי, אז אתה 1, כך שאתה אומר, "בסדר, אני הולך להוסיף 1 159 00:08:39,000 --> 00:08:41,000 לכל הספירה של וילי היה, "אז 1 + 0. 160 00:08:41,000 --> 00:08:43,000 כעת אתה 1 אז התשובה שלך לימין היא עכשיו 161 00:08:43,000 --> 00:08:45,000 1. >> ושלי יהיה 2. 162 00:08:45,000 --> 00:08:48,000 טוב, אז אתה לוקח את התשובה הקודמת של 1, 163 00:08:48,000 --> 00:08:51,000 הוספת הכמות המזערית של עבודה שאתה רוצה לעשות, שהוא +1. 164 00:08:51,000 --> 00:08:55,000 כעת יש לך 2, ואז אתה נותן לי ערך ש? 165 00:08:55,000 --> 00:08:57,000 3, אני מתכוון, סליחה, 2. 166 00:08:57,000 --> 00:08:59,000 טוב. 167 00:08:59,000 --> 00:09:02,000 >> ובכן, היו לנו 0 עד השמאל. 168 00:09:02,000 --> 00:09:05,000 ואז היה לנו 1, ולאחר מכן אנו מוסיפים 2, 169 00:09:05,000 --> 00:09:07,000 ועכשיו אתה מסרת לי את המספר 2, 170 00:09:07,000 --> 00:09:10,000 ולכן אני אומרת, בסדר, +1, 3. 171 00:09:10,000 --> 00:09:13,000 יש אכן 3 אנשים שעמדו לידי בשלב זה, 172 00:09:13,000 --> 00:09:16,000 ואז הייתי יכול לעשות את זה מאוד ברור באופן ליניארי, 173 00:09:16,000 --> 00:09:19,000 מאוד באופנה הברורה, אבל מה שאנחנו באמת עשינו? 174 00:09:19,000 --> 00:09:21,000 אנחנו לקחנו את הבעיה של גודל 3 בתחילה. 175 00:09:21,000 --> 00:09:24,000 אז שברנו אותו לבעיה של גודל 2, 176 00:09:24,000 --> 00:09:27,000 אז בעיה של גודל 1, ולבסוף מקרה הבסיס 177 00:09:27,000 --> 00:09:29,000 היה באמת, אוי, אין שם איש, 178 00:09:29,000 --> 00:09:33,000 ובנקודה וילי חזר יעילות תשובה בקוד כמה פעמים, 179 00:09:33,000 --> 00:09:36,000 והשנייה לאחר מכן עלתה ובעבעה, פעפע, בעבע, 180 00:09:36,000 --> 00:09:39,000 ולאחר מכן על ידי הוספה ב1 1 נוסף זה 181 00:09:39,000 --> 00:09:41,000 אנחנו יישמנו הרעיון הבסיסי הזה של רקורסיה. 182 00:09:41,000 --> 00:09:44,000 >> עכשיו, במקרה הזה זה לא באמת לפתור את הבעיה 183 00:09:44,000 --> 00:09:46,000 כל בצורה יעילה יותר ואז שראינו עד כה. 184 00:09:46,000 --> 00:09:48,000 אבל תחשוב על האלגוריתמים שנעשינו איתם על במה עד כה. 185 00:09:48,000 --> 00:09:51,000 היו לנו 8 חתיכות של נייר על הלוח, 186 00:09:51,000 --> 00:09:55,000 בוידאו כאשר היה מסתכל למספר 7, ומה שהוא באמת עשה? 187 00:09:55,000 --> 00:09:58,000 ובכן, הוא לא עשה כל סוג של פרד ומשול. 188 00:09:58,000 --> 00:10:01,000 הוא לא עשה שום סוג של רקורסיה. 189 00:10:01,000 --> 00:10:03,000 במקום זאת, הוא פשוט עשה את האלגוריתם ליניארי זה. 190 00:10:03,000 --> 00:10:07,000 אבל כאשר הצגנו את הרעיון של מספרים ממוינים על במה בהופעה חיה בשבוע שעבר 191 00:10:07,000 --> 00:10:09,000 אז היה לנו האינסטינקט הזה של ללכת לאמצע, 192 00:10:09,000 --> 00:10:13,000 ובשלב זה לא היה לנו רשימה קטנה יותר בגודל 4 או רשימה נוספת של גודל 4, 193 00:10:13,000 --> 00:10:17,000 ואז הייתה לנו באותה הבעיה בדיוק, ולכן אנחנו חוזרים, חזרנו, חזרנו. 194 00:10:17,000 --> 00:10:19,000 במילים אחרות, אנו recursed. 195 00:10:19,000 --> 00:10:24,000 תודה רבה לך ל3 המתנדבים שלנו כאן עבור הוכחת רקורסיה איתנו. 196 00:10:24,000 --> 00:10:28,000 >> בואו נראה אם ​​אנחנו לא יכולים לעשות את זה עכשיו קצת יותר קונקרטי, 197 00:10:28,000 --> 00:10:30,000 פתרון בעיה ששוב אנחנו יכולים לעשות די בקלות, 198 00:10:30,000 --> 00:10:34,000 אבל אנחנו מתכוונים להשתמש בו כקרש קפיצה ליישומו של רעיון בסיסי זה. 199 00:10:34,000 --> 00:10:37,000 אם אני רוצה לחשב את הסיכום של חבורה של מספרים, 200 00:10:37,000 --> 00:10:39,000 למשל, אם אתה עובר במספר 3, 201 00:10:39,000 --> 00:10:42,000 אני רוצה לתת לך את הערך של 3 סיגמא, 202 00:10:42,000 --> 00:10:46,000 כך הסכום של 3 + 2 + 1 + 0. 203 00:10:46,000 --> 00:10:48,000 אני רוצה לקבל בחזרה את התשובה 6, 204 00:10:48,000 --> 00:10:51,000 לכן אנו ליישם פונקציה זו סיגמא, פונקצית סיכום זה 205 00:10:51,000 --> 00:10:54,000 כי, שוב, לוקח בקלט, ולאחר מכן מחזיר את הסיכום 206 00:10:54,000 --> 00:10:57,000 מהמספר הזה את כל הדרך למטה עד 0. 207 00:10:57,000 --> 00:10:59,000 אנחנו יכולים לעשות את זה די פשוט, נכון? 208 00:10:59,000 --> 00:11:01,000 אנחנו יכולים לעשות את זה עם איזה סוג של מבנה מסובב, 209 00:11:01,000 --> 00:11:04,000 אז תן לי להמשיך ולקבל את זה התחיל. 210 00:11:04,000 --> 00:11:07,000 >> כולל stdio.h. 211 00:11:07,000 --> 00:11:09,000 תן לי את עצמי לתוך עיקרי לעבוד עם כאן. 212 00:11:09,000 --> 00:11:12,000 בואו נשמור את זה כsigma.c. 213 00:11:12,000 --> 00:11:14,000 ואז אני הולך לכאן, ואני הולך להכריז n int, 214 00:11:14,000 --> 00:11:18,000 ואני הולך לעשות את הפעולות הבאות בזמן שהמשתמש לא משתף פעולה. 215 00:11:18,000 --> 00:11:22,000 בזמן שהמשתמש לא נתן לי מספר חיובי 216 00:11:22,000 --> 00:11:26,000 תן לי ללכת קדימה ותנחה אותם לGetInt = n, 217 00:11:26,000 --> 00:11:28,000 ולתת לי לתת להם כמה הוראות לגבי מה לעשות, 218 00:11:28,000 --> 00:11:33,000 כך printf ("מספר חיובי בבקשה"). 219 00:11:33,000 --> 00:11:39,000 רק משהו פשוט יחסית כמו זה, כך שעד שפגענו בקו 14 220 00:11:39,000 --> 00:11:42,000 כעת יש לנו מספר חיובי ככל הנראה בn. 221 00:11:42,000 --> 00:11:44,000 >> עכשיו בואו נעשה עם זה משהו. 222 00:11:44,000 --> 00:11:50,000 תן לי ללכת קדימה ולחשב את הסיכום, כך int סכום = sigma (n). 223 00:11:50,000 --> 00:11:54,000 סיגמא הוא רק סיכום, אז אני רק כותב את זה בדרך יותר המסובכת. 224 00:11:54,000 --> 00:11:56,000 אנחנו פשוט קוראים לזה סיגמא שם. 225 00:11:56,000 --> 00:11:58,000 זה הסכום, ועכשיו אני הולך להדפיס את התוצאה, 226 00:11:58,000 --> 00:12:08,000 printf ("הסכום הוא% d \ n", הסכום). 227 00:12:08,000 --> 00:12:11,000 ואז אני אחזיר 0 למען סדר טוב. 228 00:12:11,000 --> 00:12:15,000 עשינו כל מה שהתכנית הזו דורשת, פרט לחלק המעניין, 229 00:12:15,000 --> 00:12:18,000 שהוא למעשה ליישם את פונקצית סיגמא. 230 00:12:18,000 --> 00:12:22,000 >> תן לי לרדת לכאן לתחתית, ותנו לי להכריז על הפונקציה סיגמא. 231 00:12:22,000 --> 00:12:26,000 זה חייב לקחת במשתנה זה מסוג שלם, 232 00:12:26,000 --> 00:12:30,000 ומה סוג נתונים אני רוצה לחזור מן הסתם מסיגמא? 233 00:12:30,000 --> 00:12:34,000 Int, כי אני רוצה את זה כדי להתאים את הציפיות שלי בקו 15. 234 00:12:34,000 --> 00:12:37,000 כאן נתן לי ללכת קדימה וליישם את זה 235 00:12:37,000 --> 00:12:41,000 באופן די פשוט. 236 00:12:41,000 --> 00:12:45,000 >> בואו נגיד את סכום int = 0, 237 00:12:45,000 --> 00:12:47,000 ועכשיו אני הולך להיות קצת ללולאה כאן 238 00:12:47,000 --> 00:12:50,000 שיגיד משהו כזה, 239 00:12:50,000 --> 00:13:01,000 עבור (אני int = 0; אני <= מספר; אני + +) סכום + = i. 240 00:13:01,000 --> 00:13:05,000 ואז אני הולך להחזיר סכום. 241 00:13:05,000 --> 00:13:07,000 אני לא הייתי יכול לבצע את זה בכל מיני דרכים. 242 00:13:07,000 --> 00:13:09,000 הייתי יכול להשתמש בלולאת זמן. 243 00:13:09,000 --> 00:13:11,000 הייתי יכול להיחלץ בעזרת משתנה הסכום אם אני באמת רוצה, 244 00:13:11,000 --> 00:13:15,000 אבל בקיצור, אנחנו רק צריכים פונקציה שאם אני לא לפשל מצהיר סכום הוא 0. 245 00:13:15,000 --> 00:13:18,000 אז זה סובב מ 0 על דרך המספר, 246 00:13:18,000 --> 00:13:23,000 ועל כל איטרציה הוא מוסיף כי ערך הנוכחי לסכום ולאחר מכן מחזיר סכום. 247 00:13:23,000 --> 00:13:25,000 >> עכשיו, יש אופטימיזציה קלה כאן. 248 00:13:25,000 --> 00:13:29,000 זה כנראה צעד מבוזבז, אבל ניחא. זה בסדר לעת עתה. 249 00:13:29,000 --> 00:13:32,000 אנחנו לפחות מנסים להיות יסודיים והולכים 0 כל הדרך למעלה. 250 00:13:32,000 --> 00:13:34,000 לא קשה מאוד ודי פשוט, 251 00:13:34,000 --> 00:13:37,000 אבל מסתבר שעם פונקצית סיגמא שיש לנו את אותה ההזדמנות 252 00:13:37,000 --> 00:13:39,000 כפי שעשינו כאן על במה. 253 00:13:39,000 --> 00:13:42,000 על במה, אנחנו ספרנו כמה אנשים היו לידי, 254 00:13:42,000 --> 00:13:47,000 אלא אם אנחנו רוצים לספור את המספר 3 + 2 + 1 255 00:13:47,000 --> 00:13:51,000 על עד 0 שיכולנו בדומה דוגית לפונקציה 256 00:13:51,000 --> 00:13:55,000 שבמקום זאת תתאר כרקורסיבית. 257 00:13:55,000 --> 00:13:57,000 הנה בואו נעשה את השפיות מהירה לבדוק ולוודא שלא עשה טעויות. 258 00:13:57,000 --> 00:14:00,000 >> אני יודע שיש לפחות דבר אחד בתכנית זו שעשיתי לא בסדר. 259 00:14:00,000 --> 00:14:04,000 כשפגעתי להיכנס אני הולך לקבל כל סוג של לצעוק עליי? 260 00:14:04,000 --> 00:14:06,000 מה אני הולך להיות צעקתי עליו? 261 00:14:06,000 --> 00:14:11,000 כן, שכחתי את האבטיפוס, ולכן אני משתמש בפונקציה שנקראת סיגמא ב 15 לקו, 262 00:14:11,000 --> 00:14:16,000 אבל זה לא הצהיר עד 22 בקו, אז הכי טוב ללכת באופן יזום כאן 263 00:14:16,000 --> 00:14:22,000 ולהכריז על אב טיפוס, ואני אגיד את int סיגמא (מספר int), וזהו. 264 00:14:22,000 --> 00:14:24,000 זה מיושם בתחתית. 265 00:14:24,000 --> 00:14:27,000 >> או בדרך אחרת שאני יכול לפתור את זה, 266 00:14:27,000 --> 00:14:30,000 אני יכול להעביר את הפונקציה לשם, וזה לא רע, 267 00:14:30,000 --> 00:14:32,000 אבל לפחות כאשר התוכניות שלך מתחילות לקבל ארוך, כנות, 268 00:14:32,000 --> 00:14:35,000 אני חושב שיש ערך כלשהו בתמיד נתקל ראשי בחלק העליון 269 00:14:35,000 --> 00:14:38,000 כך שאתה בקורא יכול לפתוח את הקובץ ולאחר מכן לראות מייד 270 00:14:38,000 --> 00:14:40,000 מה התכנית עושה מבלי לחפש דרכו 271 00:14:40,000 --> 00:14:42,000 מחפש שתפקידו העיקרי. 272 00:14:42,000 --> 00:14:49,000 בואו נרד לחלון המסוף שלי כאן, נסה לעשות סיגמא להפוך סיגמא, 273 00:14:49,000 --> 00:14:51,000 וגם אני דפוק כאן. 274 00:14:51,000 --> 00:14:55,000 הצהרה המרומזת של GetInt פונקציה אומרת ששכחתי לעשות מה עוד? 275 00:14:55,000 --> 00:14:57,000 [לא ברור לתלמיד] 276 00:14:57,000 --> 00:15:00,000 טוב, אז כנראה טעות נפוצה, אז בואו נשאיר את זה כאן, 277 00:15:00,000 --> 00:15:04,000 cs50.h, ועכשיו בואו נחזור לחלון המסוף שלי. 278 00:15:04,000 --> 00:15:08,000 >> אני לנקות את המסך, ואני אעשה שידור חוזר סיגמא. 279 00:15:08,000 --> 00:15:11,000 נראה שהוא חבר. תן לי עכשיו לרוץ סיגמא. 280 00:15:11,000 --> 00:15:15,000 אני להקליד את המספר 3, ואני לא מקבל 6, אז לא בדיקה קפדנית, 281 00:15:15,000 --> 00:15:18,000 אבל לפחות זה נראה שזה עובד במבט הראשון, אבל עכשיו בואו לקרוע אותו לגזרים, 282 00:15:18,000 --> 00:15:21,000 ובואו בעצם למנף את הרעיון של רקורסיה, שוב, 283 00:15:21,000 --> 00:15:24,000 בהקשר פשוט מאוד כך שבזמן של כמה שבועות 284 00:15:24,000 --> 00:15:27,000 כאשר אנו מתחילים לחקור מבני נתונים יפים ממערכים 285 00:15:27,000 --> 00:15:30,000 יש לנו כלי נוסף בארגז הכלים עם אשר 286 00:15:30,000 --> 00:15:33,000 לתפעל מבני הנתונים האלה כפי שאנו נראים. 287 00:15:33,000 --> 00:15:36,000 זו הגישה איטרטיבי, גישת לולאה המבוססת. 288 00:15:36,000 --> 00:15:39,000 >> תן לי עכשיו במקום לעשות את זה. 289 00:15:39,000 --> 00:15:44,000 תן לי במקום לומר שהסיכום של מספר 290 00:15:44,000 --> 00:15:48,000 על עד 0 הוא באמת אותו הדבר כמו 291 00:15:48,000 --> 00:15:53,000 מספר + סיגמא (מספר - 1). 292 00:15:53,000 --> 00:15:57,000 במילים אחרות, בדיוק כמו שאני על במת בעט לכל אחד מאנשים הקרובים אליי, 293 00:15:57,000 --> 00:16:00,000 והם בתורם המשיכו בעיטה עד שסוף סוף הגיעו לנקודת השפל בווילי, 294 00:16:00,000 --> 00:16:03,000 שהיה צריך להחזיר תשובה בקידוד קשיח כמו 0. 295 00:16:03,000 --> 00:16:07,000 הנה עכשיו אנחנו דומי חתירה לסיגמא 296 00:16:07,000 --> 00:16:10,000 את אותו הדבר כמו שנקרא במקור, אבל תובנה המרכזית כאן 297 00:16:10,000 --> 00:16:12,000 הוא שאנחנו כבר לא קוראים לסיגמא באופן זהה. 298 00:16:12,000 --> 00:16:14,000 אנחנו לא עוברים בn. 299 00:16:14,000 --> 00:16:17,000 אנחנו בבירור אתה עוברים במספר - 1, 300 00:16:17,000 --> 00:16:20,000 אז בעיה קצת יותר קטנה, בעיה קצת יותר קטנה. 301 00:16:20,000 --> 00:16:23,000 >> למרבה הצער, זה לא ממש פתרון, ולפני שאנחנו לתקן 302 00:16:23,000 --> 00:16:26,000 מה שניתן לקופץ החוצה ברגע ברור בכמה מכם 303 00:16:26,000 --> 00:16:28,000 תן לי ללכת קדימה ולהפוך את השידור חוזר. 304 00:16:28,000 --> 00:16:30,000 נראה לי לקמפל בסדר. 305 00:16:30,000 --> 00:16:32,000 תן לי שידור חוזר סיגמא עם 6. 306 00:16:32,000 --> 00:16:37,000 אופס, תן לי שידור חוזר סיגמא עם 6. 307 00:16:37,000 --> 00:16:42,000 ראינו את זה בעבר, אם כי בזמן האחרון בטעות גם כן. 308 00:16:42,000 --> 00:16:48,000 מדוע קבל אשמת הפילוח המסתורי הזה? כן. 309 00:16:48,000 --> 00:16:50,000 [לא ברור לתלמיד] 310 00:16:50,000 --> 00:16:53,000 אין מקרה בסיס, ולייתר דיוק, מה שכנראה קרה? 311 00:16:53,000 --> 00:16:58,000 זה סימפטום של איזו התנהגות? 312 00:16:58,000 --> 00:17:00,000 תגיד את זה בקול רם יותר. 313 00:17:00,000 --> 00:17:02,000 [לא ברור לתלמיד] 314 00:17:02,000 --> 00:17:05,000 זה לולאה אינסופית ביעילות, ובעיה עם לולאות אינסופיות 315 00:17:05,000 --> 00:17:08,000 כאשר הם כרוכים ברקורסיה במקרה זה, פונקציה שקראה לעצמה, 316 00:17:08,000 --> 00:17:10,000 מה שקורה בכל פעם שאתה קורא לפונקציה? 317 00:17:10,000 --> 00:17:13,000 ובכן, תחשוב על איך אנחנו ערוכים הזיכרון במחשב. 318 00:17:13,000 --> 00:17:16,000 אנחנו אמרנו שיש נתח זה של זיכרון נקרא המחסנית זה בתחתית, 319 00:17:16,000 --> 00:17:19,000 וכל פעם שאתה קורא לפונקצית זיכרון קצת יותר תכניס את 320 00:17:19,000 --> 00:17:24,000 על הערימה כביכול הזה מכיל משתנים או פרמטרים המקומיים השל הפונקציה, 321 00:17:24,000 --> 00:17:27,000 כך שאם סיגמא שיחות סיגמא סיגמא קורא סיגמא 322 00:17:27,000 --> 00:17:29,000  קורא סיגמא היכן מסתיים הסיפור הזה? 323 00:17:29,000 --> 00:17:31,000 >> ובכן, זה סופו של דבר הסכום הכולל צפות 324 00:17:31,000 --> 00:17:33,000 זיכרון שיש לך זמין למחשב שלך. 325 00:17:33,000 --> 00:17:37,000 אתה מוצף קטע שאתה אמור להישאר במסגרת, 326 00:17:37,000 --> 00:17:40,000 ואתה מקבל את אשמת פילוח זה, ליבה זרקה, 327 00:17:40,000 --> 00:17:43,000 ומה זרק ליבת משמעות הוא שעכשיו יש לי קובץ שנקרא ליבה 328 00:17:43,000 --> 00:17:46,000 שהוא קובץ המכיל אפסים ואחדים 329 00:17:46,000 --> 00:17:49,000 כי למעשה בעתיד יהיה diagnostically שימושי. 330 00:17:49,000 --> 00:17:52,000 אם זה לא ברור לך איפה הבאג שלך הוא 331 00:17:52,000 --> 00:17:54,000 אתה באמת יכול לעשות קצת ניתוח משפטי, אם אפשר לומר כך, 332 00:17:54,000 --> 00:17:58,000 בקובץ dump ליבה זו, ששוב, היא פשוט כל חבורה של אפסים ואחדים 333 00:17:58,000 --> 00:18:02,000 שבעצם מייצג את המצב של התכנית שלך בזיכרון 334 00:18:02,000 --> 00:18:05,000 ברגע שהתרסק בדרך זו. 335 00:18:05,000 --> 00:18:11,000 >> התיקון כאן הוא שאנחנו לא יכולים פשוט עיוור לחזור סיגמא, 336 00:18:11,000 --> 00:18:14,000 המספר + סיגמא של בעיה קצת יותר קטנה. 337 00:18:14,000 --> 00:18:16,000 אנחנו צריכים שיהיו איזשהו מקרה בסיס כאן, 338 00:18:16,000 --> 00:18:19,000 ומה צריך מקרה הבסיס כנראה יהיה? 339 00:18:19,000 --> 00:18:22,000 [לא ברור לתלמיד] 340 00:18:22,000 --> 00:18:25,000 אוקיי, אז עוד המספר חיובי שצריך להחזיר את זה, 341 00:18:25,000 --> 00:18:29,000 או במילים אחרות, אם מספר הוא, יניח, <= ל 0 342 00:18:29,000 --> 00:18:32,000 אתה יודע מה, אני אמשיך הלאה ולהחזיר 0, 343 00:18:32,000 --> 00:18:36,000 כמו ווילי עשה, ואחר, אני הולך קדימה 344 00:18:36,000 --> 00:18:41,000 ולהחזיר את זה, אז זה לא כל כך הרבה יותר קצר 345 00:18:41,000 --> 00:18:44,000 יותר מהגרסה איטרטיבי שהצלפנו באמצעות ראשון ללולאה, 346 00:18:44,000 --> 00:18:48,000 אבל שם לב שיש סוג כזה של אלגנטיות אליו. 347 00:18:48,000 --> 00:18:51,000 במקום להחזיר חלק מספר וביצוע כל מתמטיקה זה 348 00:18:51,000 --> 00:18:54,000 והוספת דברים עם משתנים מקומיים 349 00:18:54,000 --> 00:18:57,000 אתה במקום אתה אומר "בסדר, אם מדובר בבעית סופר קלה, 350 00:18:57,000 --> 00:19:01,000 כמו המספר הוא <0, הרשה לי להחזיר 0 באופן מיידי ". 351 00:19:01,000 --> 00:19:03,000 >> אנחנו לא הולכים להטריד את המספרים שליליים תומכים, 352 00:19:03,000 --> 00:19:05,000 אז אני הולך לקוד קשה הערך של 0. 353 00:19:05,000 --> 00:19:08,000 אבל חוץ מזה, כדי ליישם את הרעיון הזה של סיכום 354 00:19:08,000 --> 00:19:11,000 כל המספרים האלה יחד אתה יכול למעשה לקחת ביס קטן 355 00:19:11,000 --> 00:19:14,000 מתוך הבעיה, ממש כמו שעשינו פה על במה, 356 00:19:14,000 --> 00:19:18,000 אז דוגית שאר הבעיה לאדם הבא, 357 00:19:18,000 --> 00:19:20,000 אבל במקרה הזה האדם הבא הוא אתה עצמך. 358 00:19:20,000 --> 00:19:22,000 זה פונקציה בשם זהה. 359 00:19:22,000 --> 00:19:25,000 רק להעביר אותו קטנה יותר וקטנה יותר ויותר בעיה בכל פעם, 360 00:19:25,000 --> 00:19:28,000 ולמרות שיש לנו דברים לא פורמלית למדי בקוד כאן 361 00:19:28,000 --> 00:19:33,000 זה בדיוק מה שקרה בשבוע 0 עם ספר טלפונים. 362 00:19:33,000 --> 00:19:36,000 זה בדיוק מה שקורה בשבועות אחרונים עם שון 363 00:19:36,000 --> 00:19:39,000 ועם ההפגנות של חיפוש מספרים שלנו. 364 00:19:39,000 --> 00:19:42,000 זה לקחת בעיה וחלוקתו שוב ושוב. 365 00:19:42,000 --> 00:19:44,000 >> במילים אחרות, יש דרך עכשיו בתרגום 366 00:19:44,000 --> 00:19:47,000 מבנה זה עולם אמיתי, מבנה זה רמה גבוה יותר 367 00:19:47,000 --> 00:19:51,000 של פרד ומשול ועושה משהו שוב ושוב 368 00:19:51,000 --> 00:19:56,000 בקוד, אז זה משהו שאנחנו רואים שוב לאורך זמן. 369 00:19:56,000 --> 00:20:00,000 עכשיו, כמו בצד, אם אתה חדש ברקורסיה אתה צריך לפחות להבין עכשיו 370 00:20:00,000 --> 00:20:02,000 למה זה מצחיק. 371 00:20:02,000 --> 00:20:05,000 אני הולך ל-google.com, 372 00:20:05,000 --> 00:20:17,000 ואני הולך לחפש כמה טיפים וטריקים על רקורסיה, זן. 373 00:20:17,000 --> 00:20:21,000 תגיד אדם שלידך אם הם לא צוחקים רק עכשיו. 374 00:20:21,000 --> 00:20:23,000 האם התכוונת רקורסיה? 375 00:20:23,000 --> 00:20:25,000 האם התכוון ל-אה, יש לנו ללכת. 376 00:20:25,000 --> 00:20:28,000 אוקיי, עכשיו זה המנוחה של כולם. 377 00:20:28,000 --> 00:20:30,000 ביצת פסחא קטנה מוטבעת איפשהו שם בגוגל. 378 00:20:30,000 --> 00:20:33,000 במאמר מוסגר, אחד מהקישורים שאנחנו מעבירים באתר האינטרנט של הקורס 379 00:20:33,000 --> 00:20:36,000 להיום היא רק רשת זו של אלגוריתמי מיון שונים, 380 00:20:36,000 --> 00:20:39,000 חלק בו אנו נראים בשבוע שעבר, אבל מה שיפה זה הדמיה 381 00:20:39,000 --> 00:20:43,000 כפי שאתה מנסה לקלוט את הדברים שונים הקשורים לאלגוריתמים 382 00:20:43,000 --> 00:20:46,000 יודע שאתה יכול מאוד בקלות עכשיו להתחיל עם סוגים שונים של תשומות. 383 00:20:46,000 --> 00:20:50,000 כל הכניסות הפוכות, התשומות מסודרות בעיקר, את התשומות אקראיות וכן הלאה. 384 00:20:50,000 --> 00:20:53,000 כפי שאתה מנסה, שוב, להבדיל את הדברים האלה בראש שלך 385 00:20:53,000 --> 00:20:57,000 מבין שכתובת URL זו באתר האינטרנט של הקורס בדף ההרצאות 386 00:20:57,000 --> 00:21:00,000 עשוי לעזור לך סיבה דרך כמה מאלה. 387 00:21:00,000 --> 00:21:05,000 >> היום אנחנו סוף הסוף לפתור את הבעיה הזו ממזמן, 388 00:21:05,000 --> 00:21:08,000 שהיה שפונקצית swap זה פשוט לא עבדה, 389 00:21:08,000 --> 00:21:12,000 ומה היה הבעיה הבסיסית עם החלפה בפונקציה זו, 390 00:21:12,000 --> 00:21:15,000 שמטרתה הייתה, שוב, להחליף ערך כאן וכאן 391 00:21:15,000 --> 00:21:17,000 כך שזה קורה? 392 00:21:17,000 --> 00:21:20,000 זה ממש לא עבד. למה? 393 00:21:20,000 --> 00:21:22,000 כן. 394 00:21:22,000 --> 00:21:28,000 [לא ברור לתלמיד] 395 00:21:28,000 --> 00:21:31,000 בדיוק, הסבר לזה bugginess 396 00:21:31,000 --> 00:21:34,000 פשוט בגלל שכשאתה קורא פונקציות ב-C 397 00:21:34,000 --> 00:21:38,000 והפונקציות האלה לקחת טיעונים, כמו ב וכאן, 398 00:21:38,000 --> 00:21:42,000 אתה עובר בעותקים של כל ערך שאתה מספק לתפקוד. 399 00:21:42,000 --> 00:21:46,000 אתה לא מספק את הערכים המקוריים עצמם, 400 00:21:46,000 --> 00:21:49,000 כך ראינו את זה בהקשר של buggyc, 401 00:21:49,000 --> 00:21:52,000 buggy3.c, שנראה משהו קטן כזה. 402 00:21:52,000 --> 00:21:57,000 >> זוכר שהיו לנו x ו-y מאותחלים ל 1 ו 2, בהתאמה. 403 00:21:57,000 --> 00:21:59,000 אז הדפיס את מה שהם היו. 404 00:21:59,000 --> 00:22:03,000 אז טענתי שאני מחליף אותם על ידי קריאת החלפה של x, y. 405 00:22:03,000 --> 00:22:06,000 אבל הבעיה הייתה שההחלפה עבדה, 406 00:22:06,000 --> 00:22:10,000 רק בהיקף של ההחלפה אבל פונקציה עצם. 407 00:22:10,000 --> 00:22:13,000 ברגע שפגענו בקו 40 הערכים המוחלפים האלה 408 00:22:13,000 --> 00:22:16,000 הושלכו לפח, וכך דבר 409 00:22:16,000 --> 00:22:21,000 בתפקידו המקורי עיקרי בעצם השתניתי כלל, 410 00:22:21,000 --> 00:22:26,000 כך שאם אתה חושב אז על מה זה נראה כמו במונחים של הזיכרון שלנו 411 00:22:26,000 --> 00:22:29,000 אם צד שמאל של הלוח מייצג- 412 00:22:29,000 --> 00:22:33,000 ואני אעשה את הכי טוב שלי לכולם לראות את זה, אם צד השמאלי של הלוח 413 00:22:33,000 --> 00:22:37,000 מייצג, יניח, זכרון RAM שלך, והערימה הולכת לגדול בעד דרך זו, 414 00:22:37,000 --> 00:22:43,000 ואנחנו קוראים בפונקציה כמו ראשי, וראשיים יש 2 משתנה מקומי, X ו-Y, 415 00:22:43,000 --> 00:22:48,000 בואו נתאר אותם כx כאן, ובואו נתאר אותם כy כאן, 416 00:22:48,000 --> 00:22:55,000 ובואו נשים את ערכי 1 ו 2, אז זה כאן הוא ראשי, 417 00:22:55,000 --> 00:22:58,000 וכשקורא עיקריים של מערכת הפעלת פונקצית ההחלפה 418 00:22:58,000 --> 00:23:02,000 נותן פונקצית החלפת רצועה של זיכרון משלו במחסנית, 419 00:23:02,000 --> 00:23:04,000 המסגרת שלו בערימה, אם אפשר לומר כך. 420 00:23:04,000 --> 00:23:08,000 זה גם מקצה 32 ביטים לints אלה. 421 00:23:08,000 --> 00:23:11,000 זה קורה לקורא להם וb, אבל זה שרירותי לחלוטין. 422 00:23:11,000 --> 00:23:13,000 זה היה יכול להיות כינה אותם מה שהיא רוצה, אבל מה קורה כאשר עיקרית 423 00:23:13,000 --> 00:23:19,000 החלפת שיחות היא זה שלוקח 1, מעביר עותק שם, מעמיד את עותק לשם. 424 00:23:19,000 --> 00:23:23,000 >> יש משתנה מקומי אחר 1 בהחלפה, הנקראת במה? Tmp. >> 425 00:23:23,000 --> 00:23:27,000 Tmp, אז בוא אתן לעצמי עוד 32 סיבי כאן, 426 00:23:27,000 --> 00:23:29,000 ומה שעשיתי בפונקציה זו? 427 00:23:29,000 --> 00:23:34,000 אמרתי tmp int מקבל, ולכן יש 1, אז עשיתי את זה עוד כששחקנו בפעם האחרונה בדוגמה זו. 428 00:23:34,000 --> 00:23:39,000 ואז מקבל ב, ולכן b הוא 2, אז עכשיו זה הופך להיות 2, 429 00:23:39,000 --> 00:23:42,000 ועכשיו ב מקבל זמנית, ולכן טמפ 'הוא 1, 430 00:23:42,000 --> 00:23:44,000 אז עכשיו ב הופך לזה. 431 00:23:44,000 --> 00:23:46,000 זה נהדר. זה עבד. 432 00:23:46,000 --> 00:23:49,000 אבל אז ברגע שיחזור לתפקד 433 00:23:49,000 --> 00:23:52,000 הזיכרון של החלפת יעילות נעלם כך שניתן לעשות שימוש חוזר 434 00:23:52,000 --> 00:23:58,000 על ידי כמה תפקיד אחר בעתיד, ועיקרי הוא ברור ומוחלט ללא שינוי. 435 00:23:58,000 --> 00:24:00,000 אנחנו זקוקים לדרך לפתרון בעיה זו המיסוד, 436 00:24:00,000 --> 00:24:03,000 והיום אנחנו סוף סוף יש דרך לעשות את זה לפי 437 00:24:03,000 --> 00:24:06,000 אנו יכולים להציג משהו שנקרא מצביע. 438 00:24:06,000 --> 00:24:09,000 מתבררים שאנחנו יכולים לפתור את הבעיה הזו 439 00:24:09,000 --> 00:24:12,000 לא על ידי העברה בעותקים של x ו-y 440 00:24:12,000 --> 00:24:18,000 אלא על ידי העברה במה, לדעתך, לפונקצית ההחלפה? 441 00:24:18,000 --> 00:24:20,000 כן, מה עם הכתובת? 442 00:24:20,000 --> 00:24:22,000 אנחנו לא ממש דברנו על כתובות בפירוט רב, 443 00:24:22,000 --> 00:24:25,000 אבל אם לוח זה מייצג את הזיכרון של המחשב שלי 444 00:24:25,000 --> 00:24:28,000 אנחנו בהחלט יכולים להתחיל את מספור הבתים בזכרון RAM שלי 445 00:24:28,000 --> 00:24:31,000 ואומר זה בית המס '1, זה בית המס' 2, בית המס '3, 446 00:24:31,000 --> 00:24:35,000 בית המס '4, בייט # ... 2 מיליארדים אם יש לי 2 ג'יגה בייט של זכרון RAM, 447 00:24:35,000 --> 00:24:38,000 כך שאנחנו בהחלט יכולים לבוא עם איזו תכנית מספור שרירותית 448 00:24:38,000 --> 00:24:41,000 לכל הבתים הבודדים בזיכרון של המחשב שלי. 449 00:24:41,000 --> 00:24:43,000 >> מה אם במקום כשאני מתקשר להחלפה 450 00:24:43,000 --> 00:24:47,000 במקום לעבור בעותקים של x ו-y 451 00:24:47,000 --> 00:24:51,000 למה שאני לא אעבור במקום בכתובת של x כאן, 452 00:24:51,000 --> 00:24:55,000 הכתובת של Y כאן, בעצם הכתובת למשלוח דואר 453 00:24:55,000 --> 00:24:59,000 של x ו-y כי אז להחליף, אם הוא הודיע 454 00:24:59,000 --> 00:25:01,000 של הכתובת בזיכרון של X ו-Y, 455 00:25:01,000 --> 00:25:04,000 אז להחליף, אם היינו מאמנים אותו קצת, 456 00:25:04,000 --> 00:25:07,000 הוא עלול לנהוג לכתובת זו, אם אפשר לומר כך, 457 00:25:07,000 --> 00:25:11,000 x, ולשנות את המספר לשם, ואז לנסוע לכתובת של Y, 458 00:25:11,000 --> 00:25:16,000 לשנות את המספר שם, אפילו שגם אם לא מקבל עותקים של הערכים האלה בעצמו, 459 00:25:16,000 --> 00:25:19,000 אז למרות שדברנו על זה כזיכרון של עיקרי 460 00:25:19,000 --> 00:25:23,000 וזיכרון כשל עסקה זו החזק והחלק המסוכן של C 461 00:25:23,000 --> 00:25:28,000 הוא שכל פונקציה יכולה לגעת בכל מקום בזכרון המחשב, 462 00:25:28,000 --> 00:25:32,000 וזו היא עצמה שבאתה יכול לעשות דברים מאוד מפוארים עם תוכניות מחשב בג 463 00:25:32,000 --> 00:25:36,000 זה מסוכן, כי אתה יכול גם לפשל בקלות רבה. 464 00:25:36,000 --> 00:25:39,000 למעשה, אחת הדרכים הנפוצות ביותר לתוכניות בימים אלה ניתן לנצל 465 00:25:39,000 --> 00:25:42,000 עדיין היא למתכנת שלא מבינה 466 00:25:42,000 --> 00:25:45,000 שהוא או היא המאפשר לנתונים 467 00:25:45,000 --> 00:25:49,000 להיות כתוב במיקום בזיכרון שלא נועד. 468 00:25:49,000 --> 00:25:51,000 >> למשל, הוא או היא מצהיר על מערך בגודל 10 469 00:25:51,000 --> 00:25:56,000 אבל אז מנסה בטעות לשים 11 בתים שבמערך של זיכרון, 470 00:25:56,000 --> 00:25:59,000 ואתה מתחיל לגעת בחלקים של זיכרון שאינם תקפים עוד. 471 00:25:59,000 --> 00:26:02,000 בדיוק לזה קשר, שחלקכם אולי יודע ש 472 00:26:02,000 --> 00:26:06,000 תוכנה תבקש ממך לעתים קרובות למספרים סידוריים או מפתחות רישום, 473 00:26:06,000 --> 00:26:08,000 ו-Word פוטושופ ותוכניות מהסוג הזה. 474 00:26:08,000 --> 00:26:12,000 קיימים סדקים, כפי שחלקכם יודע, באופן מקוון שבו תוכל להפעיל תכנית קטנה, 475 00:26:12,000 --> 00:26:14,000 וזהו, לא יותר בקשה למספר סידורי. 476 00:26:14,000 --> 00:26:16,000 איך זה עובד? 477 00:26:16,000 --> 00:26:21,000 במקרים רבים את הדברים האלה פשוט מוצאים במחשבים 478 00:26:21,000 --> 00:26:24,000 קטעי טקסט באפסים והאחדים בפועל של המחשב 479 00:26:24,000 --> 00:26:28,000 איפה היא פונקציה שבו המספר הסידורי מתבקש, 480 00:26:28,000 --> 00:26:31,000 ואתה לדרוס חלל, או בזמן שהתכנית פועלת 481 00:26:31,000 --> 00:26:33,000 אתה יכול להבין היכן המפתח מאוחסן בפועל 482 00:26:33,000 --> 00:26:37,000 באמצעות משהו שנקרא הבאגים, ואתה יכול לפצח שדרך תוכנה. 483 00:26:37,000 --> 00:26:40,000 זה לא אומר שזה המטרה שלנו לימים הקרובים, 484 00:26:40,000 --> 00:26:42,000 אבל יש לו השלכות מאוד בעולם אמיתי. 485 00:26:42,000 --> 00:26:45,000 כי אחד קורה לערב גניבה של תוכנה, 486 00:26:45,000 --> 00:26:47,000 אבל יש גם פשרה של מכונות שלמות. 487 00:26:47,000 --> 00:26:50,000 >> למעשה, כאשר אתרי אינטרנט בימים אלה מנוצלים 488 00:26:50,000 --> 00:26:53,000 והתפשרתי ונתונים דלפו וסיסמות נגנבו 489 00:26:53,000 --> 00:26:58,000 לעתים קרובות זה קשור לניהול גרוע של הזיכרון שלו, 490 00:26:58,000 --> 00:27:01,000 או, במקרה של מסדי נתונים, כישלון לחזות 491 00:27:01,000 --> 00:27:03,000 קלט יריב, אז עוד על כך בשבועות הקרובים, 492 00:27:03,000 --> 00:27:07,000 אך לעת עתה רק הצגה מקדימה של הסוג של ניזק שאתה יכול לעשות 493 00:27:07,000 --> 00:27:11,000 בכך שלא הבנתי כיצד דברים עובדים מתחת למכסת המנוע. 494 00:27:11,000 --> 00:27:14,000 בואו נלך על הבנה מדוע זה נשבר 495 00:27:14,000 --> 00:27:17,000 עם כלי שהפך יותר ויותר שימושיים 496 00:27:17,000 --> 00:27:19,000 כתוכניות שלנו נעשה יותר מורכבות. 497 00:27:19,000 --> 00:27:21,000 עד כה, כאשר היה לך באג בתכנית שלך 498 00:27:21,000 --> 00:27:23,000 איך יש לך הלך על ניפויו? 499 00:27:23,000 --> 00:27:25,000 מה הטכניקות שלך היו עד כה, אם נלמדו על ידי TF 500 00:27:25,000 --> 00:27:27,000 או סתם אוטודידקט? 501 00:27:27,000 --> 00:27:29,000 [סטודנטים] printf. 502 00:27:29,000 --> 00:27:31,000 Printf, אז printf יש כנראה היה החבר שלך בכך שאם אתה רוצה לראות 503 00:27:31,000 --> 00:27:33,000 מה קורה בתוך התכנית שלך 504 00:27:33,000 --> 00:27:36,000 אתה פשוט לשים printf כאן, printf כאן, printf כאן. 505 00:27:36,000 --> 00:27:38,000 ואז אתה מפעיל את זה, ואתה מקבל כל מיני דברים על המסך 506 00:27:38,000 --> 00:27:43,000 כי אתה יכול להשתמש ואז להסיק מה בעצם השתבש בתכנית שלך. 507 00:27:43,000 --> 00:27:45,000 >> Printf נוטה להיות דבר חזק מאוד, 508 00:27:45,000 --> 00:27:47,000 אבל זה תהליך מאוד ידני. 509 00:27:47,000 --> 00:27:49,000 אתה צריך לשים את printf כאן, printf כאן, 510 00:27:49,000 --> 00:27:51,000 ואם תשים אותו בתוך לולאה אתה יכול לקבל 100 קווים 511 00:27:51,000 --> 00:27:53,000 תפוקה, כי אז אתה צריך לנפות. 512 00:27:53,000 --> 00:27:58,000 זה לא מנגנון ידידותי למשתמש או אינטרקטיווי מאוד לתוכניות איתור באגים, 513 00:27:58,000 --> 00:28:00,000 אבל לשמחתי קיים חלופות. 514 00:28:00,000 --> 00:28:03,000 יש תכנית, למשל, נקראת GDB, גנה Debugger, 515 00:28:03,000 --> 00:28:06,000 שהוא מסתורי קטן בכמה אתה משתמש בו. 516 00:28:06,000 --> 00:28:08,000 זה מורכב קצת, אבל בכנות, 517 00:28:08,000 --> 00:28:11,000 זה אחד מאותם דברים שבו אם אתה שם בשבוע הבא ו 518 00:28:11,000 --> 00:28:14,000 שעה נוספת כדי להבין משהו כמו GDB 519 00:28:14,000 --> 00:28:18,000 זה יחסוך לכם כנראה עשרות שעות בטווח הארוך, 520 00:28:18,000 --> 00:28:21,000 אז עם זה, ייתן לך טיזר של איך הדבר הזה עובד. 521 00:28:21,000 --> 00:28:23,000 >> אני בחלון המסוף שלי. 522 00:28:23,000 --> 00:28:26,000 תן לי ללכת קדימה ולקמפל תכנית זו, buggy3. 523 00:28:26,000 --> 00:28:28,000 זה כבר מעודכן. 524 00:28:28,000 --> 00:28:31,000 תן לי לנהל את זה בדיוק כמו שעשינו חזרה בזמן, ואכן, הוא שבור. 525 00:28:31,000 --> 00:28:34,000 אבל למה זה? אולי אני דפוק פונקצית הדפדוף. 526 00:28:34,000 --> 00:28:37,000 אולי זה ב. אני לא ממש אני נע סביבם בצורה נכונה. 527 00:28:37,000 --> 00:28:39,000 תן לי ללכת קדימה ולעשות את זה. 528 00:28:39,000 --> 00:28:43,000 ולא רק לרוץ buggy3 תן לי במקום לרוץ GDB תכנית זו, 529 00:28:43,000 --> 00:28:48,000 ואני הולך להגיד לו לרוץ buggy3, 530 00:28:48,000 --> 00:28:52,000 ואני מתכוון לכלול טיעון שורת פקודה,-Tui, 531 00:28:52,000 --> 00:28:55,000 ואנחנו נשים את זה בבעיות עתידיות במפרט כדי להזכיר. 532 00:28:55,000 --> 00:28:57,000 ועכשיו ממשק שחור ולבן זה צץ כי, שוב, 533 00:28:57,000 --> 00:28:59,000 הוא קצת מוחץ בהתחלה, כי יש את כל זה 534 00:28:59,000 --> 00:29:02,000 מידע על אחריות לכאן, אבל לפחות יש משהו מוכר. 535 00:29:02,000 --> 00:29:04,000 בחלק העליון של החלון הוא הקוד האמיתי שלי, 536 00:29:04,000 --> 00:29:08,000 ואם אני לגלול עד כאן נתתי לי לגלול לחלקו עליון של התיק שלי, 537 00:29:08,000 --> 00:29:11,000 ואכן, יש buggy3.c, והודעה בחלק התחתון של חלון זה 538 00:29:11,000 --> 00:29:13,000 יש לי GDB הנחיה זו. 539 00:29:13,000 --> 00:29:16,000 >> זה לא אותו הדבר כמו ג'ון הרווארד הפקודה הרגילה שלי. 540 00:29:16,000 --> 00:29:19,000 זו פקודה שהולכת כדי לאפשר לי לשלוט GDB. 541 00:29:19,000 --> 00:29:21,000 GDB הוא הבאגים. 542 00:29:21,000 --> 00:29:24,000 הבאגים הוא תכנית המאפשרת לך ללכת דרך 543 00:29:24,000 --> 00:29:27,000 ביצוע התכנית שלך על ידי שורת שורה אחרת שורה, 544 00:29:27,000 --> 00:29:30,000 לאורך הדרך לעשות מה שאתה רוצה בתכנית, 545 00:29:30,000 --> 00:29:33,000 אפילו קוראים פונקציות, או מחפש, וחשוב יותר, 546 00:29:33,000 --> 00:29:35,000 בערכים של משתנים שונים. 547 00:29:35,000 --> 00:29:37,000 בואו נלך קדימה ולעשות את זה. 548 00:29:37,000 --> 00:29:40,000 אני הולך קדימה, והקלד בשורת הפקודה בטווח של GDB, 549 00:29:40,000 --> 00:29:43,000 כך תבחין בפינה השמאלית התחתונה של מסך הקלדה שבצעתי, 550 00:29:43,000 --> 00:29:45,000 ואני פגעתי להיכנס, ומה זה עשה? 551 00:29:45,000 --> 00:29:50,000 זה ממש רץ את התכנית שלי, אבל בעצם לא רואה הרבה בארץ הזאת 552 00:29:50,000 --> 00:29:55,000 כי אני לא ממש אמרתי לי הבאגים 553 00:29:55,000 --> 00:29:57,000 להפסקתו ברגע נתון בזמן. 554 00:29:57,000 --> 00:29:59,000 פשוט להקליד ריצה מפעילה את התכנית. 555 00:29:59,000 --> 00:30:01,000 אני לא ממש רואה שום דבר. אני לא יכול לטפל בו. 556 00:30:01,000 --> 00:30:03,000 >> במקום לתת לי לעשות את זה. 557 00:30:03,000 --> 00:30:08,000 בGDB הפקודה הזאת נתנה לי במקום להקליד הפסקה, להיכנס. 558 00:30:08,000 --> 00:30:10,000 זה לא מה שהתכוונתי להקליד. 559 00:30:10,000 --> 00:30:13,000 בואו במקום להקליד הפסקה ראשית. 560 00:30:13,000 --> 00:30:15,000 במילים אחרות, אני רוצה להגדיר משהו שנקרא נקודת עצירה, 561 00:30:15,000 --> 00:30:18,000 אשר נקרא על שם צדק, כי זה ישבור או שהייה 562 00:30:18,000 --> 00:30:21,000 ביצוע התכנית שלך באותו מקום מסוים. 563 00:30:21,000 --> 00:30:23,000 העיקרי הוא השם של הפונקציה שלי. 564 00:30:23,000 --> 00:30:25,000 שים לב שGDB הוא די חכם. 565 00:30:25,000 --> 00:30:28,000 זה הבין שקורה עיקרי להתחיל בערך בקו 18 566 00:30:28,000 --> 00:30:32,000 של buggy3.c, ואז מבחין כאן בפינה שמאלית עליונה 567 00:30:32,000 --> 00:30:34,000 ב + הוא ממש ליד קו 18. 568 00:30:34,000 --> 00:30:38,000 זה מזכיר לי שאני צריך להגדיר נקודת עצירה בקו 18. 569 00:30:38,000 --> 00:30:42,000 הפעם, כשאני מקליד ריצה, אני הולך להפעיל את התכנית שלי 570 00:30:42,000 --> 00:30:45,000 עד שזה מכה נקודת עצירה, 571 00:30:45,000 --> 00:30:48,000 לכן התכנית תושהה לי בקו 18. 572 00:30:48,000 --> 00:30:50,000 הנה, לרוץ. 573 00:30:50,000 --> 00:30:53,000 שום דבר לא נראה שקרה, אבל הודעה בפינה שמאלית תחתונה 574 00:30:53,000 --> 00:30:58,000 תכנית מתחילה, buggy3, נקודת עצירה 1 בקו ראשי בbuggy3.c 18. 575 00:30:58,000 --> 00:31:00,000 מה אני יכול לעשות עכשיו? 576 00:31:00,000 --> 00:31:03,000 >> שים לב שאני יכול להתחיל להקליד דברים כמו הדפסה, 577 00:31:03,000 --> 00:31:08,000 לא printf, x הדפסה, וזה הדבר מוזר. 578 00:31:08,000 --> 00:31:11,000 1 $ הם רק סקרנות, כפי שנראים 579 00:31:11,000 --> 00:31:14,000 בכל פעם שאתה מדפיס משהו שאתה מקבל ערך חדש $. 580 00:31:14,000 --> 00:31:18,000 זה כדי שתוכל לחזור ולעיין בערכים קודמים לכל מקרה, 581 00:31:18,000 --> 00:31:21,000 אך לעת עתה מה הדפסה אומרת לי הוא שהערך של x בנקודה זו בסיפור 582 00:31:21,000 --> 00:31:26,000 כנראה 134514032. 583 00:31:26,000 --> 00:31:29,000 מה? איפה עוד זה בא? 584 00:31:29,000 --> 00:31:31,000 [לא ברור לתלמיד] 585 00:31:31,000 --> 00:31:34,000 ואכן, זה מה שאנחנו קוראים ערך אשפה, ואנחנו כבר לא מדברים על זה עדיין, 586 00:31:34,000 --> 00:31:37,000 אבל הסיבה שמאותחל משתנים 587 00:31:37,000 --> 00:31:40,000 ברור, כך שיש להם איזה ערך שאתה רוצה לתת להם. 588 00:31:40,000 --> 00:31:44,000 אבל לתפוס אותו לזכור שאתה יכול להצהיר על משתנה 589 00:31:44,000 --> 00:31:46,000 כמו שעשיתי לפני רגע בדוגמא סיגמא 590 00:31:46,000 --> 00:31:48,000 מבלי לתת להם ממש ערך. 591 00:31:48,000 --> 00:31:50,000 זוכר את מה שעשיתי כאן בסיגמא. 592 00:31:50,000 --> 00:31:52,000 אני הכרזתי n, אבל מה ערך שאני נותן לו? 593 00:31:52,000 --> 00:31:56,000 אף אחד, משום שידעתי כי בשורות הבאות 594 00:31:56,000 --> 00:31:59,000 GetInt ידאג לבעיה של לשים את הערך הפנימי של n. 595 00:31:59,000 --> 00:32:02,000 >> אבל בנקודה זו בסיפורו של קו 11 596 00:32:02,000 --> 00:32:05,000 וקו 12 וקו 13 וקו 14 597 00:32:05,000 --> 00:32:08,000 לאורך כמה השורות האלה הוא מה הערך של n? 598 00:32:08,000 --> 00:32:10,000 ב C אתה פשוט לא יודע. 599 00:32:10,000 --> 00:32:14,000 זה בדרך כלל ערך כלשהו אשפה, חלק המספר אקראי לחלוטין 600 00:32:14,000 --> 00:32:17,000 מה שנשאר על מהותו מתפקיד כלשהו קודם 601 00:32:17,000 --> 00:32:21,000 לאחר שהופעל, כך שהתכנית שלך פועלת 602 00:32:21,000 --> 00:32:24,000 זוכר שפונקציה מקבלת פונקציה, פונקציה, פונקציה. 603 00:32:24,000 --> 00:32:27,000 כל מסגרות אלה לקבל לשים על זיכרון, ואז מי שהחזרת פונקציות, 604 00:32:27,000 --> 00:32:31,000 ובדיוק כמו שהצעתי עם מחק זכרם נעשה שימוש חוזר בסופו של דבר. 605 00:32:31,000 --> 00:32:37,000 ובכן, זה פשוט כל כך קורה כי x משתנה זה בתכנית זו 606 00:32:37,000 --> 00:32:41,000 נראה שהכיל כמה ערך זבל כמו 134514032 607 00:32:41,000 --> 00:32:44,000 מכמה פונקציה קודמת, לא אחד שאני כתבתי. 608 00:32:44,000 --> 00:32:47,000 זה יכול להיות משהו שמגיע בצורה יעילה עם מערכת ההפעלה, 609 00:32:47,000 --> 00:32:49,000 כמה פונקציה מתחת למכסת המנוע. 610 00:32:49,000 --> 00:32:52,000 >> אוקיי, זה בסדר, אבל בואו עכשיו להתקדם לשורה הבאה. 611 00:32:52,000 --> 00:32:55,000 אם אני מקליד "בא" בGDB המהיר ואני מכה להיכנס, 612 00:32:55,000 --> 00:32:58,000 שם לב שהדגשת מהלכים עד לקו 19, 613 00:32:58,000 --> 00:33:01,000 אבל המשמעות הלוגית היא שקו 18 614 00:33:01,000 --> 00:33:06,000 עכשיו סיים הרצה, כך שאם אני שוב להקליד "הדפסת x" 615 00:33:06,000 --> 00:33:10,000 אני צריך עכשיו לראות 1, ואכן, אני עושה. 616 00:33:10,000 --> 00:33:14,000 שוב, דברי $ הם דרך GDB מזכיר לך 617 00:33:14,000 --> 00:33:17,000 מה ההיסטוריה של הדפסים שעשיתם. 618 00:33:17,000 --> 00:33:21,000 עכשיו תן לי ללכת קדימה ולהדפיס את y, ואכן, y הוא ערך כלשהו מטורף, כמו גם, 619 00:33:21,000 --> 00:33:24,000 אבל לא עניין גדול, כי בקו 19 שאנחנו עומדים להקצות את 620 00:33:24,000 --> 00:33:27,000 הערך 2, אז תן לי להקליד "הבא" שוב. 621 00:33:27,000 --> 00:33:29,000 ועכשיו אנחנו בקו printf. 622 00:33:29,000 --> 00:33:31,000 תן לי לעשות x הדפסה. 623 00:33:31,000 --> 00:33:34,000 תן לי לעשות y הדפסה. בכנות, אני מקבל קצת עייף של הדפסה זו. 624 00:33:34,000 --> 00:33:38,000 תן לי במקום להקליד "x התצוגה" ו" התצוגה y " 625 00:33:38,000 --> 00:33:41,000 ועכשיו בכל פעם שאני מקליד פקודה בעתיד 626 00:33:41,000 --> 00:33:45,000 אני להיזכר מה X ו-Y, מה X ו-Y, מה x ו-y. 627 00:33:45,000 --> 00:33:48,000 >> אני יכול גם, כדרך אגב, בסוג "המקומיים מידע". 628 00:33:48,000 --> 00:33:50,000 מידע הוא פקודה מיוחדת. 629 00:33:50,000 --> 00:33:52,000 המקומיים אומרים שזה מראה לי את המשתנים המקומיים. 630 00:33:52,000 --> 00:33:55,000 רק למקרה שאשכח או זו היא פונקציה מטורפת, מסובכת 631 00:33:55,000 --> 00:33:57,000 שאני או מישהו אחר כתבתי המקומיים מידע יגידו לך 632 00:33:57,000 --> 00:34:00,000 מה ערך של כל המשתנים המקומיים בתוך פונקציה מקומית זה 633 00:34:00,000 --> 00:34:03,000 שאולי אכפת לך אם תרצה לחטט. 634 00:34:03,000 --> 00:34:07,000 עכשיו, printf עומד לבצע, אז תן לי ללכת קדימה ופשוט להקליד "הבא". 635 00:34:07,000 --> 00:34:10,000 מכיוון שאנו נמצאים בסביבה זו שאנחנו לא באמת רואים אותו 636 00:34:10,000 --> 00:34:14,000 ביצוע כאן למטה, אבל שם לב לזה נהיה קצת מעווה כאן. 637 00:34:14,000 --> 00:34:17,000 אבל שם לב שזה מבטל את המסך שם, 638 00:34:17,000 --> 00:34:21,000 אז זה לא תכנית מושלמת כאן, אבל זה בסדר, כי אני תמיד יכול לחטט 639 00:34:21,000 --> 00:34:23,000 שימוש בהדפסה אם אני רוצה. 640 00:34:23,000 --> 00:34:26,000 >> תן לי להקליד הבא שוב, ועכשיו הנה חלק המעניין. 641 00:34:26,000 --> 00:34:29,000 בנקודה זו בסיפור y הוא 2, ו-x הוא 1, 642 00:34:29,000 --> 00:34:32,000 כפי שהוצע כאן, ושוב, 643 00:34:32,000 --> 00:34:35,000 מהסיבה זו באופן אוטומטי מציגה כרגע היא בגלל שהשתמשתי בפקודה 644 00:34:35,000 --> 00:34:40,000 התצוגה x ו-y תצוגה, וברגע שאני מהסוג הבא 645 00:34:40,000 --> 00:34:43,000 בתאורית x ו-y צריך להיות מוחלף. 646 00:34:43,000 --> 00:34:45,000 עכשיו, אנחנו כבר יודעים שלא הולכים להיות המקרה, 647 00:34:45,000 --> 00:34:49,000 אבל נראה ברגע איך אנחנו יכולים לצלול עמוק יותר כדי להבין למה זה נכון. 648 00:34:49,000 --> 00:34:54,000 בשלב בא, ולמרבה הצער, y הוא עדיין 2 ו x הוא עדיין 1, ואני יכול לאשר כל כך הרבה. 649 00:34:54,000 --> 00:34:56,000 ההדפסה x, y הדפסה. 650 00:34:56,000 --> 00:34:59,000 אכן, אין החלפה שכבר קרה, אז בואו נתחיל עם זה שוב. 651 00:34:59,000 --> 00:35:01,000 ברור שהחלפה היא שבורה. 652 00:35:01,000 --> 00:35:04,000 בואו במקום להקליד "לרוץ" שוב. 653 00:35:04,000 --> 00:35:07,000 הרשה לי לומר, כן, אני רוצה להפעיל מחדש את זה מההתחלה, זן. 654 00:35:07,000 --> 00:35:09,000 >> עכשיו אני חוזר אל קו 18. 655 00:35:09,000 --> 00:35:11,000 עכשיו שם לב x ו-y הם ערכי אשפה שוב. 656 00:35:11,000 --> 00:35:15,000 בשלב בא, הבא, הבא, הבא. 657 00:35:15,000 --> 00:35:17,000 אם אני משתעמם אני יכול גם פשוט להקליד n לבא. 658 00:35:17,000 --> 00:35:21,000 אתה יכול לקצר אותו לרצף הקצר ביותר האפשרי של תווים. 659 00:35:21,000 --> 00:35:23,000 דפדוף עכשיו נשבר. 660 00:35:23,000 --> 00:35:25,000 בואו לצלול ב, אז במקום להקליד הבא, 661 00:35:25,000 --> 00:35:30,000 עכשיו אני הולך להקליד צעד, כך שאני דורך בתוך פונקציה זו 662 00:35:30,000 --> 00:35:33,000 כך שאני יכול לעבור אותו, ולכן אני מכה צעד ואז להיכנס. 663 00:35:33,000 --> 00:35:37,000 שים לב שקפיצות ההדגשה למטה נמוכות בתכנית שלי לקו 36. 664 00:35:37,000 --> 00:35:39,000 עכשיו, מה הם את המשתנים המקומיים? 665 00:35:39,000 --> 00:35:41,000 המקומיים מידע. 666 00:35:41,000 --> 00:35:43,000 שום דבר לא פשוט כי אנחנו עדיין לא יצאנו לי לאותו קו, 667 00:35:43,000 --> 00:35:47,000 אז בואו נלך קדימה ואומרים "הבא". 668 00:35:47,000 --> 00:35:50,000 עכשיו אנחנו נראים לי tmp, tmp הדפסה. 669 00:35:50,000 --> 00:35:52,000 ערך זבל, נכון? אני חושב שכן. 670 00:35:52,000 --> 00:35:55,000 מה דעתך על להדפיס, הדפסה ב, 1 ו 2? 671 00:35:55,000 --> 00:35:58,000 ברגע, ברגע שאני מקליד הבא שוב 672 00:35:58,000 --> 00:36:02,000 tmp הולך לקחת על ערך של 1, בתקווה, 673 00:36:02,000 --> 00:36:05,000 בגלל tmp הולך להיות מוקצה הערך. 674 00:36:05,000 --> 00:36:08,000 >> עכשיו בואו ניתן להדפיס, ב הדפסה, 675 00:36:08,000 --> 00:36:11,000 אבל עכשיו להדפיס tmp, וזה אכן 1. 676 00:36:11,000 --> 00:36:14,000 תן לי לעשות לי בא. תן לי לעשות לי בא. 677 00:36:14,000 --> 00:36:16,000 אני כבר סיימתי את פונקצית ההחלפה. 678 00:36:16,000 --> 00:36:19,000 אני עדיין בתוכו בקו 40, אז תן לי להדפיס, 679 00:36:19,000 --> 00:36:22,000 הדפסה ב, ולא אכפת לי מה הוא tmp. 680 00:36:22,000 --> 00:36:27,000 זה נראה כמו ההחלפה היא נכונה, כאשר הוא מגיע להחלפה וכן ב. 681 00:36:27,000 --> 00:36:31,000 אבל אם אני עכשיו אקליד בא, אני קופץ חזרה לקו 25, 682 00:36:31,000 --> 00:36:34,000 וכמובן, אם אני מקליד בx ו-y הדפסה 683 00:36:34,000 --> 00:36:38,000 הם עדיין לא השתנו, ולכן אנחנו לא תקנו את הבעיה. 684 00:36:38,000 --> 00:36:41,000 אבל diagnostically עכשיו אולי עם תכנית GDB זה 685 00:36:41,000 --> 00:36:44,000 לפחות לי שהבנו צעד אחד קרוב יותר להבנה 686 00:36:44,000 --> 00:36:47,000 מה השתבש מבלי ללכלך את הקוד שלנו על ידי הצבת printf כאן, 687 00:36:47,000 --> 00:36:50,000 printf כאן, printf כאן ולאחר מכן מפעיל אותו שוב ושוב 688 00:36:50,000 --> 00:36:52,000 מנסה להבין מה השתבש. 689 00:36:52,000 --> 00:36:55,000 >> אני הולך קדימה ולפרוש מזה לגמרי עם לפרוש. 690 00:36:55,000 --> 00:36:57,000 זה הולך אז אמר, "לצאת בכל זאת?" כן. 691 00:36:57,000 --> 00:37:00,000 עכשיו אני שוב בהנחיה הרגילה שלי, ואני עושה שימוש GDB. 692 00:37:00,000 --> 00:37:03,000 כהערת אגב, אתה לא צריך להשתמש בדגל-Tui זה. 693 00:37:03,000 --> 00:37:07,000 למעשה, אם אתה משמיט אותו אתה מקבל בעצם את החצי התחתון של המסך. 694 00:37:07,000 --> 00:37:11,000 אם לאחר מכן הקלד הפסקה ראשית ולאחר מכן להפעיל 695 00:37:11,000 --> 00:37:15,000 אני עדיין יכול להפעיל את התכנית שלי, אבל מה זה יעשה יותר טקסטואלית 696 00:37:15,000 --> 00:37:18,000 רק תראה לי 1 הקו הנוכחי בכל פעם. 697 00:37:18,000 --> 00:37:21,000 -Tui, ממשק המשתמש טקסטואלי, 698 00:37:21,000 --> 00:37:25,000 רק מראה לך יותר מפעם אחת בתכנית, שהוא כנראה קצת יותר קל מושגית. 699 00:37:25,000 --> 00:37:27,000 אבל אכן, אני יכול פשוט לעשות בא, בא, בא, 700 00:37:27,000 --> 00:37:30,000 ואני הולך לראות שורה אחת בכל פעם, ואם אני באמת רוצה לראות מה קורה 701 00:37:30,000 --> 00:37:35,000 אני יכול להקליד רשימה ולראות חבורה שלמה של קווים שכנים. 702 00:37:35,000 --> 00:37:39,000 >> יש וידאו שאנחנו כבר בקשנו שאתה צופה לבעיה קובעת 3 703 00:37:39,000 --> 00:37:43,000 שבה תאט מכסה חלק מהמורכבויות של GDB, 704 00:37:43,000 --> 00:37:46,000 וזה אחד מהדברים האלה, בכנות, שבו אחוז מסוים שאינם טריוויאלי שלך 705 00:37:46,000 --> 00:37:49,000 לעולם לא לגעת GDB, וזה יהיה דבר רע 706 00:37:49,000 --> 00:37:53,000 כי ממש אתה תהיה בסופו של דבר לבלות יותר זמן בהמשך הסמסטר 707 00:37:53,000 --> 00:37:56,000 רודף אחרי חרקים אז היית אם לשים שבחצי שעה / השעה 708 00:37:56,000 --> 00:38:00,000 השבוע והלמידה הבאה כדי לקבל נוח עם GDB. 709 00:38:00,000 --> 00:38:02,000 Printf היה החבר שלך. 710 00:38:02,000 --> 00:38:05,000 GDB צריך עכשיו להיות החבר שלך. 711 00:38:05,000 --> 00:38:08,000 >> כל שאלות על GDB? 712 00:38:08,000 --> 00:38:12,000 והנה רשימה מהירה של חלק מהפקודות השימושיות והחזקות ביותר. 713 00:38:12,000 --> 00:38:15,000 כן. >> האם אתם יכולים להדפיס מחרוזת? 714 00:38:15,000 --> 00:38:17,000 אתה יכול להדפיס את מחרוזת? בהחלט כן. 715 00:38:17,000 --> 00:38:19,000 זה לא חייב להיות רק מספרים שלמים. 716 00:38:19,000 --> 00:38:22,000 אם זה משתנה הוא מחרוזת רק בסוג של הדפסה. 717 00:38:22,000 --> 00:38:24,000 זה ייראה לך מה שמשתנה הוא המחרוזת. 718 00:38:24,000 --> 00:38:26,000 [לא ברור לתלמיד] 719 00:38:26,000 --> 00:38:28,000 זה ייתן לך את הכתובת ואת המחרוזת עוצמה. 720 00:38:28,000 --> 00:38:32,000 זה ייראה גם לך. 721 00:38:32,000 --> 00:38:34,000 ודבר אחד אחרון, פשוט כי אלה טובים לדעת יותר מדי. 722 00:38:34,000 --> 00:38:37,000 Backtrace ומסגרת, בואו לצלול אליי פעם אחת האחרונה, 723 00:38:37,000 --> 00:38:39,000 אותה תכנית מדויקת עם GDB. 724 00:38:39,000 --> 00:38:44,000 תן לי ללכת קדימה ולהפעיל את גרסת ממשק משתמש טקסטואלי, 725 00:38:44,000 --> 00:38:46,000 לשבור ראשי. 726 00:38:46,000 --> 00:38:49,000 תן לי ללכת קדימה ולרוץ שוב. הנה אני. 727 00:38:49,000 --> 00:38:55,000 עכשיו בואו נלך הבא, בא, בא, בא, הבא לי, צעד, להיכנס. 728 00:38:55,000 --> 00:39:00,000 >> ועכשיו יניחו שאני עכשיו בהחלפה במתכוון, אבל אני כמו "לעזאזל, מה היה הערך של x?" 729 00:39:00,000 --> 00:39:02,000 אני לא יכול לעשות x יותר. 730 00:39:02,000 --> 00:39:05,000 אני לא יכול לעשות y בגלל שהם לא בהיקפו. 731 00:39:05,000 --> 00:39:07,000 הם לא בהקשר, אבל אין שום בעיה. 732 00:39:07,000 --> 00:39:09,000 אני יכול להקליד backtrace. 733 00:39:09,000 --> 00:39:13,000 זה מראה לי את כל הפונקציות שבוצעו עד לנקודה זו בזמן. 734 00:39:13,000 --> 00:39:16,000 שים לב ש1 בתחתית, הראשי, שורות עם ראשי 735 00:39:16,000 --> 00:39:18,000 להיות בחלק התחתון של התמונה שלנו כאן. 736 00:39:18,000 --> 00:39:22,000 העובדה שהחלפה היא מעליו קווים עם החלפה להיות מעליו בזיכרון כאן, 737 00:39:22,000 --> 00:39:26,000 ואם אני רוצה לחזור לעיקר זמני אני יכול לומר "מסגרת". 738 00:39:26,000 --> 00:39:30,000 מה מספר? העיקרי הוא מסגרת # 1. 739 00:39:30,000 --> 00:39:32,000 אני הולך קדימה, ואומר "מסגרת 1." 740 00:39:32,000 --> 00:39:36,000 >> עכשיו אני שוב בראשי, ואני יכול להדפיס את x, ואני יכול להדפיס y, 741 00:39:36,000 --> 00:39:40,000 אבל אני לא יכול להדפיס או ב. 742 00:39:40,000 --> 00:39:43,000 אבל אני יכול, אם אני אומר, "בסדר, חכה רגע. איפה הייתה ההחלפה?" 743 00:39:43,000 --> 00:39:46,000 תן לי ללכת קדימה ולומר "0 מסגרת." 744 00:39:46,000 --> 00:39:48,000 עכשיו אני חוזר לשם אני רוצה להיות, וכמו בצד, 745 00:39:48,000 --> 00:39:52,000 יש פקודות אחרות, כמו אם אתה באמת מקבל הקלדה הבאה, הבאה, הבאה, הבאה משועממת, 746 00:39:52,000 --> 00:39:56,000 אתה בדרך כלל יכול להגיד דברים כמו "10 הבאים", וכי יהיה צעד דרך 10 השורות הבאות. 747 00:39:56,000 --> 00:39:59,000 אתה יכול גם לכתוב "המשך" כאשר אתה באמת תימאס דריכה דרכו. 748 00:39:59,000 --> 00:40:05,000 המשך יהיה להפעיל את התכנית ללא הפרעה עד שהוא פוגע נקודת עצירה נוספת, 749 00:40:05,000 --> 00:40:07,000 אם בלולאה או למטה בתכנית שלך. 750 00:40:07,000 --> 00:40:11,000 >> במקרה זה המשכנו עד הסוף, והתכנית יצאה כרגיל. 751 00:40:11,000 --> 00:40:13,000 זו היא דרך מפוארת, תהליך נחות. 752 00:40:13,000 --> 00:40:16,000 רק התכנית שלך יצאה באופן נורמלי. 753 00:40:16,000 --> 00:40:24,000 עוד על כך בוידאו ובניפוי שגיאות מפגשים הבאים. 754 00:40:24,000 --> 00:40:26,000 זה היה הרבה. 755 00:40:26,000 --> 00:40:35,000 בואו ניקח ההפסקה שלנו 5-הדקה פה, ונחזור עם structs וקבצים. 756 00:40:35,000 --> 00:40:38,000 >> אם יש לך צלל לתוך pset השבוע כבר 757 00:40:38,000 --> 00:40:41,000 אתה יודע שאנחנו משתמשים בקוד ההפצה, 758 00:40:41,000 --> 00:40:45,000 את קוד המקור שאנו מספקים לך כנקודת פתיחה, כמה טכניקות חדשות. 759 00:40:45,000 --> 00:40:50,000 בפרט, אנו הצגנו המילה החדשה הזה שנקרא struct, למבנה, 760 00:40:50,000 --> 00:40:53,000 כדי שנוכל ליצור משתנים מותאמים אישית של מינים. 761 00:40:53,000 --> 00:40:57,000 אנחנו גם הצגנו את הרעיון של קובץ קלט / פלט, ופלט לקובץ, 762 00:40:57,000 --> 00:41:00,000 וזה, כדי שנוכל להציל את המדינה 763 00:41:00,000 --> 00:41:03,000 הלוח של המירוץ שלך לקובץ בדיסק 764 00:41:03,000 --> 00:41:06,000 כך שעמיתי ההוראה ואני יכולים להבין 765 00:41:06,000 --> 00:41:09,000 מה קורה בתוך התכנית שלך באופן ידני מבלי לשחק 766 00:41:09,000 --> 00:41:11,000 עשרות משחקים של מירוץ. 767 00:41:11,000 --> 00:41:13,000 אנחנו יכולים לעשות את זה יותר automatedly. 768 00:41:13,000 --> 00:41:18,000 >> רעיון זה של struct פותר בעיה די משכנעת. 769 00:41:18,000 --> 00:41:21,000 תניח שאנחנו רוצים ליישם חלק התכנית 770 00:41:21,000 --> 00:41:25,000 שאיכשהו עוקב אחר מידע על סטודנטים, 771 00:41:25,000 --> 00:41:28,000 ותלמידים יכולים להיות, למשל, תעודת זהות, שם 772 00:41:28,000 --> 00:41:31,000 ובית במקום כמו הרווארד, ולכן אלה הם 3 חתיכות של מידע 773 00:41:31,000 --> 00:41:34,000 אנחנו רוצים לשמור על הסביבה, אז תן לי ללכת קדימה ולהתחיל לכתוב תכנית קטנה כאן, 774 00:41:34,000 --> 00:41:38,000 כולל stdio.h. 775 00:41:38,000 --> 00:41:42,000 תן לי לעשות כולל cs50.h. 776 00:41:42,000 --> 00:41:44,000 ואז תתחיל הפונקציה העיקרית שלי. 777 00:41:44,000 --> 00:41:46,000 אני לא אטרח עם כל הארגומנטים בשורת פקודה, 778 00:41:46,000 --> 00:41:49,000 וכאן אני רוצה להיות תלמיד, אז אני הולך להגיד 779 00:41:49,000 --> 00:41:54,000 סטודנט יש לו שם, אז אני הולך לומר "שם מחרוזת". 780 00:41:54,000 --> 00:41:59,000 ואז אני הולך לומר תלמיד יש גם זהות, זהות כך int, 781 00:41:59,000 --> 00:42:03,000 ותלמיד יש לו בית, אז אני גם הולך לומר "בית מחרוזת". 782 00:42:03,000 --> 00:42:06,000 אז אני הזמנתי את אלה קצת יותר נקיים כזה. 783 00:42:06,000 --> 00:42:11,000 אוקיי, עכשיו יש לי 3 משתנה עם אשר מייצגים תלמיד, ולכן "תלמיד". 784 00:42:11,000 --> 00:42:15,000 >> ועכשיו אני רוצה לאכלס את הערכים הללו, אז תנו לי ללכת קדימה ואומרים משהו כמו: 785 00:42:15,000 --> 00:42:18,000 "Id = 123". 786 00:42:18,000 --> 00:42:21,000 שם הוא הולך לקבל דוד. 787 00:42:21,000 --> 00:42:24,000 בואו נגיד שבית הוא הולך לקבל מאת'ר, 788 00:42:24,000 --> 00:42:31,000 ואז אני הולך לעשות משהו שרירותי כמו printf ("% s, 789 00:42:31,000 --> 00:42:37,000 זהותו היא% d, מתגוררת ב% s. 790 00:42:37,000 --> 00:42:41,000 ועכשיו, מה אני רוצה לחבר כאן, אחד אחרי השני? 791 00:42:41,000 --> 00:42:47,000 שם, שם, בית; תשואה 0. 792 00:42:47,000 --> 00:42:50,000 אוקיי, אלא אם כן אני דפוק איפשהו כאן 793 00:42:50,000 --> 00:42:54,000 אני חושב שיש לנו תכנית די טובה שמאחסנת תלמיד אחד. 794 00:42:54,000 --> 00:42:57,000 כמובן, זה לא כל כך מעניין. מה אם אני רוצה יש לי 2 תלמידים? 795 00:42:57,000 --> 00:42:59,000 זה לא עניין גדול. אני יכול לתמוך 2 אנשים. 796 00:42:59,000 --> 00:43:03,000 תן לי ללכת קדימה ולהבליט זאת ולרדת לכאן, 797 00:43:03,000 --> 00:43:09,000 ואני יכול לומר "id ​​= 456" למישהו כמו רוב המתגורר בקירקלנד. 798 00:43:09,000 --> 00:43:12,000 >> אוקיי, תחכה, אבל אני לא יכול לקרוא להם את אותו הדבר, 799 00:43:12,000 --> 00:43:15,000 וזה נראה כאילו אני הולך צריך להעתיק את זה, 800 00:43:15,000 --> 00:43:19,000 אז הרשה לי לומר כי אלה יהיו המשתנים של הדוד, 801 00:43:19,000 --> 00:43:23,000 ותן לי כמה עותקים של אלה לרוב. 802 00:43:23,000 --> 00:43:27,000 אנחנו קוראים לאלה של רוב אבל זה לא הולך עכשיו לעבודה 803 00:43:27,000 --> 00:43:33,000 כי יש לי לחכות, בואו תחליפו אותי לID1, name1 וhouse1. 804 00:43:33,000 --> 00:43:35,000 רוב יהיו 2, 2. 805 00:43:35,000 --> 00:43:42,000 אני חייב לשנות את זה כאן, כאן, כאן, כאן, כאן, כאן. 806 00:43:42,000 --> 00:43:45,000 חכה, מה עם טומי? בואו נעשה זאת שוב. 807 00:43:45,000 --> 00:43:49,000 ברור שאם אתה עדיין חושב שזו דרך טובה ביותר לעשות זאת, זה לא, 808 00:43:49,000 --> 00:43:52,000 כך העתק / דבק רע. 809 00:43:52,000 --> 00:43:55,000 אבל פתר את זה לפני שבוע. 810 00:43:55,000 --> 00:43:59,000 >> מה היה הפתרון שלנו כאשר אנו רוצים להיות מספר מופעים של אותו סוג הנתונים? 811 00:43:59,000 --> 00:44:01,000 [סטודנטים] מערך. 812 00:44:01,000 --> 00:44:03,000 מערך, אז תן לי לנסות לנקות את זה. 813 00:44:03,000 --> 00:44:07,000 תן לי לעשות קצת מקום לעצמי בראש, ותן לי במקום לעשות את זה כאן. 814 00:44:07,000 --> 00:44:12,000 אנחנו קוראים לאנשים האלה, ובמקום זאת אני הולך לומר "מזהי int", 815 00:44:12,000 --> 00:44:14,000 ואני מתכוון לתמיכה 3 מאתנו לעת עתה. 816 00:44:14,000 --> 00:44:18,000 אני הולך לומר "שמות מייתרים," ואני אתמוך בי 3 מאתנו, 817 00:44:18,000 --> 00:44:22,000 ואז אני הולך לומר "בתי מייתר," ואני הולך לתמוך 3 מאתנו. 818 00:44:22,000 --> 00:44:26,000 עכשיו בפה, במקום דוד מקבל המשתנים המקומיים שלו 819 00:44:26,000 --> 00:44:28,000 אנחנו יכולים להיפטר מאלה. 820 00:44:28,000 --> 00:44:30,000 זה מרגיש טוב שאנחנו מנקים את זה. 821 00:44:30,000 --> 00:44:35,000 אז אני יכול להגיד הדוד הולך להיות [0] ושמות [0] 822 00:44:35,000 --> 00:44:38,000 ובתים [0]. 823 00:44:38,000 --> 00:44:41,000 ולאחר מכן לשדוד אנחנו דומים יכולים לשמור על זה. 824 00:44:41,000 --> 00:44:46,000 בואו נשים את זה כאן למטה, כך שהוא הולך באופן שרירותי להיות מזהים [1]. 825 00:44:46,000 --> 00:44:50,000 הוא הולך להיות שמות [1], 826 00:44:50,000 --> 00:44:53,000 ואז לבסוף, בתים [1]. 827 00:44:53,000 --> 00:44:57,000 >> עדיין קצת משעמם, ועכשיו אני צריך להבין את זה, 828 00:44:57,000 --> 00:45:03,000 אז בואו נאמרתי "שמות [0], שם [0], בתים [0], 829 00:45:03,000 --> 00:45:06,000 ובואו pluralize זה. 830 00:45:06,000 --> 00:45:09,000 מזהה, תארים, תעודות. 831 00:45:09,000 --> 00:45:12,000 ושוב, אני עושה את זה, אז שוב, אני כבר להזדקק העתק / דבק שוב, 832 00:45:12,000 --> 00:45:14,000 אז רוב הסיכויים הם שיש פתרון אחר כאן. 833 00:45:14,000 --> 00:45:18,000 אני כנראה יכול לנקות את זה עוד יותר עם לולאה או משהו כזה, 834 00:45:18,000 --> 00:45:21,000 כך שבקיצור, זה קצת יותר טוב אבל עדיין מרגיש כמו 835 00:45:21,000 --> 00:45:24,000 אני להזדקק העתק / דבק, אבל גם זה, אני טוען, 836 00:45:24,000 --> 00:45:27,000 הוא לא באמת ביסוד הפתרון הנכון משום 837 00:45:27,000 --> 00:45:29,000 מה אם מתישהו נחליט אתם יודעים מה? 838 00:45:29,000 --> 00:45:32,000 אנחנו באמת צריכים לאחסון כתובות דוא"ל לדוד ורוב 839 00:45:32,000 --> 00:45:34,000 וכל אחד אחר בתכנית זו. 840 00:45:34,000 --> 00:45:36,000 אנחנו צריכים גם לאחסן מספרי טלפון. 841 00:45:36,000 --> 00:45:39,000 אנחנו צריכים גם לאחסן מספרי קשר לשעת חירום. 842 00:45:39,000 --> 00:45:41,000 יש לנו את כל החלקים הללו של נתונים שאנו רוצים לאחסן, 843 00:45:41,000 --> 00:45:43,000 אז איך אתה הולך לעשות את זה? 844 00:45:43,000 --> 00:45:46,000 >> אתה מצהיר מערך אחר בראש, ואז אתה להוסיף באופן ידני 845 00:45:46,000 --> 00:45:49,000 כתובת הדוא"ל [0] כתובת, דואר אלקטרוני [1] 846 00:45:49,000 --> 00:45:51,000 לדוד ורוב וכן הלאה. 847 00:45:51,000 --> 00:45:56,000 אבל יש באמת רק הנחה העומדת בבסיס עיצוב זה 848 00:45:56,000 --> 00:45:59,000 כי אני משתמש במערכת הכבוד לדעת כי 849 00:45:59,000 --> 00:46:03,000 [I] בכל אחת מכמה מערכים 850 00:46:03,000 --> 00:46:06,000 פשוט כל כך קורה למתייחס לאותו האדם, 851 00:46:06,000 --> 00:46:10,000 כך [0] בזיהוי הוא המספר 123, 852 00:46:10,000 --> 00:46:13,000 ואני הולך להניח ששמות [0] 853 00:46:13,000 --> 00:46:16,000 השם והבתים [0] של אותו האדם 854 00:46:16,000 --> 00:46:21,000 הוא ביתו של אותו האדם וכן הלאה לכל מערכים השונים שאני יוצר. 855 00:46:21,000 --> 00:46:24,000 אבל שם לב שאין הצמדה בסיסית 856 00:46:24,000 --> 00:46:27,000 בין 3 החלקים האלה של מידע, זיהוי, שם והבית, 857 00:46:27,000 --> 00:46:32,000 למרות שהישות שאנחנו מנסים מודל בתכנית זו היא לא מערכים. 858 00:46:32,000 --> 00:46:35,000 מערכים הם רק דרך תכנותית זה לעשות את זה. 859 00:46:35,000 --> 00:46:38,000 מה שאנחנו באמת רוצים לבנות מודל בתכנית שלנו הוא אדם 860 00:46:38,000 --> 00:46:41,000 כמו דוד, אדם כמו רוב בתוכה 861 00:46:41,000 --> 00:46:46,000 או encapsulating הוא שם ותעודת זהות ובית. 862 00:46:46,000 --> 00:46:49,000 >> יכולים איכשהו אנו מביעים את הרעיון הזה של אנקפסולציה 863 00:46:49,000 --> 00:46:52,000 לפי אדם יש זהות, שם ובית 864 00:46:52,000 --> 00:46:55,000 ולא לנקוט באמת זה גרזן בו אנו פשוט 865 00:46:55,000 --> 00:46:58,000 לסמוך על כך שמשהו הסוגר 866 00:46:58,000 --> 00:47:02,000 מתייחס לאותה הישות אנושית בכל אחד ממערכים השונים אלה? 867 00:47:02,000 --> 00:47:04,000 אנחנו באמת יכולים לעשות את זה. 868 00:47:04,000 --> 00:47:08,000 תן לי ללכת מעל עיקרי לעכשיו, ותנו לי ליצור סוג הנתונים שלי 869 00:47:08,000 --> 00:47:10,000 לבאמת בפעם הראשונה. 870 00:47:10,000 --> 00:47:14,000 אנחנו השתמשנו בשיטה הזאת במירוץ, 871 00:47:14,000 --> 00:47:17,000 אבל כאן אני הולך קדימה וליצור סוג נתונים, 872 00:47:17,000 --> 00:47:19,000 ואתה יודע מה, אני הולך לקרוא לו תלמיד, או אדם, 873 00:47:19,000 --> 00:47:23,000 ואני מתכוון להשתמש לtypedef מגדיר סוג. 874 00:47:23,000 --> 00:47:25,000 אני הולך להגיד שזה מבנה, 875 00:47:25,000 --> 00:47:29,000 ולאחר מכן במבנה הזה הולך להיות של תלמיד סוג, אנחנו נגיד, 876 00:47:29,000 --> 00:47:31,000 למרות שזה קצת יצא עכשיו בשבילי. 877 00:47:31,000 --> 00:47:33,000 אנחנו נגיד "int id". 878 00:47:33,000 --> 00:47:35,000 אנחנו נגיד "שם מחרוזת". 879 00:47:35,000 --> 00:47:37,000 אז אנחנו אומרים "בית מחרוזת" 880 00:47:37,000 --> 00:47:40,000 אז עכשיו עד הסוף כמה השורות האלה של קוד 881 00:47:40,000 --> 00:47:45,000 יש לי רק למדתי את הצלצול כי קיים 882 00:47:45,000 --> 00:47:49,000 סוג נתונים מלבד ints, מלבד מייתרים, מלבד מכפיל, מלבד צף. 883 00:47:49,000 --> 00:47:54,000 >> נכון לרגע זה בקו 11 פעם, יש עכשיו סוג נתונים חדש בשם תלמידים, 884 00:47:54,000 --> 00:47:58,000 ועכשיו אני יכול להצהיר על משתנה תלמיד בכל מקום שאני רוצה, 885 00:47:58,000 --> 00:48:01,000 אז תן לי לגלול למטה כאן לאנשים. 886 00:48:01,000 --> 00:48:05,000 עכשיו אני יכול להיפטר מזה, ואני יכול לרדת בחזרה לדוד כאן, 887 00:48:05,000 --> 00:48:10,000 ודוד אני יכול באמת להגיד שדוד, 888 00:48:10,000 --> 00:48:13,000 אנחנו ממש יכולים שם משתנים אחרי עצמי, 889 00:48:13,000 --> 00:48:16,000 הולך להיות תלמיד של סוג. 890 00:48:16,000 --> 00:48:18,000 זה אולי נראה קצת מוזר, אבל זה לא כל כך שונה 891 00:48:18,000 --> 00:48:22,000 מלהכריז משהו כמו int או מחרוזת או לצוף. 892 00:48:22,000 --> 00:48:24,000 זה פשוט כל כך קורה להיקרא תלמיד עכשיו, 893 00:48:24,000 --> 00:48:28,000 ואם אני רוצה לשים משהו בתוך מבנה זה 894 00:48:28,000 --> 00:48:31,000 עכשיו יש לי להשתמש ביצירה חדשה של תחביר, אבל זה די פשוט, 895 00:48:31,000 --> 00:48:39,000 david.id = 123, david.name = "דוד" בבירת D, 896 00:48:39,000 --> 00:48:42,000 וdavid.house = "ר", 897 00:48:42,000 --> 00:48:46,000 ועכשיו אני יכול להיפטר מהחומר הזה כאן. 898 00:48:46,000 --> 00:48:51,000 שים לב יש לנו עכשיו מחדש בתכנית שלנו באמת דרך הרבה יותר טוב 899 00:48:51,000 --> 00:48:54,000 בתכנית שלנו שעכשיו משקפת את העולם האמיתי. 900 00:48:54,000 --> 00:48:57,000 >> יש מושג בעולם האמיתי של אדם או תלמיד. 901 00:48:57,000 --> 00:49:02,000 כאן יש לנו עכשיו גרסת C של אדם או לייתר דיוק תלמיד. 902 00:49:02,000 --> 00:49:05,000 בתוכו של אותו האדם הם מאפיינים רלוונטיים אלה, 903 00:49:05,000 --> 00:49:10,000 זהות, שם ובית, ולכן רוב למעשה הופך את אותו הדבר כאן למטה, 904 00:49:10,000 --> 00:49:14,000 כך התלמיד לשדוד, ועכשיו rob.id = 456, 905 00:49:14,000 --> 00:49:17,000 rob.name = "רוב". 906 00:49:17,000 --> 00:49:20,000 העובדה שהמשתנה נקראת רוב היא סוג של משמעות. 907 00:49:20,000 --> 00:49:22,000 אנחנו יכולים לקרוא לה X או Y או Z. 908 00:49:22,000 --> 00:49:25,000 אנחנו רק בשמו לשדוד להיות עקבי מבחינה סמנטית, 909 00:49:25,000 --> 00:49:28,000 אבל באמת שם נמצא שמהשדה עצמו, 910 00:49:28,000 --> 00:49:30,000 אז עכשיו יש לי את זה. 911 00:49:30,000 --> 00:49:33,000 זה גם לא מרגיש כמו העיצוב הטוב ביותר, כי אני כבר בקוד קשה דוד. 912 00:49:33,000 --> 00:49:35,000 אני קוד קשה רוב. 913 00:49:35,000 --> 00:49:39,000 ואני עדיין צריך לפנות אל עותק מסוים ולהדביק בכל פעם שאני רוצה משתנים חדשים. 914 00:49:39,000 --> 00:49:43,000 יתר על כן, יש לי כנראה כדי לתת לכל אחד מהמשתנים הללו שם, 915 00:49:43,000 --> 00:49:46,000 למרות שהייתי מעדיף שאתאר המשתנים הללו 916 00:49:46,000 --> 00:49:48,000  יותר הגנרי תלמידים. 917 00:49:48,000 --> 00:49:52,000 >> עכשיו אנחנו יכולים למזג את הרעיונות שכבר עובדים היטב עבורנו 918 00:49:52,000 --> 00:49:56,000 ובמקום לומר: "אתה יודע מה, תן לי תלמידים שנקראו משתנים, 919 00:49:56,000 --> 00:50:01,000 ובואו שזה יצטרך להיות בגודל 3 ", אז עכשיו אני יכול לחדד את זה עוד יותר, 920 00:50:01,000 --> 00:50:04,000 להיפטר מהדוד הכריז באופן ידני, 921 00:50:04,000 --> 00:50:08,000 ואני יכול לומר במקום משהו כמו תלמידים [0] כאן. 922 00:50:08,000 --> 00:50:11,000 אז אני יכול לומר לתלמידים [0] כאן, 923 00:50:11,000 --> 00:50:14,000 תלמידים [0] פה, וכן הלאה, ואני יכולים להסתובב 924 00:50:14,000 --> 00:50:16,000 ולנקות את העסק הזה לרוב. 925 00:50:16,000 --> 00:50:19,000 גם אני יכול ללכת עכשיו והוספתי לולאה אולי 926 00:50:19,000 --> 00:50:23,000 ושימוש GetString וGetInt למעשה לקבל ערכים אלה מהמשתמש. 927 00:50:23,000 --> 00:50:27,000 אני יכול ללכת על הוספה מתמדת בגלל זה הוא בדרך כלל נוהג רע 928 00:50:27,000 --> 00:50:29,000 לקוד קשה קצת מספר שרירותי כמו 3 כאן 929 00:50:29,000 --> 00:50:33,000 ואז רק תזכור שאתה צריך לשים לא יותר מ 3 תלמידים בו. 930 00:50:33,000 --> 00:50:36,000 אני חושב שיהיה טוב יותר לשימוש # להגדיר בראש הקובץ שלי 931 00:50:36,000 --> 00:50:40,000 וגורם שיצא, אז אכן, נתן לי ללכת קדימה ולהכליל זה. 932 00:50:40,000 --> 00:50:43,000 >> בואו תפתחו לי דוגמה שבין היום 933 00:50:43,000 --> 00:50:46,000 דוגמאות מראש, structs1. 934 00:50:46,000 --> 00:50:49,000 זוהי תכנית שלמה יותר המשתמשת להגדיר עד כאן # 935 00:50:49,000 --> 00:50:51,000 ואומר שאנחנו הולכים לנו 3 תלמידים כברירת מחדל. 936 00:50:51,000 --> 00:50:54,000 הנה אני מכריז שווה בכיתה של תלמידים, 937 00:50:54,000 --> 00:50:57,000 כך כיתת תלמידים, ועכשיו אני משתמש בלולאה 938 00:50:57,000 --> 00:51:00,000 רק כדי להפוך את הקוד קצת יותר אלגנטי, לאכלס את הכיתה 939 00:51:00,000 --> 00:51:05,000 עם כניסתו של המשתמש, כך לחזר מi = 0 בעד סטודנטים, שהוא 3. 940 00:51:05,000 --> 00:51:07,000 ואז אני מנחה את המשתמש בגרסה זו 941 00:51:07,000 --> 00:51:10,000  מה זהותו של התלמיד, ואני מקבל את זה עם GetInt. 942 00:51:10,000 --> 00:51:13,000 מה שמו של התלמיד, ואז אני מקבל את זה עם GetString. 943 00:51:13,000 --> 00:51:15,000 איך הבית של התלמיד? אני מקבל את זה עם GetString. 944 00:51:15,000 --> 00:51:19,000 ואז בתחתית כאן אני פשוט החלטתי לשנות 945 00:51:19,000 --> 00:51:22,000 איך אני מדפיס אותם ובעצם להשתמש בלולאה, 946 00:51:22,000 --> 00:51:24,000 ושאני מדפיס? 947 00:51:24,000 --> 00:51:27,000 על פי התגובה אני מדפיס מישהו במאת'ר, 948 00:51:27,000 --> 00:51:30,000 וזהו זה כל כך רוב וטומי וכן הלאה, ולמעשה של טומי במאת'ר. 949 00:51:30,000 --> 00:51:34,000 יהיו כתובים טומי ודוד במקרה הזה, אבל איך זה עובד? 950 00:51:34,000 --> 00:51:40,000 אנחנו לא ראינו את הפונקציה הזו בעבר, אבל ניקח ניחוש על מה זה עושה. 951 00:51:40,000 --> 00:51:42,000 משווה מחרוזות. 952 00:51:42,000 --> 00:51:45,000 >> זה אינו מובן מאליו קצת איך זה בהשוואת מחרוזות כי מסתבר 953 00:51:45,000 --> 00:51:49,000 אם היא מחזירה 0 זה אומר על המייתרים שווים. 954 00:51:49,000 --> 00:51:53,000 אם הוא מחזיר -1 שמשמעותו אחת מגיעה אלפביתי לפני אחר, 955 00:51:53,000 --> 00:51:57,000 ואם הוא חוזר 1 שפירוש המילה האחרת מגיע אלפביתי 956 00:51:57,000 --> 00:52:00,000 לפני אחרים, ואתה יכול לחפש באינטרנט או בדף האדם 957 00:52:00,000 --> 00:52:04,000 כדי לראות בדיוק הדרך שבה היא, אבל כל זה עכשיו עושה הוא זה אומר 958 00:52:04,000 --> 00:52:09,000 אם [אני]. הבית שווה "ר" 959 00:52:09,000 --> 00:52:13,000 אז קדימה להדפיס כך וכך הוא במאת'ר. 960 00:52:13,000 --> 00:52:16,000 אבל הנה משהו שלא ראה לפני כן, ואנחנו נחזור לזה. 961 00:52:16,000 --> 00:52:21,000 לא זכור לי שאצטרך לעשות את זה בכל אחת מהתוכניות שלי. 962 00:52:21,000 --> 00:52:24,000 חינם כנראה מתייחס לזיכרון, לשחרר זיכרון, 963 00:52:24,000 --> 00:52:31,000 אבל מה זיכרון אני כנראה לשחרר בלולאה זה בחלק התחתון של תכנית זו? 964 00:52:31,000 --> 00:52:34,000 זה נראה כאילו אני משחרר את שמו של האדם 965 00:52:34,000 --> 00:52:37,000 וביתו של אדם, אך מדוע זה כך? 966 00:52:37,000 --> 00:52:41,000 >> מתברר כל השבועות האלה שאתה כבר משתמש בGetString 967 00:52:41,000 --> 00:52:45,000 אנחנו כבר מציגים סוג של באג בכל אחת מהתוכניות שלך. 968 00:52:45,000 --> 00:52:51,000 GetString ידי זיכרון מקצה עיצוב, כך שניתן לחזור אליך מחרוזת, 969 00:52:51,000 --> 00:52:55,000 כמו דוד, או רוב, ואז אתה יכול לעשות מה שאתה רוצה 970 00:52:55,000 --> 00:52:59,000 עם מחרוזת בתכנית שלך, כי יש לנו שמור בזיכרון בשבילך. 971 00:52:59,000 --> 00:53:02,000 הבעיה היא כל הזמן הזה בכל פעם שאתה קורא GetString 972 00:53:02,000 --> 00:53:05,000 אנחנו, כותבי GetString, היו מבקשים את מערכת ההפעלה 973 00:53:05,000 --> 00:53:07,000 כדי לתת לנו קצת RAM עבור מחרוזת זו. 974 00:53:07,000 --> 00:53:09,000 תן לנו קצת RAM עבור המחרוזת הבאה. 975 00:53:09,000 --> 00:53:11,000 תן לנו קצת יותר זיכרון RAM למחרוזת הבאה. 976 00:53:11,000 --> 00:53:13,000 מה אתה, המתכנת, מעולם לא הייתי עושה 977 00:53:13,000 --> 00:53:15,000 נותן לנו שיחזור הזיכרון, 978 00:53:15,000 --> 00:53:17,000 כך במשך כמה השבועות האלה את כל התוכניות שכתבת 979 00:53:17,000 --> 00:53:20,000 יש לו את מה שנקרא קפיצת זיכרון לפיה הם ימשיכו להשתמש 980 00:53:20,000 --> 00:53:24,000 יותר ויותר זיכרון בכל פעם שאתה קורא GetString, וזה בסדר גמור. 981 00:53:24,000 --> 00:53:27,000 אנחנו בכוונה לעשות את זה בשבועות הראשונים, כי זה לא כל כך מעניין 982 00:53:27,000 --> 00:53:29,000 צריך לדאוג היכן החוט שממנו מגיע. 983 00:53:29,000 --> 00:53:34,000 כל מה שאתה רוצה הוא המילה Rob לחזור כאשר סוגיו פנימה המשתמש 984 00:53:34,000 --> 00:53:38,000 >> אך אם אתקדם הלאה יש לנו עכשיו כדי להתחיל לקבל יותר מתוחכם בעניין הזה. 985 00:53:38,000 --> 00:53:42,000 בכל פעם שאנו מקצים זכרוננו טוב יותר סופו של דבר למסור אותו בחזרה. 986 00:53:42,000 --> 00:53:45,000 אחרת בעולם האמיתי ב-Mac או במחשב האישי שלך שאולי יש מדי פעם מנוסה 987 00:53:45,000 --> 00:53:50,000 סימפטומים שבו המחשב שלך שנעצר לבסוף 988 00:53:50,000 --> 00:53:54,000 או כדור החוף מסתובב הטיפשי פשוט כובש את המחשב של 989 00:53:54,000 --> 00:53:56,000 כל תשומת לב, ואתה לא יכול לעשות דברים. 990 00:53:56,000 --> 00:54:00,000 זה יכול להיות מוסבר על ידי כל מספר של חרקים, אבל בין אלה אפשריים באגים 991 00:54:00,000 --> 00:54:03,000 הם דברים בשם דליפות זיכרון לפי מישהו שכתב את קטע זה של תוכנה 992 00:54:03,000 --> 00:54:07,000 אתה משתמש לא זכרת לזיכרון פנוי 993 00:54:07,000 --> 00:54:10,000 שהוא או היא שאל את מערכת הפעלה ב, 994 00:54:10,000 --> 00:54:14,000 לא משתמש GetString, כי זה דבר CS50, אבל שימוש בפונקציות דומות 995 00:54:14,000 --> 00:54:16,000 שישאלו את מערכת ההפעלה לזיכרון. 996 00:54:16,000 --> 00:54:19,000 אם אתה או הם מפשל ולא ממש חוזרים זיכרון 997 00:54:19,000 --> 00:54:24,000 סימפטום שיכול להיות שתכנית מאטה ומאטה ומאטה 998 00:54:24,000 --> 00:54:26,000 אלא אם כן אתה לזכור לקרוא בחינם. 999 00:54:26,000 --> 00:54:28,000 >> אנחנו נחזור אל מתי ולמה שאתם מכנים חופשיים, 1000 00:54:28,000 --> 00:54:32,000 אבל בואו נלך קדימה רק למען סדר טוב ונסה להפעיל תכנית מסוימת הזאת. 1001 00:54:32,000 --> 00:54:35,000 זה נקרא structs1, זן. 1002 00:54:35,000 --> 00:54:40,000 תנו לי ללכת קדימה ולהפעיל structs1, 123, הדוד מאת'ר, 1003 00:54:40,000 --> 00:54:47,000 456, רוב קירקלנד, 789, 1004 00:54:47,000 --> 00:54:50,000 טומי מאת'ר, ואנו רואים בדוד של מאת'ר, טומי של מאת'ר. 1005 00:54:50,000 --> 00:54:53,000 זה רק בדיקת שפיות קטנה שהתכנית פועלת. 1006 00:54:53,000 --> 00:54:56,000 עכשיו, למרבה הצער, תכנית זו היא קצת מתסכלת שב 1007 00:54:56,000 --> 00:55:00,000 אני לא כל העבודה, הקלדתי ב9 מחרוזות שונות, הקש על Enter, 1008 00:55:00,000 --> 00:55:04,000 נאמר לי שהייתה במאת'ר, אך ברור שידעתי שהיה במאת'ר כבר כי הקלדתי את זה. 1009 00:55:04,000 --> 00:55:07,000 זה יהיה נחמד אם לפחות תכנית זו היא יותר כמו מסד נתונים 1010 00:55:07,000 --> 00:55:10,000 וזה בעצם מה שאני זוכר שהקלדתי ב 1011 00:55:10,000 --> 00:55:12,000 אז אני לא אצטרך שוב קלט רישומי סטודנטים אלה. 1012 00:55:12,000 --> 00:55:15,000 אולי זה כמו מערכת registrarial. 1013 00:55:15,000 --> 00:55:21,000 >> אנו יכולים לעשות זאת באמצעות טכניקה זו ידועה כקובץ קלט / פלט, ופלט לקובץ, 1014 00:55:21,000 --> 00:55:24,000 דרך כללית מאוד להגיד את כל זמן שאתה רוצה לקרוא קבצים או לכתוב קבצים 1015 00:55:24,000 --> 00:55:26,000 אתה יכול לעשות את זה עם קבוצה מסוימת של פונקציות. 1016 00:55:26,000 --> 00:55:29,000 תן לי ללכת קדימה ולפתוח structs2.c דוגמה זו, 1017 00:55:29,000 --> 00:55:33,000 שהיא כמעט זהה, אבל בואנה נראית מה הוא עושה עכשיו. 1018 00:55:33,000 --> 00:55:36,000 בחלק העליון של הקובץ אני מצהיר בכיתה של תלמידים. 1019 00:55:36,000 --> 00:55:38,000 אז לאכלס את הכיתה עם הקלט של המשתמש, 1020 00:55:38,000 --> 00:55:41,000 כך קווים אלה של קוד הם בדיוק כמו בעבר. 1021 00:55:41,000 --> 00:55:45,000 אז אם אני לגלול למטה כאן אני מדפיס כל מי שנמצא במאת'ר שרירותי כמו בעבר, 1022 00:55:45,000 --> 00:55:47,000 אבל זו תכונה חדשה ומעניינת. 1023 00:55:47,000 --> 00:55:51,000 השורות אלה של קוד הן חדשות, והם מציגים כאן משהו, 1024 00:55:51,000 --> 00:55:55,000 כל הקובץ, הכובעים, ויש לה * בכאן גם כן. 1025 00:55:55,000 --> 00:55:58,000 תן לי להזיז את זה לכאן, * לכאן גם כן. 1026 00:55:58,000 --> 00:56:00,000 >> פונקציה זו שלא ראתה קודם, fopen, 1027 00:56:00,000 --> 00:56:03,000 אבל זה אומר שקובץ פתוח, אז בואו לרחף באמצעות אלה, 1028 00:56:03,000 --> 00:56:05,000 וזה משהו שאנחנו נחזור לpsets העתידי, 1029 00:56:05,000 --> 00:56:10,000 אבל הקו הזה כאן למעשה נפתח קובץ בשם מסד נתונים, 1030 00:56:10,000 --> 00:56:13,000 וזה דווקא פותח אותו בצורה כזו שהוא יכול לעשות מה זה? 1031 00:56:13,000 --> 00:56:15,000 [לא ברור לתלמיד] 1032 00:56:15,000 --> 00:56:19,000 בסדר, אז "w" רק אומר שזה אומר מערכת ההפעלה 1033 00:56:19,000 --> 00:56:21,000 לפתוח קובץ זה באופן כזה שאני יכול לכתוב את זה. 1034 00:56:21,000 --> 00:56:23,000 אני לא רוצה לקרוא אותו. אני לא רוצה רק להסתכל על זה. 1035 00:56:23,000 --> 00:56:26,000 אני רוצה לשנות אותו ולהוסיף דברים שעלולים להיות לזה, 1036 00:56:26,000 --> 00:56:28,000 ואת הקובץ הוא הולך להיות שם מסד נתונים. 1037 00:56:28,000 --> 00:56:30,000 זה יכול להיות משהו. 1038 00:56:30,000 --> 00:56:32,000 זה יכול להיות database.txt. זה יכול להיות. דציבלים. 1039 00:56:32,000 --> 00:56:37,000 זו יכולה להיות מילה כמו foo, אבל אני באופן שרירותי בחר לקרוא לנתוני קובץ. 1040 00:56:37,000 --> 00:56:42,000 זוהי בדיקת שפיות קטנה שנחזור לפירוט רב לאורך זמן, 1041 00:56:42,000 --> 00:56:47,000 אם fp, למצביע קובץ, לא שווה NULL זה אומר שמכיל בסדר. 1042 00:56:47,000 --> 00:56:51,000 >> סיפור ארוך קצר, פונקציות כמו fopen לפעמים נכשלות. 1043 00:56:51,000 --> 00:56:53,000 אולי הקובץ אינו קיים. אולי אתה מחוץ לשטח דיסק. 1044 00:56:53,000 --> 00:56:55,000 אולי אין לך הרשאה לתיקייה, 1045 00:56:55,000 --> 00:56:58,000 כך שאם fopen מחזיר משהו ריק קרה רע. 1046 00:56:58,000 --> 00:57:02,000 לעומת זאת, אם fopen לא יחזיר null הכל טוב 1047 00:57:02,000 --> 00:57:04,000 ואני יכול להתחיל לכתוב בקובץ זה. 1048 00:57:04,000 --> 00:57:06,000 הנה טריק חדש. 1049 00:57:06,000 --> 00:57:08,000 זה לולאה לזה iterating על כל אחד מהסטודנטים שלי, 1050 00:57:08,000 --> 00:57:10,000 וזה נראה כל כך דומה למה שעשינו בעבר, 1051 00:57:10,000 --> 00:57:15,000 אבל התפקיד הזה הוא בן דודו של בשם printf fprintf לקובץ printf, 1052 00:57:15,000 --> 00:57:18,000 ושים לב שזה שונה בדרכים רק 2. 1053 00:57:18,000 --> 00:57:20,000 אחד, זה מתחיל עם F במקום p, 1054 00:57:20,000 --> 00:57:23,000 אבל אז הטענה הראשונה שלה היא ככל הנראה מה? 1055 00:57:23,000 --> 00:57:25,000 [סטודנטים] קובץ. >> זה קובץ. 1056 00:57:25,000 --> 00:57:30,000 הדבר הזה שנקרא FP, שאנחנו בסופו להקניט מלבד מה מצביע קובץ, 1057 00:57:30,000 --> 00:57:35,000 אך לעת עתה fp פשוט מייצג את הקובץ שאני פתחתי, 1058 00:57:35,000 --> 00:57:41,000 כך fprintf כאן מדבר להדפיס תעודת הזהות של משתמש זה לקובץ, ולא על גבי המסך. 1059 00:57:41,000 --> 00:57:44,000 דפס שמו של המשתמש לקובץ, ולא על המסך, 1060 00:57:44,000 --> 00:57:47,000 הבית לקובץ, ולא על המסך, ולאחר מכן לכאן, כמובן, 1061 00:57:47,000 --> 00:57:50,000 לסגור את התיק, ולאחר מכן לכאן ללא זיכרון. 1062 00:57:50,000 --> 00:57:53,000 >> ההבדל היחיד בין גרסה זו 2 וגרסה 1 1063 00:57:53,000 --> 00:57:58,000 הוא המבוא של fopen וקובץ זה עם * 1064 00:57:58,000 --> 00:58:01,000 והרעיון הזה של fprintf, אז בואו לראות מה התוצאה הסופית היא. 1065 00:58:01,000 --> 00:58:03,000 תן לי ללכת לחלון המסוף שלי. 1066 00:58:03,000 --> 00:58:06,000 תן לי לרוץ structs2, זן. 1067 00:58:06,000 --> 00:58:09,000 נראה כאילו הכל טוב. בואו structs2 שידור חוזר. 1068 00:58:09,000 --> 00:58:15,000 123, הדוד מאת'ר, 456, רוב קירקלנד, 1069 00:58:15,000 --> 00:58:19,000 789, טומי מאת'ר, זן. 1070 00:58:19,000 --> 00:58:23,000 נראה כמו שהוא התנהג אותו הדבר, אבל אם אני עכשיו עושה ls 1071 00:58:23,000 --> 00:58:28,000 שים לב למה קובץ הוא כאן בין כל הקוד שלי, מסד נתונים, 1072 00:58:28,000 --> 00:58:32,000 אז בואו נפתח את זה, מבט gedit של מסד נתונים, ובאותו. 1073 00:58:32,000 --> 00:58:34,000 זה לא סקסי ביותר פורמטים של קבצים. 1074 00:58:34,000 --> 00:58:38,000 זה באמת חתיכה אחת של קו נתונים בכל שורה בכל שורה, 1075 00:58:38,000 --> 00:58:42,000 אבל אלה מכם שמשתמשים בקבצי Excel או CSV, ערכים מופרדים באמצעות פסיקים, 1076 00:58:42,000 --> 00:58:47,000 בהחלט הייתי יכול להיעזר בי fprintf במקום אולי לעשות משהו כזה 1077 00:58:47,000 --> 00:58:50,000 כך שאני יכול למעשה ליצור את המקבילה של קובץ Excel 1078 00:58:50,000 --> 00:58:53,000 על ידי הפרדת דברים עם פסיקים, לא רק קווים חדשים. 1079 00:58:53,000 --> 00:58:56,000 >> במקרה זה אם הייתי משתמש בפסיקים במקום קווים חדשים במקום 1080 00:58:56,000 --> 00:59:01,000 אני ממש יכול לפתוח קובץ מסד נתונים זה ב-Excel אם אני במקום גרמתי לזה להיראות ככה. 1081 00:59:01,000 --> 00:59:03,000 בקיצור, עכשיו שיש לנו את הכח לכתוב לקבצים 1082 00:59:03,000 --> 00:59:07,000 עכשיו אנחנו יכולים להתחיל נתונים מתמשכים, שמירה סביבו על דיסק 1083 00:59:07,000 --> 00:59:10,000 כדי שנוכל לשמור את המידע סביב שוב ושוב. 1084 00:59:10,000 --> 00:59:14,000 שים לב כמה דברים אחרים שהם עכשיו קצת יותר מוכרים. 1085 00:59:14,000 --> 00:59:16,000 בחלק העליון של קובץ C זה יש לנו typedef 1086 00:59:16,000 --> 00:59:21,000 מכיוון שרצינו ליצור סוג נתונים שמייצג מילה, 1087 00:59:21,000 --> 00:59:25,000 לכן סוג זה נקרא מילה, וחלק פנימי של מבנה זה 1088 00:59:25,000 --> 00:59:27,000 זה קצת להשתכלל עכשיו. 1089 00:59:27,000 --> 00:59:30,000 מדוע מילה מורכבת מככל הנראה מערך? 1090 00:59:30,000 --> 00:59:33,000 מה היא מילה רק באופן אינטואיטיבי? 1091 00:59:33,000 --> 00:59:35,000 >> זה מערך של תווים. 1092 00:59:35,000 --> 00:59:37,000 זה רצף של תווי גב אל גב אל גב. 1093 00:59:37,000 --> 00:59:41,000 האותיות גדולות קורות להיות שרירותי אומרים שהאורך המרבי 1094 00:59:41,000 --> 00:59:44,000 של כל מילה במילון שבו אנו משתמשים למירוץ. 1095 00:59:44,000 --> 00:59:46,000 למה אני צריך +1? 1096 00:59:46,000 --> 00:59:48,000 תו null. 1097 00:59:48,000 --> 00:59:51,000 זוכר אותו כשעשינו למשל Bananagrams אנו זקוקים ערך מיוחד 1098 00:59:51,000 --> 00:59:55,000 בסוף המילה כדי לעקוב אחר 1099 00:59:55,000 --> 00:59:59,000 משם מילים הסתיימו למעשה, וכפי שאומר מפרט סט הבעיה 1100 00:59:59,000 --> 01:00:03,000 כאן אנחנו מתחברים עם מילת נתונת ערך בוליאני, 1101 01:00:03,000 --> 01:00:05,000 דגל, כביכול, אמת או שקר. 1102 01:00:05,000 --> 01:00:09,000 האם מצא את המילה הזו כבר, כי אנחנו מבינים 1103 01:00:09,000 --> 01:00:13,000 אנחנו באמת צריכים דרך לזכור לא רק את מה שמילה הוא במירוץ 1104 01:00:13,000 --> 01:00:15,000 אבל אם אתה, אנושי, מצאת אותו 1105 01:00:15,000 --> 01:00:20,000 כך שאם אתה מוצא את המילה "" אתה לא יכול פשוט להקליד, זן,, זן,, זן 1106 01:00:20,000 --> 01:00:23,000 ומקבל 3 נקודות, 3 נקודות, 3 נקודות, 3 נקודות. 1107 01:00:23,000 --> 01:00:26,000 אנחנו רוצים להיות מסוגלים לרשימה שחורת מילה שעל ידי הגדרת bool 1108 01:00:26,000 --> 01:00:29,000 לאמיתי אם כבר מצאת אותו, ולכן זו הסיבה שאנו 1109 01:00:29,000 --> 01:00:31,000 מארז אותו במבנה זה. 1110 01:00:31,000 --> 01:00:35,000 >> עכשיו, כאן למטה במירוץ יש struct האחר זה נקרא מילון. 1111 01:00:35,000 --> 01:00:39,000 כאן הוא בהיעדר המילה typedef כי במקרה זה 1112 01:00:39,000 --> 01:00:43,000 אנחנו צריכים לתמצת את הרעיון של מילון, 1113 01:00:43,000 --> 01:00:46,000 ומילון מכיל חבורה שלמה של מילים, 1114 01:00:46,000 --> 01:00:49,000 כפי שמשתמע ממערך זה, וכמה מהדברים האלה שם? 1115 01:00:49,000 --> 01:00:51,000 ובכן, מה שנקרא גודל משתנה זה אומר. 1116 01:00:51,000 --> 01:00:53,000 אבל אנחנו רק צריכים מילון אחד. 1117 01:00:53,000 --> 01:00:55,000 אנחנו לא צריכים את טיפוס בשם מילון. 1118 01:00:55,000 --> 01:00:58,000 אנחנו פשוט צריכים אחד מהם, כך מתבררים בC 1119 01:00:58,000 --> 01:01:03,000 שאם אתה לא אומר typedef, אתה רק אומר struct, אז בתוך הסוגריים המסולסלים 1120 01:01:03,000 --> 01:01:05,000 אתה שם את המשתנים שלך, אז אתה מכניס את השם. 1121 01:01:05,000 --> 01:01:09,000 זו הכרזת מילון משתנה אחד בשם 1122 01:01:09,000 --> 01:01:11,000 שנראה כמו זה. 1123 01:01:11,000 --> 01:01:16,000 לעומת זאת, קווים אלה יוצרים מבנה נתונים לשימוש חוזר בשם מילה 1124 01:01:16,000 --> 01:01:19,000 כי אתה יכול ליצור עותקים מרובים של, בדיוק כמו שיצרנו 1125 01:01:19,000 --> 01:01:22,000 עותקים מרובים של תלמידים. 1126 01:01:22,000 --> 01:01:24,000 >> מה זה סופו של דבר יאפשר לנו לעשות? 1127 01:01:24,000 --> 01:01:30,000 תן לי לחזור אליו, תניחו, למשל פשוט מזמנים פשוטים יותר, 1128 01:01:30,000 --> 01:01:34,000 ותנו לי לפתוח, יניח, compare1.c. 1129 01:01:34,000 --> 01:01:38,000 הבעיה כאן, ביד היא למעשה נקלף 1130 01:01:38,000 --> 01:01:41,000 השכבה של מחרוזת ולהתחיל לקחת את גלגלי עזר אלה 1131 01:01:41,000 --> 01:01:44,000 כי מסתבר שכל הזמן הזה מחרוזת 1132 01:01:44,000 --> 01:01:47,000 היא כפי שהבטחנו בשבוע 1 באמת רק כינוי, 1133 01:01:47,000 --> 01:01:51,000 מילה נרדפת מCS50 הספרייה למשהו שנראה קצת יותר מסתורי, 1134 01:01:51,000 --> 01:01:53,000 * Char, וראינו כוכבים זה בעבר. 1135 01:01:53,000 --> 01:01:55,000 ראינו את זה בהקשר של קבצים. 1136 01:01:55,000 --> 01:01:59,000 >> עכשיו בואו נראה למה אנחנו כבר מסתירים פרט זה כבר כמה זמן. 1137 01:01:59,000 --> 01:02:02,000 הנה קובץ שנקרא compare1.c, 1138 01:02:02,000 --> 01:02:07,000 וזה ככל הנראה שואל את המשתמש עבור 2 מחרוזות, s ו t, 1139 01:02:07,000 --> 01:02:11,000 ואז הוא מנסה להשוות את המייתרים הללו לשוויון בקו 26, 1140 01:02:11,000 --> 01:02:14,000 ואם הם שווים זה אומר, "אתה הקלדת את אותו הדבר" 1141 01:02:14,000 --> 01:02:17,000 ואם הם לא שווים שהוא אומר, "אתה הקלדת דברים שונים". 1142 01:02:17,000 --> 01:02:19,000 תן לי ללכת קדימה ולהפעיל תכנית זו. 1143 01:02:19,000 --> 01:02:23,000 תן לי ללכת לספריית המקור שלי, להפוך את compare1. זה הידור בסדר. 1144 01:02:23,000 --> 01:02:25,000 תן לי לרוץ compare1. 1145 01:02:25,000 --> 01:02:27,000 אני להתקרב, להיכנס. 1146 01:02:27,000 --> 01:02:29,000 תגיד משהו. שלום. 1147 01:02:29,000 --> 01:02:32,000 אני אגיד משהו שוב. שלום. 1148 01:02:32,000 --> 01:02:34,000 אני בהחלט לא להקליד דברים שונים. 1149 01:02:34,000 --> 01:02:37,000 >> תן לי לנסות את זה שוב. ביי ביי. 1150 01:02:37,000 --> 01:02:40,000 בהחלט לא שונה, אז מה קורה כאן? 1151 01:02:40,000 --> 01:02:44,000 ובכן, מה באמת מושווה בקו 26? 1152 01:02:44,000 --> 01:02:46,000 [לא ברור לתלמיד] 1153 01:02:46,000 --> 01:02:49,000 כן, כך מתבררת, שהמחרוזת, סוג נתונים, היא סוג של שקר לבן. 1154 01:02:49,000 --> 01:02:53,000 מחרוזת היא * char, אבל מה היא * char? 1155 01:02:53,000 --> 01:02:56,000 * Char, כמו שאומרים, הוא מצביע, 1156 01:02:56,000 --> 01:03:00,000 ומצביע הוא למעשה כתובת, 1157 01:03:00,000 --> 01:03:05,000 מיקום סכום בזיכרון, ואם קורים לך שהקליד במילה כמו שלום, 1158 01:03:05,000 --> 01:03:08,000 זוכרים מהדיונים האחרונים של מחרוזות 1159 01:03:08,000 --> 01:03:16,000 זה כמו המילה שלום. 1160 01:03:16,000 --> 01:03:19,000 זכור שמילה כמו שלום יכולה להיות מיוצגת 1161 01:03:19,000 --> 01:03:22,000 כמערך של תווים כמו זה 1162 01:03:22,000 --> 01:03:25,000 ולאחר מכן עם דמות מיוחדת בסוף נקרא תו null, 1163 01:03:25,000 --> 01:03:27,000 כמסמל \. 1164 01:03:27,000 --> 01:03:29,000 מה היא בעצם מחרוזת? 1165 01:03:29,000 --> 01:03:32,000 שימו לב שזה חתיכות מרובות של זיכרון, 1166 01:03:32,000 --> 01:03:36,000 ולמעשה, בסופו של זה ידוע רק פעם אחת אתה מסתכל דרך כל השרשרת 1167 01:03:36,000 --> 01:03:38,000 מחפש תו null המיוחד. 1168 01:03:38,000 --> 01:03:41,000 אבל אם זה הוא נתח של זיכרון מהזיכרון של המחשב שלי, 1169 01:03:41,000 --> 01:03:44,000 בואו שרירותי אומרים שמחרוזת זו פשוט הייתה לו מזל, 1170 01:03:44,000 --> 01:03:47,000 והוא הלך לממוקם בתחילה מאוד של זכרון RAM של המחשב שלי. 1171 01:03:47,000 --> 01:03:54,000 זה ייט 0, 1, 2, 3, 4, 5, 6 ... 1172 01:03:54,000 --> 01:04:02,000 >> כשאני אומר משהו כמו GetString ואני עושה מחרוזת s = GetString 1173 01:04:02,000 --> 01:04:04,000 מה שבאמת שחזר? 1174 01:04:04,000 --> 01:04:08,000 במשך כמה שבועות האחרונים, מה באמת מאוחסנים בשל 1175 01:04:08,000 --> 01:04:13,000 לא זו מחרוזת כשלעצמה, אבל במקרה הזה מה שמאוחסן 1176 01:04:13,000 --> 01:04:18,000 0 מספר משום מה GetString עושה בפועל 1177 01:04:18,000 --> 01:04:20,000 הוא לא פיזי להחזיר מחרוזת. 1178 01:04:20,000 --> 01:04:22,000 זה אפילו לא באמת הגיוני רעיוני. 1179 01:04:22,000 --> 01:04:24,000 מה זה עושה החזרה היא מספר. 1180 01:04:24,000 --> 01:04:28,000 מספר זה הוא הכתובת של שלום בזיכרון, 1181 01:04:28,000 --> 01:04:32,000 ומחרוזת של אז, אם נקלף את השכבה, מחרוזת אינה קיימות באמת. 1182 01:04:32,000 --> 01:04:35,000 זה רק בפישוט CS50 הספרייה. 1183 01:04:35,000 --> 01:04:38,000 >> זה באמת משהו שנקרא * char. 1184 01:04:38,000 --> 01:04:41,000 Char הגיוני משום מה מילה, כמו הלו? 1185 01:04:41,000 --> 01:04:44,000 ובכן, מדובר בסדרה של תווים, סדרה של תווים. 1186 01:04:44,000 --> 01:04:47,000 * Char פירושו הכתובת של אופי, 1187 01:04:47,000 --> 01:04:50,000 אז מה זה אומר לחזור מחרוזת? 1188 01:04:50,000 --> 01:04:53,000 , דרך פשוטה נחמדה לחזור מחרוזת 1189 01:04:53,000 --> 01:04:57,000 היא במקום לנסות להבין איך אני חוזר ל5 או 6 בתים שונים 1190 01:04:57,000 --> 01:05:01,000 בואו תחזירו אותי לכתובת שהבתים? 1191 01:05:01,000 --> 01:05:03,000 ראשון. 1192 01:05:03,000 --> 01:05:06,000 במילים אחרות, תן לי לתת לך את הכתובת של דמות בזיכרון. 1193 01:05:06,000 --> 01:05:10,000 זה מה ש* char מייצג, את הכתובת של תו בודד אחד בזיכרון. 1194 01:05:10,000 --> 01:05:12,000 קוראים לזה של משתנה. 1195 01:05:12,000 --> 01:05:15,000 חנות בים שכתובת מסוימת, שבו אני באופן שרירותי אמר היא 0, 1196 01:05:15,000 --> 01:05:19,000 רק כדי לשמור על דברים פשוטים, אבל במציאות זה בדרך כלל מספר גדול יותר. 1197 01:05:19,000 --> 01:05:21,000 >> חכה רגע. 1198 01:05:21,000 --> 01:05:23,000 אם אתה רק נותן לי את הכתובת של התו הראשון, איך אני יודע מה כתובתו 1199 01:05:23,000 --> 01:05:25,000 בתו השני, השלישי, הרביעי והחמישי? 1200 01:05:25,000 --> 01:05:27,000 [לא ברור לתלמיד] 1201 01:05:27,000 --> 01:05:31,000 אתה רק יודע איפה סוף המחרוזת הוא בדרך של הטריק השימושי הזה, 1202 01:05:31,000 --> 01:05:35,000 לכן כאשר אתה משתמש במשהו כמו printf, מה printf ממש לוקח כטענתה, 1203 01:05:35,000 --> 01:05:39,000 זוכר שאנחנו משתמשים מציינים מיקום של% הזה, ואז אתה עובר ב 1204 01:05:39,000 --> 01:05:41,000 משתנה זה אחסון מחרוזת. 1205 01:05:41,000 --> 01:05:47,000 מה אתה באמת עובר הוא הכתובת של התו הראשון של מחרוזת ש. 1206 01:05:47,000 --> 01:05:50,000 Printf אז משתמש ללולאה או לולאה בזמן, עם קבלת כתובת ש, 1207 01:05:50,000 --> 01:05:53,000 למשל, 0, אז תן לי לעשות את זה עכשיו, 1208 01:05:53,000 --> 01:06:02,000 printf ("% s \ n", הים); 1209 01:06:02,000 --> 01:06:07,000 כשאני קורא printf ("% s \ n", הים), מה אני באמת מתן עם printf 1210 01:06:07,000 --> 01:06:13,000 היא הכתובת של התו הראשון בים, שבמקרה זה היא שרירותי ח 1211 01:06:13,000 --> 01:06:16,000 >> איך printf אינו יודע מה בדיוק כדי להציג על המסך? 1212 01:06:16,000 --> 01:06:19,000 מי שיישם יושם לולאה בזמן או ללולאת printf 1213 01:06:19,000 --> 01:06:23,000 שאומר אין אופי זה שווה תו null המיוחד? 1214 01:06:23,000 --> 01:06:25,000 אם לא, להדפיס אותו. מה דעתך על זה? 1215 01:06:25,000 --> 01:06:28,000 אם לא להדפיס אותו, להדפיס אותו, להדפיס אותו, להדפיס אותו. 1216 01:06:28,000 --> 01:06:32,000 אה, זה אחד מיוחד. להפסיק את ההדפסה ולחזור למשתמש. 1217 01:06:32,000 --> 01:06:35,000 וזה ממש כל מה שקורה מתחת למכסת המנוע, 1218 01:06:35,000 --> 01:06:38,000 וזה הרבה לעכל ביום הראשון של כיתה, 1219 01:06:38,000 --> 01:06:43,000 אך לעת עתה זה ממש אבן הבניין של כל הבנה 1220 01:06:43,000 --> 01:06:46,000 שנמשך כבר בתוך הזיכרון של המחשב שלנו, 1221 01:06:46,000 --> 01:06:49,000 וסופו של דבר אנחנו נתגרה זה בנפרד עם קצת עזרה 1222 01:06:49,000 --> 01:06:51,000 מאחד מהחברים שלנו בסטנפורד. 1223 01:06:51,000 --> 01:06:56,000 >> פרופסור ניק Parlante בסטנפורד עשה רצף וידאו הנפלא הזה 1224 01:06:56,000 --> 01:06:58,000 מכל מיני שפות שונות שהציגו 1225 01:06:58,000 --> 01:07:00,000 ינקי זה קצת אולפן אופי. 1226 01:07:00,000 --> 01:07:03,000 הקול שאתה עומד לשמוע רק כמה לחמוק תצוגה מקדימה 2 1227 01:07:03,000 --> 01:07:05,000 הוא זו של פרוף בסטנפורד, ואתה מקבל 1228 01:07:05,000 --> 01:07:07,000 רק 5 או 6 שניות של זכות זו עכשיו, 1229 01:07:07,000 --> 01:07:09,000 אבל זה בצליל שנוכל להסיק היום 1230 01:07:09,000 --> 01:07:11,000 ותתחיל ביום רביעי. 1231 01:07:11,000 --> 01:07:15,000 אני נותן לך כיף עם פוינטר בינקי, תצוגה המקדימה. 1232 01:07:15,000 --> 01:07:18,000 [♪ מוסיקת ♪] [פרופ Parlante] היי, בינקי. 1233 01:07:18,000 --> 01:07:21,000 תתעורר. זה זמן בשביל כיף מצביע. 1234 01:07:21,000 --> 01:07:24,000 [ינקי] מה זה? למד על מצביעים? 1235 01:07:24,000 --> 01:07:26,000 או, יופי! 1236 01:07:26,000 --> 01:07:29,000 >> אנחנו רואים אותך ביום רביעי. 1237 01:07:29,000 --> 01:07:32,000 [CS50.TV]