1
00:00:00,000 --> 00:00:09,572

2
00:00:09,572 --> 00:00:12,030
ROB אודן: היי, אני רוב אודן,
ובואו נדבר על quiz0.

3
00:00:12,030 --> 00:00:13,280

4
00:00:13,280 --> 00:00:14,545
>> אז, השאלה ראשונה.

5
00:00:14,545 --> 00:00:17,750
זו השאלה שבי
אתה צריך לקודד את המספר

6
00:00:17,750 --> 00:00:21,270
127 בנורות בינארי.

7
00:00:21,270 --> 00:00:23,550
אם אתה רוצה, אתה יכול
לעשות את ההמרה הרגילה

8
00:00:23,550 --> 00:00:25,950
מbi-- או, מנקודה העשרונית בינארי.

9
00:00:25,950 --> 00:00:28,300
אבל זה כנראה הולך
לקחת הרבה זמן.

10
00:00:28,300 --> 00:00:31,750
אני מתכוון, אתה יכול להבין את זה,
אישור, 1 הוא שם, 2 הוא שם,

11
00:00:31,750 --> 00:00:33,650
4 הוא שם, 8 הוא שם.

12
00:00:33,650 --> 00:00:39,280
דרך קלה יותר, 127 היא 128 פחות אחד.

13
00:00:39,280 --> 00:00:42,013
שהנורה השמאלית ביותר היא האור של 128 סיביות.

14
00:00:42,013 --> 00:00:43,490

15
00:00:43,490 --> 00:00:47,860
אז 127 הוא באמת רק כל
של נורות האחרות,

16
00:00:47,860 --> 00:00:51,420
מכיוון שזה השמאלי ביותר
הנורה מינוס 1.

17
00:00:51,420 --> 00:00:52,800
זהו זה לשאלה הזאת.

18
00:00:52,800 --> 00:00:54,060
>> שאלה אחת.

19
00:00:54,060 --> 00:00:56,710
אז עם 3 חתיכות שאתה יכול
לייצג 8 ערכים שונים.

20
00:00:56,710 --> 00:01:01,000
מדוע, אם כן, הוא 7 שאינם שלילי הגדול ביותר
מספר שלם עשרוני אתה יכול לייצג?

21
00:01:01,000 --> 00:01:04,050
ובכן, אם אנחנו יכולים רק
לייצג 8 ערכים שונים,

22
00:01:04,050 --> 00:01:07,430
אז מה אנחנו הולכים להיות
מייצגים הוא 0 עד 7.

23
00:01:07,430 --> 00:01:08,745
0 לוקח את אחד מהערכים.

24
00:01:08,745 --> 00:01:09,980

25
00:01:09,980 --> 00:01:11,190
>> שאלה שתי.

26
00:01:11,190 --> 00:01:14,610
עם חתיכות n, כמה מובחן
ערכים אתה יכול לייצג?

27
00:01:14,610 --> 00:01:19,080
אז, עם חתיכות n, יש לך 2
ערכים אפשריים עבור כל ביט.

28
00:01:19,080 --> 00:01:22,300
אז יש לנו 2 ערכים אפשריים עבור
קצת הראשון, 2 ערכים אפשריים

29
00:01:22,300 --> 00:01:24,450
לשני, 2
אפשרי לשלישי.

30
00:01:24,450 --> 00:01:28,730
ואז זה 2 כפול 2 כפול 2, ו
סופו של דבר התשובה היא 2 עד n.

31
00:01:28,730 --> 00:01:30,010

32
00:01:30,010 --> 00:01:31,100
>> שאלה שלוש.

33
00:01:31,100 --> 00:01:33,450
מה 0x50 בינארי?

34
00:01:33,450 --> 00:01:39,490
אז לזכור שהקסדצימלי יש מאוד
המרה פשוטה לינארי.

35
00:01:39,490 --> 00:01:43,180
אז הנה, אנחנו רק צריכים להסתכל על
5 ו0 באופן עצמאי.

36
00:01:43,180 --> 00:01:45,110
אז מה 5 בינארי?

37
00:01:45,110 --> 00:01:48,400
0101, זה קצת 1 ו4 הביט.

38
00:01:48,400 --> 00:01:49,900
מה 0 בינארי?

39
00:01:49,900 --> 00:01:50,520
לא מסובך.

40
00:01:50,520 --> 00:01:52,180
0000.

41
00:01:52,180 --> 00:01:54,970
אז פשוט לשים אותם יחד, ו
זה המספר המלא בינארי.

42
00:01:54,970 --> 00:01:57,640
01,010,000.

43
00:01:57,640 --> 00:02:00,439
ואם אתה רוצה אתה יכול
תוריד את האפס השמאלי ביותר.

44
00:02:00,439 --> 00:02:01,105
זה לא רלוונטי.

45
00:02:01,105 --> 00:02:02,920

46
00:02:02,920 --> 00:02:05,733
>> אז לחלופין,
מה הוא 0x50 עשרוניים?

47
00:02:05,733 --> 00:02:08,649
אם אתה רוצה, אתה could-- אם אתה
יותר נוח עם בינארי,

48
00:02:08,649 --> 00:02:11,340
אתה יכול לקחת את זה תשובה בינארית
ולהמיר את זה לעשרוני.

49
00:02:11,340 --> 00:02:13,870
או שאנחנו יכולים רק לזכור
הקסדצימלי ש.

50
00:02:13,870 --> 00:02:21,140
כך ש0 הוא במקום 0-ה, ו
5 הוא ב-16 למקום הראשון.

51
00:02:21,140 --> 00:02:25,990
אז הנה, יש לנו 5 פעמים 16 ל
ראשון, בתוספת 0 פעמים 16 לאפס,

52
00:02:25,990 --> 00:02:27,520
הוא 80.

53
00:02:27,520 --> 00:02:29,710
ומי שהבטת ב
כותרת לשאלה,

54
00:02:29,710 --> 00:02:32,920
זה היה 80 CS, שהיה סוג של
רמז לתשובה לבעיה זו.

55
00:02:32,920 --> 00:02:34,460

56
00:02:34,460 --> 00:02:35,420
>> שאלה חמש.

57
00:02:35,420 --> 00:02:40,320
יש לנו תסריט Scratch זה, שהוא
חוזר 4 פעמים ריבת חמאת בוטנים.

58
00:02:40,320 --> 00:02:42,800
אז איך אנחנו עכשיו קוד שב- C?

59
00:02:42,800 --> 00:02:47,730
ובכן, יש לנו here-- החלק מודגש
הוא החלק היחיד שאתה צריך ליישם.

60
00:02:47,730 --> 00:02:51,950
אז יש לנו לולאה 4 זה לולאת 4
פעמים, ריבת חמאת בוטנים ing-printf,

61
00:02:51,950 --> 00:02:53,910
עם קו חדש הבעיה מבקשת.

62
00:02:53,910 --> 00:02:55,250

63
00:02:55,250 --> 00:02:57,490
>> שאלה שש, בעיה שריטה נוספת.

64
00:02:57,490 --> 00:03:00,210
אנחנו רואים שאנחנו נמצאים בלולאה לנצח.

65
00:03:00,210 --> 00:03:05,000
אנחנו אומרים שאני משתנה
ולאחר מכן להגדיל כל i ב- 1.

66
00:03:05,000 --> 00:03:09,580
עכשיו אנחנו רוצים לעשות את זה בC. יש
מספר דרכים שאנחנו יכולים לעשות את זה.

67
00:03:09,580 --> 00:03:12,840
כאן קרו לנו הקוד
לנצח לולאה כזמן (אמיתי).

68
00:03:12,840 --> 00:03:16,600
אז אנחנו מצהירים על המשתנה שאני, רק
כמו שהיו לנו אני משתנה בגרד.

69
00:03:16,600 --> 00:03:21,950
להכריז אני משתנה, ועד העולם
בזמן (אמיתי), אנחנו אומרים משתנים i.

70
00:03:21,950 --> 00:03:25,260
אז printf% אני- או שאתה יכול השתמשת% d.

71
00:03:25,260 --> 00:03:27,985
אנחנו אומרים שמשתנים, ו
אז להגדיל אותו, i ++.

72
00:03:27,985 --> 00:03:29,560

73
00:03:29,560 --> 00:03:30,830
>> שאלה שבע.

74
00:03:30,830 --> 00:03:35,560
עכשיו אנחנו רוצים לעשות משהו דומה מאוד
למריו נקודת ג מבעיה להגדיר אחד.

75
00:03:35,560 --> 00:03:39,110
אנחנו רוצים להדפיס hashtags אלה,
אנו רוצים להדפיס חמש

76
00:03:39,110 --> 00:03:40,700
על ידי שלושה מלבן של Hash אלה.

77
00:03:40,700 --> 00:03:41,770

78
00:03:41,770 --> 00:03:43,162
אז איך אנחנו הולכים לעשות את זה?

79
00:03:43,162 --> 00:03:45,370
ובכן, אנחנו נותנים לכם את כל
חבורה של קוד, ואתה פשוט

80
00:03:45,370 --> 00:03:47,560
צריך למלא את פונקצית רשת הדפסה.

81
00:03:47,560 --> 00:03:49,540
>> אז מה עושה PrintGrid נראה?

82
00:03:49,540 --> 00:03:51,480
ובכן אתה האחרון
רוחב והגובה.

83
00:03:51,480 --> 00:03:53,520
אז יש לנו חיצוני 4
לולאה, זה לולאה

84
00:03:53,520 --> 00:03:57,650
על כל השורות של זה
רשת שאנחנו רוצים להדפיס.

85
00:03:57,650 --> 00:04:01,250
אז יש לנו 4 הלולאה בין-מקוננת,
זה הדפסה על פני כל עמודה.

86
00:04:01,250 --> 00:04:06,210
אז עבור כל שורה, אנחנו מדפיסים ל
כל עמודה, חשיש אחת.

87
00:04:06,210 --> 00:04:10,045
ואז בסוף השורה אנחנו מדפיסים
הקו חדש יחיד ללכת לשורה הבאה.

88
00:04:10,045 --> 00:04:11,420
וזהו לכל הרשת.

89
00:04:11,420 --> 00:04:12,810

90
00:04:12,810 --> 00:04:13,675
>> שאלה שמונה.

91
00:04:13,675 --> 00:04:17,170
פונקציה כמו PrintGrid הוא אמרה
יש תופעת לוואי, אך לא חזרה

92
00:04:17,170 --> 00:04:17,670
ערך.

93
00:04:17,670 --> 00:04:19,209
הסבר את ההבחנה.

94
00:04:19,209 --> 00:04:23,080
אז זה מסתמך עליך לזכור
מה הוא תופעת לוואי.

95
00:04:23,080 --> 00:04:25,180
ובכן, תשואה value--
אנחנו יודעים PrintGrid לא

96
00:04:25,180 --> 00:04:28,180
יש ערך מוחזר, מאז
כאן זה אומר חלל.

97
00:04:28,180 --> 00:04:31,150
אז כל דבר שחוזר ריק
לא ממש מחזיר שום דבר.

98
00:04:31,150 --> 00:04:32,200

99
00:04:32,200 --> 00:04:33,620
אז מה היא תופעת הלוואי?

100
00:04:33,620 --> 00:04:36,620
ובכן, תופעת לוואי הוא
כל דבר שסוג של נמשך

101
00:04:36,620 --> 00:04:39,500
לאחר סיום הפונקציה
זה היה לא רק חזר,

102
00:04:39,500 --> 00:04:41,340
וזה לא היה רק ​​מהתשומות.

103
00:04:41,340 --> 00:04:44,970
>> כך, למשל, אולי אנחנו
לשנות משתנה גלובלי.

104
00:04:44,970 --> 00:04:46,590
זה יהיה תופעת לוואי.

105
00:04:46,590 --> 00:04:49,000
במקרה הספציפי הזה,
תופעת לוואי חשוב מאוד

106
00:04:49,000 --> 00:04:51,070
מדפיס על המסך.

107
00:04:51,070 --> 00:04:53,110
כך שהוא תופעת לוואי
יש PrintGrid ש.

108
00:04:53,110 --> 00:04:54,980
אנו מדפיסים את הדברים האלה על המסך.

109
00:04:54,980 --> 00:04:56,370
ואתה יכול לחשוב על
כי כתופעת לוואי,

110
00:04:56,370 --> 00:04:58,690
מכיוון שזה משהו ש
נמשך לאחר פונקציה זו מסתיימת.

111
00:04:58,690 --> 00:05:01,481
זה משהו שמחוץ לתחום
של פונקציה זו שסופו של דבר

112
00:05:01,481 --> 00:05:03,380
הוא להיות שונה,
תוכן של המסך.

113
00:05:03,380 --> 00:05:05,200

114
00:05:05,200 --> 00:05:05,839
>> שאלה תשע.

115
00:05:05,839 --> 00:05:07,880
קחו למשל את התכנית בהמשך,
שלמספרי שורות

116
00:05:07,880 --> 00:05:09,740
נוספו ל
לצורך דיון.

117
00:05:09,740 --> 00:05:13,480
אז בתכנית זו אנחנו רק
קורא GetString, לאחסן אותו

118
00:05:13,480 --> 00:05:16,220
בסעיף משתנה זה, ולאחר מכן
הדפסת שהים משתנה.

119
00:05:16,220 --> 00:05:16,720
אישור.

120
00:05:16,720 --> 00:05:19,090
אז להסביר למה קו אחד הוא הווה.

121
00:05:19,090 --> 00:05:20,920
h נקודת cs50 #include.

122
00:05:20,920 --> 00:05:23,820
למה אנחנו צריכים #include h נקודת cs50?

123
00:05:23,820 --> 00:05:26,180
ובכן אנחנו קוראים
GetString פונקציה,

124
00:05:26,180 --> 00:05:28,840
וGetString מוגדר
בספריית cs50.

125
00:05:28,840 --> 00:05:31,600
אז אם לא היה לנו
h נקודת cs50 #include,

126
00:05:31,600 --> 00:05:35,760
היינו מקבל כי הכרזה משתמעת
של שגיאת פונקצית GetString

127
00:05:35,760 --> 00:05:36,840
מהמהדר.

128
00:05:36,840 --> 00:05:40,110
אז אנחנו צריכים לכלול את library--
אנחנו צריכים לכלול את קובץ הכותרת,

129
00:05:40,110 --> 00:05:42,870
או לא אחר מהדר
להכיר בכך שGetString קיים.

130
00:05:42,870 --> 00:05:44,380

131
00:05:44,380 --> 00:05:46,140
>> להסביר למה קו שני נוכח.

132
00:05:46,140 --> 00:05:47,890
h נקודת io כך סטנדרטי.

133
00:05:47,890 --> 00:05:50,430
זה בדיוק אותו הדבר
כבעיה הקודמת,

134
00:05:50,430 --> 00:05:53,310
אלא שבמקום להתמודד עם
GetString, אנחנו מדברים על printf מדברים.

135
00:05:53,310 --> 00:05:56,654
אז אם אנחנו לא אומרים שאנחנו צריכים
לכלול h נקודת io הסטנדרטי,

136
00:05:56,654 --> 00:05:58,820
אז אנחנו לא יהיו מסוגלים
כדי להשתמש בפונקצית printf,

137
00:05:58,820 --> 00:06:00,653
כי מהדר
לא הייתי יודע על זה.

138
00:06:00,653 --> 00:06:01,750

139
00:06:01,750 --> 00:06:05,260
>> Why-- מה המשמעות
של החלל בקו ארבעה?

140
00:06:05,260 --> 00:06:08,010
אז הנה יש לנו int main (void).

141
00:06:08,010 --> 00:06:10,600
זה רק אומר לנו ש
לא מקבלים שורת פקודת כל

142
00:06:10,600 --> 00:06:12,280
טיעונים לעיקריים.

143
00:06:12,280 --> 00:06:17,390
זכור כי נוכל לומר int
סוגריים עיקריים int argc argv המחרוזת.

144
00:06:17,390 --> 00:06:20,400
אז הנה אנחנו רק אומרים חלל לומר שאנחנו
מתעלמים טיעוני שורת הפקודה.

145
00:06:20,400 --> 00:06:21,840

146
00:06:21,840 --> 00:06:25,225
>> להסביר, ביחס לזיכרון, בדיוק
מה GetString בקו שש חזרות.

147
00:06:25,225 --> 00:06:27,040

148
00:06:27,040 --> 00:06:31,640
GetString חוזר בלוק של
זיכרון, מערך של תווים.

149
00:06:31,640 --> 00:06:34,870
זה באמת חוזר
מצביע לתו הראשון.

150
00:06:34,870 --> 00:06:37,170
זכור כי מחרוזת היא כוכב char.

151
00:06:37,170 --> 00:06:41,360
אז ככה, שעה הוא מצביע לראשון
אופי בכל המחרוזת היא

152
00:06:41,360 --> 00:06:43,510
שהמשתמש נכנס במקלדת.

153
00:06:43,510 --> 00:06:47,070
וזיכרון שקורה להיות malloced,
כך הזיכרון שנמצא בערימה.

154
00:06:47,070 --> 00:06:49,080

155
00:06:49,080 --> 00:06:50,450
>> שאלה 13.

156
00:06:50,450 --> 00:06:51,960
קחו למשל את התכנית בהמשך.

157
00:06:51,960 --> 00:06:55,579
אז כל התכנית הזו עושה
הוא printf-ing 1 מחולק ב -10.

158
00:06:55,579 --> 00:06:57,370
אז וכאשר נערכו
, תכנית שבוצעה זה

159
00:06:57,370 --> 00:07:01,170
פלטים 0.0, למרות ש
1 מחולק ב -10 הוא 0.1.

160
00:07:01,170 --> 00:07:02,970
אז למה זה 0.0?

161
00:07:02,970 --> 00:07:05,510
ובכן, זה בגלל ש
של חלוקה של מספרים שלמים.

162
00:07:05,510 --> 00:07:08,580
אז 1 הוא מספר שלם, 10 הוא מספר שלם.

163
00:07:08,580 --> 00:07:11,980
אז 1 חלקי 10, כל מה ש
מטופל כמספרים שלמים,

164
00:07:11,980 --> 00:07:16,380
ובC, כאשר אנחנו עושים חלוקה של מספרים שלמים,
אנחנו לחתוך כל נקודה עשרונית.

165
00:07:16,380 --> 00:07:19,590
אז 1 חלקי 10 הוא
0, ולאחר מכן אנחנו מנסים

166
00:07:19,590 --> 00:07:24,410
להדפיס כי כלצוף, כך
אפס מודפס כמצוף הוא 0.0.

167
00:07:24,410 --> 00:07:27,400
ובגלל זה אנחנו מקבלים 0.0.

168
00:07:27,400 --> 00:07:28,940
>> קחו למשל את התכנית בהמשך.

169
00:07:28,940 --> 00:07:31,280
עכשיו אנחנו מדפיסים 0.1.

170
00:07:31,280 --> 00:07:34,280
אז לא חלוקה של מספרים שלמים,
אנחנו רק הדפסת 0.1,

171
00:07:34,280 --> 00:07:37,100
אבל אנחנו מדפיסים אותו
עד 28 ספרות אחרי נקודה עשרוניות.

172
00:07:37,100 --> 00:07:41,810
ואנחנו מקבלים 0.1000 זה, כל חבורה
של אפסים, 5 5 5, בלה בלה בלה.

173
00:07:41,810 --> 00:07:45,495
אז השאלה כאן היא מדוע עושה את זה
להדפיס כי, במקום בדיוק 0.1?

174
00:07:45,495 --> 00:07:46,620

175
00:07:46,620 --> 00:07:49,640
>> אז הסיבה כאן היא עכשיו
צף חוסר דיוק נקודה.

176
00:07:49,640 --> 00:07:53,410
זכור כי לצוף הוא רק 32 סיביות.

177
00:07:53,410 --> 00:07:57,540
לכן אנחנו רק יכולים לייצג מספר סופי
של ערכי נקודה צפה עם 32 אלה

178
00:07:57,540 --> 00:07:58,560
ביטים.

179
00:07:58,560 --> 00:08:01,760
ובכן יש סופו של דבר לאין שיעור
ערכי נקודה צפו רבים,

180
00:08:01,760 --> 00:08:04,940
ויש רבים לאין שיעור צף
ערכי נקודה שבבין 0 ו -1,

181
00:08:04,940 --> 00:08:07,860
ואנחנו כמובן יכולים
מייצג עוד יותר ערכים מזה.

182
00:08:07,860 --> 00:08:13,230
אז אנחנו צריכים להקריב קורבנות ל
תוכל לייצג את רוב הערכים.

183
00:08:13,230 --> 00:08:16,960
>> אז ערך כמו 0.1, ככל הנראה
אנחנו לא יכולים לייצג כי בדיוק.

184
00:08:16,960 --> 00:08:22,500
אז במקום לייצג 0.1 אנחנו עושים
הכי טוב שאנחנו יכולים לייצג 0.100000 5 5 זה

185
00:08:22,500 --> 00:08:23,260
5.

186
00:08:23,260 --> 00:08:26,306
וזה די קרוב, אבל
עבור הרבה יישומים

187
00:08:26,306 --> 00:08:28,430
אתה צריך לדאוג
צף חוסר דיוק נקודה,

188
00:08:28,430 --> 00:08:30,930
בגלל שאנחנו פשוט לא יכולים לייצג
צפה כולם נקודות בדיוק.

189
00:08:30,930 --> 00:08:32,500

190
00:08:32,500 --> 00:08:33,380
>> שאלה 15.

191
00:08:33,380 --> 00:08:34,679
קחו למשל את הקוד שלהלן.

192
00:08:34,679 --> 00:08:36,630
אנחנו רק הדפסת 1 פלוס 1.

193
00:08:36,630 --> 00:08:38,289
לכן אין שום טריק כאן.

194
00:08:38,289 --> 00:08:41,780
1 פלוס 1 מעריך 2, ו
אז אנחנו מדפיסים ש.

195
00:08:41,780 --> 00:08:42,789
זה פשוט מדפיס 2.

196
00:08:42,789 --> 00:08:43,850

197
00:08:43,850 --> 00:08:44,700
>> שאלה 16.

198
00:08:44,700 --> 00:08:49,450
עכשיו אנחנו מדפיסים את התו
1 בתוספת האופי 1.

199
00:08:49,450 --> 00:08:52,110
אז למה עושה את זה לא
להדפיס את אותו הדבר?

200
00:08:52,110 --> 00:08:57,680
ובכן האופי 1 בתוספת האופי
1, יש לו את האופי 1 ערך ASCII 49.

201
00:08:57,680 --> 00:09:04,840
אז זה באמת אומר 49 בתוספת 49, ו
סופו של דבר זה הולך להדפיס 98.

202
00:09:04,840 --> 00:09:06,130
אז זה לא מדפיס 2.

203
00:09:06,130 --> 00:09:08,070

204
00:09:08,070 --> 00:09:09,271
>> שאלה 17.

205
00:09:09,271 --> 00:09:11,520
השלם את היישום
של מוזר מתחת בצורה כזאת

206
00:09:11,520 --> 00:09:14,615
שהפונקציה מחזירה אמת אם
n הוא מוזר ושגוי, אם n הוא אפילו.

207
00:09:14,615 --> 00:09:16,710

208
00:09:16,710 --> 00:09:19,330
זוהי מטרה גדולה
למפעיל mod.

209
00:09:19,330 --> 00:09:24,530
אז אנחנו לוקחים n הטיעון שלנו,
אם n mod 2 שווה 1, גם

210
00:09:24,530 --> 00:09:28,030
זה אומר שמחולק n
על ידי 2 הייתה שארית.

211
00:09:28,030 --> 00:09:33,270
אם נחלק n על ידי 2 הייתה שארית, ש
משמעות הדבר היא כי n הוא מוזר, ואנחנו חוזרים אמיתיים.

212
00:09:33,270 --> 00:09:34,910
עוד אנחנו בתמורת שווא.

213
00:09:34,910 --> 00:09:39,070
אתה גם יכול לעשות n mod 2 שווים
אפס, בתמורת שווא, אחר לחזור נכון.

214
00:09:39,070 --> 00:09:41,600

215
00:09:41,600 --> 00:09:43,640
>> קחו למשל את הפונקציה רקורסיבית להלן.

216
00:09:43,640 --> 00:09:46,920
אז אם n הוא פחות או
שווה ל 1, 1 חזור,

217
00:09:46,920 --> 00:09:50,430
תמורה אחרת n פעמים f של n מינוס 1.

218
00:09:50,430 --> 00:09:52,556
אז מה היא פונקציה זו?

219
00:09:52,556 --> 00:09:54,305
ובכן, זה פשוט
פונקצית עצרת.

220
00:09:54,305 --> 00:09:55,410

221
00:09:55,410 --> 00:09:57,405
זה יפה מיוצג
כעצרת n.

222
00:09:57,405 --> 00:09:58,720

223
00:09:58,720 --> 00:10:02,310
>> אז שאלה של 19 עכשיו, אנחנו רוצים
לקחת פונקציה רקורסיבית זה.

224
00:10:02,310 --> 00:10:04,530
אנחנו רוצים לעשות את זה איטרטיבי.

225
00:10:04,530 --> 00:10:05,874
אז איך אנחנו עושים את זה?

226
00:10:05,874 --> 00:10:07,790
ובכן לצוות
פתרון, ושוב יש

227
00:10:07,790 --> 00:10:11,090
דרכים רבות שהיה יכול לעשות
כי, אנחנו מתחילים עם מוצר int זה

228
00:10:11,090 --> 00:10:11,812
שווה 1.

229
00:10:11,812 --> 00:10:13,520
וכל אותו
ללולאה, אנחנו הולכים

230
00:10:13,520 --> 00:10:17,590
להכפלת מוצר לסופו של דבר
בסופו של העצרת המלאה.

231
00:10:17,590 --> 00:10:21,870
אז לint i שווה 2, הוא אני
קטן או שווה ל- n, i ++.

232
00:10:21,870 --> 00:10:24,130
>> ייתכן שאתה תוהה למה אני שווה 2.

233
00:10:24,130 --> 00:10:28,380
ובכן, תזכור שיש לנו כאן ל
לוודא מקרה הבסיס שלנו הוא נכון.

234
00:10:28,380 --> 00:10:32,180
אז אם n הוא פחות או שווה
ל1, אנחנו רק חוזרים 1.

235
00:10:32,180 --> 00:10:34,830
אז כאן, אנחנו מתחילים בi שווה 2.

236
00:10:34,830 --> 00:10:39,090
ובכן, אם אני היה 1, ולאחר מכן the-- או
אם n היה 1, ולאחר מכן ללולאה

237
00:10:39,090 --> 00:10:40,600
לא לבצע בכלל.

238
00:10:40,600 --> 00:10:43,190
ואז אנחנו פשוט הייתם
מוצר תמורה, שהוא 1.

239
00:10:43,190 --> 00:10:45,920
באופן דומה, אם n היו
כל דבר פחות מ1--

240
00:10:45,920 --> 00:10:49,290
אם זה היו 0, מינוס 1, whatever--
היינו עדיין אחזור 1,

241
00:10:49,290 --> 00:10:52,260
וזה בדיוק מה
גרסה רקורסיבית עושה.

242
00:10:52,260 --> 00:10:54,660
>> עכשיו, אם n הוא גדול יותר
מ 1, אז אנחנו הולכים

243
00:10:54,660 --> 00:10:56,550
לעשות לפחות אחד
איטרציה של לולאה זה.

244
00:10:56,550 --> 00:11:00,630
אז בואו נגיד שn הוא 5, אז אנחנו
הולכים לעשות פעמים מוצר שווה 2.

245
00:11:00,630 --> 00:11:02,165
אז עכשיו מוצר הוא 2.

246
00:11:02,165 --> 00:11:04,040
עכשיו אנחנו הולכים לעשות
פעמים מוצר שווה 3.

247
00:11:04,040 --> 00:11:04,690
עכשיו זה 6.

248
00:11:04,690 --> 00:11:07,500
פעמים מוצר שווה 4, עכשיו זה 24.

249
00:11:07,500 --> 00:11:10,420
פעמים מוצר שווה 5, עכשיו זה 120.

250
00:11:10,420 --> 00:11:16,730
אז סופו של דבר, אנחנו חוזרים
120, שהוא בצורה נכונה 5 עצרת.

251
00:11:16,730 --> 00:11:17,510
>> שאלה 20.

252
00:11:17,510 --> 00:11:22,480
זה אחד שבו אתה צריך למלא
בטבלה זו עם כל אלגוריתם נתון,

253
00:11:22,480 --> 00:11:25,735
כל דבר שאנחנו רואים, ש
מתאים אלה אלגוריתמיים ריצה

254
00:11:25,735 --> 00:11:28,060
פעמים לרוץ פעמים אסימפטוטית אלה.

255
00:11:28,060 --> 00:11:33,270
אז מה הוא אלגוריתם ש
הוא אומגה של 1, אבל O הגדול של n?

256
00:11:33,270 --> 00:11:35,970
אז יכול להיות שיש לאין שיעור
תשובות רבות כאן.

257
00:11:35,970 --> 00:11:39,790
אחד שראינו כנראה הכי
לעתים קרובות הוא רק חיפוש ליניארי.

258
00:11:39,790 --> 00:11:42,050
>> אז במקרה הטוב
תרחיש, הפריט שאנחנו

259
00:11:42,050 --> 00:11:44,050
מחפש ב
תחילתה של הרשימה

260
00:11:44,050 --> 00:11:47,400
וכך באומגה של 1 צעדים,
הדבר הראשון שאנחנו בודקים,

261
00:11:47,400 --> 00:11:49,740
אנחנו פשוט באופן מיידי לחזור
שמצאנו את הפריט.

262
00:11:49,740 --> 00:11:52,189
במקרה הגרוע ביותר,
הפריט הוא בסופו של הדבר,

263
00:11:52,189 --> 00:11:53,730
או הפריט אינו ברשימה בכלל.

264
00:11:53,730 --> 00:11:56,700
אז יש לנו לחפש
כל הרשימה, כל n

265
00:11:56,700 --> 00:11:58,480
אלמנטים, ולכן זה O של n.

266
00:11:58,480 --> 00:11:59,670

267
00:11:59,670 --> 00:12:04,880
>> אז עכשיו זה משהו שהוא גם
אומגה של n n יומן, וO הגדול של n n יומן.

268
00:12:04,880 --> 00:12:08,650
ובכן הדבר הרלוונטי ביותר
שראינו כאן הוא מיון מיזוג.

269
00:12:08,650 --> 00:12:12,950
אז למזג סוג, לזכור,
סופו של הדבר תטא

270
00:12:12,950 --> 00:12:16,920
של n n יומן, שבו תטא מוגדר
אם שתי אומגה וO הגדול הם אותו הדבר.

271
00:12:16,920 --> 00:12:17,580
שני n להתחבר n.

272
00:12:17,580 --> 00:12:18,690

273
00:12:18,690 --> 00:12:21,970
>> מה משהו שהוא אומגה
של n, ו- O של n בריבוע?

274
00:12:21,970 --> 00:12:23,990
ובכן, שוב יש
תשובות אפשריות רבות.

275
00:12:23,990 --> 00:12:26,440
כאן אנו לקרות לומר מיון בועות.

276
00:12:26,440 --> 00:12:28,840
מיון ההכנסה גם יעבוד כאן.

277
00:12:28,840 --> 00:12:31,400
זכור כי מיון בועות
יש אופטימיזציה שבי,

278
00:12:31,400 --> 00:12:34,630
אם אתה יכול לקבל
לאורך כל הרשימה

279
00:12:34,630 --> 00:12:37,402
ללא צורך לעשות
כל עסקות החלף, ולאחר מכן, גם,

280
00:12:37,402 --> 00:12:40,110
אנחנו יכולים מייד לחזור ש
הרשימה מוינה מלכתחילה.

281
00:12:40,110 --> 00:12:43,185
אז במקרה הטוב,
זה רק אומגה של n.

282
00:12:43,185 --> 00:12:45,960
אם זה לא רק יפה
מסודרים על רשימה מלכתחילה,

283
00:12:45,960 --> 00:12:48,270
אז יש לנו O של n בריבוע חילופים.

284
00:12:48,270 --> 00:12:49,330

285
00:12:49,330 --> 00:12:55,610
ולבסוף, יש לנו מיון בחירה
עבור n בריבוע, שניהם אומגה וO. הגדול

286
00:12:55,610 --> 00:12:56,850
>> שאלה 21.

287
00:12:56,850 --> 00:12:58,870
מה גלישת מספר שלם?

288
00:12:58,870 --> 00:13:02,160
ובכן שוב, דומה לקודם לכן,
יש לנו מספר הסופי של ביטים בלבד

289
00:13:02,160 --> 00:13:04,255
לייצג מספר שלם,
אז אולי 32 סיביות.

290
00:13:04,255 --> 00:13:06,300

291
00:13:06,300 --> 00:13:09,180
בואו נגיד שיש לנו מספר שלם שנחתם.

292
00:13:09,180 --> 00:13:12,800
אז סופו של דבר הגבוה ביותר
מספר חיובי שאנחנו יכולים לייצג

293
00:13:12,800 --> 00:13:15,910
הוא 2 עד 31 מינוס 1.

294
00:13:15,910 --> 00:13:19,370
אז מה קורה אם אנו מנסים
אז להגדיל מספר שלם ש?

295
00:13:19,370 --> 00:13:25,320
ובכן, אנחנו הולכים ללכת בין 2 ל 31
מינוס 1, כל הדרך למטה עד 2 שליליים

296
00:13:25,320 --> 00:13:26,490
ליום 31 ב.

297
00:13:26,490 --> 00:13:29,470
אז גלישת מספר שלם זה
כאשר אתה להגדיל כל,

298
00:13:29,470 --> 00:13:32,330
וסופו של דבר אתה לא יכול
מקבל רק יותר גבוה, וזה

299
00:13:32,330 --> 00:13:34,520
עוטף את כל הדרך חזרה
סביב לערך שלילי.

300
00:13:34,520 --> 00:13:35,850

301
00:13:35,850 --> 00:13:37,779
>> מה לגבי הצפת מאגר?

302
00:13:37,779 --> 00:13:39,820
אז חיץ overflow--
זוכר מה הוא חיץ.

303
00:13:39,820 --> 00:13:41,000
זה פשוט גוש של זיכרון.

304
00:13:41,000 --> 00:13:43,350
משהו כמו מערך הוא חיץ.

305
00:13:43,350 --> 00:13:46,120
אז גלישת מאגר היא כאשר
אתה מנסה לגשת לזיכרון

306
00:13:46,120 --> 00:13:47,880
מעבר לסוף המערך ש.

307
00:13:47,880 --> 00:13:50,410
אז אם יש לך
מערך של גודל 5 ואתה

308
00:13:50,410 --> 00:13:53,700
תנסה לגשת הסוגר מערך
5 או 6 או הסוגר הסוגר 7,

309
00:13:53,700 --> 00:13:56,610
או כל דבר מעבר ל
סוף, או אפילו כל דבר

310
00:13:56,610 --> 00:14:00,790
תושבת מערך below-- 1-- שליליות
כל אלה הם גולש חיץ.

311
00:14:00,790 --> 00:14:02,810
אתה נוגע בזיכרון בדרכים רעות.

312
00:14:02,810 --> 00:14:04,090

313
00:14:04,090 --> 00:14:04,730
>> שאלה 23.

314
00:14:04,730 --> 00:14:05,760

315
00:14:05,760 --> 00:14:09,100
אז בזה שאתה צריך
ליישם strlen.

316
00:14:09,100 --> 00:14:11,630
ואנו אומרים לך שאתה יכול
להניח של לא יהיה ריק,

317
00:14:11,630 --> 00:14:13,790
ולכן אין לך
לעשות בדיקה כלשהי לnull.

318
00:14:13,790 --> 00:14:16,190
ויש דרכים רבות
אתה יכול לעשות את זה.

319
00:14:16,190 --> 00:14:18,440
כאן אנחנו פשוט לקחת את פשוטים.

320
00:14:18,440 --> 00:14:21,780
אנחנו מתחילים עם דלפק, n. n הוא
לספור כמה תווים יש.

321
00:14:21,780 --> 00:14:25,560
אז אנחנו מתחילים ב 0, ולאחר מכן אנו
לחזר על כל הרשימה.

322
00:14:25,560 --> 00:14:29,092
>> האם הסוגר של 0 שווה ל
אופי שליחות קטלנית null?

323
00:14:29,092 --> 00:14:31,425
זכור שאנחנו מחפשים
אופי שליחות קטלנית null

324
00:14:31,425 --> 00:14:33,360
כדי לקבוע כמה זמן המחרוזת שלנו היא.

325
00:14:33,360 --> 00:14:35,890
כי הוא הולך לסיים
כל מחרוזת רלוונטית.

326
00:14:35,890 --> 00:14:39,400
אז הוא הסוגר של 0 שווים
לשליחות קטלנית null?

327
00:14:39,400 --> 00:14:42,850
אם זה לא, אז אנחנו הולכים ל
להסתכל של תושבת 1, של התושבת 2.

328
00:14:42,850 --> 00:14:45,050
אנחנו ממשיכים לנסוע עד ש
למצוא את שליחות קטלנית null.

329
00:14:45,050 --> 00:14:48,580
ברגע שמצאנו אותו, ואז n מכיל
האורך הכולל של המחרוזת,

330
00:14:48,580 --> 00:14:49,942
ואנחנו יכולים רק לחזור ש.

331
00:14:49,942 --> 00:14:51,180

332
00:14:51,180 --> 00:14:51,865
>> שאלה 24.

333
00:14:51,865 --> 00:14:53,010

334
00:14:53,010 --> 00:14:56,050
אז זה אחד שבו אתה
צריך לעשות את הסחר.

335
00:14:56,050 --> 00:14:59,810
אז דבר אחד טוב באחד
דרך, אבל באיזה אופן זה רע?

336
00:14:59,810 --> 00:15:02,980
אז הנה, מיון המיזוג נוטה
להיות מהיר יותר ממיון בועות.

337
00:15:02,980 --> 00:15:06,530
אחרי שאמר את that-- גם, יש
תשובות מרובות כאן.

338
00:15:06,530 --> 00:15:12,930
אבל העיקרי שבן הוא מיון בועות
הוא אומגה של n לרשימה ממוינת.

339
00:15:12,930 --> 00:15:14,950
>> זכור את השולחן שרק שראינו קודם לכן.

340
00:15:14,950 --> 00:15:17,600
אז בועה ממיינת אומגה של
n, במקרה הטוב

341
00:15:17,600 --> 00:15:20,010
הוא שזה יכול רק לעבור על
הרשימה פעם אחת, לקבוע

342
00:15:20,010 --> 00:15:22,270
היי הדבר הזה הוא כבר
מסודרים, וחזרה.

343
00:15:22,270 --> 00:15:25,960
מיון מיזוג, לא משנה מה
אתה עושה, הוא אומגה של n n יומן.

344
00:15:25,960 --> 00:15:29,200
אז לרשימה ממוינת, בועה
סוג זה הולך להיות מהיר יותר.

345
00:15:29,200 --> 00:15:30,870

346
00:15:30,870 --> 00:15:32,430
>> עכשיו מה לגבי רשימות מקושרות?

347
00:15:32,430 --> 00:15:36,070
אז רשימה מקושרת יכולה לגדול ולהתכווץ
כדי שיתאים לאלמנטים לפי צורך.

348
00:15:36,070 --> 00:15:38,489
אחרי שאמר את that-- כך
בדרך כלל ההשוואה הישירה

349
00:15:38,489 --> 00:15:40,280
הולך להיות קשור
רשימה עם מערך.

350
00:15:40,280 --> 00:15:41,600

351
00:15:41,600 --> 00:15:44,050
אז למרות שמערכים יכולים
בקלות לגדול ולהתכווץ

352
00:15:44,050 --> 00:15:47,130
כדי שיתאים לאלמנטים רבים
במידת צורך, קשור רשימה

353
00:15:47,130 --> 00:15:49,600
בהשוואה לarray--
יש מערך גישה אקראית.

354
00:15:49,600 --> 00:15:52,960
אנחנו יכולים מדד לכל
אלמנט מסוים של המערך.

355
00:15:52,960 --> 00:15:56,430
>> אז לרשימה מקושרת, אנחנו לא יכולים
פשוט ללכת לאלמנט החמישי,

356
00:15:56,430 --> 00:16:00,260
אנחנו צריכים לעבור מההתחלה
עד שנגיע לאלמנט החמישי.

357
00:16:00,260 --> 00:16:03,990
וזה הולך כדי למנוע מאתנו
עושה משהו כמו חיפוש בינארי.

358
00:16:03,990 --> 00:16:08,150
אם כבר מדברים על החיפוש בינארי חיפוש, בינארי
נוטה להיות מהיר יותר מאשר החיפוש ליניארי.

359
00:16:08,150 --> 00:16:11,120
אחרי שאמר את that--
כך, דבר אחד אפשרי

360
00:16:11,120 --> 00:16:13,380
הוא שאתה לא יכול לעשות בינארי
חיפוש ברשימות מקושרות,

361
00:16:13,380 --> 00:16:14,730
אתה יכול לעשות את זה רק על מערכים.

362
00:16:14,730 --> 00:16:18,030
אבל כנראה וחשוב יותר,
אתה לא יכול לעשות חיפוש בינארי

363
00:16:18,030 --> 00:16:20,690
במערך שאינו ממוין.

364
00:16:20,690 --> 00:16:23,990
מראש שאולי אתה צריך למיין
המערך, ורק אז יכול

365
00:16:23,990 --> 00:16:25,370
אתה עושה את החיפוש בינארי.

366
00:16:25,370 --> 00:16:27,660
אז אם הקטע שלכם הוא לא
מיון מלכתחילה,

367
00:16:27,660 --> 00:16:29,250
אז החיפוש ליניארי יכול להיות מהיר יותר.

368
00:16:29,250 --> 00:16:30,620

369
00:16:30,620 --> 00:16:31,740
>> שאלה 27.

370
00:16:31,740 --> 00:16:34,770
לכן קחו בחשבון את התכנית מתחת,
אשר יהיה בשקופית הבאה.

371
00:16:34,770 --> 00:16:37,790
ואת זה הוא אחד שבו אנחנו
הולך רוצה להצהיר באופן מפורש

372
00:16:37,790 --> 00:16:39,980
הערכים עבור משתנים שונים.

373
00:16:39,980 --> 00:16:41,990
אז בואו נסתכל על זה.

374
00:16:41,990 --> 00:16:43,160
>> אז בשורה אחת.

375
00:16:43,160 --> 00:16:45,457
יש לנו x int שווה 1.

376
00:16:45,457 --> 00:16:47,040
זה הדבר היחיד שקרה.

377
00:16:47,040 --> 00:16:50,440
אז בשורה אחת, שאנו רואים בנו
שולחן, y ש, a, b, וtmp כל

378
00:16:50,440 --> 00:16:51,540
הושחר.

379
00:16:51,540 --> 00:16:52,280
אז מה הוא X?

380
00:16:52,280 --> 00:16:53,860
ובכן אנחנו פשוט להגדיר את זה שווה ל -1.

381
00:16:53,860 --> 00:16:55,020

382
00:16:55,020 --> 00:16:58,770
ולאחר מכן בשורה שתיים, גם,
אנו רואים כי y מוגדר 2,

383
00:16:58,770 --> 00:17:00,550
והשולחן הוא כבר
מילאתי ​​את מקומנו.

384
00:17:00,550 --> 00:17:03,040
אז x הוא 1 ו- Y הוא 2.

385
00:17:03,040 --> 00:17:05,890
>> עכשיו, קו שלוש, אנחנו עכשיו
בתוך פונקצית swap.

386
00:17:05,890 --> 00:17:07,560
מה עשה לעבור כדי להחליף?

387
00:17:07,560 --> 00:17:11,609
עברנו x אמפרסנד ל
, ו- y אמפרסנד לב.

388
00:17:11,609 --> 00:17:15,160
איפה הבעיה קודם לכן
ציין כי כתובתו של x

389
00:17:15,160 --> 00:17:17,520
הוא 0x10, ואת הכתובת של y היא 0x14.

390
00:17:17,520 --> 00:17:18,970

391
00:17:18,970 --> 00:17:21,909
אז A ו- B שווה ל
0x10 ו0x14, בהתאמה.

392
00:17:21,909 --> 00:17:23,670

393
00:17:23,670 --> 00:17:26,250
>> עכשיו בקו שלושה, מה הם x ו- y?

394
00:17:26,250 --> 00:17:28,554
ובכן, שום דבר לא השתנה
על x ו- y בנקודה זו.

395
00:17:28,554 --> 00:17:30,470
למרות שהם
בתוך מסגרת ערימה העיקרית,

396
00:17:30,470 --> 00:17:32,469
עדיין יש להם את אותו
ערכים שהם עשו לפני.

397
00:17:32,469 --> 00:17:34,030
אנחנו לא שונה כל זיכרון.

398
00:17:34,030 --> 00:17:35,710
אז x הוא 1, y הוא 2.

399
00:17:35,710 --> 00:17:36,550

400
00:17:36,550 --> 00:17:37,050
בְּסֵדֶר.

401
00:17:37,050 --> 00:17:40,300
אז עכשיו אנחנו אמרתי tmp int שווה לככב.

402
00:17:40,300 --> 00:17:44,410
אז בקו ארבעה, כל מה ש
הוא אותו הדבר מלבד tmp.

403
00:17:44,410 --> 00:17:47,130
לא שינינו את כל ערכים
של כל דבר פרט לtmp.

404
00:17:47,130 --> 00:17:49,230
אנו מציבים tmp שווה לככב.

405
00:17:49,230 --> 00:17:50,620
מה הוא כוכב?

406
00:17:50,620 --> 00:17:56,240
ובכן, נקודות לx, אז כוכב
הולך x שווה, שהוא 1.

407
00:17:56,240 --> 00:18:00,080
אז כל מה שמועתק
מטה, וtmp מוגדר 1.

408
00:18:00,080 --> 00:18:01,110
>> עכשיו השורה הבאה.

409
00:18:01,110 --> 00:18:03,380
כוכבים שווים כוכב ב.

410
00:18:03,380 --> 00:18:10,000
זאת על ידי קו five-- גם שוב, כל מה ש
הוא אותו הדבר מלבד מה שכוכב הוא.

411
00:18:10,000 --> 00:18:10,830
מה הוא כוכב?

412
00:18:10,830 --> 00:18:13,720
ובכן, אנחנו פשוט אמרו כוכב הוא x.

413
00:18:13,720 --> 00:18:16,400
אז אנו משנים x לב כוכב שווה.

414
00:18:16,400 --> 00:18:18,960
מהו כוכב ב? y. נקודות ב ל Y.

415
00:18:18,960 --> 00:18:21,030
אז כוכב b הוא y.

416
00:18:21,030 --> 00:18:25,140
אז אנחנו קביעת x שווה ל- y,
וכל דבר אחר הוא זהה.

417
00:18:25,140 --> 00:18:29,130
כך אנו רואים בשורה הבאה שx הוא עכשיו
2, והשאר פשוט העתיק קודם.

418
00:18:29,130 --> 00:18:31,120
>> עכשיו בשורה הבאה, כוכב ב שווה tmp.

419
00:18:31,120 --> 00:18:34,740
ובכן, אנחנו פשוט אמרו כוכב b הוא y,
לכן אנחנו קביעת y שווה לtmp.

420
00:18:34,740 --> 00:18:37,450
כל השאר הוא אותו הדבר,
ככה הכול מועתק.

421
00:18:37,450 --> 00:18:42,050
אנחנו קביעת y שווה לTMP, שהוא
אחד, וכל דבר אחר הוא זהה.

422
00:18:42,050 --> 00:18:43,210
>> עכשיו סוף סוף, קו שבע.

423
00:18:43,210 --> 00:18:44,700
אנחנו שוב בפונקציה העיקרית.

424
00:18:44,700 --> 00:18:46,350
אנחנו אחרי ההחלפה נגמרה.

425
00:18:46,350 --> 00:18:48,972
אבד לנו, ב, ו
tmp, אבל סופו של דבר אנחנו

426
00:18:48,972 --> 00:18:51,180
לא משנים את כל ערכים
של דבר, בשלב זה,

427
00:18:51,180 --> 00:18:52,800
אנחנו פשוט להעתיק x ולמטה y.

428
00:18:52,800 --> 00:18:56,490
ואנו רואים כי x ו- y הם
עכשיו 2 ו 1 במקום 1 ו -2.

429
00:18:56,490 --> 00:18:58,160
ההחלפה ביצעה בהצלחה.

430
00:18:58,160 --> 00:18:59,500

431
00:18:59,500 --> 00:19:00,105
>> שאלה 28.

432
00:19:00,105 --> 00:19:01,226

433
00:19:01,226 --> 00:19:03,100
נניח שאתה נתקל ב
הודעות השגיאה

434
00:19:03,100 --> 00:19:06,790
להלן בשעתי עבודה
בשנה הבאה כCA או TF.

435
00:19:06,790 --> 00:19:08,930
לייעץ איך לתקן את כל השגיאות האלה.

436
00:19:08,930 --> 00:19:11,160
התייחסות כל כך לא מוגדרת לGetString.

437
00:19:11,160 --> 00:19:12,540
מדוע אתה עשוי לראות את זה?

438
00:19:12,540 --> 00:19:15,380
ובכן, אם תלמיד משתמש
GetString בקוד שלהם,

439
00:19:15,380 --> 00:19:20,310
הם כראוי לי חשיש כלול cs50
h הנקודה לכלול את ספריית cs50.

440
00:19:20,310 --> 00:19:22,380
>> ובכן, מה לעשות שהם
צריך לתקן את השגיאה?

441
00:19:22,380 --> 00:19:26,810
הם צריכים לעשות lcs50 מקף ב
שורת הפקודה כאשר הם קומפילציה.

442
00:19:26,810 --> 00:19:29,501
אז אם הם לא עברו את
lcs50 מקף צלצול, הם

443
00:19:29,501 --> 00:19:32,000
לא הולך להיות בפועל
קוד המיישם GetString.

444
00:19:32,000 --> 00:19:33,190

445
00:19:33,190 --> 00:19:34,170
>> שאלה 29.

446
00:19:34,170 --> 00:19:36,190
במרומז הכרזה
פונקצית ספריית strlen.

447
00:19:36,190 --> 00:19:37,550

448
00:19:37,550 --> 00:19:40,360
ובכן זה עכשיו, יש להם לא
עשיתי את החשיש הנכון כולל.

449
00:19:40,360 --> 00:19:41,440

450
00:19:41,440 --> 00:19:45,410
במקרה הספציפי הזה, בקובץ הכותרת
הם צריכים לכלול הוא h נקודת מחרוזת,

451
00:19:45,410 --> 00:19:48,710
ובכלל זה h נקודת מחרוזת, עכשיו
student-- עכשיו מהדר

452
00:19:48,710 --> 00:19:51,750
יש לו גישה ל
הצהרות של strlen,

453
00:19:51,750 --> 00:19:54,120
והוא יודע שהקוד שלך
הוא strlen באמצעות צורה נכונה.

454
00:19:54,120 --> 00:19:55,380

455
00:19:55,380 --> 00:19:56,580
>> שאלה 30.

456
00:19:56,580 --> 00:20:00,240
המרות אחוזים יותר
מאשר טיעוני נתונים.

457
00:20:00,240 --> 00:20:01,540
אז מה זה?

458
00:20:01,540 --> 00:20:06,470
זוכר היטב שאחוזים אלה
signs-- איך הן רלוונטיות לprintf.

459
00:20:06,470 --> 00:20:08,890
אז בprintf אולי percent--
אולי להדפיס משהו

460
00:20:08,890 --> 00:20:11,380
כמו אחוזים i קו נטוי n.

461
00:20:11,380 --> 00:20:15,310
או שאולי אנחנו להדפיס כמו שאני אחוזים,
מרחב, אני אחוזים, חלל, אחוזים אני.

462
00:20:15,310 --> 00:20:18,950
אז לכל אחד מאלה
סימני אחוזים, אנחנו צריכים

463
00:20:18,950 --> 00:20:21,560
להעביר משתנה בסופו של printf.

464
00:20:21,560 --> 00:20:26,980
>> אז אם אנחנו אומרים אחוזים סוגר printf
אני קו נטוי קרובים n סוגריים,

465
00:20:26,980 --> 00:20:30,270
בסדר, אנחנו אומרים שאנחנו
הולך להדפיס מספר שלם,

466
00:20:30,270 --> 00:20:33,970
אבל אז אנחנו לא עוברים printf
מספר שלם כדי להדפיס בפועל.

467
00:20:33,970 --> 00:20:37,182
אז הנה עוד אחוזים
המרות מאשר טיעוני הנתונים?

468
00:20:37,182 --> 00:20:39,390
זה אומר שיש לנו
חבורה שלמה של אחוזים,

469
00:20:39,390 --> 00:20:42,445
ואין לנו מספיק משתנים
למעשה כדי למלא באחוזים אלה.

470
00:20:42,445 --> 00:20:44,850

471
00:20:44,850 --> 00:20:50,010
>> ואז בהחלט, לשאלה 31,
בהחלט איבד 40 בתים באחד בלוקים.

472
00:20:50,010 --> 00:20:52,350
אז זה טעות Valgrind.

473
00:20:52,350 --> 00:20:54,720
זה אומר ש
אי שם בקוד שלך,

474
00:20:54,720 --> 00:20:59,010
יש לך הקצאה שהיא 40
בתים גדולים, כך שmalloced 40 בתים,

475
00:20:59,010 --> 00:21:00,515
ואתה אף פעם לא שחרר אותו.

476
00:21:00,515 --> 00:21:02,480

477
00:21:02,480 --> 00:21:05,140
סביר להניח שאתה פשוט צריך
למצוא דליפת זיכרון,

478
00:21:05,140 --> 00:21:07,650
ולמצוא בו אתה צריך
לשחרר את הבלוק הזה של זיכרון.

479
00:21:07,650 --> 00:21:08,780

480
00:21:08,780 --> 00:21:11,910
>> ושאלה 32,
כתיבה לא חוקית של גודל 4.

481
00:21:11,910 --> 00:21:13,250
שוב זה שגיאת Valgrind.

482
00:21:13,250 --> 00:21:15,440
זה לא צריך לעשות
עם דליפות זיכרון עכשיו.

483
00:21:15,440 --> 00:21:20,750
זה, רוב likely-- אני מתכוון, זה
איזה זכויות זיכרון לא חוקיות.

484
00:21:20,750 --> 00:21:23,270
וסביר להניח שזה חלק
סוג של הצפת מאגר.

485
00:21:23,270 --> 00:21:26,560
איפה יש לך מערך, אולי
מערך של מספרים שלמים, ובוא

486
00:21:26,560 --> 00:21:30,115
אומר שזה בגודל 5, ואתה
מנסה לגעת הסוגר מערך 5.

487
00:21:30,115 --> 00:21:34,150
אז אם אתה מנסה לכתוב של
הערך, שלא פיסת הזיכרון

488
00:21:34,150 --> 00:21:37,440
כי בעצם יש לך גישה ל, ו
כך שאתה הולך לקבל את השגיאה הזו,

489
00:21:37,440 --> 00:21:39,272
אומר כתיבה לא חוקית של גודל 4.

490
00:21:39,272 --> 00:21:42,480
Valgrind הולך להכיר לך
מנסה לגעת בזיכרון בצורה בלתי הולמת.

491
00:21:42,480 --> 00:21:43,980
>> וזהו לquiz0.

492
00:21:43,980 --> 00:21:47,065
אני רוב אודן, וזה CS50.

493
00:21:47,065 --> 00:21:51,104