1
00:00:00,000 --> 00:00:10,550

2
00:00:10,550 --> 00:00:14,050
>> דוד י מלאן: זה CS50 ו
זה הוא ההתחלה של שבוע ארבעה.

3
00:00:14,050 --> 00:00:18,630
ו, ילד, הוא בפולקסווגן
צרות כל בגלל תוכנה.

4
00:00:18,630 --> 00:00:20,264
תן לנו להעיף מבט.

5
00:00:20,264 --> 00:00:20,930
[וידאו השמעה]

6
00:00:20,930 --> 00:00:25,560
-Cars, הדמויות החכמים ביותר
בסרטים המהיר ועצבני.

7
00:00:25,560 --> 00:00:29,100
יצרנית מכוניות גרמנית השבוע
פולקסווגן מצא את עצמה

8
00:00:29,100 --> 00:00:32,490
באמצע שערורייה של
פרופורציות פוטנציאל פליליות.

9
00:00:32,490 --> 00:00:36,060
>> -Volkswagen הוא מרענן למליארד
בקנסות, אישומים פליליים אפשריים

10
00:00:36,060 --> 00:00:38,560
למנהליה, כ
החברה מתנצלת

11
00:00:38,560 --> 00:00:41,840
לחבלול 11 מ'מכוניות ל
לעזור לו לנצח את בדיקות פליטה.

12
00:00:41,840 --> 00:00:44,950
>> דגמי דיזל -Certain היו
נועד עם תוכנה מתוחכמת

13
00:00:44,950 --> 00:00:48,440
שמידע משומש כוללים
עמדת ההיגוי והרכב

14
00:00:48,440 --> 00:00:51,870
להאיץ כדי לקבוע את הרכב היה
עובר בדיקות פליטה.

15
00:00:51,870 --> 00:00:55,650
תחת נסיבות ש, המנוע
יפחית את פליטות רעילות.

16
00:00:55,650 --> 00:00:59,070
אבל המכונית הייתה מבוים כדי לעקוף
כי כשזה היה מונע.

17
00:00:59,070 --> 00:01:03,320
פליטה מוגברת 10 עד 40
פעמים מעל רמות EPA מקובלות.

18
00:01:03,320 --> 00:01:04,280
>> [סוף ההשמעה]

19
00:01:04,280 --> 00:01:05,220
>> דוד י מלאן: אז בוא
תסתכל על זה

20
00:01:05,220 --> 00:01:07,250
ולראות בדיוק איך זה
יכול להיות מיושם

21
00:01:07,250 --> 00:01:09,680
ואיך ייתכן שזה משפיע
כל כך הרבה מכוניות כמו זה.

22
00:01:09,680 --> 00:01:12,840
אז ביד שלי כאן הן העיתונות
שחרור שהונפק על ידי EPA--

23
00:01:12,840 --> 00:01:14,620
הסביבה
סוכנות להגנה ש

24
00:01:14,620 --> 00:01:18,032
היא סוכנות הרגולציה האמריקנית ש
מטפל בחששות סביבתיים,

25
00:01:18,032 --> 00:01:19,740
ולאחר מכן בפועל
הודעה משפטית שהייתה

26
00:01:19,740 --> 00:01:22,420
לשלוח לפולקסווגן רק לפני כמה ימים.

27
00:01:22,420 --> 00:01:26,530
>> אז EPA כותב, וחושף כעת
בפומבי, תוכנה מתוחכמת

28
00:01:26,530 --> 00:01:29,390
אלגוריתם על מסוים
כלי רכב פולקסווגן מזהה

29
00:01:29,390 --> 00:01:32,630
כאשר המכונית עוברת
בדיקת פליטה רשמית

30
00:01:32,630 --> 00:01:36,505
והופך את פליטות מלאים
שולט על רק במהלך הבדיקה.

31
00:01:36,505 --> 00:01:38,380
היעילות של
זיהום כלי רכב אלה

32
00:01:38,380 --> 00:01:43,260
מכשירי בקרת פליטות הוא מאוד
מופחת במהלך כל הנסיעה הרגילה

33
00:01:43,260 --> 00:01:44,320
מצבים.

34
00:01:44,320 --> 00:01:48,190
התוצאה היא מכוניות שעומדות ב
סטנדרטים במעבדה או הבדיקות

35
00:01:48,190 --> 00:01:52,790
תחנה, אך במהלך פעולה רגילה
לפלוט oxides-- חנקן או NOx--

36
00:01:52,790 --> 00:01:54,950
במהירות של עד 40 פעמים סטנדרטית.

37
00:01:54,950 --> 00:01:58,220
התוכנה המיוצרת על ידי פולקסווגן
הוא מכשיר סוף ציטוט ציטוט, תבוסה,

38
00:01:58,220 --> 00:02:00,650
כפי שהוגדר בנקי
חוק האוויר בארה"ב.

39
00:02:00,650 --> 00:02:03,410
>> הם ממשיכים ואומרים ש
המשרד לאיכות הסביבה וסוכנות אחרת

40
00:02:03,410 --> 00:02:07,020
נחשף מכשיר התבוסה
תוכנה לאחר ניתוח עצמאי

41
00:02:07,020 --> 00:02:09,660
על ידי חוקרים במערב
אוניברסיטת וירג'יניה.

42
00:02:09,660 --> 00:02:14,160
זיהום NOx תורם ל
דו תחמוצת חנקן, אוזון בגובה קרקע,

43
00:02:14,160 --> 00:02:15,700
וחומר חלקיקים עדין.

44
00:02:15,700 --> 00:02:18,090
חשיפה לאלה
מזהמים נקשר

45
00:02:18,090 --> 00:02:20,870
עם מגוון רחב של
השפעות בריאותיות חמורות,

46
00:02:20,870 --> 00:02:23,637
כולל אסתמה גדלה
התקפות ונשימה אחרת

47
00:02:23,637 --> 00:02:26,470
מחלות שיכולות להיות רציני מספיק
לשלוח אנשים לבית החולים.

48
00:02:26,470 --> 00:02:28,660
חשיפה לאוזון ו
חומר חלקיקים יש גם

49
00:02:28,660 --> 00:02:31,960
נקשר עם מוקדם
מוות עקב נשימה קשורה

50
00:02:31,960 --> 00:02:35,690
או לב וכלי דם הקשורים אפקטים.

51
00:02:35,690 --> 00:02:38,940
ילדים, הקשישים, אנשים עם
מחלות בדרכי הנשימה קיימות מראש

52
00:02:38,940 --> 00:02:42,840
במיוחד בסיכון ל
השפעות בריאותיות של מזהמים אלה.

53
00:02:42,840 --> 00:02:45,056
>> די הוא לומר, שזה די רציני.

54
00:02:45,056 --> 00:02:46,930
ובואו נלך על לקרוא
רק קטע אחד יותר

55
00:02:46,930 --> 00:02:49,370
ואז נסתכל
ההשלכות הבסיסיות

56
00:02:49,370 --> 00:02:50,920
זה בהקשר של מכונית.

57
00:02:50,920 --> 00:02:53,730
באופן ספציפי, פולקסווגן
מיוצר ומותקן

58
00:02:53,730 --> 00:02:56,210
תוכנה שבנקראה
בקרה אלקטרונית

59
00:02:56,210 --> 00:02:59,320
module-- או ECM-- של
כלי רכב אלה שחשו

60
00:02:59,320 --> 00:03:03,580
כאשר הרכב שנבדק ל
עמידה בתקני פליטת ה- EPA.

61
00:03:03,580 --> 00:03:07,510
בהתבסס על תשומות שונות, כוללים
עמדתו של גלגל ההגה, רכב

62
00:03:07,510 --> 00:03:11,280
מהירות, משך המנוע של
פעולה, ולחץ ברומטרי,

63
00:03:11,280 --> 00:03:13,720
בדיוק תשומות אלה
מעקב הפרמטרים

64
00:03:13,720 --> 00:03:17,600
של הליך הבדיקה הפדרלי המשמש ל
בדיקת פליטה לאישור המשרד לאיכות הסביבה

65
00:03:17,600 --> 00:03:18,400
מטרות.

66
00:03:18,400 --> 00:03:21,850
>> במהלך בדיקת הפליטה של ​​המשרד לאיכות הסביבה,
תוכנת ECM כלי הרכב

67
00:03:21,850 --> 00:03:25,060
רץ תוכנה אשר מיוצרת
תוצאות פליטה תואמת.

68
00:03:25,060 --> 00:03:28,340
בכל שעה האחרות,
תוכנת ECM הרכב

69
00:03:28,340 --> 00:03:31,090
רץ כביש נפרד
כיול שהקטין

70
00:03:31,090 --> 00:03:34,360
את האפקטיביות של
מערכת בקרת פליטה כוללת,

71
00:03:34,360 --> 00:03:37,864
במיוחד קטליטית סלקטיבית
הפחתה של NOx Lean trap--

72
00:03:37,864 --> 00:03:39,280
שאנחנו עוד נראה ברגע.

73
00:03:39,280 --> 00:03:43,040
כתוצאה מכך, פליטה של ​​תחמוצות חנקן
גדל בפקטור של 10 עד 40 פעמים

74
00:03:43,040 --> 00:03:47,450
מעל הרמות תואמות EPA
בהתאם לסוג של מחזור כונן.

75
00:03:47,450 --> 00:03:50,800
>> אז מה זה אומר באמת, ו
קוד מקור לריצת התוכנה

76
00:03:50,800 --> 00:03:53,190
על פולקסווגן יש לא
עדיין נחשף בפומבי,

77
00:03:53,190 --> 00:03:56,460
הוא ש, ביעילות, זה
שווה הוא איפשהו שם בפנים

78
00:03:56,460 --> 00:03:57,830
הקוד של פולקסווגן.

79
00:03:57,830 --> 00:04:02,200
אם אתה נבדקים, ואם המכונית
מזהה גורמים סביבתיים מסוימים

80
00:04:02,200 --> 00:04:04,330
כמו ההגה
עמדה או התנועה

81
00:04:04,330 --> 00:04:06,710
או היעדרה של המכונית או
כל מספר של גורמים אחרים

82
00:04:06,710 --> 00:04:09,940
ששערו כרגע
להיות חלק מנוסחה זו,

83
00:04:09,940 --> 00:04:12,370
הם פשוט להדליק
פליטה מלאה.

84
00:04:12,370 --> 00:04:15,670
במילים אחרות, הם מתחילים
פולטות פחות המזהמים.

85
00:04:15,670 --> 00:04:18,769
>> אחר, בכל מצב אחר
כאשר הוא אינו מזוהה כ

86
00:04:18,769 --> 00:04:20,790
במעבדה, הם פשוט לא.

87
00:04:20,790 --> 00:04:24,320
ואז אתה יכול לפשט את זה ליותר
פסאודו קוד בטון עם משהו

88
00:04:24,320 --> 00:04:24,820
אוהב את זה.

89
00:04:24,820 --> 00:04:27,810
אם הגלגלים פונים אבל
ההגה הוא לא, רמיזות

90
00:04:27,810 --> 00:04:30,060
כי המכונית היא בכמה
סוג של גליל מסתובב

91
00:04:30,060 --> 00:04:32,550
אבל באיזשהו
מחסן נבדק,

92
00:04:32,550 --> 00:04:36,070
אז תתנהג כ
המשרד לאיכות הסביבה הייתי רוצה ש.

93
00:04:36,070 --> 00:04:37,960
לעשות אחרת לא.

94
00:04:37,960 --> 00:04:40,420
אז בואו נסתכל
בסרטון וידאו קצר ש

95
00:04:40,420 --> 00:04:45,391
לוקח מסתכלים על מה ההשלכות
הם זה בעצם מכאני.

96
00:04:45,391 --> 00:04:48,620
>> [וידאו השמעה]

97
00:04:48,620 --> 00:04:52,800
>> -Last יום שישי ה EPA הודיע ​​כי חלק
מכוניות פולקסווגן אאודי עשו בין 2009

98
00:04:52,800 --> 00:04:55,840
והשתמש בזה שנה
מכשיר תבוסה שנקרא

99
00:04:55,840 --> 00:04:59,060
לעקוף חוקי פליטה
נועד לשמור על האוויר נקי.

100
00:04:59,060 --> 00:05:01,700
אבל מה זה אומר בדיוק?

101
00:05:01,700 --> 00:05:04,666
>> ובכן, יש לי מכוניות מודרניות עשרות
מחשבים בתוכם.

102
00:05:04,666 --> 00:05:07,040
וחלק ממחשבים אלה
לעזור לתאם את הפונקציות

103
00:05:07,040 --> 00:05:09,590
של המנוע לאופטימלי
ביצועים תוך הקפדה

104
00:05:09,590 --> 00:05:12,340
שאין יותר מדי זבל
יוצא מצינור הפליטה.

105
00:05:12,340 --> 00:05:15,170
הם בעצם עובדים
בדרך זו במשך כמה עשורים.

106
00:05:15,170 --> 00:05:17,380
בעיקרון, כל חלק
של המנוע של מכונית מודרנית

107
00:05:17,380 --> 00:05:20,080
יש חיישן או בקר
על זה, ואלה מחשבים

108
00:05:20,080 --> 00:05:23,460
קוראים בנתונים אלפי
פעמים בהתאמות קבלת השניה

109
00:05:23,460 --> 00:05:26,220
כמו היחס של דלק לאוויר
זה הולך לצילינדרים.

110
00:05:26,220 --> 00:05:28,730
>> פולקסווגן רמאות אלה
ודגמי אאודי הם דיזלים,

111
00:05:28,730 --> 00:05:30,890
ויש לי דיזלים אחד יותר
מחשב חשוב באמת

112
00:05:30,890 --> 00:05:34,030
פרמטרים מבוקרים, שהוא
כמות דלק שלא נשרף הולכת

113
00:05:34,030 --> 00:05:35,200
לפליטה.

114
00:05:35,200 --> 00:05:36,310
עכשיו זה נשמע רע.

115
00:05:36,310 --> 00:05:39,642
לא נשמע כמו שאתה רוצה
דלק לא רצוי להיכנס לפליטה.

116
00:05:39,642 --> 00:05:41,600
אבל במקרה של
דיזל, יש לך משהו

117
00:05:41,600 --> 00:05:46,110
נקרא NOx מלכודת שהוא מכשיר ש
סופג ומלכודות לתחמוצות חנקן

118
00:05:46,110 --> 00:05:48,880
כי הם מזהמים שהייתם
אחרת תלכו לאטמוספרה.

119
00:05:48,880 --> 00:05:53,040
ואת ההשפעה של שמלכודת NOx
משופר עם דלק שלא נשרף.

120
00:05:53,040 --> 00:05:56,650
אז מכשיר תבוסה היא תכנית מיוחדת
בתוך מחשבים אלה שיכולים לעשות את זה

121
00:05:56,650 --> 00:05:59,527
נראה כמו המכונית פוגשת פליטה
סטנדרטים גם כאשר זה לא.

122
00:05:59,527 --> 00:06:01,110
היה לי פולקסווגן בעיה על ידיה.

123
00:06:01,110 --> 00:06:04,050
מנועי דיזל היו ידועים
להשגת גדול במשק דלק,

124
00:06:04,050 --> 00:06:07,510
אבל מלכודת NOx עובדת רק טובה
כאשר נמצא בשימוש יותר דלק.

125
00:06:07,510 --> 00:06:10,460
אז המכונית הייתה לזהות,
שימוש במכשיר תבוסה זו,

126
00:06:10,460 --> 00:06:13,870
כאשר הוא מקבל את הפליטה
בדיקה, שזה יהיה להשתמש יותר דלק,

127
00:06:13,870 --> 00:06:16,830
לעשות את עבודת מלכודת NOx גם,
פליטות תהיה בסדר.

128
00:06:16,830 --> 00:06:21,130
אבל אז אתה מקבל על הכביש, המכשיר
מכבה, אתה שורף פחות דלק

129
00:06:21,130 --> 00:06:24,256
אבל אתה לשים עד 40 פעמים
יותר מזהמים לאטמוספרה.

130
00:06:24,256 --> 00:06:26,130
אבל איך לעזאזל עשו
המכונית יודעת שזה היה

131
00:06:26,130 --> 00:06:27,720
נבדק לתאימות פליטה?

132
00:06:27,720 --> 00:06:30,590
המשרד לאיכות הסביבה אומרת שזה היה מתוחכם
מערכת שבדקה את הדברים

133
00:06:30,590 --> 00:06:34,090
כמו גלגל הגה,
מהירות, כמה זמן המנוע היה ב,

134
00:06:34,090 --> 00:06:35,507
ואפילו בלחץ אטמוספרי.

135
00:06:35,507 --> 00:06:37,673
במילים אחרות, היה
אין דרך זה היה מקרי

136
00:06:37,673 --> 00:06:40,260
כי התוכנה הייתה
תוכנן בזהירות רבה כדי לאתר

137
00:06:40,260 --> 00:06:41,630
בדיקת פליטה רשמית.

138
00:06:41,630 --> 00:06:43,588
זה קצת רציני למדי
שטעייה וזה

139
00:06:43,588 --> 00:06:45,420
מדוע פולקסווגן הוא ב
צרות רציניות כזה.

140
00:06:45,420 --> 00:06:48,600
למעשה, המנכ"ל שלהם, מרטין
Winterkorn, רק ירד.

141
00:06:48,600 --> 00:06:49,820
>> אז מה קורה עכשיו?

142
00:06:49,820 --> 00:06:53,900
ובכן, אם אתה אחד מהמיליון והחצים
Jettas דיזל, הביטלס, גרבי ברך, Passats,

143
00:06:53,900 --> 00:06:56,220
או יבוצע אאודי A3s,
החדשות טובות היא היא

144
00:06:56,220 --> 00:06:57,886
כי המכונית שלך היא עדיין בטוחה לנהוג.

145
00:06:57,886 --> 00:07:00,510
אתה לא צריך לשים אותו משם
עד פולקסווגן מנפיק זוכר.

146
00:07:00,510 --> 00:07:02,509
אבל בשלב מסוים הם
כנראה הולך להיות

147
00:07:02,509 --> 00:07:04,230
כדי לעדכן את התוכנה בתוך המכונית שלך.

148
00:07:04,230 --> 00:07:06,927
כשזה קורה לך אולי
תקבל פחות קילומטרים למכל.

149
00:07:06,927 --> 00:07:09,260
עורכי דין כבר מתכוננים
לתובענות ייצוגיות

150
00:07:09,260 --> 00:07:12,500
כך בעלים עשויים לקבל פיצוי
בשלב מסוים בעתיד.

151
00:07:12,500 --> 00:07:15,832
אבל זה לא הולך ל
לקרות בזמן קרוב.

152
00:07:15,832 --> 00:07:16,711
>> [סוף ההשמעה]

153
00:07:16,711 --> 00:07:19,960
דוד י מלאן: אז זה מעלה למעשה
שאלת תמונה גדולה יותר מעניינת

154
00:07:19,960 --> 00:07:20,660
כלסמוך.

155
00:07:20,660 --> 00:07:21,160
נכון?

156
00:07:21,160 --> 00:07:24,300
לכולנו יש מכשירי iPhone או אנדרואידים או
משהו בכיסים שלנו סביר ביותר

157
00:07:24,300 --> 00:07:26,500
בימים אלה, או מחשבים ניידים
על הברכיים שלנו, כי הם

158
00:07:26,500 --> 00:07:28,510
תוכנה פועלת עשתה
על ידי אפל ומיקרוסופט

159
00:07:28,510 --> 00:07:30,710
וצרורות של חברות אחרות.

160
00:07:30,710 --> 00:07:34,240
אבל איך אנחנו יודעים כי מה ש
מוצרי תוכנה אלה עושים

161
00:07:34,240 --> 00:07:37,680
הוא למעשה מה אלה
חברות אומרים שהם עושים?

162
00:07:37,680 --> 00:07:39,610
>> לדוגמא, מי ל
אומר שכל פעם שאתה

163
00:07:39,610 --> 00:07:42,200
לבצע שיחת טלפון ב- iPhone שלך
או בטלפון אנדרואיד או כמו,

164
00:07:42,200 --> 00:07:45,650
שמספר הטלפון הוא גם לא
שהועלה לשרת מסוים של חברה

165
00:07:45,650 --> 00:07:48,399
בגלל כמה תכנית שיש לך
נכתב, בין אם זה ההפעלה

166
00:07:48,399 --> 00:07:51,070
מערכת עצמה כמו iOS או אנדרואיד,
או בגלל שהורדת

167
00:07:51,070 --> 00:07:53,880
כמה יישום צד שלישי
כי איכשהו הוא מקשיב

168
00:07:53,880 --> 00:07:57,120
לכל דבר שאתה מקליד באו
כל מה שאתה בעצם אומר.

169
00:07:57,120 --> 00:07:59,500
איך אתה יודע את זה, כש
אתם מפעילים קלאנג

170
00:07:59,500 --> 00:08:02,590
או הפוך ללקמפלך
תוכנה של בCS50, איך

171
00:08:02,590 --> 00:08:06,080
אתה צוות של CS50 ש,
בדרך של ספריית CS50,

172
00:08:06,080 --> 00:08:08,690
לא היה כל כניסה
מחרוזת שאי פעם קיבלו

173
00:08:08,690 --> 00:08:10,276
או בכל רמ"ח איברים אי פעם קיבלו?

174
00:08:10,276 --> 00:08:12,900
ובכן, אתה יכול בהחלט נראה
בקוד המקור של משהו

175
00:08:12,900 --> 00:08:15,233
כמו ספריית CS50,
יכול להסתכל על קוד המקור

176
00:08:15,233 --> 00:08:18,170
למערכת הפעלה לינוקס
פועל על IDE CS50.

177
00:08:18,170 --> 00:08:23,090
אבל הצגה מדהימה
הוחזר בשנת 1984

178
00:08:23,090 --> 00:08:26,730
בקבלת פרס טיורינג על ידי
מדען מחשב מפורסם מאוד ידוע

179
00:08:26,730 --> 00:08:29,750
as-- קן תומפסון שם ש
פרס טיורינג קיבל ש

180
00:08:29,750 --> 00:08:33,500
הוא סוג של המדע של מחשב
פרס נובל, אם תרצה,

181
00:08:33,500 --> 00:08:35,309
עבור עבודתו על
מערכת הפעלה בשם

182
00:08:35,309 --> 00:08:39,039
יוניקס, שהוא דומה מאוד ב
רוח למה שאנו משתמשים בו היא לינוקס.

183
00:08:39,039 --> 00:08:41,960
והשאלה שהוא שאל בו
נאום קבלה, מהות

184
00:08:41,960 --> 00:08:44,910
בהנחת המסגרת ל
שנים על גבי שנים של דיון

185
00:08:44,910 --> 00:08:46,970
על אמון וביטחון, היה זה.

186
00:08:46,970 --> 00:08:50,410
באיזו מידה צריך אמון אחד
הצהרה שprogram-- חתיכה

187
00:08:50,410 --> 00:08:53,010
של software-- הוא ללא סוסים טרויאניים?

188
00:08:53,010 --> 00:08:56,500
אולי זה חשוב יותר לתת אמון
האנשים שכתבו את התוכנה.

189
00:08:56,500 --> 00:08:58,650
>> ולמעשה, אנחנו כבר מקושרים
לשיחה שהוא

190
00:08:58,650 --> 00:09:02,400
נתן בעת ​​קבלת הפרס הזה
בשנתי ה -80 באתר האינטרנט של CS50

191
00:09:02,400 --> 00:09:04,030
תחת דף ההרצאות להיום.

192
00:09:04,030 --> 00:09:06,071
כי מה שתראה
הוא שהוא בעצם נותן לי

193
00:09:06,071 --> 00:09:09,430
דוגמא פשוטה למדי של כמה אפילו
מהדר כמו קלאנג או מה ש

194
00:09:09,430 --> 00:09:13,950
מהדרים אחרים השתמשו בעבר,
מה אם משובץ בנו מהדר

195
00:09:13,950 --> 00:09:18,190
את עצמנו משתמשים הוא קצת אם
מצב שבעצם אומר,

196
00:09:18,190 --> 00:09:22,360
אם אתה שם לב שהקוד הזה משתמש
פונקצית GetString או GetInt

197
00:09:22,360 --> 00:09:26,600
הפונקציה, קדימה ולהכניס
דלת אחורית או סוס טרויאני

198
00:09:26,600 --> 00:09:29,340
כך שתכנית ש
עכשיו יש כמה אפסים

199
00:09:29,340 --> 00:09:30,930
ואלה שעושים משהו זדוני.

200
00:09:30,930 --> 00:09:33,080
כניסה לכולכם
הקשות, העלאת נתונים ש

201
00:09:33,080 --> 00:09:35,100
לחלק שרת, או כל דבר באמת.

202
00:09:35,100 --> 00:09:37,290
>> ומה קן תומפסון
ממשיך לעשות בהרצאה שלו

203
00:09:37,290 --> 00:09:40,580
הוא להוכיח שגם אם
יש לך גישה למקור

204
00:09:40,580 --> 00:09:43,794
קוד של מהדר ש
בזדון יכול להיות עושה את זה,

205
00:09:43,794 --> 00:09:46,210
זה לא משנה, כי
יש עוף והביצה

206
00:09:46,210 --> 00:09:49,500
מציאות של רב בעבר
שנים לפי מהדרים

207
00:09:49,500 --> 00:09:51,960
משמשים לקמפל את עצמם.

208
00:09:51,960 --> 00:09:55,440
במילים אחרות, דרך חזרה, כאשר מישהו
היה שכתב את המהדר הראשון.

209
00:09:55,440 --> 00:09:59,060
ולאחר מכן, כל זמן שהם מעודכנים
מהדר על ידי שינוי קוד המקור שלה,

210
00:09:59,060 --> 00:10:02,020
הוספת תכונות וrecompiling זה
לאנשים כמונו להשתמש, גם,

211
00:10:02,020 --> 00:10:04,270
הם משתמשים ישנים
גרסה של המהדר

212
00:10:04,270 --> 00:10:06,370
לקמפל החדש
גרסה של המהדר.

213
00:10:06,370 --> 00:10:08,370
ואם אתה תסתכל
בשיחה שהוא נתן,

214
00:10:08,370 --> 00:10:10,970
תראה את זה כי
מעגלי ש,

215
00:10:10,970 --> 00:10:14,330
למעשה אתה יכול לקבל באגים או
סוסים טרויאניים מוטבעים בתוכנה

216
00:10:14,330 --> 00:10:14,990
אנו משתמשים.

217
00:10:14,990 --> 00:10:18,010
וגם אם אתה מסתכל על
קוד מקור לתוכניות אלה,

218
00:10:18,010 --> 00:10:21,550
זה אולי אפילו לא יהיה ברור
כי בתחבולות היא למעשה

219
00:10:21,550 --> 00:10:24,710
בחלק הגרסה ישנה יותר של
מהדר שמאז כבר

220
00:10:24,710 --> 00:10:27,340
הזרקת האיום לתוכנה שלנו.

221
00:10:27,340 --> 00:10:29,740
>> וזה רק כדי לומר, ש
באמת לא יכול ולא צריך

222
00:10:29,740 --> 00:10:32,939
תוכנה פועלת על אמון המחשבים הניידים שלנו
או טלפונים או כל מספר של מקומות.

223
00:10:32,939 --> 00:10:36,230
ואכן, מאוחר יותר בסמסטר הזה כש
על תכנות אינטרנט אנחנו מתחילים לדבר

224
00:10:36,230 --> 00:10:38,521
ובעצם להתחיל לבנות
יישומים עצמנו אינטרנט,

225
00:10:38,521 --> 00:10:40,285
נדבר על אלה
איומים ואחרים.

226
00:10:40,285 --> 00:10:43,410
עכשיו, לך אולי תהית ושמת לב
שיש דארת קטנטונת

227
00:10:43,410 --> 00:10:45,842
ויידר בסרטונים ש
סף היה מראה שיש

228
00:10:45,842 --> 00:10:47,550
על פולקסווגן. אם
שמעולם לא ראו, אני

229
00:10:47,550 --> 00:10:49,190
חשבנו שאנחנו צריכים להאיר
מצב הרוח כי זה כל

230
00:10:49,190 --> 00:10:50,780
מאוד מדכא ומפחיד.

231
00:10:50,780 --> 00:10:52,910
אני הולך להסתכל אחורה
בסופרבול 2,011

232
00:10:52,910 --> 00:10:55,300
כאשר מסחרי על ידי
Volkswagen-- וזה

233
00:10:55,300 --> 00:10:59,620
כמעט גורם להם חביבים again--
שודר לראשונה בטלוויזיה.

234
00:10:59,620 --> 00:11:04,039
זה הסרטון השני 60
כי אני חושב שאתה נהנה.

235
00:11:04,039 --> 00:11:04,705
[וידאו השמעה]

236
00:11:04,705 --> 00:11:08,198
[מוסיקה - נושא מתוך "מלחמת כוכבים"]

237
00:11:08,198 --> 00:11:35,643

238
00:11:35,643 --> 00:11:38,138
[כלב נובח]

239
00:11:38,138 --> 00:11:50,114

240
00:11:50,114 --> 00:11:53,607
[מכונית מתחיל]

241
00:11:53,607 --> 00:12:04,086

242
00:12:04,086 --> 00:12:05,955
[סוף ההשמעה]

243
00:12:05,955 --> 00:12:06,830
דוד י מלאן: כן.

244
00:12:06,830 --> 00:12:07,663
אני רק בודק.

245
00:12:07,663 --> 00:12:11,360
המכונית שנמצאת ברשימה של הפרות.

246
00:12:11,360 --> 00:12:12,000
בסדר.

247
00:12:12,000 --> 00:12:14,040
אז אנחנו מסתכלים על כמה
פסאודו קוד רגע לפני.

248
00:12:14,040 --> 00:12:15,380
והנה גדול יותר
קטע קוד פסאודו קוד

249
00:12:15,380 --> 00:12:16,921
כי ראינו כמה פעמים עד כה.

250
00:12:16,921 --> 00:12:19,970
ובואו נשתמש בזה הזדמנות
עכשיו להציג תכנות חדש

251
00:12:19,970 --> 00:12:23,776
טכניקה שעשינו
לראות אלגוריתמי

252
00:12:23,776 --> 00:12:25,400
בשבוע שעבר כשהסתכלנו במין מיזוג.

253
00:12:25,400 --> 00:12:28,270
אבל בואו למסד אותה ולראות איך
אנו עשויים להשתמש בו בקוד בפועל,

254
00:12:28,270 --> 00:12:30,350
ואז אנחנו הולכים להשתמש בזה
טכניקה במורד הכביש ביותר

255
00:12:30,350 --> 00:12:32,000
סביר כדי לפתור בעיות מסוימות אחרות.

256
00:12:32,000 --> 00:12:35,790
>> אז זה היה אחת התוכניות הראשונות ש
אי פעם כתב, אם כי בקוד פסאודו קוד.

257
00:12:35,790 --> 00:12:37,790
ומה בתכנית זו
אפשר לנו לעשות קורס

258
00:12:37,790 --> 00:12:41,510
היה למצוא מייק סמית בספר טלפונים.

259
00:12:41,510 --> 00:12:46,216
ושים לב בקווים מסוימים שמונה
ו -11 שהיו הצהרה עבור לזו.

260
00:12:46,216 --> 00:12:48,090
ולמעשה, מסוים
שפות, C ביניהם,

261
00:12:48,090 --> 00:12:50,006
יש לי למעשה
הצהרה שהיא, פשוטו כמשמעו,

262
00:12:50,006 --> 00:12:52,710
ללכת הלמאפשר לך
לקפוץ לשורה מסוימת.

263
00:12:52,710 --> 00:12:55,470
זה בדרך כלל בעין יפה כי
יכול להיות התעלל את זה מאוד בקלות

264
00:12:55,470 --> 00:12:58,490
ואתה יכול להתחיל לקפוץ שלך
תכנית בכל המקום, בניגוד

265
00:12:58,490 --> 00:13:00,690
לשימוש בסוג של
היגיון ובקרת הזרימה

266
00:13:00,690 --> 00:13:04,000
שהשתמשנו עד כה רק עם
לולאות ותנאים וכדומה.

267
00:13:04,000 --> 00:13:08,660
>> אבל אנחנו יכולים לפשט אלגוריתם זה
בקוד פסאודו קוד כדלקמן.

268
00:13:08,660 --> 00:13:11,250
במקום זה איטרטיבי
או לולאת גישה

269
00:13:11,250 --> 00:13:14,160
שבו אנחנו כל הזמן חוזרים ו
בחזרה וחזרנו לקו שלושה,

270
00:13:14,160 --> 00:13:18,300
למה אנחנו לא רק סוג של הדוגית ועוד
בדרך כלל אומרים בשורה שבע ו -10,

271
00:13:18,300 --> 00:13:20,570
פשוט להחליף שני אלה
זוגות של קווים עם,

272
00:13:20,570 --> 00:13:22,810
אחר אם סמית 'היא קודם לכן
בספר שנציע ב

273
00:13:22,810 --> 00:13:25,110
לחפש את מייק ב
מחצית השמאלית של הספר.

274
00:13:25,110 --> 00:13:28,560
אחר אם סמית 'היא שלב מאוחר יותר ב
ספר, לחפש את מייק בימין

275
00:13:28,560 --> 00:13:29,540
מחצית הספר.

276
00:13:29,540 --> 00:13:31,180
ושים לב כבר המעגלי.

277
00:13:31,180 --> 00:13:31,680
נכון?

278
00:13:31,680 --> 00:13:34,250
אני מחפש מייק ב
ספר טלפונים ולאחר מכן

279
00:13:34,250 --> 00:13:37,090
סופו של דבר פגע אולי
קו שבעה או אולי קו 10

280
00:13:37,090 --> 00:13:41,089
וההוראה שלי לעצמי הוא חיפוש
למייק במחצית ספר טלפונים.

281
00:13:41,089 --> 00:13:42,380
ובכן, איך אני מחפש מייק?

282
00:13:42,380 --> 00:13:44,213
אני באמצע
מחפש מייק, למה

283
00:13:44,213 --> 00:13:45,860
אתה סוג של שולח לי במעגל?

284
00:13:45,860 --> 00:13:49,590
אבל זה בסדר כי מה הוא
קורה לגודל הבעיה,

285
00:13:49,590 --> 00:13:52,630
כפי שנכתב בקו 7 ו -10?

286
00:13:52,630 --> 00:13:54,989
אנחנו לא סתם אומרים חיפוש
למייק, לחפש את מייק.

287
00:13:54,989 --> 00:13:56,280
אנחנו אומרים במפורש מה?

288
00:13:56,280 --> 00:13:58,694

289
00:13:58,694 --> 00:14:01,610
חפש אותו במחצית השמאלית של
המחצית הימנית שהיא ביעילות

290
00:14:01,610 --> 00:14:03,440
מחצית מגודלה של הבעיה.

291
00:14:03,440 --> 00:14:07,170
אז זה בסדר שאנחנו סוג של
עוסק בהמעגליות זה,

292
00:14:07,170 --> 00:14:09,180
טענה חוזר זה,
כי לפחות אנחנו

293
00:14:09,180 --> 00:14:11,090
מה שהופך את הבעיה קטנה יותר ויותר.

294
00:14:11,090 --> 00:14:14,220
וסופו של דבר אנחנו הולכים להגיע
כי במקרה בסיס מה שנקרא בי

295
00:14:14,220 --> 00:14:16,780
יש לנו רק עמוד אחד left--
כמתנדב שלנו בשבוע שעבר

296
00:14:16,780 --> 00:14:18,684
did-- היו לנו עמוד אחד
עזבנו ולאחר מכן אנחנו לא

297
00:14:18,684 --> 00:14:21,600
צריך לשמור מחפש מייק סמית
בגלל שהוא או בדף

298
00:14:21,600 --> 00:14:23,080
או שהוא לא.

299
00:14:23,080 --> 00:14:27,480
>> אז איך אנחנו יכולים ליישם את הרעיון הזה, זה
סוג של המעגליות בקוד בפועל?

300
00:14:27,480 --> 00:14:31,030
ובכן, אנחנו יכולים למנף את טכניקה
זה ידוע בדרך כלל כרקורסיה.

301
00:14:31,030 --> 00:14:33,960
וראינו את זה ב
פסאודו קוד לסוג מיזוג בשבוע שעבר.

302
00:14:33,960 --> 00:14:37,190
נזכיר כי זו הייתה
פסאודו קוד לסוג מיזוג.

303
00:14:37,190 --> 00:14:40,560
זה לטעון אפילו יותר פשוט
מיון בועות או בחירה או הכנסה

304
00:14:40,560 --> 00:14:43,310
רק במונחים של הפשטות
שבה אתה יכול לבטא את זה.

305
00:14:43,310 --> 00:14:46,750
>> אבל זה בגלל ש
אנחנו סוג של מעגלי

306
00:14:46,750 --> 00:14:51,350
אומר, לחפש משהו
על ידי מחפש את זה שוב.

307
00:14:51,350 --> 00:14:53,960
אבל אנחנו מחפשים גם ב
המחצית השמאלית או ימני המחצית

308
00:14:53,960 --> 00:14:56,070
ואז אנחנו סופו של דבר
מיזוג במקרה זה.

309
00:14:56,070 --> 00:14:58,520
אבל גם כאן, עם
שני קווי סוג, אלה

310
00:14:58,520 --> 00:15:01,320
היה לנו את זה שוב
רעיון של רקורסיה.

311
00:15:01,320 --> 00:15:05,350
וקונקרטי מה זה אומר,
בהקשר של אלגוריתם,

312
00:15:05,350 --> 00:15:10,880
הוא שאלגוריתם הוא רקורסיבית
אם היא משתמשת או קוראת לעצמו.

313
00:15:10,880 --> 00:15:14,330
>> או במונחים של C, פונקציה היא
recursive-- פונקציה שנקראת

314
00:15:14,330 --> 00:15:18,510
foo הוא רקורסיבית אם foo,
אי שם בקוד המקור שלה,

315
00:15:18,510 --> 00:15:21,250
קורא foo הפונקציה עצמה.

316
00:15:21,250 --> 00:15:25,790
וזה רע אם כל foo אי פעם עושה
הוא לקרוא את עצמו שוב ושוב.

317
00:15:25,790 --> 00:15:30,600
זה בסדר אם foo סופו של דבר ייעצר, כפי שעושה
מיון מיזוג, באומרו, חכה רגע,

318
00:15:30,600 --> 00:15:32,980
אם בעיה זו היא סופר
קטן, למשל,

319
00:15:32,980 --> 00:15:35,840
או שמצאתי לו מי אני
מחפש, רק לחזור.

320
00:15:35,840 --> 00:15:41,000
לא באופן רקורסיבי, לא
מחזור קורא לעצמי שוב.

321
00:15:41,000 --> 00:15:44,200
>> ואז בואו נסתכל
איך זה באמת עשוי לעבוד.

322
00:15:44,200 --> 00:15:48,430
אז אני הולך קדימה ופתוח
שתי דוגמאות קוד המקור כאן.

323
00:15:48,430 --> 00:15:50,321
אחד מהם נקרא סיגמא 0.

324
00:15:50,321 --> 00:15:52,320
וזה בכלל לא
רקורסיבית, אבל בואו ניקח

325
00:15:52,320 --> 00:15:53,694
להסתכל על מה התכנית הזו עושה.

326
00:15:53,694 --> 00:15:55,737
אני כבר הפשטתי את כל
הערות מזה, אבל כל

327
00:15:55,737 --> 00:15:58,070
של קוד המקור בCS50 של
יש אתר אינטרנט הערות אם אתה

328
00:15:58,070 --> 00:15:59,570
רוצה לקרוא אותו שוב מאוחר יותר.

329
00:15:59,570 --> 00:16:02,010
ובואו נעשה זוג
של שפיות בודק כאן.

330
00:16:02,010 --> 00:16:06,640
>> אז בחלק העליון של קוד זה,
יש לנו כוללים CS50.h.

331
00:16:06,640 --> 00:16:07,650
מה זה עושה?

332
00:16:07,650 --> 00:16:08,990
למה הוא כאן?

333
00:16:08,990 --> 00:16:11,740
במונחים של ההדיוט סביר.

334
00:16:11,740 --> 00:16:12,424
מה זה עושה?

335
00:16:12,424 --> 00:16:12,858
כן.

336
00:16:12,858 --> 00:16:14,160
>> קהל: אז זה פונקצית GetInt עובדת.

337
00:16:14,160 --> 00:16:16,243
>> דוד י מלאן: אז זה
פונקצית GetInt עובדת.

338
00:16:16,243 --> 00:16:18,115
בגלל בתוך זה
קובץ, CS50.h, ש

339
00:16:18,115 --> 00:16:20,950
אנו רואים לפני זמן רב ב
מבחינת קוד המקור שלה,

340
00:16:20,950 --> 00:16:23,270
יש חבורה של פונקציות
declared-- GetInt, GetString,

341
00:16:23,270 --> 00:16:26,950
וחבורה של נוספות-- ואלא אם כן
אנחנו באמת יש לי הכוללים קו,

342
00:16:26,950 --> 00:16:29,320
קלאנג מהדר הוא לא
הולך יודע שהוא קיים.

343
00:16:29,320 --> 00:16:32,400
וכנ"ל לגבי קו
שני שבו int מוגדר

344
00:16:32,400 --> 00:16:35,101
printf, שהיא פונקציה
אנחנו שומרים באמצעות לא מעט.

345
00:16:35,101 --> 00:16:37,850
עכשיו, קו ארבעה נראה קצת פאנקי
כי זה פשוט אניה אחת.

346
00:16:37,850 --> 00:16:41,570
יש לו פסיק, לא מתולתל
פלטה, שאף קוד הפנימי שלו.

347
00:16:41,570 --> 00:16:44,640
אבל מה עשה שאנו מכנים
הדבר הזה בעבר שבועות?

348
00:16:44,640 --> 00:16:45,140
כן.

349
00:16:45,140 --> 00:16:46,060
אז אב טיפוס.

350
00:16:46,060 --> 00:16:48,390
ולמה יש לנו
אב טיפוס שנראה

351
00:16:48,390 --> 00:16:51,050
להיות קצת מיותר
בדרך כלל, כי אנחנו בדרך כלל

352
00:16:51,050 --> 00:16:53,474
לראות את הפונקציה שוב
מאוחר יותר בקובץ, נכון?

353
00:16:53,474 --> 00:16:56,390
אז למה אנחנו נו-- אתה פשוט
מגרד את הראש שלך, אבל אני אקח אותה.

354
00:16:56,390 --> 00:16:57,302
כן.

355
00:16:57,302 --> 00:17:00,000
>> קהל: [לא ברור]
פונקציה לאחר העיקרי.

356
00:17:00,000 --> 00:17:01,000
דוד י מלאן: בדיוק.

357
00:17:01,000 --> 00:17:04,089
כך שהמהדר יודע ש
סופו של דבר להגדיר או ליישם

358
00:17:04,089 --> 00:17:06,579
פונקציה שלאחר עיקרי, ככל הנראה.

359
00:17:06,579 --> 00:17:08,462
אז קלאנג ורוב
מהדרים הם סוג של מטומטמים

360
00:17:08,462 --> 00:17:10,510
והם רק תדעו
מה אתה אומר להם.

361
00:17:10,510 --> 00:17:12,569
ואם ברצונך להשתמש
פונקציה שנקראת סיגמא,

362
00:17:12,569 --> 00:17:15,710
כדאי ללמד מהדר
שהיא קיימת מראש.

363
00:17:15,710 --> 00:17:17,970
>> עכשיו, עצמו עיקרי, אפילו
למרות שזה חבורה של קווים,

364
00:17:17,970 --> 00:17:19,839
הוא די מוכר בתקווה על ידי החברה.

365
00:17:19,839 --> 00:17:21,942
יש לו לעשות בזמן לולאה
מטרתו בחיים

366
00:17:21,942 --> 00:17:24,400
כאן כנראה הוא להגיע
מספר חיובי מהמשתמש.

367
00:17:24,400 --> 00:17:27,349
ורק לשמור להציק לו
או עד שהם משתפים פעולה.

368
00:17:27,349 --> 00:17:30,670
לאחר מכן, בקו 16 יש לי
שיחה מעניינת.

369
00:17:30,670 --> 00:17:31,570
IntAnswer.

370
00:17:31,570 --> 00:17:33,710
שעל יד שמאל
צד נותן לי Int

371
00:17:33,710 --> 00:17:36,650
אשר יכול store-- נקרא Answer--
שהוא הולך לאחסון, ככל הנראה,

372
00:17:36,650 --> 00:17:39,090
ערך ההחזרה של סיגמא.

373
00:17:39,090 --> 00:17:41,840
אז סיגמא הוא רק
שם שרירותי אך משמעותי

374
00:17:41,840 --> 00:17:44,500
כי אני כבר ניתנו לפונקציה
מטרתו בחיים

375
00:17:44,500 --> 00:17:47,680
הוא לקחת argument-- אחד
אנחנו קוראים לזה N בcase-- זה

376
00:17:47,680 --> 00:17:52,280
ורק כדי לקחת את הסכום של מספר ש
בתוספת כל מספר חיובי זה

377
00:17:52,280 --> 00:17:53,200
קטן יותר מזה.

378
00:17:53,200 --> 00:17:58,140
>> אז אם אני עובר במספר 2 ל
סיגמא, אני רוצה להוסיף 2 בתוספת 1

379
00:17:58,140 --> 00:18:00,240
בתוספת 0-- לא 0-- כך שנותן לי 3.

380
00:18:00,240 --> 00:18:05,320
אם אני עובר ב 3 לסיגמא, אני רוצה
יש 3 ועוד 2 בתוספת 1, אשר נותן לי 6.

381
00:18:05,320 --> 00:18:05,900
וכן הלאה.

382
00:18:05,900 --> 00:18:09,750
אז זה רק מוסיף את כל
מספרים קטנים או שווים לזה.

383
00:18:09,750 --> 00:18:12,040
>> עכשיו, כאן למטה אני פשוט הולך
להדפיס את התשובה.

384
00:18:12,040 --> 00:18:17,330
אז כבדיקת שפיות מהירה, בואו
להפוך סיגמא 0-- סיגמא הנטוי נקודת 0--

385
00:18:17,330 --> 00:18:18,690
ותן לי להקליד 2.

386
00:18:18,690 --> 00:18:19,960
ואני אכן מקבל 3.

387
00:18:19,960 --> 00:18:21,240
תן לי להקליד 3.

388
00:18:21,240 --> 00:18:22,860
אני אכן מקבל 6.

389
00:18:22,860 --> 00:18:27,636
ואם כל אחד יכול לעשות את המתמטיקה במהירות,
אם אני עושה 50 מה אני הולך לקבל?

390
00:18:27,636 --> 00:18:29,839
>> קהל: [לא ברור].

391
00:18:29,839 --> 00:18:30,880
דוד י מלאן: ובכן, לא.

392
00:18:30,880 --> 00:18:33,340
אבל 1,275 וזה די קרוב.

393
00:18:33,340 --> 00:18:38,850
אז זה הוא התוצאה של עושה 50
בתוספת 49 בתוספת 48 פלוס 47 פלוס 46

394
00:18:38,850 --> 00:18:40,349
כל הדרך למטה עד 1.

395
00:18:40,349 --> 00:18:41,390
אז זה כל סיגמא עושה.

396
00:18:41,390 --> 00:18:43,350
אבל בואו לראות איך יש לנו
יישם את זה עכשיו.

397
00:18:43,350 --> 00:18:45,790
אז כאן היא הפונקציה עצמה.

398
00:18:45,790 --> 00:18:49,000
וזה לא נראה לי
משהו לעשות עם רקורסיה עדיין.

399
00:18:49,000 --> 00:18:51,070
למעשה, אנו משתמשים
טכניקת בית ספר ישנה.

400
00:18:51,070 --> 00:18:56,680
אני אתחול סכום משתנה בשם
לאפס, אז יש לי foreloop כאן,

401
00:18:56,680 --> 00:19:00,790
ואני מכריז Int נקרא
אני, הגדרת אותו שווה ל1--

402
00:19:00,790 --> 00:19:04,080
למרות שאני יכול להגדיר אותו שווה ל
אפס, אבל מאז שאני עושה בנוסף,

403
00:19:04,080 --> 00:19:05,340
למי אכפת אם זה אפס או אחד.

404
00:19:05,340 --> 00:19:06,660
זה הולך להיות כל השפעה.

405
00:19:06,660 --> 00:19:10,110
>> אז אני iterating כל עוד אני הוא
פחות או שווה למ ', ש

406
00:19:10,110 --> 00:19:11,671
הוא הטיעון שהתקבל ב.

407
00:19:11,671 --> 00:19:13,670
ואז אני פשוט לשמור
הגדלה I. ותובנה

408
00:19:13,670 --> 00:19:20,010
של הלולאה כל מה שאני עושה הוא עושה סכום
בתוספת שווה I. וזה מכוון.

409
00:19:20,010 --> 00:19:22,326
אני לא רוצה לעשות, בזה
מקרה, כמו סכום בתוספת בתוספת.

410
00:19:22,326 --> 00:19:24,790
אני רוצה להוסיף למעשה
הערך הנוכחי שלי

411
00:19:24,790 --> 00:19:28,190
שהולך ונעשה יותר ויותר גדול
וגדול יותר לנקודתי הריצה.

412
00:19:28,190 --> 00:19:30,210
>> ואז אני חוזר סכום.

413
00:19:30,210 --> 00:19:33,850
וכך תשובה מקבלת את סכום הערך.

414
00:19:33,850 --> 00:19:35,282
ואז אני להדפיס אותו.

415
00:19:35,282 --> 00:19:37,740
אז יש כאן הזדמנות,
אם כי, כדי לפשט סוג של

416
00:19:37,740 --> 00:19:41,260
קוד זה מושגית
והסוג של מכה אחת זה

417
00:19:41,260 --> 00:19:43,250
אכפת לי במונחים של
פשטות למרות ש

418
00:19:43,250 --> 00:19:45,700
לוקח זמן כדי למיין
של להעריך למה זה

419
00:19:45,700 --> 00:19:47,330
הוא חזק בדוגמאות הקטנות הללו.

420
00:19:47,330 --> 00:19:50,380
הנה סיגמא one-- כך
גרסה שנייה של קוד זה.

421
00:19:50,380 --> 00:19:55,290
הכל למעלה הוא זהה כך
שאותו סיפור חל כמו קודם.

422
00:19:55,290 --> 00:19:59,220
אבל עכשיו בואו נסתכל על
יישום של סיגמא ש

423
00:19:59,220 --> 00:20:05,040
אני כבר שנותרתי בה רק אלה
lines-- ארבע שורות של קוד, באמת,

424
00:20:05,040 --> 00:20:06,980
בתוספת כמה סוגריים מסולסלים ושטח לבן.

425
00:20:06,980 --> 00:20:07,930
>> אבל מה אני עושה?

426
00:20:07,930 --> 00:20:11,050
אם מ 'הוא פחות או שווה ל
אפס, אני צריך להתמודד עם סוג של

427
00:20:11,050 --> 00:20:12,490
כי במקרה סופר פשוט.

428
00:20:12,490 --> 00:20:15,450
ואם אתה נותן לי אפס או כלום
שלילי שהוא פשוט מוזר,

429
00:20:15,450 --> 00:20:17,909
אני רק הולך באופן שרירותי
אבל לחזור באופן עקבי אפס.

430
00:20:17,909 --> 00:20:20,200
אני לא רוצה את הדבר הזה ל
להיכנס כמה אינסופי מוזרה

431
00:20:20,200 --> 00:20:21,810
לולאה בגלל ערך שלילי.

432
00:20:21,810 --> 00:20:25,070
אז רק שאני אומר, אם אתה נותן לי
אפס או פחות, אני חוזר לאפס.

433
00:20:25,070 --> 00:20:28,220
>> אבל זה טוב כי זה
דף הבודד של ספר טלפונים

434
00:20:28,220 --> 00:20:28,790
מה שנשאר.

435
00:20:28,790 --> 00:20:32,660
אני נושך את בעיה מאוד ספציפית
ולא קורא משהו באופן רקורסיבי.

436
00:20:32,660 --> 00:20:36,580
אבל בשורה 31, מה ש
אני נראה עושה?

437
00:20:36,580 --> 00:20:39,780
הסוגריים רק שומרים
דברים, אני מקווה, קצת יותר ברור.

438
00:20:39,780 --> 00:20:42,110
אבל כל מה שאני עושה הוא אני
חוזר m-- מה

439
00:20:42,110 --> 00:20:45,790
אתה מוסר me-- בתוספת
ערך של m-- מצטער,

440
00:20:45,790 --> 00:20:49,052
בתוספת השווי של סיגמא של מטר מינוס 1.

441
00:20:49,052 --> 00:20:50,010
אז מה זה אומר?

442
00:20:50,010 --> 00:20:53,965
אם אתה נותן לי את המספר 3 כקלט,
התשובה אני רוצה לקבל סופו של דבר

443
00:20:53,965 --> 00:20:57,307
הוא 6 כי 3 בתוספת 2 בתוספת 1 נותן לי 6.

444
00:20:57,307 --> 00:20:59,390
אבל איך אני חושב על
איך קוד זה פועל?

445
00:20:59,390 --> 00:21:03,070
בפעם הראשונה שאני קורא סיגמא
ואני עובר בשווי 3,

446
00:21:03,070 --> 00:21:07,960
זה כמו להגיד על פיסה
נייר, הנה הערך 3

447
00:21:07,960 --> 00:21:09,920
וכבר עבר את זה לא כסיגמא.

448
00:21:09,920 --> 00:21:13,090
3 הוא כמובן לא פחות מ 0 כך
המצב אם אינו חל.

449
00:21:13,090 --> 00:21:14,020
האחר עושה.

450
00:21:14,020 --> 00:21:14,990
אז מה עליי לעשות?

451
00:21:14,990 --> 00:21:19,902
אני רוצה לחזור מ ', שהוא
3, בתוספת של סיגמא מ 'מינוס 1.

452
00:21:19,902 --> 00:21:21,110
אז תן לי לעקוב אחר זה.

453
00:21:21,110 --> 00:21:22,710
אני הולך לשים את זה
פיסת נייר במורד.

454
00:21:22,710 --> 00:21:24,668
ומה ערך, להיות
ברור, אני הולך לעבור

455
00:21:24,668 --> 00:21:26,540
לסיגמא בנקודה זו בסיפור הזה?

456
00:21:26,540 --> 00:21:28,080
איזה מספר?

457
00:21:28,080 --> 00:21:28,610
2, נכון?

458
00:21:28,610 --> 00:21:29,670
3 מינוס 1 הוא 2.

459
00:21:29,670 --> 00:21:32,000
אז אני רק צריך קצת
פיסת נייר כאן.

460
00:21:32,000 --> 00:21:33,931
אז עכשיו סיגמא הוא מקבל נקרא שוב.

461
00:21:33,931 --> 00:21:35,930
וכבר במכוון אותי
את זה כי זה

462
00:21:35,930 --> 00:21:38,070
כמו סוג של השהיית
גרסה זו של הסיפור

463
00:21:38,070 --> 00:21:40,720
כי עכשיו אני ממוקד
על אות מ 'של מינוס 1.

464
00:21:40,720 --> 00:21:42,660
אז מ 'היה 3, מ' מינוס 1 הוא 2.

465
00:21:42,660 --> 00:21:45,110
אז הנה הוא 2 כי אני כבר עברתי.

466
00:21:45,110 --> 00:21:48,510
2 הוא כמובן לא פחות מ
0 כך מקרה שלא חל.

467
00:21:48,510 --> 00:21:53,445
אחר אני חוזר מ ', שהוא זה
דבר, בתוספת של סיגמא מה ערך?

468
00:21:53,445 --> 00:21:56,160

469
00:21:56,160 --> 00:21:59,650
אז אם סיגמא של 1-- כי מ 'הוא
עכשיו 2 כך 2 מינוס 1 הוא 1.

470
00:21:59,650 --> 00:22:01,950
אז עכשיו יש לי רק את הערך 1.

471
00:22:01,950 --> 00:22:04,810
אני מעביר רק את המספר
1 לsigma-- הפונקציה

472
00:22:04,810 --> 00:22:09,120
או את עצמי כאן-- כך 1 הוא כמובן לא
פחות מאפס, עדיין אינו חל.

473
00:22:09,120 --> 00:22:12,970
>> תמורה אחרת 1 בתוספת סיגמא של מה?

474
00:22:12,970 --> 00:22:13,470
0.

475
00:22:13,470 --> 00:22:14,678
אז תן לי רק לזכור ש.

476
00:22:14,678 --> 00:22:15,920
אני אחזור לכך בהמשך.

477
00:22:15,920 --> 00:22:18,060
עכשיו אני הולך קדימה ויוד
את המספר 0, כי זה

478
00:22:18,060 --> 00:22:19,470
הטיעון שלי או פרמטר.

479
00:22:19,470 --> 00:22:22,400
אני עברתי המספר 0
ולבסוף תהליך זה

480
00:22:22,400 --> 00:22:25,760
רק חוזר על עצמי מודעה
nauseum אין להפסיק משום מה

481
00:22:25,760 --> 00:22:28,820
אני מייד לעשות ברגע שאני רואה את זה 0?

482
00:22:28,820 --> 00:22:29,790
אני חוזר לאפס.

483
00:22:29,790 --> 00:22:31,790
אז עכשיו אתה צריך להריץ אחורה את הסיפור.

484
00:22:31,790 --> 00:22:34,430
>> אם אני עכשיו הולך אחורה בזמן,
מה היה הדבר האחרון

485
00:22:34,430 --> 00:22:36,670
אני עשיתי אם היית, פשוטו כמשמעו,
אחורה וידאו?

486
00:22:36,670 --> 00:22:41,630
אני הולך להרים את האחרון
1 וזה נותן לי 1 בתוספת 0 הוא 1.

487
00:22:41,630 --> 00:22:44,100
אם אני שומר אחורה
סיפור, שהולך לתת לי

488
00:22:44,100 --> 00:22:46,880
2 בתוספת ערך זה פועל, שהוא 1.

489
00:22:46,880 --> 00:22:47,789
אז זה 3.

490
00:22:47,789 --> 00:22:49,330
ואז אני הולך לשמור וינדינג.

491
00:22:49,330 --> 00:22:54,220
כשהנחתי את המספר הראשון
3-- כך 3 ועוד 3 נותן לי 6.

492
00:22:54,220 --> 00:22:57,272
>> ועכשיו, אם אתה כבר rewound
וידאו עד לנקודה זו,

493
00:22:57,272 --> 00:22:58,980
זה היה מאוד
השאלה הראשונה ששאלתי.

494
00:22:58,980 --> 00:23:01,450
כאשר עבר 3, מה הוא סיגמא של 3?

495
00:23:01,450 --> 00:23:04,204
זה אכן 6, הסכום של
את כל החלקים האלה של נייר.

496
00:23:04,204 --> 00:23:07,120
אז אם זה לוקח קצת זמן
לעטוף את דעתך מסביב, זה בסדר.

497
00:23:07,120 --> 00:23:10,700
אבל רואים את זה היה little-- זה
היה מאוד מכוון שאני נערם

498
00:23:10,700 --> 00:23:12,990
מספרים אלה על גבי זה.

499
00:23:12,990 --> 00:23:17,440
זה סוג של כמו שיש
memory-- שיא ​​בזמן,

500
00:23:17,440 --> 00:23:19,940
כמו scrubber בוידאו,
כי אני אכן יכול להריץ אחורה ב.

501
00:23:19,940 --> 00:23:24,350
ואנחנו הולכים לחזור ל
מטאפורה שבקצת.

502
00:23:24,350 --> 00:23:28,240
>> אבל קודם, מתברר שיש
הרבה חנונים ואנשים מצחיקים,

503
00:23:28,240 --> 00:23:29,614
אני מניח, בגוגל.

504
00:23:29,614 --> 00:23:31,530
היית מישהו שמאוד
טוב במוח Googling

505
00:23:31,530 --> 00:23:34,270
מתקרב לרגע ו
תעזור לי לחפש משהו?

506
00:23:34,270 --> 00:23:35,650
מפתח מאוד, נמוך מאוד.

507
00:23:35,650 --> 00:23:37,870
מישהו שאף פעם לא
לבוא לפני, אולי.

508
00:23:37,870 --> 00:23:38,370
אוקיי.

509
00:23:38,370 --> 00:23:39,030
כן?

510
00:23:39,030 --> 00:23:39,530
בחייך.

511
00:23:39,530 --> 00:23:41,410
בואו למטה.

512
00:23:41,410 --> 00:23:42,183
מה השם שלך?

513
00:23:42,183 --> 00:23:42,870
>> סם: סם.

514
00:23:42,870 --> 00:23:44,290
>> דוד י מלאן: סם, בא למטה.

515
00:23:44,290 --> 00:23:45,320
זה אותו.

516
00:23:45,320 --> 00:23:46,280
נחמד לפגוש אותך.

517
00:23:46,280 --> 00:23:46,780
היי.

518
00:23:46,780 --> 00:23:47,580
בוא לכאן.

519
00:23:47,580 --> 00:23:51,290
אז כל מה שאני צריך שתעשה, אם
אתה יכול, סם, הנה גוגל.

520
00:23:51,290 --> 00:23:53,240
אתה יכול לחפש את רקורסיה הטווח?

521
00:23:53,240 --> 00:23:55,770

522
00:23:55,770 --> 00:23:56,270
אל תקלקל.

523
00:23:56,270 --> 00:23:59,940

524
00:23:59,940 --> 00:24:00,970
>> ועכשיו let's-- כן.

525
00:24:00,970 --> 00:24:03,380
לחץ על אישור ש.

526
00:24:03,380 --> 00:24:04,315
טוב יותר לחץ על ש.

527
00:24:04,315 --> 00:24:07,020

528
00:24:07,020 --> 00:24:08,020
אהה, לקבל את זה.

529
00:24:08,020 --> 00:24:08,520
לא?

530
00:24:08,520 --> 00:24:09,050
אוקיי.

531
00:24:09,050 --> 00:24:10,430
אז בואו נעשה כמה אחרים.

532
00:24:10,430 --> 00:24:12,830
לא כל כך הרבה בנושא
אקדמי כאן, אבל יש לך

533
00:24:12,830 --> 00:24:14,520
אי פעם חיפש גוגל להיפוך אותיות?

534
00:24:14,520 --> 00:24:15,280
>> SAM: מס '

535
00:24:15,280 --> 00:24:15,520
>> דוד י מלאן: אישור.

536
00:24:15,520 --> 00:24:17,186
חפש היפוך אותיות במקום רקורסיה.

537
00:24:17,186 --> 00:24:22,540

538
00:24:22,540 --> 00:24:23,790
מה דעתך על אלכסון.

539
00:24:23,790 --> 00:24:25,515
אי פעם חיפש באלכסון?

540
00:24:25,515 --> 00:24:29,260

541
00:24:29,260 --> 00:24:32,692
עכשיו, זה אחד זה קצת קשה
אבל אני מקווה לראות everything's-- אישור.

542
00:24:32,692 --> 00:24:34,150
זה רק אתה ואני נהנים מזה.

543
00:24:34,150 --> 00:24:34,690
אוקיי.

544
00:24:34,690 --> 00:24:38,950
>> אז לבסוף, one's-- זה
זה קצת באלכסון.

545
00:24:38,950 --> 00:24:40,810
עכשיו לעשות רול חבית.

546
00:24:40,810 --> 00:24:44,460

547
00:24:44,460 --> 00:24:45,310
נפלא.

548
00:24:45,310 --> 00:24:45,910
בסדר.

549
00:24:45,910 --> 00:24:47,110
תודה גדולה לסם.

550
00:24:47,110 --> 00:24:49,416
הנה לך.

551
00:24:49,416 --> 00:24:50,400
תודה.

552
00:24:50,400 --> 00:24:52,807
>> אז מה קורה בכל
דוגמאות המטופשות האלה?

553
00:24:52,807 --> 00:24:55,640
אז באמת, מתחת למכסת המנוע של
מיליון של גוגל שורות קוד

554
00:24:55,640 --> 00:24:58,860
ככל הנראה הוא כמה טיפשי אם
תנאים שהם במהות

555
00:24:58,860 --> 00:25:01,160
בדיקה אם יש למשתמש
הקליד בביטוי הזה,

556
00:25:01,160 --> 00:25:03,760
לעשות משהו שכנראה לקח
סכום טריוויאלי של זמן

557
00:25:03,760 --> 00:25:06,080
ליישם רק ל
להיות משעשע בדרך זו.

558
00:25:06,080 --> 00:25:08,430
אבל זה כל מה שחין
עד מתחת למכסת המנוע.

559
00:25:08,430 --> 00:25:11,570
אבל, כמובן, רקורסיה
יותר מgeekier

560
00:25:11,570 --> 00:25:13,880
דוגמא בין טריקים מיוחדים אלה.

561
00:25:13,880 --> 00:25:16,880
ואין ספק שיש את האחרים שיש
כמו גם שאולי יש לנו אפילו לא

562
00:25:16,880 --> 00:25:18,230
גילה עדיין.

563
00:25:18,230 --> 00:25:22,830
>> אז תסתכל, או לשקול
עכשיו התכנית הבאה,

564
00:25:22,830 --> 00:25:24,830
ובהחלט לתפוס כל
של אלה בדרך החוצה.

565
00:25:24,830 --> 00:25:28,820
אני הולך קדימה ו
לפתוח את תכנית ש

566
00:25:28,820 --> 00:25:30,920
הולך לנסות להחליף שני ערכים.

567
00:25:30,920 --> 00:25:33,210
אבל לפני שאנחנו הולכים לשם, בואו נעשינו את זה.

568
00:25:33,210 --> 00:25:38,500
האם אנו יכולים לקבל אחד יותר
מתנדב, אני חושב?

569
00:25:38,500 --> 00:25:40,480
האם אתה רוצה להתנדב?

570
00:25:40,480 --> 00:25:40,980
לא?

571
00:25:40,980 --> 00:25:41,890
בואו למעלה.

572
00:25:41,890 --> 00:25:42,390
בואו למעלה.

573
00:25:42,390 --> 00:25:42,890
בסדר.

574
00:25:42,890 --> 00:25:44,136
אז השם שלך הוא מה?

575
00:25:44,136 --> 00:25:44,810
>> לורן: לורן.

576
00:25:44,810 --> 00:25:45,768
>> דוד י מלאן: לורן.

577
00:25:45,768 --> 00:25:46,890
בואו למעלה, לורן.

578
00:25:46,890 --> 00:25:50,140
אז לורן הוא להיות
אתגר כאן הוא כדלקמן.

579
00:25:50,140 --> 00:25:52,310
נחמד לפגוש אותך.

580
00:25:52,310 --> 00:25:55,730
אז לורן כאן יש בחזית
שתי הכוסות הריקות שלה.

581
00:25:55,730 --> 00:25:57,570
ויש לנו כמה כתום
מיץ וקצת חלב

582
00:25:57,570 --> 00:26:00,301
ואנחנו הולכים ללכת
קדימה ולעשות את הדברים הבאים.

583
00:26:00,301 --> 00:26:01,550
אנחנו רק הולכים למלא את זה.

584
00:26:01,550 --> 00:26:07,840
כמה גרם של חלב לכאן ובואו
למלא מיץ תפוזים קצת יותר כאן.

585
00:26:07,840 --> 00:26:11,475
>> ומול כל
חברים אלה הקהל,

586
00:26:11,475 --> 00:26:13,550
להחליף את שני הערכים של הכוסות הללו.

587
00:26:13,550 --> 00:26:16,970
שים את מיץ התפוזים בכוס חלב
והחלב בכוס מיץ תפוזים.

588
00:26:16,970 --> 00:26:22,380

589
00:26:22,380 --> 00:26:26,150
איך היית עושה את זה אם היית ב
הבית והיה לו גישה לאספקה ​​אחרת?

590
00:26:26,150 --> 00:26:27,400
לורן: שים את זה בכוס אחרת.

591
00:26:27,400 --> 00:26:28,191
דוד י מלאן: אישור.

592
00:26:28,191 --> 00:26:31,940
אז בואו זמני
משתנה, אם יהיה.

593
00:26:31,940 --> 00:26:35,871
וללכת קדימה עכשיו וליישם
אותו נוהל החלפה זו.

594
00:26:35,871 --> 00:26:36,370
כל כך טוב.

595
00:26:36,370 --> 00:26:41,490
אנחנו כבר לשים OJ לזמני
משתנה, חלב לתוך משתנה OJ,

596
00:26:41,490 --> 00:26:44,481
ועכשיו משתנה הזמני
למשתנת חלב.

597
00:26:44,481 --> 00:26:44,980
אוקיי.

598
00:26:44,980 --> 00:26:48,740
כל כך טוב מאוד שנעשה עד כה.

599
00:26:48,740 --> 00:26:50,990
אז מתברר out-- להחזיק ש
חשבתי לרגע.

600
00:26:50,990 --> 00:26:54,479
הנה, לסתם חנון זה קצת, זה
יהיה קוד C המקביל

601
00:26:54,479 --> 00:26:55,520
שאנחנו פשוט ליישם.

602
00:26:55,520 --> 00:26:58,650
היו לנו שתי כניסות, ו- B, שניהם
שאנחנו פשוט נגיד לפשטות הם

603
00:26:58,650 --> 00:26:59,260
int של.

604
00:26:59,260 --> 00:27:02,780
ושים לב כאן, אם אני רוצה להחליף
הערכים של שני משתנים, A ו- B,

605
00:27:02,780 --> 00:27:06,890
אנחנו אכן צריכים מתווך,
משתנה זמני, כוס זמנית,

606
00:27:06,890 --> 00:27:10,830
שלתוכו יוצק את אחד הערכים
כך שיש לנו מיקום עבורו.

607
00:27:10,830 --> 00:27:13,480
אבל אז הקוד הוא בדיוק
כלורן כאן מיושם.

608
00:27:13,480 --> 00:27:15,500
>> עכשיו, רק כדי לקבל
משוגע קצת, מתברר

609
00:27:15,500 --> 00:27:20,930
כי אתה יכול לעשות את זה בלי
משתנה זמני.

610
00:27:20,930 --> 00:27:24,870
כדי לעשות זאת כראוי, אם כי, אנחנו הולכים
יש לרמות עם כמה כימיה.

611
00:27:24,870 --> 00:27:26,380
יש לנו כמה כוסות נוספות כאן.

612
00:27:26,380 --> 00:27:29,600
אז הדבר הכי קרוב שנראה
כמו perhaps-- חלב והמים

613
00:27:29,600 --> 00:27:34,090
או חלב וOJ-- הוא שיש לנו כמה
מים, כדי שנמלא את זה

614
00:27:34,090 --> 00:27:36,486
עם כמה אונקיות של מים צלולים.

615
00:27:36,486 --> 00:27:38,332
זה כנראה יותר מדי.

616
00:27:38,332 --> 00:27:38,832
כן.

617
00:27:38,832 --> 00:27:39,934
זה בהחלט יותר מדי.

618
00:27:39,934 --> 00:27:40,600
חכה רגע.

619
00:27:40,600 --> 00:27:43,520

620
00:27:43,520 --> 00:27:48,420
>> ועכשיו יש לנו נפט, אשר, כפי שאני זוכר
ממחלקה לכימיה בבית הספר התיכונה,

621
00:27:48,420 --> 00:27:49,990
אני מקווה שזה לא לערבב עם מים.

622
00:27:49,990 --> 00:27:53,650
אבל זה סוג של סוג של
נראה כמו חלב וג'יי.

623
00:27:53,650 --> 00:27:55,760
אז עכשיו, ללא שימוש ב
משתנה זמני,

624
00:27:55,760 --> 00:27:59,260
אתה יכול להחליף את שני הערכים האלה?

625
00:27:59,260 --> 00:28:03,884
אז שמנים הולכים לכוס המים,
מים נכנס לכוס השמן.

626
00:28:03,884 --> 00:28:04,800
לורן: לא כוסות אחרות?

627
00:28:04,800 --> 00:28:05,940
דוד י מלאן: לא כוסות אחרות.

628
00:28:05,940 --> 00:28:07,860
ולי לא ממש
בדק את זה לפני השנה

629
00:28:07,860 --> 00:28:10,110
אז אני לא יודע אם זה יהיה
באמת עובדים כימי.

630
00:28:10,110 --> 00:28:16,130

631
00:28:16,130 --> 00:28:18,650
שלא היה אמור לקרות.

632
00:28:18,650 --> 00:28:19,761
האם זה עובד?

633
00:28:19,761 --> 00:28:20,260
בסדר.

634
00:28:20,260 --> 00:28:20,990
אז הפרדה?

635
00:28:20,990 --> 00:28:21,490
טוב.

636
00:28:21,490 --> 00:28:24,714
עכשיו יש לנו כדי לקבל את
מים לתוך הכוס אחרת.

637
00:28:24,714 --> 00:28:27,630
ריכוז כימיה חכם יכול
כנראה לעשות את זה יותר טוב ממני.

638
00:28:27,630 --> 00:28:28,510
>> לורן: המים זה בתחתית.

639
00:28:28,510 --> 00:28:31,910
>> דוד י מלאן: water-- שהיה
מה מפתח הפעם האחרונה שעשינו את זה.

640
00:28:31,910 --> 00:28:33,950
אתה צריך לעשות את זה בסדר הנכון.

641
00:28:33,950 --> 00:28:34,450
כן.

642
00:28:34,450 --> 00:28:35,270
זה בסדר.

643
00:28:35,270 --> 00:28:37,290
אז עכשיו יש לנו שתי כוסות של שמן.

644
00:28:37,290 --> 00:28:37,790
אוקיי.

645
00:28:37,790 --> 00:28:38,510
זה בסדר.

646
00:28:38,510 --> 00:28:40,110
אבל אם זה עבד כימי מאשר אני-

647
00:28:40,110 --> 00:28:41,200
>> לורן: זה מים.

648
00:28:41,200 --> 00:28:41,930
>> דוד י מלאן: זה בעיקר מים.

649
00:28:41,930 --> 00:28:42,430
בסדר.

650
00:28:42,430 --> 00:28:44,210
אבל זה עדיין אותו הכוס כמו קודם.

651
00:28:44,210 --> 00:28:47,570
אז לשפוך it-- לנסות את זה שם.

652
00:28:47,570 --> 00:28:49,300
אוקיי.

653
00:28:49,300 --> 00:28:51,010
זהו שימוש טוב של זמן בכיתה היום.

654
00:28:51,010 --> 00:28:51,510
אוקיי.

655
00:28:51,510 --> 00:28:53,890
אז עכשיו we-- נחמד.

656
00:28:53,890 --> 00:28:55,460
בערך.

657
00:28:55,460 --> 00:28:55,960
בסדר.

658
00:28:55,960 --> 00:28:56,690
אז מאוד טוב.

659
00:28:56,690 --> 00:29:00,006
תודה ללורן.

660
00:29:00,006 --> 00:29:01,950
מאוד יפה מאוד.

661
00:29:01,950 --> 00:29:04,570
>> אז רק כדי לפוצץ את דעתך,
וזה אולי משהו

662
00:29:04,570 --> 00:29:08,660
לשחק עם אם תרצו בזיהוי CS50,
אתה יכול, למעשה, להחליף את שני משתנים

663
00:29:08,660 --> 00:29:11,470
ללא שימוש במספר שלם זמני.

664
00:29:11,470 --> 00:29:13,060
וזה קוד C המקביל.

665
00:29:13,060 --> 00:29:16,110
ואם אתה זוכר שמעברת
יום רביעי, הצגנו, אם לזמן קצר,

666
00:29:16,110 --> 00:29:19,720
כמה מפעילים חדשים בג ועושה
מישהו זוכר מה הגזר הקטן

667
00:29:19,720 --> 00:29:23,660
סמל הוא, כי משולש קטן
סמל מהמקלדת מייצג?

668
00:29:23,660 --> 00:29:26,003
מה סיבי האופרטור מפעיל?

669
00:29:26,003 --> 00:29:26,770
>> קהל: EXOR.

670
00:29:26,770 --> 00:29:27,645
>> דוד י מלאן: EXOR.

671
00:29:27,645 --> 00:29:28,560
בלעדי או.

672
00:29:28,560 --> 00:29:32,920
אז אם אתה רוצה, רק בשביל כיף ב
בית, לתת וב שני שרירותי

673
00:29:32,920 --> 00:29:36,072
ערכים כמו כל eight-- ואני
היה בוחר ערך שמונה קצת.

674
00:29:36,072 --> 00:29:38,530
אם אתה עושה את זה עם 32 סיביות,
אתה משתעמם מהר מאוד.

675
00:29:38,530 --> 00:29:42,150
אבל רק לתת קצת שמונה
ערך זה מה ש, אחד או שניים,

676
00:29:42,150 --> 00:29:43,790
ולתת לי ב ערך דומה.

677
00:29:43,790 --> 00:29:46,810
ולאחר מכן באמצעות ההגדרה
של XOR מיום רביעי שעבר,

678
00:29:46,810 --> 00:29:52,560
חלים שלאט לאט, כל אחד מ
שמונה סיביות בכל אחד מאלה וב,

679
00:29:52,560 --> 00:29:54,980
ואז לעשות את זה בדיוק לקוד זה.

680
00:29:54,980 --> 00:29:58,170
וזה לא נכון מה
אתה רואה כאן על המסך.

681
00:29:58,170 --> 00:30:02,100
זה אכן מסתכם
לשלוש פעולות XOR

682
00:30:02,100 --> 00:30:05,910
ואיכשהו באורח פלא ו
ב יחליף תפקידים

683
00:30:05,910 --> 00:30:08,010
מבלי לאבד את כל מידע.

684
00:30:08,010 --> 00:30:11,580
>> אז טריק השמן ומים הוא
גלגול עולם אמיתי קרוב

685
00:30:11,580 --> 00:30:12,980
אני יכול לחשוב עליו כדי לחקות את זה.

686
00:30:12,980 --> 00:30:15,950
אבל זה בוודאי קל יותר
להשתמש משתנים זמני,

687
00:30:15,950 --> 00:30:16,920
כמו במקרה זה כאן.

688
00:30:16,920 --> 00:30:21,190
וגם זה הזדמנות לומר,
מדי, של מיקרו אופטימיזציה סוג זה,

689
00:30:21,190 --> 00:30:23,590
כמדען מחשב
הייתי אומר, אילו סוג של כיף

690
00:30:23,590 --> 00:30:27,060
להתרברב איך עשה את זה בלי
כמו החלפה עם משתנה נוסף,

691
00:30:27,060 --> 00:30:28,640
זה לא כל כך משכנע.

692
00:30:28,640 --> 00:30:31,619
בגלל להציל 32 סיביות, כ
במקרה של int בפועל,

693
00:30:31,619 --> 00:30:33,410
לא כל כך משכנע
במערכת שבה

694
00:30:33,410 --> 00:30:36,722
ייתכן שאתה משתמש עשרות מגה בייט
או זיכרון כזה עוד יותר בימים אלה.

695
00:30:36,722 --> 00:30:38,680
ואכן, כאשר אנו מקבלים
לקבוצת בעיה מאוחר יותר

696
00:30:38,680 --> 00:30:41,010
ואתה מיישם כישוף
בודק ואתה

697
00:30:41,010 --> 00:30:43,550
לערער לעשות זאת עם
זיכרון RAM קטן כמו זה וקצת כ

698
00:30:43,550 --> 00:30:46,820
זמן ככל האפשר על
computer-- אתה עדיין

699
00:30:46,820 --> 00:30:50,160
יש לי שבוע ליישם
it-- אתה נו-- אתה תהיה

700
00:30:50,160 --> 00:30:51,799
מאותגר כדי למזער את המשאבים הללו.

701
00:30:51,799 --> 00:30:53,840
וזה באמת רק
חובילח סמסטר זה

702
00:30:53,840 --> 00:30:57,940
שבו תוכל להיות מעודד לגלח
את אפילו הביצועים הטובים ביותר

703
00:30:57,940 --> 00:30:59,340
עולה אחר.

704
00:30:59,340 --> 00:31:02,200
>> אז יכולים what-- איך אנחנו
רואה את זה בקוד בפועל?

705
00:31:02,200 --> 00:31:04,530
תן לי ללכת קדימה עכשיו
ולפתוח את הדוגמא

706
00:31:04,530 --> 00:31:07,700
שבכוונה נקרא
לא להחליף, כי זה לא

707
00:31:07,700 --> 00:31:10,670
למעשה להחליף את המשתנים
כפי שאתה בעצם יכול לצפות.

708
00:31:10,670 --> 00:31:12,260
אז בואו נסתכל.

709
00:31:12,260 --> 00:31:17,050
הנה תכנית שאין לה CS50
ספרייה קורה, I / O סטנדרטי פשוט.

710
00:31:17,050 --> 00:31:19,560
עכשיו יש לנו אב טיפוס
להחלפה למעלה שרק

711
00:31:19,560 --> 00:31:21,540
אומר שזה חייב להיות מוגדר מאוחר יותר.

712
00:31:21,540 --> 00:31:22,550
והנה עיקרי.

713
00:31:22,550 --> 00:31:26,000
>> אני באופן שרירותי שהוקצה x ו- y,
בהתאמה, אחד הערכים ושני

714
00:31:26,000 --> 00:31:28,590
רק בגלל שהם קטנים
וקל לחשוב עליו.

715
00:31:28,590 --> 00:31:32,280
ואז יש לי רק חבורה של printfs
שבו יש לי צ'ק על שפיות. x הוא 1

716
00:31:32,280 --> 00:31:35,110
ו- y הוא 2 הוא ככל הנראה
מה printfs אלה יגיד.

717
00:31:35,110 --> 00:31:36,530
אז לא קסם עד כה.

718
00:31:36,530 --> 00:31:40,100
>> אז אני הולך לתבוע ב
להדפיס def, החלפת נקודת נקודת נקודה.

719
00:31:40,100 --> 00:31:43,730
אני הולך להתקשר להחלפה
פונקציה, עובר בx ו- y.

720
00:31:43,730 --> 00:31:47,350
ובואו נניח לעת עתה ש
החלפה מתבצעת בדיוק

721
00:31:47,350 --> 00:31:49,930
כפי שהיה לפני רגע
עם משתנה זמני.

722
00:31:49,930 --> 00:31:52,670
ואז אני טוען באומץ, החליף.

723
00:31:52,670 --> 00:31:55,429
x הוא עכשיו זה וy הוא החברה ש.

724
00:31:55,429 --> 00:31:57,220
אבל את הקובץ, כמובן,
נקרא לא להחליף.

725
00:31:57,220 --> 00:31:58,678
אז בואו באמת רואים מה קורה.

726
00:31:58,678 --> 00:32:04,450
אם אני לא לקמפל החלפה ולאחר מכן
לעשות ./noswap, x הוא 1, y הוא 2.

727
00:32:04,450 --> 00:32:05,770
החלפה החליף.

728
00:32:05,770 --> 00:32:07,200
x הוא 1, y הוא 2.

729
00:32:07,200 --> 00:32:11,980
כך זה נראה למעשה להיות פגום גם
למרות swap-- בואו לגלול למטה now--

730
00:32:11,980 --> 00:32:16,542
מיושם בדיוק ל
קוד הצעתי לפני רגע.

731
00:32:16,542 --> 00:32:19,000
אז אנחנו לא הולכים לקבל מפוארים
עם חומר XOR לעת עתה.

732
00:32:19,000 --> 00:32:21,890
גם זה, רק צריך לעבוד
כמו עם חלב וג'יי,

733
00:32:21,890 --> 00:32:25,820
אבל זה לא נראה שזה עובד.

734
00:32:25,820 --> 00:32:27,180
>> אז בואו נעשה את זה שוב.

735
00:32:27,180 --> 00:32:29,310
אולי אני פשוט לא רצתי את זה נכון.

736
00:32:29,310 --> 00:32:32,010
אז בואו לרוץ לא להחליף שוב.

737
00:32:32,010 --> 00:32:32,900
אולי אני- לא.

738
00:32:32,900 --> 00:32:34,400
אז זה פשוט לא עובד.

739
00:32:34,400 --> 00:32:36,060
אז בואו לעשות בדיקת שפיות קטנה.

740
00:32:36,060 --> 00:32:39,690
תן לי ללכת קדימה כאן בהחלפה
ורק להוסיף, חכה רגע,

741
00:32:39,690 --> 00:32:43,856
הוא אני% / n ובוא
התוספת הערך של.

742
00:32:43,856 --> 00:32:45,730
כי אני באמת רוצה
כדי לראות מה קורה.

743
00:32:45,730 --> 00:32:47,570
ואכן, זה הוא
טכניקת ניפוי

744
00:32:47,570 --> 00:32:50,028
שייתכן שאתה משתמש ב
שעות משרד או בבית כבר,

745
00:32:50,028 --> 00:32:53,560
בדומה למחצית הראשונה של דן
הווידאו של Armendariz בPSET3

746
00:32:53,560 --> 00:32:56,870
שבו אנו הצגנו הדפסת def כ
טכניקה מומלצת, לפחות

747
00:32:56,870 --> 00:32:58,080
במקרים פשוטים.

748
00:32:58,080 --> 00:33:01,720
תן לי ללכת קדימה ולרוץ לעשות
אין החלפה שוב, ./noswap.

749
00:33:01,720 --> 00:33:04,370

750
00:33:04,370 --> 00:33:05,840
>> מעניין.

751
00:33:05,840 --> 00:33:11,670
אז שם לב מה שנראה אמיתי. איקס
הוא 1, y הוא 2, אבל הוא 2 כאשר b הוא 1.

752
00:33:11,670 --> 00:33:16,790
אז שני אלה איכשהו החליפו
אבל x ו- y לא מקבלים החליפו.

753
00:33:16,790 --> 00:33:21,090
אז כדי להיות ברור, מה שקורה
הוא, כאן יש לי x ו- y

754
00:33:21,090 --> 00:33:25,380
ואלה הם משתנים מקומיים ב
היקף העיקרי, אני מעביר בx ו- y

755
00:33:25,380 --> 00:33:26,170
כדי להחליף.

756
00:33:26,170 --> 00:33:29,080
עכשיו, החלפה, כפונקציה נפרדת,
הוא חופשי להתקשר טיעוניה

757
00:33:29,080 --> 00:33:30,590
או כל דבר הפרמטרים שלו שהוא רוצה.

758
00:33:30,590 --> 00:33:33,280
Foo או בר או x או y או או ב.

759
00:33:33,280 --> 00:33:36,870
רק כדי להבהיר שהם
אינו זהה לx ו- y כשלעצמה,

760
00:33:36,870 --> 00:33:38,020
אני כבר אמרתי וב.

761
00:33:38,020 --> 00:33:40,040
אבל אנחנו יכולים לקרוא להם כל מה שאנחנו רוצים.

762
00:33:40,040 --> 00:33:43,960
>> וכך זה נראה כמו
ההחלפה מתבצעת עברה

763
00:33:43,960 --> 00:33:48,980
x-- AKA זה-- וזה
שעבר AKA ב y--.

764
00:33:48,980 --> 00:33:51,900
איכשהו שלושת קווים אלה
החלפת ערכים אלה בדיוק

765
00:33:51,900 --> 00:33:53,510
כלורן עשה עם חלב וג'יי.

766
00:33:53,510 --> 00:33:56,010
אבל כאשר אנחנו להדפיס
הערכים, A ו- B

767
00:33:56,010 --> 00:34:01,340
אכן להחליף אבל x ו
יש לי y ללא שינוים.

768
00:34:01,340 --> 00:34:03,150
נזכיר כי x ו- y הם כאן.

769
00:34:03,150 --> 00:34:05,320
>> אז אנחנו יכולים לראות את זה באמצעות
טכניקה אחרת גם כן.

770
00:34:05,320 --> 00:34:08,110
וגם זה טכניקה
משובץ בבעיה להגדיר שלוש.

771
00:34:08,110 --> 00:34:10,780
בואו נלך קדימה ולעשות את זה ב
CS50 מזהה אם אתה לא כבר יש.

772
00:34:10,780 --> 00:34:13,730
עלינו צד יד ימין
יש לי כרטיסיית Debugger זה.

773
00:34:13,730 --> 00:34:16,159
ואם אתה פותח את זה,
יש איזה מידע מסתורי

774
00:34:16,159 --> 00:34:17,530
זה שזרק אותך בהתחלה.

775
00:34:17,530 --> 00:34:19,310
אבל בואו להפריד זה ממש מהר.

776
00:34:19,310 --> 00:34:21,620
>> אז אחד, אתה רואה משתנים מקומיים.

777
00:34:21,620 --> 00:34:26,230
מתברר כי לבנות לIDE CS50, ו
הרבה סביבות פיתוח נוסף

778
00:34:26,230 --> 00:34:28,060
בדרך כלל, הוא הבאגים.

779
00:34:28,060 --> 00:34:31,340
כלי שמאפשר לך לראות באופן חזותי
מה קורה בתוך התכנית שלך

780
00:34:31,340 --> 00:34:34,380
מבלי להזדקק להוספה
printfs ועריכה והפעלה

781
00:34:34,380 --> 00:34:37,588
והוספה של printf והידור ו
ריצה, שכבר, בשעתי עבודה

782
00:34:37,588 --> 00:34:40,070
או בבית, הוא כנראה
מקבל די משעמם.

783
00:34:40,070 --> 00:34:43,090
>> אז הנה, ברגע, אנחנו
הולך לראות בזמן אמת

784
00:34:43,090 --> 00:34:44,760
הערכים של המשתנים המקומיים שלנו.

785
00:34:44,760 --> 00:34:47,880
אנחנו גם הולכים להיות מסוגלים להגדיר
מה שנקרא נקודות עצירה ש

786
00:34:47,880 --> 00:34:52,570
הזדמנויות בתכנית שלי כדי להשהות
ביצוע בשורה מסוימת של קוד

787
00:34:52,570 --> 00:34:53,710
כי אני סקרן לגבי.

788
00:34:53,710 --> 00:34:54,210
נכון?

789
00:34:54,210 --> 00:34:55,969
תוכניות אלה מנוהלות בשבריר שני.

790
00:34:55,969 --> 00:35:00,450
זה סוג של נחמד לבני אדם האיטיים
כדי להיות מסוגל להשהות, לקחת רגע, לראות

791
00:35:00,450 --> 00:35:02,380
מה שקורה סביב
קו מסוים של קוד

792
00:35:02,380 --> 00:35:05,050
ללא חריש התכנית
דרכו וסיימתי לגמרי.

793
00:35:05,050 --> 00:35:08,510
אז נקודות עצירה הולכת כדי לאפשר לנו
לשבור ולהשהות בשלב מסוים.

794
00:35:08,510 --> 00:35:12,990
>> ערימת שיחה היא דרך מפוארת של
אומר מה פונקציות כרגע

795
00:35:12,990 --> 00:35:14,140
להיקרא באותו הרגע.

796
00:35:14,140 --> 00:35:15,370
ראשי תמיד נקרא ראשון.

797
00:35:15,370 --> 00:35:17,230
אבל אם ראשי קוראים
פונקציה שנקראת החלפה,

798
00:35:17,230 --> 00:35:20,470
אנחנו באמת הולכים לראות את זה
מגדל של פונקציות שהיו

799
00:35:20,470 --> 00:35:22,400
נקרא בסדר כרונולוגי הפוכים.

800
00:35:22,400 --> 00:35:23,310
אז בואו לראות את זה.

801
00:35:23,310 --> 00:35:24,327
>> אני הולך להקטין את התצוגה.

802
00:35:24,327 --> 00:35:25,660
אני הולך לחזור לקוד שלי.

803
00:35:25,660 --> 00:35:27,540
ורק בגלל שאני רוצה
להיות קפדן כאן,

804
00:35:27,540 --> 00:35:31,100
אני הולך קדימה ולחץ
רק בצד השמאל של קו חמש.

805
00:35:31,100 --> 00:35:32,830
וזה יוצר נקודה אדומה.

806
00:35:32,830 --> 00:35:36,200
ושים לב בצד ימין
שהבאגים יודעים, היי,

807
00:35:36,200 --> 00:35:41,020
אני רק אמרתי נקודת עצירה ב
במיוחד קו noswap.c חמש,

808
00:35:41,020 --> 00:35:42,480
בקו הזה של קוד.

809
00:35:42,480 --> 00:35:45,090
אז הבאגים יודעים אני ש
ביקש שבפעם הבאה

810
00:35:45,090 --> 00:35:48,530
אני מפעיל אותו להשהות את התכנית שלי
ביצוע יש ולא רק

811
00:35:48,530 --> 00:35:50,390
מנהל את כל עסק סופר מהיר.

812
00:35:50,390 --> 00:35:53,889
>> אז עכשיו אני הולך ללחוץ על Debug
כפתור בחלקו העליון של IDE

813
00:35:53,889 --> 00:35:55,430
וזה הולך לעשות את הדברים הבאים.

814
00:35:55,430 --> 00:36:00,680
זה הולך לפתוח בתחילה מעט
מסוף שני מחפש מפחיד window--

815
00:36:00,680 --> 00:36:02,679
איתור באגים מרחוק מ
לארח כזה וsuch--

816
00:36:02,679 --> 00:36:04,970
ואנחנו נחזור למה ש
כל זה אומר שלפני זמן רב.

817
00:36:04,970 --> 00:36:09,020
אבל מה שחשוב עבור החברה
הוא שהנקודה אדומה נפגעה,

818
00:36:09,020 --> 00:36:11,735
הבאגים יש במכוון
עצרתי execution--

819
00:36:11,735 --> 00:36:15,560
לא על קו שכשלעצמם אלא בראשון
שורת קוד בפועל בתפקיד זה.

820
00:36:15,560 --> 00:36:18,040
ולכן קו שבעה הוא
עכשיו מודגש בצהוב.

821
00:36:18,040 --> 00:36:20,550
>> ועכשיו בואו נסתכל
בצד ימין.

822
00:36:20,550 --> 00:36:27,300
זה נראה כמו, כברירת מחדל,
יפה מספיק, יש x מה ערך?

823
00:36:27,300 --> 00:36:27,860
0.

824
00:36:27,860 --> 00:36:29,750
ויש לו y מה ערך?

825
00:36:29,750 --> 00:36:30,410
אפס.

826
00:36:30,410 --> 00:36:35,540
וזה צפוי במובן
שx וy-- שיש line-- הצהוב

827
00:36:35,540 --> 00:36:36,770
לא בוצע עדיין.

828
00:36:36,770 --> 00:36:38,510
אז x לא צריך את ערך 1.

829
00:36:38,510 --> 00:36:41,470
אולי יש לו כל ערך אחר,
ערך זבל שנקרא.

830
00:36:41,470 --> 00:36:44,320
והיינו לנו מזל שבזה
אפס בנקודה זו, במהות.

831
00:36:44,320 --> 00:36:46,400
>> אז עכשיו יש רק כמה
כפתורים שאנחנו צריכים לטפל

832
00:36:46,400 --> 00:36:48,100
על כאשר באגים בדרך זו.

833
00:36:48,100 --> 00:36:49,970
שימו לב כאן, יש לנו לחצן הפעלה.

834
00:36:49,970 --> 00:36:51,877
ואם נשחקנו או נפגע
לחדש, זה רק

835
00:36:51,877 --> 00:36:53,710
הולך לרוץ דרך
שאר התכנית

836
00:36:53,710 --> 00:36:55,300
או עד שהוא מגיע נקודת עצירה נוספת.

837
00:36:55,300 --> 00:36:56,910
אבל אני כבר לא קבעתי אחר
נקודות עצירה כך שזה רק

838
00:36:56,910 --> 00:36:58,118
הולך לרוץ עד הסוף.

839
00:36:58,118 --> 00:37:00,280
סוג זה של תבוסות
המטרה לחטט.

840
00:37:00,280 --> 00:37:03,290
>> אז במקום, אכפת לי
סמלים אלה בצד הימין.

841
00:37:03,290 --> 00:37:05,360
ואם אני מרחף מעל
שלהם, כפי שאתה גם צריך,

842
00:37:05,360 --> 00:37:07,450
תראה טיפים כלי tips-- קטנים.

843
00:37:07,450 --> 00:37:09,020
זה אחד הוא לדרוך על.

844
00:37:09,020 --> 00:37:11,290
עכשיו זה לא אומר שדלג
את השורה הבאה של קוד.

845
00:37:11,290 --> 00:37:14,840
זה רק אומר לבצע את זה ו
להעביר למשנהו, להעביר למשנהו,

846
00:37:14,840 --> 00:37:15,580
להעביר למשנהו.

847
00:37:15,580 --> 00:37:17,610
במילים אחרות, באמצעות
כפתור ש, אני יכול ללכת

848
00:37:17,610 --> 00:37:20,390
באמצעות הצעד שלי קוד אחד בכל פעם.

849
00:37:20,390 --> 00:37:21,914
שורה אחרת שורה, פשוטו כמשמעו.

850
00:37:21,914 --> 00:37:23,830
עכשיו, בצד הימין של
כי, יש עוד אחד

851
00:37:23,830 --> 00:37:25,163
שנראה ברגע.

852
00:37:25,163 --> 00:37:27,820
זה מה שנקרא
צעד לתוך סמל זה

853
00:37:27,820 --> 00:37:30,300
הולך כדי לאפשר לי צלילה
לפונקציה אחרת.

854
00:37:30,300 --> 00:37:31,800
אבל בואו יראו את זה ברגע.

855
00:37:31,800 --> 00:37:33,280
אז אני הולך ללחוץ לדרוך על.

856
00:37:33,280 --> 00:37:35,820
ועכשיו שם לב, כפי שאני לוחץ
לחצן זה בצד ימין למעלה,

857
00:37:35,820 --> 00:37:41,260
לשמור על העיניים שלך בערך פי מקומי
משתנים ולראות מה קורה לx.

858
00:37:41,260 --> 00:37:44,115
x הוא כעת 1 כי
קו צהוב עכשיו ביצע

859
00:37:44,115 --> 00:37:45,840
ואנחנו כבר עברנו לקו 8.

860
00:37:45,840 --> 00:37:49,840
ורק y רגע
צריך לקוות להיות 2.

861
00:37:49,840 --> 00:37:52,330
>> עכשיו, שום דבר שמעניין
קורה לקצת.

862
00:37:52,330 --> 00:37:53,390
כל זה הוא printf.

863
00:37:53,390 --> 00:37:58,010
ושים לב, במסוף המשני שלי
חלון, אני רואה את הפלט של def הדפסה.

864
00:37:58,010 --> 00:38:01,080
ועכשיו אני צריך לעשות
החלטה כמתכנת.

865
00:38:01,080 --> 00:38:04,360
אני יכול לדרוך על הקו הזה של
קוד, הרצתו אבל לא

866
00:38:04,360 --> 00:38:06,220
מקבל סקרן לגבי מה שבפנים.

867
00:38:06,220 --> 00:38:11,130
או שאני יכול באמת להיכנס לזה
ולהיכנס פנימה של החלפה עצמו.

868
00:38:11,130 --> 00:38:12,340
אז בואו נעשה את זה האחרון.

869
00:38:12,340 --> 00:38:15,550
>> תן לי ללכת קדימה ולחצו
לא שלב במהלך אבל צעד לתוך.

870
00:38:15,550 --> 00:38:17,300
שים לב, פתאום
חלון השינויים

871
00:38:17,300 --> 00:38:19,330
כדי להדגיש הראשון
שורת קוד בהחלפה.

872
00:38:19,330 --> 00:38:20,710
זהו קו 21.

873
00:38:20,710 --> 00:38:25,220
ועכשיו, מה סוג של פאנקי הוא ש,
אם אתה מסתכל על כאן, כצפוי,

874
00:38:25,220 --> 00:38:29,720
ב פסיק הוא 1 ו -2, בהתאמה.

875
00:38:29,720 --> 00:38:33,840
למה הוא זמני 32,767?

876
00:38:33,840 --> 00:38:36,560
נזכר זמני ש, בדומה
הכוס הריקה לפני רגע,

877
00:38:36,560 --> 00:38:38,980
הוא הכריז כאן על קו 21.

878
00:38:38,980 --> 00:38:43,390
למה 32,000- אני מתכוון, למה הוא
זה רק חלק הערך מוזר?

879
00:38:43,390 --> 00:38:43,890
כן?

880
00:38:43,890 --> 00:38:45,190
>> קהל: זה לא אותחל.

881
00:38:45,190 --> 00:38:46,940
>> דוד י מלאן: זה
לא אותחל.

882
00:38:46,940 --> 00:38:49,370
אז המחשב שלנו תמיד
יש זיכרון פיזי.

883
00:38:49,370 --> 00:38:50,544
תמיד יש לו זיכרון RAM הפיזי.

884
00:38:50,544 --> 00:38:52,710
ותמיד יש אפס של
ואחד שנמצא שם, נכון?

885
00:38:52,710 --> 00:38:54,626
מכיוון שאנו משתמשים
מחשב כל היום,

886
00:38:54,626 --> 00:38:57,210
אתה משתמש IDE CS50
או השרתים כל היום.

887
00:38:57,210 --> 00:39:01,159
אז RAM כי יש גם כמה אפסים או
חלק אחד של חלק או את האפסים ואחדים.

888
00:39:01,159 --> 00:39:02,950
לא משנה אם או
אתה לא משתמש בהם.

889
00:39:02,950 --> 00:39:05,270
אתה לא יכול פשוט יש לי ריק
חללים שבו אתה רוצה ביטים.

890
00:39:05,270 --> 00:39:06,850
הם גם אפסים ואחדים.

891
00:39:06,850 --> 00:39:09,610
>> אז מתברר זמני, כי
לא אנחנו כבר אותחלו את זה עדיין,

892
00:39:09,610 --> 00:39:14,580
יש לנו 32 סיביות אלה אבל יש להם לא
אותחל לכל ערכים ידועים.

893
00:39:14,580 --> 00:39:18,110
אז כל מה שהם היו רוב
בשימוש לאחרונה for-- אלה 32 bits--

894
00:39:18,110 --> 00:39:23,000
אנחנו רק רואים את החפצים של כמה
שימוש קודם של 32 בפרט אלה

895
00:39:23,000 --> 00:39:23,500
ביטים.

896
00:39:23,500 --> 00:39:27,780
ברגע שלוחץ על שלב מעל אם כי,
אוף, טמפ הוא הולך לקבל את הערך 1.

897
00:39:27,780 --> 00:39:31,600
ואם אני עושה את זה שוב, הוא
הולך להיות נתון הערך 2

898
00:39:31,600 --> 00:39:33,830
ולאחר מכן ב הולך
יינתן הערך 1.

899
00:39:33,830 --> 00:39:36,390
>> ואז מה נחמד עכשיו ב
נקודה זו של הסיפור

900
00:39:36,390 --> 00:39:39,750
הוא שהבאגים הוא
מראה לי, סופר לאט

901
00:39:39,750 --> 00:39:42,640
בקצב שלי, מה ש
המצב של החלפה הוא.

902
00:39:42,640 --> 00:39:47,490
אבל שם לב שבחלק העליון כאן, הודעה
שערימת השיחה בפועל

903
00:39:47,490 --> 00:39:49,180
יש לו שתי שכבות לזה.

904
00:39:49,180 --> 00:39:53,240
עכשיו אחד שמודגש כ
החלפה, אם אני לוחץ על ראשי במקום,

905
00:39:53,240 --> 00:39:57,100
שימו לב כמה המשתנים המקומיים לשנות
כי המפתחים פשוט יכולים לקפוץ

906
00:39:57,100 --> 00:39:59,740
סביב ולהיכנס לכל היקף שונה.

907
00:39:59,740 --> 00:40:04,070
אז למרות שאנחנו עושים את כל זה
לעבוד בצורה נכונה והחלפת A ו- B,

908
00:40:04,070 --> 00:40:09,080
אם אני הולך קדימה ואחורה בין החלפה
שבו הוא 2 ו- B הוא 1 וראשים,

909
00:40:09,080 --> 00:40:11,851
יש ראשי נפגעו בכלל?

910
00:40:11,851 --> 00:40:12,350
מס '

911
00:40:12,350 --> 00:40:13,930
אז מה takeaway כאן?

912
00:40:13,930 --> 00:40:18,200
ובכן, מתברר שכל זמן
אתה קורא לפונקציה כמו החלפה,

913
00:40:18,200 --> 00:40:21,600
ואתה עובר את טענותיו, מה ש
אתה עובר לפונקצית החלפה

914
00:40:21,600 --> 00:40:24,730
במקרה זה הוא עותק
טיעונים אלה.

915
00:40:24,730 --> 00:40:28,620
אז אם x ו- y הם כל בהתאמה
32 סיביות, מה שהחלפה הוא מקבל

916
00:40:28,620 --> 00:40:30,760
הוא מקומי שתי חדש
משתנים, או טענות,

917
00:40:30,760 --> 00:40:34,380
נקרא וb-- אבל אלה הם שרירותיים
names-- אבל הדפוס של אפסים

918
00:40:34,380 --> 00:40:39,520
ואלה בתוך A ו- B הם
בשורה לתהיה זהה לx ו- y

919
00:40:39,520 --> 00:40:42,610
אבל הם לא
אותו דבר כמו x ו- y.

920
00:40:42,610 --> 00:40:46,880
>> זה כאילו ראשי יש בחתיכה שלה
נייר המספר 1 ו -2 לx ו- y,

921
00:40:46,880 --> 00:40:49,260
ואז כשזה ידיים ש
פיסת נייר כדי להחליף,

922
00:40:49,260 --> 00:40:51,970
החלפה מקבלת מהר מאוד
העט שלו, רושם

923
00:40:51,970 --> 00:40:56,240
1 ו -2 על גיליון נייר משלו,
ידיים לגבות XY המקורי לראשים

924
00:40:56,240 --> 00:40:58,790
ואז עושה משלו
דבר עם A ו- B.

925
00:40:58,790 --> 00:41:01,940
וזה עכשיו סופר חשוב כי
יש לכך השלכות לא טריוויאלי

926
00:41:01,940 --> 00:41:06,260
לבעצם כתיבת קוד נכון
כי זה היה נראה שאנחנו לא יכולים להחליף

927
00:41:06,260 --> 00:41:07,500
שני משתנים.

928
00:41:07,500 --> 00:41:09,150
>> כתבתי פונקצית החלפה נכונה.

929
00:41:09,150 --> 00:41:12,770
אנחנו התקנו אותו עם לורן כ
פונקצית החלפה נכונה במציאות,

930
00:41:12,770 --> 00:41:16,700
אבל כנראה אף אחד שמ
עניינים אם אתה לא יכול למעשה

931
00:41:16,700 --> 00:41:19,530
להחליף שני ערכים באופן קבוע.

932
00:41:19,530 --> 00:41:21,970
אז אנחנו צריכים בדרך אחרת
כדי לקבל למעשה בשלב זה,

933
00:41:21,970 --> 00:41:24,472
ואנחנו צריכים להיות מסוגלים
למעשה לפתור את הבעיה הזו.

934
00:41:24,472 --> 00:41:27,180
ומתברר out-- ואנחנו נבוא
חזרה לתמונה מסוימת זה

935
00:41:27,180 --> 00:41:30,500
לפני long-- זו דרך אחת ש
אולי אתה מצייר זיכרון של המחשב שלך.

936
00:41:30,500 --> 00:41:31,460
זה רק מלבן.

937
00:41:31,460 --> 00:41:32,960
אתה יכול לצייר אותו בכל
מספר הדרכים אבל זה

938
00:41:32,960 --> 00:41:35,740
נוח לצייר אותו כ
מלבן מהסיבה הבאה.

939
00:41:35,740 --> 00:41:40,040
>> אנחנו הולכים להתחיל היום ומעבר
מדבר על הערימה שנקרא.

940
00:41:40,040 --> 00:41:43,870
והערימה היא רק נתח
של RAM-- נתח של memory--

941
00:41:43,870 --> 00:41:47,100
כי יש פונקציות גישה
כאשר הם נקראים.

942
00:41:47,100 --> 00:41:49,800
וכך מתברר כי ב
תחתית ערימה זו

943
00:41:49,800 --> 00:41:53,590
מקום שבו כל המשתנים המקומיים של ראשי
ו- C org וV org וכל הדברים האלה

944
00:41:53,590 --> 00:41:56,950
הולכים ללכת כברירת מחדל. ואם ראשי
קורא תפקיד אחר כמו החלפה,

945
00:41:56,950 --> 00:42:00,330
גם, החלפה הוא הולכת לקבל עוד
שכבה של זיכרון עד מעליו.

946
00:42:00,330 --> 00:42:04,490
>> וכך, רק כדי לתת לך שטחי מהירה
תמונה של זה, אם אני הולך על כאן--

947
00:42:04,490 --> 00:42:09,450
ותן לי המראה הזאת ב
מעל כ"תראה מה באמת יש לי,

948
00:42:09,450 --> 00:42:12,100
אם אכפת לנו רק על
חלק תחתון של תמונה זו לעת עתה,

949
00:42:12,100 --> 00:42:15,070
הוא שכאשר אני מפעיל את תכנית
והראשים מקבל נקראים,

950
00:42:15,070 --> 00:42:18,330
ראשי ניתן נתח של
זיכרון RAM במחשב שלי שהוא

951
00:42:18,330 --> 00:42:20,060
בתחתית ערימה זה מה שנקרא.

952
00:42:20,060 --> 00:42:22,143
ואני הולך לצייר אותו
בכוונה כריבוע.

953
00:42:22,143 --> 00:42:24,540
אז זה כמו 32 ​​סיביות או ארבעה בתים.

954
00:42:24,540 --> 00:42:28,790
ואם פונקציה העיקרית זה יש
x משתנה בשם עם ערך של 1

955
00:42:28,790 --> 00:42:32,626
ויש לה משתנה בשם
y עם הערך של 2, זה

956
00:42:32,626 --> 00:42:35,750
כמו לקחת רסיס זה של זיכרון ש
ראשי ניתנו על ידי ההפעלה

957
00:42:35,750 --> 00:42:38,850
מערכת וחלוקה אותו כך ש
משתנה המקומי הראשון הולך כאן,

958
00:42:38,850 --> 00:42:40,930
השנייה אחת הולך כאן, וזהו זה.

959
00:42:40,930 --> 00:42:45,590
>> כאשר ראשי קוראים החלפה, החלפה
מקבל פרוסת זיכרון משלו

960
00:42:45,590 --> 00:42:48,280
שאנחנו לצייר ככה
ממערכת ההפעלה,

961
00:42:48,280 --> 00:42:50,820
וזה הולך לה
מבוסס משתנים מקומיים של

962
00:42:50,820 --> 00:42:53,825
ביישום שלנו קודם לכן
עם משתנים מקומיים

963
00:42:53,825 --> 00:42:58,010
וb שתחילה
לקבל את הערכים 1 ו -2.

964
00:42:58,010 --> 00:43:00,450
אבל אז, ברגע ש
קוד החלפה מבצע,

965
00:43:00,450 --> 00:43:03,760
ולורן מחליפה למעשה
ג'יי וחלב, מה קורה?

966
00:43:03,760 --> 00:43:09,030
ובכן, 2 זה הופך 1, זה
1 הופך 2, ו, דרך אגב,

967
00:43:09,030 --> 00:43:13,360
יש משתנה זמני זה להיות
שימוש שכל הזמן שסופו של דבר

968
00:43:13,360 --> 00:43:14,470
הולך.

969
00:43:14,470 --> 00:43:16,720
אבל זה לא משנה
כמה עבודה שאתה עושה

970
00:43:16,720 --> 00:43:22,160
בשורה זו ל-- במרחב זיכרון זה,
x ו- y הם נגע לחלוטין.

971
00:43:22,160 --> 00:43:26,320
>> אז אנחנו צריכים איזו דרך הנתינה
החלפה ופונקציות כמו זה

972
00:43:26,320 --> 00:43:32,640
גישת סוד, אם תרצה, ל
פונקציות like-- לזיכרון כמו x ו- y.

973
00:43:32,640 --> 00:43:35,110
אז בואו נסתכל
דוגמא שעוזרת

974
00:43:35,110 --> 00:43:38,220
שלנו לראות בדיוק מה היה
הולך על זה כל זמן.

975
00:43:38,220 --> 00:43:40,284
אני הולך קדימה
ולפתוח השוואה אפס.

976
00:43:40,284 --> 00:43:42,200
ואני הולך לסגור
הבאגים שלנו, אני הולך

977
00:43:42,200 --> 00:43:44,360
כדי לסגור הודעה מחפשת זה מפחיד
רק אומר, חכה רגע,

978
00:43:44,360 --> 00:43:45,800
אתה באמצע הניפוי.

979
00:43:45,800 --> 00:43:48,383
אני הולך להסתיר כרטיסייה זו כאן
רק כדי לחזור לפשטות.

980
00:43:48,383 --> 00:43:50,160
אז אל תדאגו אם GDB נהרג.

981
00:43:50,160 --> 00:43:53,910
זה רק אומר שיש לו את התכנית
כבר להפסיק, בכוונה במקרה זה,

982
00:43:53,910 --> 00:43:54,820
על ידי.

983
00:43:54,820 --> 00:43:57,700
>> ועכשיו שקלו אפס עושה את זה.

984
00:43:57,700 --> 00:44:00,110
אני משתמש CS50
ספרייה בקלט / פלט סטנדרטי.

985
00:44:00,110 --> 00:44:04,319
יש לי פונקציה העיקרית שראשון
אומר, לומר משהו, ומקבל מחרוזת.

986
00:44:04,319 --> 00:44:06,110
אז אומר את זה שוב ו
מקבל מחרוזת אחרת.

987
00:44:06,110 --> 00:44:09,910
ושים לב ששתי מחרוזות אלה
נקראים ים ולא, בהתאמה.

988
00:44:09,910 --> 00:44:12,910
ועכשיו בתכנית זו, שקלו
אפס, המטרה שלה בחיים,

989
00:44:12,910 --> 00:44:15,470
זה אמור להגיד לי,
לא אני מקליד את אותו הדבר?

990
00:44:15,470 --> 00:44:16,910
ואז אני חוזר לשבוע אחד.

991
00:44:16,910 --> 00:44:19,950
אני משתמש המפעיל שווה שווה שלי
שהינה מפעילת האיכות.

992
00:44:19,950 --> 00:44:22,220
לא מפעיל המשימה,
מפעיל השוויון.

993
00:44:22,220 --> 00:44:23,890
אני רק השוואה של ולא.

994
00:44:23,890 --> 00:44:27,470
>> אז בואו באמת ללכת קדימה ולעשות את זה.

995
00:44:27,470 --> 00:44:32,680
ואני הולך קדימה
ולעשות השוואת אפס.

996
00:44:32,680 --> 00:44:35,110
אני הולך לעשות ./comparezero.

997
00:44:35,110 --> 00:44:37,150
ואני מתכוון ללכת
קדימה ולומר משהו

998
00:44:37,150 --> 00:44:43,450
כמו, בואו נעשה את אמא באותיות קטנה
ומה לגבי אמא באותיות גדולה.

999
00:44:43,450 --> 00:44:45,034
וכמובן אני מקליד דברים שונים.

1000
00:44:45,034 --> 00:44:45,533
בסדר.

1001
00:44:45,533 --> 00:44:46,570
זה היה צפוי.

1002
00:44:46,570 --> 00:44:47,640
>> בואו להפעיל אותו שוב.

1003
00:44:47,640 --> 00:44:49,740
בשתי פעמים לעשות אותיות קטנות, אותיות קטנות.

1004
00:44:49,740 --> 00:44:51,490
זה נראה סופר זהה לי.

1005
00:44:51,490 --> 00:44:52,930
הזן.

1006
00:44:52,930 --> 00:44:53,430
אוקיי.

1007
00:44:53,430 --> 00:44:55,804
אולי זה פשוט מוזר כי
זה לא לחבב את הדקדוק שלי.

1008
00:44:55,804 --> 00:44:59,930
אז בואו לעשות MOM הון,
ההון MOM, זהה.

1009
00:44:59,930 --> 00:45:01,490
דברים שונים.

1010
00:45:01,490 --> 00:45:03,907
>> אז למה זה?

1011
00:45:03,907 --> 00:45:06,240
ובכן, מה באמת הולך
במתחת למכסת המנוע כאן?

1012
00:45:06,240 --> 00:45:08,180
אז בואו נחזור על
כאן לרגע

1013
00:45:08,180 --> 00:45:10,910
ולשקול מה GetString
הוא בעצם עושה.

1014
00:45:10,910 --> 00:45:13,385
כשאתה מתקשר GetString,
זה אנחנו פונקציה

1015
00:45:13,385 --> 00:45:16,510
את עצמנו כתבנו וזה איכשהו מקבל
רצף של תווים מהמשתמש.

1016
00:45:16,510 --> 00:45:20,280
ונניח שראשון
זמן אני קורא GetString, שנותן לי

1017
00:45:20,280 --> 00:45:21,930
נתח של זיכרון שנראה כך.

1018
00:45:21,930 --> 00:45:26,990
ואם הקלדתי בכל האותיות הקטנות
מ 'O-m-- ומה שקורה אחרי זה?

1019
00:45:26,990 --> 00:45:28,840
רק בדיקת שפיות מהירה.

1020
00:45:28,840 --> 00:45:29,780
>> אפס קו נטוי.

1021
00:45:29,780 --> 00:45:30,510
אנחנו יודעים את זה.

1022
00:45:30,510 --> 00:45:32,784
וזוכרים ששחקנו
סביב עם שמו של Zamila

1023
00:45:32,784 --> 00:45:34,950
וחבורה של שמות אחרים
כאשר רוב היה כאן מחפשים

1024
00:45:34,950 --> 00:45:36,280
על מה שקורה בתוך זיכרון.

1025
00:45:36,280 --> 00:45:37,780
אז סיפור זה בדיוק אותו הדבר.

1026
00:45:37,780 --> 00:45:40,160
זה מה שGetString
חוזר אליי.

1027
00:45:40,160 --> 00:45:44,780
עכשיו, הקוד שלי רגע לפני מאוחסן
ערך ההחזרה של GetString

1028
00:45:44,780 --> 00:45:47,510
בשם של במשתנה.

1029
00:45:47,510 --> 00:45:51,390
ואז, בפעם השנייה אני קורא לזה,
זה מאוחסן בזה לא משתנה בשם.

1030
00:45:51,390 --> 00:45:55,070
>> אז אם אני הולך לכאן, אני צריך
לצייר variable-- המקומי זה

1031
00:45:55,070 --> 00:45:59,610
ואני בדרך כלל הולך ל
לצייר מחרוזת כפשוט-- שנציע ב

1032
00:45:59,610 --> 00:46:02,360
קורא לזה s-- כריבוע קטן כאן.

1033
00:46:02,360 --> 00:46:09,760
ועכשיו, somehow-- איך אמא
ללכת בתוך ים משתנה זה?

1034
00:46:09,760 --> 00:46:12,010
ובכן, אנחנו צריכים לחזור
לעקרונות הראשונים כאן.

1035
00:46:12,010 --> 00:46:15,660
מה GetString חוזר בעצם?

1036
00:46:15,660 --> 00:46:19,030
>> אז מתברר שM-O-M
קו נטוי אפס, וכל מספר

1037
00:46:19,030 --> 00:46:22,364
מיתרים אחרים בזיכרון כמו
Zamila ורוב או אנדי או כל האחרים,

1038
00:46:22,364 --> 00:46:24,280
כמובן בנו
זיכרון RAM של המחשב או זיכרון.

1039
00:46:24,280 --> 00:46:27,760
והזיכרון RAM שלך יש like-- יש לך
חלטורה של זיכרון RAM, שתי הופעות של זיכרון RAM,

1040
00:46:27,760 --> 00:46:30,860
או מיליארדים או שני מליארד בייטים,
או אולי אפילו יותר בימים אלה.

1041
00:46:30,860 --> 00:46:34,070
אז בואו נניח, למטרות של היום,
כי זה לא משנה איך אנחנו מונים

1042
00:46:34,070 --> 00:46:36,640
שלהם, אבל אנחנו יכולים למנות כל
מאותם מיליארדים או שני מיליארדים

1043
00:46:36,640 --> 00:46:37,880
או ארבעה מליארד בייטים.

1044
00:46:37,880 --> 00:46:42,240
>> ובואו רק באופן שרירותי אומרים ש
זה הביס הראשון, הנגיסה שנייה,

1045
00:46:42,240 --> 00:46:43,380
שלישי, רביעי.

1046
00:46:43,380 --> 00:46:46,570
אני לא במכוון באמצעות אפס ל
היום אבל אנחנו נחזור לזה.

1047
00:46:46,570 --> 00:46:49,570
אז במילים אחרות, אם זה
פעם הראשונה שאני משתמש בתכנית,

1048
00:46:49,570 --> 00:46:52,715
אני רק מקבל מזל וראשון
נשיכה היא במיקום אחד ואז שתי

1049
00:46:52,715 --> 00:46:53,590
אז שלושה מארבעה.

1050
00:46:53,590 --> 00:46:57,430
ואם אמשיך ציור, מספר התיבה
שני מליארד יהיו דרך לכאן.

1051
00:46:57,430 --> 00:47:02,200
>> אז מה אתה חושב, אז,
GetString חוזר בעצם?

1052
00:47:02,200 --> 00:47:06,010
זה לא חוזר קו נטוי M-O-M
אפס כשלעצמה, משום שברור

1053
00:47:06,010 --> 00:47:08,180
לא יתאים בתיבה שאני נמשך.

1054
00:47:08,180 --> 00:47:11,210
אז מה עוד יכול GetString למעשה
חוזר כל השבועות האלה?

1055
00:47:11,210 --> 00:47:14,410

1056
00:47:14,410 --> 00:47:16,820
התשובה היא ב
מנהלים כאן איפשהו.

1057
00:47:16,820 --> 00:47:20,390
אתה לא יכול להתאים קו נטוי M-O-M אפס,
אז מה יכול להיות הגיוני במקום?

1058
00:47:20,390 --> 00:47:23,424
אם היית צריך להיות סופר חכם, לשים
על כובע ההנדסה שנקרא,

1059
00:47:23,424 --> 00:47:24,340
מה אתה יכול לחזור?

1060
00:47:24,340 --> 00:47:27,340
מהו הסכום לפחות של מידע
אתה יכול לחזור כי היית עדיין

1061
00:47:27,340 --> 00:47:30,610
לך למצוא M-O-M בזיכרון?

1062
00:47:30,610 --> 00:47:31,270
כן?

1063
00:47:31,270 --> 00:47:31,950
>> קהל: אחת.

1064
00:47:31,950 --> 00:47:32,200
>> דוד י מלאן: אחת.

1065
00:47:32,200 --> 00:47:33,021
ולמה אחד?

1066
00:47:33,021 --> 00:47:35,520
קהל: כי זה הייתי אומר לי
לך לאן ללכת [לא ברור].

1067
00:47:35,520 --> 00:47:38,391

1068
00:47:38,391 --> 00:47:39,390
דוד י מלאן: בדיוק.

1069
00:47:39,390 --> 00:47:44,300
אני רק הולך להחזיר את כתובת
של המחרוזת שאני מקבל.

1070
00:47:44,300 --> 00:47:46,570
הכתובת בזה
מקרה הוא מקום אחד.

1071
00:47:46,570 --> 00:47:51,280
אז מה באמת מאוחסן בs--
וכל כך משתנה מחרוזת far--

1072
00:47:51,280 --> 00:47:53,430
רק היה
כתובת של מחרוזת ש.

1073
00:47:53,430 --> 00:47:57,840
>> בינתיים, אם אני קורא
GetString פעם שנייה ואני

1074
00:47:57,840 --> 00:48:03,300
הקלד ב, פשוטו כמשמעו, באותו thing--
M-O-M עם M-O-M lowercase--

1075
00:48:03,300 --> 00:48:06,200
וקו נטוי אחר אפס,
ועכשיו אולי התכנית שלי של

1076
00:48:06,200 --> 00:48:09,820
כבר פועל מזה זמן אז אולי זה
הוא 10, זה מיקום 11, זה 12,

1077
00:48:09,820 --> 00:48:10,700
זה 13.

1078
00:48:10,700 --> 00:48:13,590
המחשבים באמצעות כמה אחרים
זיכרון מכל סיבה.

1079
00:48:13,590 --> 00:48:18,172
מה עכשיו הולך בשני שלי
משתנה בt התכנית שלי?

1080
00:48:18,172 --> 00:48:19,390
10.

1081
00:48:19,390 --> 00:48:20,050
בדיוק.

1082
00:48:20,050 --> 00:48:23,910
>> ולכן כאשר אנו מסתכל על
קוד מקור של תכנית זו

1083
00:48:23,910 --> 00:48:26,550
שבו אני פשוט מנסה
להשוות בין שני ערכים,

1084
00:48:26,550 --> 00:48:32,180
הוא זה שווה שווה לt, מה
התשובה האנושית הברורה?

1085
00:48:32,180 --> 00:48:34,890
רק לא כי 1 לא שווה 10.

1086
00:48:34,890 --> 00:48:36,861
וכך טמון
הזדמנות עבורנו באמת

1087
00:48:36,861 --> 00:48:39,610
רק כדי לחזור ל, שוב, ראשון
עקרונות וחושבים על, ובכן,

1088
00:48:39,610 --> 00:48:41,110
מה קורה מתחת למכסת המנוע?

1089
00:48:41,110 --> 00:48:43,240
אנחנו כבר מדברים על
פיסות בתים וזיכרון,

1090
00:48:43,240 --> 00:48:46,820
אבל זה באמת שימושי כדי להבין
כי כשאתה קורא GetString,

1091
00:48:46,820 --> 00:48:50,280
למרות שאנו חושבים על זה
חוזר M-O-M או אמא מחרוזת

1092
00:48:50,280 --> 00:48:53,120
או אנדי או Zamila או
כמו, מבחינה טכנית

1093
00:48:53,120 --> 00:48:55,510
זה פשוט מחזיר את הכתובת
של נתח זה של זיכרון.

1094
00:48:55,510 --> 00:48:56,910
>> אבל זה בסדר.

1095
00:48:56,910 --> 00:49:00,570
כי איך אני יודע
איפה המחרוזת מסתיימת?

1096
00:49:00,570 --> 00:49:03,840
אם אני רק נתתי ההתחלה?

1097
00:49:03,840 --> 00:49:05,380
ובכן, הקו הנטוי אפס, נכון?

1098
00:49:05,380 --> 00:49:08,800
בדיוק בזמן ליניארי שאני יכול
להדפיס עם M-O-M def ההדפסה.

1099
00:49:08,800 --> 00:49:11,820
וברגע שאני רואה את קו נטוי
אפס, לא אכפת לי שבו התחלתי,

1100
00:49:11,820 --> 00:49:14,950
אני כבר יודע במשתמע
שבו אני צריך לסיים.

1101
00:49:14,950 --> 00:49:18,700
>> וכך היום מסמן את beginning-- ו
תן לי לעשות את זה כי אנחנו באופן דרמטי

1102
00:49:18,700 --> 00:49:21,800
עבר הרבה צרות ל
להגיע לכאן אלה הכשרת wheels--

1103
00:49:21,800 --> 00:49:29,840
אז היום את הגלגלים העזר להתחיל
לרדת ואנו חושפים בleast--

1104
00:49:29,840 --> 00:49:31,373
>> [מחיאות כפות]

1105
00:49:31,373 --> 00:49:33,220

1106
00:49:33,220 --> 00:49:36,160
>> זה היה בהחלט שווה את הנסיעה
ליעד זה בבוקר, כן?

1107
00:49:36,160 --> 00:49:39,600
אז now-- יש, מתברר
את, אין דבר כזה מחרוזת.

1108
00:49:39,600 --> 00:49:41,140
מחרוזת לא קיימת.

1109
00:49:41,140 --> 00:49:43,760
זה מילה נרדפת שהיו לנו
בתוך ספריית CS50.

1110
00:49:43,760 --> 00:49:48,660
מכאן ואילך, אנחנו הולכים להתחיל לקרוא
ים ולא לא מחרוזות אבל כוכבי char.

1111
00:49:48,660 --> 00:49:51,180
וכוכב char שנציע ב
להפריד לפני זמן רב.

1112
00:49:51,180 --> 00:49:53,510
אבל זה אומר,
כי גם אם אנו ממשיכים

1113
00:49:53,510 --> 00:49:56,180
באמצעות GetString לעכשיו,
מבחינה טכנית אני צריך

1114
00:49:56,180 --> 00:49:59,010
להיות כוכב אומר char וכוכב char.

1115
00:49:59,010 --> 00:50:01,720
>> ומתברר מה כוכב ש
הולך לציון הוא משהו

1116
00:50:01,720 --> 00:50:04,340
בשם מצביע או כתובת.

1117
00:50:04,340 --> 00:50:06,110
ולמעשה, טיזר
למה שלפנינו

1118
00:50:06,110 --> 00:50:09,760
הוא קליפ שני זה 20 משלנו
חבר ניק Parlante בסטנפורד

1119
00:50:09,760 --> 00:50:12,927
ש, לפני די הרבה זמן, לבלות
סכום מגוחך של זמן,

1120
00:50:12,927 --> 00:50:15,010
כטוב ביותר שאני יכול לומר בו
מטבח או במרתפו,

1121
00:50:15,010 --> 00:50:17,140
מה שהופך את האולפן
מציג לעולם

1122
00:50:17,140 --> 00:50:20,010
דמות בשם
בינקי שאיתם אנו יהיו

1123
00:50:20,010 --> 00:50:22,010
להיות הציג בפעם הבאה למצביעים.

1124
00:50:22,010 --> 00:50:24,588
אז הנה תצוגה מקדימה של מה לבוא.

1125
00:50:24,588 --> 00:50:26,370
>> [וידאו השמעה]

1126
00:50:26,370 --> 00:50:27,510
>> היי, בינקי.

1127
00:50:27,510 --> 00:50:28,260
התעורר.

1128
00:50:28,260 --> 00:50:30,672
זה זמן בשביל כיף מצביע.

1129
00:50:30,672 --> 00:50:31,616
>> -מה זה?

1130
00:50:31,616 --> 00:50:33,032
למד על מצביעים?

1131
00:50:33,032 --> 00:50:34,450
אה, סוכריה.

1132
00:50:34,450 --> 00:50:35,431
>> [סוף ההשמעה]

1133
00:50:35,431 --> 00:50:38,055
דוד י מלאן: ובנימה זאת,
אנו רואים אותך ביום רביעי.

1134
00:50:38,055 --> 00:50:47,590

1135
00:50:47,590 --> 00:50:48,090
בסדר.

1136
00:50:48,090 --> 00:50:48,740
מי ריקודים?

1137
00:50:48,740 --> 00:50:49,240
בחייך.

1138
00:50:49,240 --> 00:50:50,330
מי ריקודים?

1139
00:50:50,330 --> 00:50:51,820
אתה רוצה שאני לקבל את זה התחיל?

1140
00:50:51,820 --> 00:50:53,770
אני לקבל את זה התחיל.

1141
00:50:53,770 --> 00:50:54,270
Woooo!

1142
00:50:54,270 --> 00:51:04,070

1143
00:51:04,070 --> 00:51:07,580
>> לורן: מפואר מתוק משה.