1
00:00:00,000 --> 00:00:00,487

2
00:00:00,487 --> 00:00:11,210
>> [השמעת מוסיקה]

3
00:00:11,210 --> 00:00:12,100
>> ROB בודן: בסדר.

4
00:00:12,100 --> 00:00:15,620
לכן, דבר הראשון ראשון, של וידאו
מפרצוף מוכר.

5
00:00:15,620 --> 00:00:22,080

6
00:00:22,080 --> 00:00:22,560
>> [וידאו השמעה]

7
00:00:22,560 --> 00:00:23,370
>> -בסדר.

8
00:00:23,370 --> 00:00:27,150
זה CS50, וזה
תחילת השבוע שלושה.

9
00:00:27,150 --> 00:00:29,980
אני מצטער אני לא יכול להיות שם איתך
היום, אך הרשה לי להציג

10
00:00:29,980 --> 00:00:32,880
של רוב בודן של CS50.

11
00:00:32,880 --> 00:00:33,872
>> [השמעת וידאו END]

12
00:00:33,872 --> 00:00:39,340
>> [מחיאות כפות וקריאות עידוד]

13
00:00:39,340 --> 00:00:41,277
>> ROB בודן: הסרטים ב
וידאו כי הוא פנטסטי.

14
00:00:41,277 --> 00:00:47,280

15
00:00:47,280 --> 00:00:47,770
בסדר.

16
00:00:47,770 --> 00:00:50,960
אז קודם כל, יש ארוחת צהריים אחר.

17
00:00:50,960 --> 00:00:52,330
זה מחר בשעה 1:15.

18
00:00:52,330 --> 00:00:54,480
אין ארוחת צהריים ביום שישי הקרוב.

19
00:00:54,480 --> 00:00:55,810
זה עם Quora.

20
00:00:55,810 --> 00:01:00,190
וטומי עדיין לא כאן, אבל אחד
אנשים שיש CF לשעבר הראש,

21
00:01:00,190 --> 00:01:01,530
טומי McWilliam.

22
00:01:01,530 --> 00:01:02,730
אז הוא בחור כיף.

23
00:01:02,730 --> 00:01:04,819
אתה צריך לבוא.

24
00:01:04,819 --> 00:01:05,900
>> בסדר.

25
00:01:05,900 --> 00:01:11,360
אז בשבוע שעבר, התחלנו מתפרקים
על מה מחרוזת באמת.

26
00:01:11,360 --> 00:01:14,830
אנחנו מכירים מאז תחילת ש
זה רצף של תווים.

27
00:01:14,830 --> 00:01:18,130
אבל בשבוע שעבר, אנחנו התעמקתי בעובדה
כי מה הוא באמת רצף של

28
00:01:18,130 --> 00:01:22,110
דמויות, טוב, עכשיו יש לנו
מערכים של תווים.

29
00:01:22,110 --> 00:01:26,450
ואנחנו יודעים שמחרוזת, זה מערך
של דמויות, ממש בסוף,

30
00:01:26,450 --> 00:01:30,920
יש לנו הבתים null המיוחדים הזה, זה
קו נטוי הפוך 0, המציין את סוף

31
00:01:30,920 --> 00:01:32,230
המחרוזת.

32
00:01:32,230 --> 00:01:36,970
>> וכך מחרוזת היא מערך של
דמויות, אבל יכול להיות לנו יותר מ

33
00:01:36,970 --> 00:01:39,530
רק מערך של תווים,
יכול להיות לנו מערך של כל

34
00:01:39,530 --> 00:01:40,890
סוג של דבר שאנחנו רוצים.

35
00:01:40,890 --> 00:01:51,570
לכן, אם אתם זוכרים משבוע שעבר,
גילאי תכנית שהציג דוד

36
00:01:51,570 --> 00:01:53,560
ממש מהר.

37
00:01:53,560 --> 00:01:57,010
דבר אז קודם כל אנחנו הולכים לעשות הוא
לשאול את המשתמש למספר שלם,

38
00:01:57,010 --> 00:01:58,800
מספר האנשים בחדר.

39
00:01:58,800 --> 00:02:01,260
ברגע שיש לנו מספר שלם,
אנחנו מכריזים מערך.

40
00:02:01,260 --> 00:02:02,890
שים לב תחביר סוגר זה.

41
00:02:02,890 --> 00:02:04,540
אתה הולך להתרגל לזה.

42
00:02:04,540 --> 00:02:09,430
>> אז אנחנו מכריזים על מערך של משתנה
נקרא גילים, ויש n

43
00:02:09,430 --> 00:02:12,080
מספרים שלמים במערך זה.

44
00:02:12,080 --> 00:02:16,480
אז דפוס זה ממש כאן, int 4 זה
אני שווה 0, הוא שאני פחות מ n, i בתוספת

45
00:02:16,480 --> 00:02:20,580
בתוספת, שהוא גם הולך להיות דפוס
שאתה מקבל מאוד בעבר.

46
00:02:20,580 --> 00:02:24,000
כי זה פחות או יותר איך אתה
תמיד הולך לחזר על מערכים.

47
00:02:24,000 --> 00:02:26,330
אז לזכור כי n הוא
אורכו של המערך שלנו.

48
00:02:26,330 --> 00:02:32,120
וכן כאן, אנו מבקשים שוב ושוב
לגיל שלי אדם בחדר.

49
00:02:32,120 --> 00:02:36,640
>> אחרי זה, אנחנו יורדים, ועל כל מה
סיבה שרירותית, שלאחר מכן

50
00:02:36,640 --> 00:02:40,220
להדפיס את הבנים כמה הם הולכים
להיות שנה מעכשיו.

51
00:02:40,220 --> 00:02:49,980
והפעלת תכנית ש, בואי
להפוך גילים, מנקדים גילים נטויים.

52
00:02:49,980 --> 00:02:53,010
אז מספר האנשים בחדר,
נניח שיש שלוש.

53
00:02:53,010 --> 00:02:59,880
ואומר, האדם הראשון הוא 13,
הבא הוא 26, והאחרון הוא 30.

54
00:02:59,880 --> 00:03:05,080
אז זה יהיה לחזר על שלושה אלה
אנשים, להדפיס 14 החוצה, 27, ויום 31.

55
00:03:05,080 --> 00:03:16,060
>> אז לזכור שכאשר אנו מצהירים
מערך בגודל n, המדדים שב

56
00:03:16,060 --> 00:03:19,950
מערך, יש לו את המערך ערכים ו
מדדי 0, 1, 2, כל הדרך

57
00:03:19,950 --> 00:03:21,680
עד n מינוס 1.

58
00:03:21,680 --> 00:03:26,255
לכן, כאשר אנו אמרתי שיש שלושה אנשים
בחדר, ואנחנו מכניסים לפה

59
00:03:26,255 --> 00:03:29,850
איטרציה הראשונה תעבור את זה
לולאה, אני הולך להיות 0.

60
00:03:29,850 --> 00:03:31,650
אז במדד 0.

61
00:03:31,650 --> 00:03:34,540
אנו מקצים הראשונים
גיל משתמש המזין.

62
00:03:34,540 --> 00:03:38,870
אז בפעם הבאה, אנחנו נכנסים
שני n משתמש מזין, וב

63
00:03:38,870 --> 00:03:40,580
לצד שני, n האחרון.

64
00:03:40,580 --> 00:03:44,200
>> אז שם לב שמערך של גודל
שלוש אין שום דבר

65
00:03:44,200 --> 00:03:46,040
במדד בשלוש.

66
00:03:46,040 --> 00:03:49,036
זו אינה בתוקף.

67
00:03:49,036 --> 00:03:50,250
בסדר.

68
00:03:50,250 --> 00:03:55,136
אז, חוזר כאן.

69
00:03:55,136 --> 00:03:57,650

70
00:03:57,650 --> 00:04:01,590
אז עכשיו שיש לנו עסק עם מערכים,
יש לנו כמה היכרות.

71
00:04:01,590 --> 00:04:03,780
עכשיו אנחנו הולכים לעבור לפקודה
שורת טענות, אשר הולכים להיות

72
00:04:03,780 --> 00:04:05,890
די רלוונטי לקבוצה את הבעיה הזו.

73
00:04:05,890 --> 00:04:09,670
>> אז עד עכשיו, בכל פעם שיש לך
הכריז הפונקציה העיקרית שלך, יש לנו

74
00:04:09,670 --> 00:04:11,230
אמר void main int.

75
00:04:11,230 --> 00:04:14,070
אז הריק רק אומר כי
אנחנו לא עוברים כל

76
00:04:14,070 --> 00:04:16,440
טיעונים לפונקציה זו.

77
00:04:16,440 --> 00:04:19,190
עכשיו אנחנו הולכים לראות עיקריים ש
יכול לקחת כמה טיעונים.

78
00:04:19,190 --> 00:04:22,470
כאן אנחנו קוראים להם int argc
וסוגר argv מחרוזת.

79
00:04:22,470 --> 00:04:26,930
בסוגריים, שוב, מה שמצביעים
עם מערכים שיש לנו עסק.

80
00:04:26,930 --> 00:04:31,850
אז הנה, בסוגריים argv המחרוזת, אנחנו
התמודדות עם מערך של מחרוזות.

81
00:04:31,850 --> 00:04:35,360
אז argc, שהולך להצביע
כמה טיעונים שיש לנו

82
00:04:35,360 --> 00:04:37,580
עבר לתכנית זו.

83
00:04:37,580 --> 00:04:46,050
ולראות מה זה אומר,
בואו נסגור את זה.

84
00:04:46,050 --> 00:04:46,490
>> על אישור.

85
00:04:46,490 --> 00:04:50,790
אז עד עכשיו, יש לנו לרוץ בכל
תכנית כמו גילאי לוכסן נקודה.

86
00:04:50,790 --> 00:04:55,250
אנחנו יכולים גם, בשורת הפקודה, בעבר
להעביר טיעונים, ולכן המונח, פקודה

87
00:04:55,250 --> 00:04:56,550
שורת טענות.

88
00:04:56,550 --> 00:04:59,760
אז הטענה הראשונה, שלום עולם.

89
00:04:59,760 --> 00:05:03,350
אז הנה, argc יהיה שלוש.

90
00:05:03,350 --> 00:05:07,720
זה הספירה של הטיעונים
בשורת הפקודה.

91
00:05:07,720 --> 00:05:12,840
Argc הוא תמיד לפחות 1, שכן נקודה
סלאש גילים, עצמו, נחשב כאחד

92
00:05:12,840 --> 00:05:14,490
טיעוני שורת הפקודה.

93
00:05:14,490 --> 00:05:17,010
>> אז שלום הוא הראשון.

94
00:05:17,010 --> 00:05:20,460
אם גילאי לוכסן נקודה הוא האפס, ולאחר מכן
שלום הוא ראשון, והעולם הוא

95
00:05:20,460 --> 00:05:22,830
ויכוח שורת הפקודה שני.

96
00:05:22,830 --> 00:05:29,490
אז argv המחרוזת, אנחנו הולכים לראות,
מכיל מחרוזות, לוכסן הנקודה

97
00:05:29,490 --> 00:05:33,830
גיליו, הלו, ועולם.

98
00:05:33,830 --> 00:05:38,945
ו, לפי בקשתו של דוד, אנחנו הולכים
לשחק וידאו מציג את זה.

99
00:05:38,945 --> 00:05:42,486

100
00:05:42,486 --> 00:05:43,890
>> [וידאו השמעה]

101
00:05:43,890 --> 00:05:46,240
>> -עד עכשיו בתוכניות שיש לנו
כתב, יש לנו להכריז

102
00:05:46,240 --> 00:05:48,500
void main int כעיקרי.

103
00:05:48,500 --> 00:05:51,170
וכל הזמן הזה, יש חלל ש
פשוט היה לציין כי

104
00:05:51,170 --> 00:05:54,430
תכנית אינה לוקחת כל
טיעוני שורת הפקודה.

105
00:05:54,430 --> 00:05:57,750
במילים אחרות, כאשר משתמש מפעיל
תכנית, הוא או היא יכולה לספק הפקודה

106
00:05:57,750 --> 00:06:01,710
טיעוני שורה על ידי כתיבה נוספת
מילות או ביטויים לאחר התכנית

107
00:06:01,710 --> 00:06:03,000
שם בשורת הפקודה.

108
00:06:03,000 --> 00:06:06,550
>> ובכן, אם אין לך אתה רוצה את התכנית שלך ל
לקחת טיעוני שורת הפקודה, אחד או

109
00:06:06,550 --> 00:06:10,540
עוד מילות כאלה, אנחנו צריכים להחליף
לבטל עם כמה טיעונים.

110
00:06:10,540 --> 00:06:12,200
אז בואו לעשות את זה.

111
00:06:12,200 --> 00:06:15,750
כולל CS50.h.

112
00:06:15,750 --> 00:06:19,360
כולל io.h. הסטנדרטי

113
00:06:19,360 --> 00:06:20,760
Int הראשי.

114
00:06:20,760 --> 00:06:26,330
ועכשיו, במקום הריק, אני הולך
תציין int נקרא argc, ו

115
00:06:26,330 --> 00:06:28,780
מערך של מחרוזות הנקראות argv.

116
00:06:28,780 --> 00:06:31,820
עכשיו, argc ו argv הוא
פשוט אמנות.

117
00:06:31,820 --> 00:06:34,000
>> אנחנו יכולים קראנו טיעונים אלה
רוב מה שאנחנו רוצים.

118
00:06:34,000 --> 00:06:37,630
אבל מה שחשוב הוא שargc הוא
int כי, בהגדרה, הוא

119
00:06:37,630 --> 00:06:41,360
הולך להכיל את ספירת הוויכוח,
מספר המילים בסך הכל ש

120
00:06:41,360 --> 00:06:43,380
המשתמש הקליד בשורת הפקודה שלו או שלה.

121
00:06:43,380 --> 00:06:47,910
argv, בינתיים, וקטור ויכוח, הוא
באמת הולך להיות מערך אחסון

122
00:06:47,910 --> 00:06:52,020
את כל המילים שיש למשתמש
הקליד בשורת הפקודה שלו או שלה.

123
00:06:52,020 --> 00:06:54,500
>> בואו להמשיך לעשות משהו עכשיו
עם אחד או יותר מאלה

124
00:06:54,500 --> 00:06:55,660
טיעוני שורת הפקודה.

125
00:06:55,660 --> 00:07:00,070
בפרט, בואו נלך קדימה והדפסה
מה מילת המשתמש מקליד

126
00:07:00,070 --> 00:07:03,960
אחרי השם של התכנית
בשורת הפקודה.

127
00:07:03,960 --> 00:07:04,730
סוגר פתוח.

128
00:07:04,730 --> 00:07:06,240
סוגר על סגור.

129
00:07:06,240 --> 00:07:10,510
קו נטוי הפוך אחוזים printf ים ופסיק.

130
00:07:10,510 --> 00:07:14,550
ועכשיו אני צריך להגיד לי printf מה ערך
כדי לחבר אל מציין מיקום זה.

131
00:07:14,550 --> 00:07:18,600
אני רוצה את המילה הראשונה שיש למשתמש
הקליד אחרי השם של התכנית,

132
00:07:18,600 --> 00:07:23,130
ואז אני הולך כדי לציין
argv סוגר 1, קרוב

133
00:07:23,130 --> 00:07:24,830
סוגריים, פסיק.

134
00:07:24,830 --> 00:07:27,290
>> עכשיו, למה סוגר סוגר 1 ולא 0?

135
00:07:27,290 --> 00:07:30,990
ובכן, מתברר, מאוחסן באופן אוטומטי
בargv 0 הולכים להיות

136
00:07:30,990 --> 00:07:32,620
השם האמיתי של התכנית.

137
00:07:32,620 --> 00:07:36,180
אז המילה הראשונה שהמשתמש מקליד
אחרי השם של התכנית הוא, על ידי

138
00:07:36,180 --> 00:07:38,990
אמנה, הולך להיות
מאוחסן בargv 1.

139
00:07:38,990 --> 00:07:42,380
בואו עכשיו לקמפל ו
להפעיל את התכנית.

140
00:07:42,380 --> 00:07:47,780
>> הפוך argv 0, argv לוכסן נקודת 0.

141
00:07:47,780 --> 00:07:50,520
ועכשיו מילה כמו שלום.

142
00:07:50,520 --> 00:07:51,670
Enter.

143
00:07:51,670 --> 00:07:53,520
ויש לנו את זה, הלו.

144
00:07:53,520 --> 00:07:55,750
>> [השמעת וידאו END]

145
00:07:55,750 --> 00:07:57,000
>> ROB בודן: בסדר.

146
00:07:57,000 --> 00:07:59,380

147
00:07:59,380 --> 00:08:01,230
סגור את זה.

148
00:08:01,230 --> 00:08:16,730
אז לוקח תסתכל על תכנית ש
אנחנו פשוט גם הצגנו לנו,, רק

149
00:08:16,730 --> 00:08:24,710
להראות, אם אנחנו להדפיס argv 0, לעשות, עכשיו
מה זה, argv 0, argv לוכסן נקודת 0.

150
00:08:24,710 --> 00:08:30,440
אז, כצפוי, הוא מדפיס את
שמה של התכנית, שכן argv 0 הוא

151
00:08:30,440 --> 00:08:32,970
תמיד הולך להיות
שם של התכנית.

152
00:08:32,970 --> 00:08:35,640
אבל בואו נעשה משהו
קצת יותר מעניין.

153
00:08:35,640 --> 00:08:42,080
>> אז בסט הבעיה, אתה תהיה
הציג לפונקציה, atoi זה.

154
00:08:42,080 --> 00:08:44,440
אז מה אנחנו משתמשים atoi ל?

155
00:08:44,440 --> 00:08:48,550
זה הולך להמיר
מחרוזת למספר שלם.

156
00:08:48,550 --> 00:08:53,280
אז אם אני עובר את המחרוזת, אחת שתיים שלוש,
לatoi, זה יהיה להמיר את זה

157
00:08:53,280 --> 00:08:56,910
למספר השלם, אחת שתיים שלוש.

158
00:08:56,910 --> 00:09:01,480
אז אנחנו הולכים להמיר הראשונים
ויכוח שורת הפקודה למספר שלם,

159
00:09:01,480 --> 00:09:05,690
ואז פשוט להדפיס מספר שלם.

160
00:09:05,690 --> 00:09:09,680
>> אז בעצם, אנחנו סוג של
מחדש של getint, רק

161
00:09:09,680 --> 00:09:12,350
מספר השלם נכנס בפקודת
קו במקום בתכנית

162
00:09:12,350 --> 00:09:14,560
באופן אינטראקטיבי.

163
00:09:14,560 --> 00:09:23,170
אז, מה שהופך argv 0, בואו נעשיתי את
זה כאן, ולסגור את זה.

164
00:09:23,170 --> 00:09:27,670
אז פועל argv 0, ובואו להיכנס
מספר שלם, אחת שתיים שלוש ארבע אחת שתיים.

165
00:09:27,670 --> 00:09:30,840
אז זה יהיה להדפיס את המספר השלם, אחד
שתיים שלושה ארבעה אחת שתיים.

166
00:09:30,840 --> 00:09:35,500
יש כמה דקויות לatoi כי
זה יהיה להפסיק לדאוג לכל דבר

167
00:09:35,500 --> 00:09:39,040
מעבר לאופי מספרי חוקי,
אבל זה לא משנה.

168
00:09:39,040 --> 00:09:42,870
>> אז מה אתה חושב שקורה
אם אני עושה את זה?

169
00:09:42,870 --> 00:09:45,520

170
00:09:45,520 --> 00:09:47,050
אשמת פילוח.

171
00:09:47,050 --> 00:09:50,410
אז למה זה?

172
00:09:50,410 --> 00:09:56,060
אם אתה מסתכל אחורה על התכנית שלנו, אנחנו
המרת argv 1, הטענה הראשונה

173
00:09:56,060 --> 00:09:59,610
לאחר את שם התכנית, למספר שלם.

174
00:09:59,610 --> 00:10:03,350
אבל אין ויכוח עבר
לאחר שם התכנית.

175
00:10:03,350 --> 00:10:08,060
אז הנה, אנחנו רואים שמדובר בעגלה
תכנית, שכן, אם ננסה להפעיל אותו

176
00:10:08,060 --> 00:10:10,530
ללא כל ויכוחים
זה פשוט יתרסק.

177
00:10:10,530 --> 00:10:16,950
>> אז עוד דפוס נפוץ תראה
הוא משהו כמו, אם argc הוא פחות

178
00:10:16,950 --> 00:10:21,100
משני, המצביעים על כך שלא היה
לפחות את שם התכנית ו

179
00:10:21,100 --> 00:10:29,100
טענה ראשונה, אז אנחנו נעשה משהו
כמו printf, לא מספיק

180
00:10:29,100 --> 00:10:31,190
טיעוני שורת הפקודה.

181
00:10:31,190 --> 00:10:33,170
זה כנראה לא אחד טוב כדי להדפיס,
זה כנראה משהו, כמו

182
00:10:33,170 --> 00:10:35,440
אתה צריך להיכנס למספר שלם
בשורת הפקודה.

183
00:10:35,440 --> 00:10:37,450
אני רק בסופו של אותו שם.

184
00:10:37,450 --> 00:10:39,600
ולאחר מכן לחזור 1.

185
00:10:39,600 --> 00:10:44,740
אז לזכור שבסופו שלנו
תכנית, אם אנחנו חוזרים 0, זה סוג של

186
00:10:44,740 --> 00:10:47,060
מצביע על הצלחה.

187
00:10:47,060 --> 00:10:50,940
ועיקרי גם באופן אוטומטי
מחזיר 0 אם לא.

188
00:10:50,940 --> 00:10:55,800
>> אז הנה, אנחנו retuning 1 כדי לציין
שזה לא הצלחה.

189
00:10:55,800 --> 00:11:01,000
ואתה יכול להחזיר את מה שאתה רוצה,
פשוט, 0 מציין הצלחה, ו

190
00:11:01,000 --> 00:11:03,390
כל דבר אחר מצביע על כישלון.

191
00:11:03,390 --> 00:11:04,855
אז בואו להפעיל גרסה זו של דברים.

192
00:11:04,855 --> 00:11:12,880

193
00:11:12,880 --> 00:11:16,600
אז עכשיו, אם אנחנו לא נכנסים לשורת הפקודה
ויכוח, זה יהיה נכון להגיד לי

194
00:11:16,600 --> 00:11:18,290
שלנו, לא שורת הפקודה מספיק.

195
00:11:18,290 --> 00:11:20,610
לא סיימתי את המשפט.

196
00:11:20,610 --> 00:11:24,950
אחר, אם אנחנו באמת להעביר אותו אחד,
הוא יכול להשלים את התכנית.

197
00:11:24,950 --> 00:11:27,920
אז ככה היית משתמש בתכנית +
כדי לאמת את מספר

198
00:11:27,920 --> 00:11:30,630
טיעוני שורת הפקודה כי
הם עברו בפועל.

199
00:11:30,630 --> 00:11:39,360
>> אז בואו לעשות את התכנית הזאת קצת יותר
מסובך, ומסתכל השני

200
00:11:39,360 --> 00:11:42,180
איטרציה של דברים.

201
00:11:42,180 --> 00:11:46,310
אז עכשיו, אנחנו לא רק הדפסה
ויכוח שורת הפקודה ראשון.

202
00:11:46,310 --> 00:11:51,210
הנה, אנחנו iterating משווי i int
0, הוא שאני פחות מ argc, אני בתוספת

203
00:11:51,210 --> 00:11:55,280
בתוספת, וargv הדפסה, אינדקס i.

204
00:11:55,280 --> 00:11:59,300
אז דפוס זה, שוב, זה אותו הדבר
דפוס כמו קודם, רק שבמקום

205
00:11:59,300 --> 00:12:02,600
לקרוא למשתנה
n, אנחנו משתמשים בתכנית +.

206
00:12:02,600 --> 00:12:09,520
>> אז זה iterating מעל כל מדד
במערך, ומדפיס כל

207
00:12:09,520 --> 00:12:11,910
אלמנט במערך זה.

208
00:12:11,910 --> 00:12:20,300
וכך, כאשר אנו מפעילים תכנית זו, טוב,
אני לא נכנסתי לשורת פקודת כל

209
00:12:20,300 --> 00:12:22,540
טיעונים, כך שזה רק הדפסים
את שם התכנית.

210
00:12:22,540 --> 00:12:26,053
אם אני נכנסתי לחבורה של דברים, זה יהיה
להדפיס אחד, כל אחד בשורה הנפרדת.

211
00:12:26,053 --> 00:12:31,213

212
00:12:31,213 --> 00:12:32,210
>> על אישור.

213
00:12:32,210 --> 00:12:34,770
אז בואו ניקח את זה צעד אחד קדימה.

214
00:12:34,770 --> 00:12:38,890
ובמקום להדפיס כל ארגומנט
בשורה הנפרדת, בואו להדפיס כל

215
00:12:38,890 --> 00:12:42,590
אופיו של כל ארגומנט
בשורה הנפרדת.

216
00:12:42,590 --> 00:12:46,700
אז לזכור כי argv הוא
מערך של מחרוזות.

217
00:12:46,700 --> 00:12:50,960
אז מה היא מחרוזת, אבל
מערך של תווים?

218
00:12:50,960 --> 00:12:57,140
אז זה אומר שargv הוא באמת
מערך של מערך של תווים.

219
00:12:57,140 --> 00:13:04,920
אז מנצל את זה,
בואו להתעלם מכך לעת עתה.

220
00:13:04,920 --> 00:13:08,190
בואו רק לשקול את argv המחרוזת 0.

221
00:13:08,190 --> 00:13:14,170
>> אז אם אנחנו רוצים להביא את כל תו של
argv 0 בשורה הנפרדת, ולאחר מכן אני רוצה

222
00:13:14,170 --> 00:13:19,500
לעשות את הדפוס שאנחנו רגילים, הוא אני
פחות מאורכו של המערך,

223
00:13:19,500 --> 00:13:23,990
אשר כאן, strlen של, זה
לא מה שאני רוצה לעשות, מחרוזת

224
00:13:23,990 --> 00:13:26,450
ים שווה argv 0.

225
00:13:26,450 --> 00:13:30,390
אז האם אני פחות מאורכו שלנו
מערך, אשר במקרה זה הוא מערך

226
00:13:30,390 --> 00:13:34,410
של דמויות, אני בתוספת בתוספת.

227
00:13:34,410 --> 00:13:41,040
וכך, כפי שראינו בשבוע שעבר, זה אידיאלי
אם נעבור שstrlen מחוץ

228
00:13:41,040 --> 00:13:45,210
של המצב, שכן n יהיה הוספה
strlen של ים בכל פעם שאנחנו הולכים

229
00:13:45,210 --> 00:13:47,720
דרך הלולאה, וזה
לא הולך להיות שינוי.

230
00:13:47,720 --> 00:13:50,230
כך תהיה לנו להגדיר אותו שווה ל n לכאן.

231
00:13:50,230 --> 00:13:54,260

232
00:13:54,260 --> 00:13:55,170
>> על אישור.

233
00:13:55,170 --> 00:14:01,320
אז עכשיו, אנחנו iterating מעל
כל מדד במערך.

234
00:14:01,320 --> 00:14:05,630
וכך, אם אנחנו רוצים להדפיס כל
דמות שבמערך, אחוזים ג היא

235
00:14:05,630 --> 00:14:06,880
את הדגל אנחנו רוצים להשתמש
לתווים.

236
00:14:06,880 --> 00:14:10,750

237
00:14:10,750 --> 00:14:19,770
ועכשיו אני סוגר הולך להיות
מחרוזת, אופי אינדקס i, כך שאם

238
00:14:19,770 --> 00:14:20,970
מחרוזת היתה שלום.

239
00:14:20,970 --> 00:14:27,530
לאחר מכן s 0 הולכים להיות שעות, שעות והסוגר
1 יהיה בדואר, וכן הלאה.

240
00:14:27,530 --> 00:14:30,800
>> אז עכשיו אנחנו רוצים לשלב
את שני הדברים האלה.

241
00:14:30,800 --> 00:14:35,440
אנחנו רוצים להדפיס כל תו
של כל ארגומנט שורת הפקודה.

242
00:14:35,440 --> 00:14:38,950
אז אנחנו הולכים להיות
מקוננות עבור לולאה.

243
00:14:38,950 --> 00:14:47,480
ומקובל, הדלפק הראשון
אני, הבא הולך להיות j, n

244
00:14:47,480 --> 00:14:54,450
יהיה strlen של i argv, i
היא פחות מ n, בתוספת בתוספת i.

245
00:14:54,450 --> 00:14:59,150

246
00:14:59,150 --> 00:15:06,870
ועכשיו במקום שאני argv הדפסה, כך
argv סוגר אני הולך למדד -

247
00:15:06,870 --> 00:15:14,280
זה הולך להיות בשורת פקודת i-ה
ויכוח, argv i, j הולך

248
00:15:14,280 --> 00:15:16,925
להיות דמות JTH של
טיעון i-ה.

249
00:15:16,925 --> 00:15:20,580

250
00:15:20,580 --> 00:15:24,810
אני להיפטר מזה עד כאן עכשיו
מאז שהכנסנו אותו לתוך הלולאה ש.

251
00:15:24,810 --> 00:15:33,900
אז שווה לשווים של המחרוזת
argv i, j ולאחר מכן סוגר את ים.

252
00:15:33,900 --> 00:15:36,980
>> ובכן, אנחנו לא צריכים להצהיר
של משתנה זה.

253
00:15:36,980 --> 00:15:44,530
במקום זאת, אנחנו פשוט לשלב הבאים
שני למה שהיה לנו, argv i, j.

254
00:15:44,530 --> 00:15:45,780
>> 1 רמקול: [לא ברור].

255
00:15:45,780 --> 00:15:48,850

256
00:15:48,850 --> 00:15:49,680
>> ROB בודן: שיחה טובה.

257
00:15:49,680 --> 00:15:52,936
אז זהו שבורים.

258
00:15:52,936 --> 00:15:55,510
אם אני באמת רצתי אותו, הייתי עושה זאת
הבין את זה.

259
00:15:55,510 --> 00:16:01,210
אז הדלפק אכפת לי
בזה במיוחד עבור

260
00:16:01,210 --> 00:16:05,410
לולאה היא j, איטרטור.

261
00:16:05,410 --> 00:16:08,560
אז היית להיתקל בבעיות,
כנראה ללולאה אינסופית, אם אנחנו

262
00:16:08,560 --> 00:16:09,540
לא תקן את זה.

263
00:16:09,540 --> 00:16:12,220
זו הסיבה שאנחנו גם מדברים
על באגים היום.

264
00:16:12,220 --> 00:16:13,120
>> על אישור.

265
00:16:13,120 --> 00:16:15,240
אז בואו נריץ את התכנית.

266
00:16:15,240 --> 00:16:21,200
ובואו בעצם להוסיף printf נפרד
ממש כאן, כי פשוט תדפיס

267
00:16:21,200 --> 00:16:27,480
קו נוסף, שכן זה אומר שכאשר אנו
להפעיל את התכנית, יהיה ריק

268
00:16:27,480 --> 00:16:31,830
קו בין כל תו של
כל ארגומנט שורת הפקודה.

269
00:16:31,830 --> 00:16:33,448
ובכן, נראה מה זה אומר.

270
00:16:33,448 --> 00:16:37,310

271
00:16:37,310 --> 00:16:37,790
אופס.

272
00:16:37,790 --> 00:16:39,870
יש כמה באגים.

273
00:16:39,870 --> 00:16:42,860
שגיאה במשתמע הכרזה
פונקצית ספריית strlen.

274
00:16:42,860 --> 00:16:51,630
>> אז חוזר לתכנית שלנו, אני
שכח חשיש כולל string.h.

275
00:16:51,630 --> 00:16:54,240

276
00:16:54,240 --> 00:16:57,730
אז string.h הולך להיות
קובץ כותרת שמצהיר

277
00:16:57,730 --> 00:16:58,980
פונקצית strlen.

278
00:16:58,980 --> 00:17:04,650

279
00:17:04,650 --> 00:17:06,060
בסדר, זה הידור.

280
00:17:06,060 --> 00:17:09,109
עכשיו, בואו להפעיל אותו.

281
00:17:09,109 --> 00:17:10,930
אז בדיוק את זה.

282
00:17:10,930 --> 00:17:17,790
זה הולך להדפיס אותנו
שם תכנית, שלום עולם.

283
00:17:17,790 --> 00:17:23,510
זה הולך להדפיס כל דבר, שכל אחד
אופי, בשורה הנפרדת.

284
00:17:23,510 --> 00:17:24,540
על אישור.

285
00:17:24,540 --> 00:17:30,625
>> אז בואו באמת לקחת את זה
צעד אחד קדימה.

286
00:17:30,625 --> 00:17:34,050

287
00:17:34,050 --> 00:17:39,700
ובמקום להשתמש string.h, בואו
לחשוב על איך היינו ליישמנו

288
00:17:39,700 --> 00:17:41,420
פונקצית strlen.

289
00:17:41,420 --> 00:17:45,600
אז מייד אני אתן לי
חתימת פונקציה.

290
00:17:45,600 --> 00:17:52,900
אז בואו נקראים בmy_strlen, וזה
הולך לקחת את מחרוזת כטיעון,

291
00:17:52,900 --> 00:17:57,220
ואנו מצפים לחזור
אורכו של חוט זה.

292
00:17:57,220 --> 00:18:03,430
אז, איפה בחור?

293
00:18:03,430 --> 00:18:04,990
כן.

294
00:18:04,990 --> 00:18:06,740
על אישור.

295
00:18:06,740 --> 00:18:12,900
אז זוכר מהשקופית מוקדם יותר כי
היה גם בשבוע שעבר, כי

296
00:18:12,900 --> 00:18:18,890
מערך של תווים, טוב, מחרוזת,
אז בואו נגיד שזה של המחרוזת שלנו.

297
00:18:18,890 --> 00:18:29,870
אז אם ים הוא המחרוזת, הלו, ולאחר מכן,
H-E-L-L-O, בזיכרון, שהולך

298
00:18:29,870 --> 00:18:35,610
להיות, ולאחר מכן קו נטוי הפוך זה
0 אופי.

299
00:18:35,610 --> 00:18:39,170
>> אז איך אנחנו מקבלים את אורכו של ים?

300
00:18:39,170 --> 00:18:43,190
ובכן, החוכמה היא מחפשת את זה
תגובה נגד 0 אופי, null זה

301
00:18:43,190 --> 00:18:44,380
שליחות קטלנית.

302
00:18:44,380 --> 00:18:50,270
אז האלגוריתם הולך
להיות משהו כמו כמה

303
00:18:50,270 --> 00:18:51,510
מספיק דמויות ש--

304
00:18:51,510 --> 00:18:56,180
בואו יש יד זה מייצג חלק
דלפק, בואו נקראים לאורך int זה.

305
00:18:56,180 --> 00:19:00,060
לכן, החלו מכאן, אנחנו
הולך לחזר על המחרוזת שלנו.

306
00:19:00,060 --> 00:19:04,100
>> אז התו הראשון, זה H,
וזה לא יחזור לקצץ 0, ולכן

307
00:19:04,100 --> 00:19:05,170
האורך הוא 1.

308
00:19:05,170 --> 00:19:08,050
לחזר לתו הבא,
E, וזה לא קו נטוי הפוך 0.

309
00:19:08,050 --> 00:19:09,630
אורך הוא 2.

310
00:19:09,630 --> 00:19:10,960
L, 3.

311
00:19:10,960 --> 00:19:11,850
L, 4.

312
00:19:11,850 --> 00:19:13,050
O, 5.

313
00:19:13,050 --> 00:19:16,690
ולבסוף, אנו מגיעים לקו נטוי
0, ולכן זה אומר, גם,

314
00:19:16,690 --> 00:19:17,780
מחרוזת זה נגמרה.

315
00:19:17,780 --> 00:19:20,130
אז בואו נחזור 5.

316
00:19:20,130 --> 00:19:33,630
>> אז בעצם יישום זה, ראשון,
אורך n שלי שווה 0, יד ימין שלי.

317
00:19:33,630 --> 00:19:36,088
ואנחנו הולכים לחזר -

318
00:19:36,088 --> 00:19:38,000
>> 1 רמקול: [לא ברור]

319
00:19:38,000 --> 00:19:38,640
>> ROB בודן: אה, לירות.

320
00:19:38,640 --> 00:19:39,870
שיחה טובה.

321
00:19:39,870 --> 00:19:42,680
בום.

322
00:19:42,680 --> 00:19:44,140
אז אורך n שווה 0.

323
00:19:44,140 --> 00:19:46,910

324
00:19:46,910 --> 00:19:58,310
אז עכשיו, באורך של הזמן שלא
שווה ולאחר מכן, קו נטוי הפוך 0.

325
00:19:58,310 --> 00:20:04,660
אז תזכור, קו נטוי הפוך זה 0, זה הוא
דמות ממשית, וזה מצביע על

326
00:20:04,660 --> 00:20:05,820
סוף המחרוזת.

327
00:20:05,820 --> 00:20:09,850
בדיוק כמו, גם, קו נטוי הפוך
n הוא דמות ממשית.

328
00:20:09,850 --> 00:20:14,040
קו נטוי הפוך 0 הולך להצביע
סוף המחרוזת שלנו.

329
00:20:14,040 --> 00:20:15,414
אני לא רוצה לשים את זה שם.

330
00:20:15,414 --> 00:20:19,190

331
00:20:19,190 --> 00:20:25,620
ובעוד של אינדקס על ידי אורך הוא לא
שווה לשליחות קטלנית null, אז

332
00:20:25,620 --> 00:20:27,130
אנחנו רק הולכים להגדיל אורך.

333
00:20:27,130 --> 00:20:29,860

334
00:20:29,860 --> 00:20:34,880
אז, בסוף התכנית שלנו,
אורך הוא סופו של דבר הולך

335
00:20:34,880 --> 00:20:37,610
להיות 5 במקרה זה.

336
00:20:37,610 --> 00:20:39,210
ואנחנו רק נחזור אורך.

337
00:20:39,210 --> 00:20:42,570

338
00:20:42,570 --> 00:20:43,530
>> על אישור.

339
00:20:43,530 --> 00:20:48,290
אז עכשיו כאן למטה, אני לא
לעשות my_strlen.

340
00:20:48,290 --> 00:20:50,700
בואו לאסוף אותו כדי לוודא
הכל פועל בצורה חלקה.

341
00:20:50,700 --> 00:20:55,820

342
00:20:55,820 --> 00:20:58,210
אני עושה ב 2?

343
00:20:58,210 --> 00:21:00,565
או שזה היה 1?

344
00:21:00,565 --> 00:21:01,940
שצריך לעשות.

345
00:21:01,940 --> 00:21:02,690
בסדר.

346
00:21:02,690 --> 00:21:08,490
אז זה argv 2.

347
00:21:08,490 --> 00:21:11,585
עובד כצפוי, אם כי
היה שהאחד עשיתי את זה ב?

348
00:21:11,585 --> 00:21:15,060

349
00:21:15,060 --> 00:21:15,550
כן.

350
00:21:15,550 --> 00:21:16,760
על אישור.

351
00:21:16,760 --> 00:21:21,820
גרסה זו של דברים שלא הייתה לי
קו printf החדש אחרי, אבל זה

352
00:21:21,820 --> 00:21:22,910
לא עושה שום הבדל.

353
00:21:22,910 --> 00:21:23,300
על אישור.

354
00:21:23,300 --> 00:21:25,780
אז עבד כמצופה.

355
00:21:25,780 --> 00:21:34,750
>> עכשיו אנחנו יכולים אפילו לשלב את זה צעד אחד
נוסף, שבו הודעה לכאן, טוב,

356
00:21:34,750 --> 00:21:38,920
ראשון, שאנו אוחזים strlen של argv
i, ולאחר מכן אנחנו iterating מעל

357
00:21:38,920 --> 00:21:41,450
כל תו במחרוזת.

358
00:21:41,450 --> 00:21:47,480
אז במקום לעשות את זה, מה אם אנחנו
פשוט לשלב את ההיגיון הזה של המתנה

359
00:21:47,480 --> 00:21:50,740
עד שהגענו לקו נטוי הפוך 0 תקין
לתוך זה ללולאה?

360
00:21:50,740 --> 00:21:53,740

361
00:21:53,740 --> 00:22:07,490
אז לחזר בזמן שאני argv, j עושה
קו נטוי הפוך לא שווה 0.

362
00:22:07,490 --> 00:22:10,680
אז בואו להפעיל אותו ראשונה.

363
00:22:10,680 --> 00:22:19,838

364
00:22:19,838 --> 00:22:21,180
>> בסדר.

365
00:22:21,180 --> 00:22:27,655
אז הנה, מצב זה אומר -

366
00:22:27,655 --> 00:22:38,090

367
00:22:38,090 --> 00:22:40,060
בואו לנקות את זה.

368
00:22:40,060 --> 00:22:49,140
אז עכשיו, לתת לזה להיות argv שלנו.

369
00:22:49,140 --> 00:22:55,290
לכן, כאשר אני פשוט רצתי תכנית שלפני,
argv הוא מערך של מחרוזות.

370
00:22:55,290 --> 00:23:03,100
וכך, אם אני מפעיל את זה עם argv לוכסן הנקודה
2, שלום העולם, אז argv

371
00:23:03,100 --> 00:23:07,650
את עצמו הוא באורך 3, לargv
אפס, הלו, ועולם.

372
00:23:07,650 --> 00:23:11,700

373
00:23:11,700 --> 00:23:19,660
>> ובתוך כל אחד ממדדים אלה הוא,
עצמו מערך, שבו זה אהיה

374
00:23:19,660 --> 00:23:23,780
נקודה, זה יהיה קו נטוי, אני לא יודע
אם זה היה בכיוון הנכון, אני

375
00:23:23,780 --> 00:23:25,680
לא חושב שזה היה.

376
00:23:25,680 --> 00:23:30,110
-R-V מקף, צריך יותר מקום.

377
00:23:30,110 --> 00:23:32,570
בואו לחתוך למערך זה.

378
00:23:32,570 --> 00:23:38,230
-R-V מקף 0, ולאחר מכן קו נטוי הפוך 0.

379
00:23:38,230 --> 00:23:43,160
ולאחר מכן באנדרלמוסיה יהיה שלום.

380
00:23:43,160 --> 00:23:45,910
בואו נגיד, קו נטוי הפוך H-E 0.

381
00:23:45,910 --> 00:23:51,130
ולבסוף, קו נטוי הפוך W-O 0.

382
00:23:51,130 --> 00:23:59,730
>> אז האלגוריתם שאנחנו פשוט כתבנו,
מקונן ללולאות, מה שהם

383
00:23:59,730 --> 00:24:07,321
עושים הוא, שיש לנו ראשון
דלפק אני ולאחר מכן j.

384
00:24:07,321 --> 00:24:15,206
זה יהיה קל יותר עם קוד על
מסך, בואו נחזור לזה.

385
00:24:15,206 --> 00:24:17,476
על אישור.

386
00:24:17,476 --> 00:24:24,600
אז שם לב שהוא אני איטרטור זה
iterating על כל פקודה

387
00:24:24,600 --> 00:24:25,610
קו טיעון.

388
00:24:25,610 --> 00:24:28,870
וי הוא iterating איטרטור
על כל תו שב

389
00:24:28,870 --> 00:24:30,410
ויכוח שורת הפקודה.

390
00:24:30,410 --> 00:24:46,755
אז מה printf הפנימי ביותר זה עושה
הוא, יש לנו printf argv 0 0, printf

391
00:24:46,755 --> 00:24:58,680
argv 0 1, argv printf 0 2, 0 3, 0 4, 0
5, 6 0, אבל עכשיו, argv 0 7 הולך

392
00:24:58,680 --> 00:25:00,670
קו נטוי הפוך שווה 0.

393
00:25:00,670 --> 00:25:05,730
>> אז אנחנו יוצאים כי ללולאה,
ועכשיו אני סובב ל1.

394
00:25:05,730 --> 00:25:10,910
ועכשיו אנחנו הולכים להדפסה
argv 1 0, argv 1 - 1

395
00:25:10,910 --> 00:25:17,040
טוב, עכשיו, מאז שחתכתי שלום קצר,
argv 1 2 הולך שוב להיות

396
00:25:17,040 --> 00:25:18,170
קו נטוי הפוך 0.

397
00:25:18,170 --> 00:25:25,050
וכך, להגדיל i ולהמשיך, ו
כן הלאה, עד שלהדפיס את כל

398
00:25:25,050 --> 00:25:28,580
עולם, ואלו הם שורת פקודת שלוש
טיעונים, ואנחנו נצא מתוך

399
00:25:28,580 --> 00:25:31,670
הלולאה החיצונית ביותר, ו
לסיים את התכנית שלנו.

400
00:25:31,670 --> 00:25:38,390

401
00:25:38,390 --> 00:25:39,640
על אישור.

402
00:25:39,640 --> 00:25:43,903

403
00:25:43,903 --> 00:25:46,795
>> אז בואו נחזור לכאן.

404
00:25:46,795 --> 00:25:49,670

405
00:25:49,670 --> 00:25:52,370
אז תוכל להרוויח היכרות מסוימת עם
טיעוני שורת הפקודה על זה

406
00:25:52,370 --> 00:25:54,460
בעיה מסוימת שנקבעה.

407
00:25:54,460 --> 00:25:56,630
>> עכשיו, ניפוי שגיאות.

408
00:25:56,630 --> 00:26:01,680
אז אתה כנראה כבר היה צריך לעשות
ניפוי חלקם עם הקודם שלך

409
00:26:01,680 --> 00:26:03,120
בעיה מוגדרת.

410
00:26:03,120 --> 00:26:08,420
ודרך קלה מאוד אחד מהניפוי,
קודם כל, בואו נסתכל על תכנית מרכבה.

411
00:26:08,420 --> 00:26:20,710

412
00:26:20,710 --> 00:26:23,830
ובכן, הליכה בתכנית זו,
אנחנו הולכים לשאול את המשתמש עבור

413
00:26:23,830 --> 00:26:29,350
מספר שלם, מספר שלם לתפוס את זה, ולאחר מכן,
באופן שרירותי, יש לנו לולאה בזמן ש

414
00:26:29,350 --> 00:26:32,280
הוא רק הולך הפחה
אני עד שזה שווה ל10.

415
00:26:32,280 --> 00:26:35,820
בואו רק נניח אני נכנסתי
מספר שלם גדול מ 10.

416
00:26:35,820 --> 00:26:38,700
אז הפחה אני עד שזה שווה ל10.

417
00:26:38,700 --> 00:26:42,630
>> ואז יש לנו בזמן שעוד לולאה
זאת, בזמן שאני עושה לא שווה 0, אנחנו

418
00:26:42,630 --> 00:26:44,540
הולך הפחת i ידי 3.

419
00:26:44,540 --> 00:26:49,790
אז אם אתה רואה את הכוונה של באג
כאן, זה שזה יהיה ההפחה i כדי

420
00:26:49,790 --> 00:26:57,010
להיות 10, ואז זה יהיה תוך לולאה
מפחית i מ10, 7, 4, 1,

421
00:26:57,010 --> 00:27:02,880
ל2 שליליים, לשלילי 5, וכן הלאה,
לאינסוף שלילי, מאז אני

422
00:27:02,880 --> 00:27:05,920
אף פעם לא באמת שווה 0.

423
00:27:05,920 --> 00:27:08,610
ואז בסוף של תכנית זו,
יש לנו את פונקצית foo שהיא

424
00:27:08,610 --> 00:27:12,130
הולך על הדפסה שאני.

425
00:27:12,130 --> 00:27:16,520
>> אז זו תכנית קצרה וסתמית,
ובאג הוא מובן מאליו,

426
00:27:16,520 --> 00:27:18,790
במיוחד אחרי שרק
אמר את מה שהיה באג.

427
00:27:18,790 --> 00:27:24,840
אבל כאן הכוונה היא, ובכן, אולי זה
בעצם נראה כמו חלק משלך

428
00:27:24,840 --> 00:27:30,040
פתרונות מחמדנים מהאחרונים
בעיה מוגדרת, ואולי יש לך

429
00:27:30,040 --> 00:27:32,800
כמה לולאה אינסופית בתכנית שלך,
ואין לך מושג

430
00:27:32,800 --> 00:27:34,100
מה גורם לכך.

431
00:27:34,100 --> 00:27:38,690
אז טכניקת ניפוי מאוד שימושית
הוא רק להוסיף printfs

432
00:27:38,690 --> 00:27:40,180
בכל רחבי את הקוד שלך.

433
00:27:40,180 --> 00:27:49,200
>> אז הנה אני רוצה printf מחוץ
בעוד לולאה ראשונה.

434
00:27:49,200 --> 00:27:53,155
וכאן אני רוצה printf,
ואני פשוט אדפיס לי.

435
00:27:53,155 --> 00:27:55,670

436
00:27:55,670 --> 00:27:58,330
אני מוכן אפילו לעשות קודם ואילו לולאה, i.

437
00:27:58,330 --> 00:28:05,130

438
00:28:05,130 --> 00:28:09,040
בחוץ, שני בזמן לולאה.

439
00:28:09,040 --> 00:28:12,170
שוב, להדפיס בתוך
מכאן, הערך i.

440
00:28:12,170 --> 00:28:16,270

441
00:28:16,270 --> 00:28:17,520
ובואו נריץ את זה.

442
00:28:17,520 --> 00:28:22,620

443
00:28:22,620 --> 00:28:24,800
>> באגים לוכסן אז נקודה.

444
00:28:24,800 --> 00:28:25,610
הזן את מספר שלם.

445
00:28:25,610 --> 00:28:28,150
בואו נעשה 13.

446
00:28:28,150 --> 00:28:28,760
ובום.

447
00:28:28,760 --> 00:28:33,300
אנחנו רואים שאנחנו לולאות אינסופיות
בתוך תוך הלולאה השנייה.

448
00:28:33,300 --> 00:28:36,305
אז עכשיו אנחנו יודעים מה הוא באג.

449
00:28:36,305 --> 00:28:39,610

450
00:28:39,610 --> 00:28:45,610
אבל ניפוי printf הוא מושלם גדול,
אבל ברגע שהתוכניות שלך לקבל

451
00:28:45,610 --> 00:28:50,560
יותר ויותר מסובך, יש
פתרונות מתוחכמים יותר ל

452
00:28:50,560 --> 00:28:51,705
מקבלים דברים עובדים.

453
00:28:51,705 --> 00:28:52,955
אז בואו נסיר את כל printfs אלה.

454
00:28:52,955 --> 00:29:06,242

455
00:29:06,242 --> 00:29:08,896
ובואו נוודא שאני לא
לשבור שום דבר.

456
00:29:08,896 --> 00:29:09,850
על אישור.

457
00:29:09,850 --> 00:29:14,180
>> אז התכנית אנחנו הולכים
להציג נקרא

458
00:29:14,180 --> 00:29:16,715
GDB, לGNU Debugger.

459
00:29:16,715 --> 00:29:21,892

460
00:29:21,892 --> 00:29:27,510
טוב, בעצם, בואו להסיר באגים עבור
שני, ולעשות את הניפוי שוב.

461
00:29:27,510 --> 00:29:31,420

462
00:29:31,420 --> 00:29:34,440
ובכן, למעשה ראשון, שיעור טוב
בטיעוני שורת הפקודה.

463
00:29:34,440 --> 00:29:37,780
שים לב שפקודת קלאנג זה שהוא
איסוף כל מה שהוא עבר

464
00:29:37,780 --> 00:29:41,300
בשורת הפקודה, אלה
טיעוני שורת הפקודה.

465
00:29:41,300 --> 00:29:46,250
אז איך בדיוק אתה הולך להיות באמצעות
טיעוני שורת הפקודה, כפי שאנו

466
00:29:46,250 --> 00:29:51,500
עשה בעבר, וכמו שאתה יהיה בPSET
2, ככה קלאנג הוא משתמש בהם.

467
00:29:51,500 --> 00:30:00,070
>> אז שם לב שדגל, מקף הראשון
ggdb3, מה שאומר הוא, קלאנג,

468
00:30:00,070 --> 00:30:03,790
אתה צריך לקמפל את קובץ עם
כוונה שסופו של דבר נעשינו את זה

469
00:30:03,790 --> 00:30:05,380
צריך לנפות אותו.

470
00:30:05,380 --> 00:30:13,840
אז כל עוד יש לך דגל ש,
אז אנחנו יכולים ניפוי שגיאות GDB.

471
00:30:13,840 --> 00:30:17,380
וזה יהיה לפתוח את הבאגים של גנו.

472
00:30:17,380 --> 00:30:22,920
>> אז יש הרבה פקודות
כי אתה צריך להתרגל.

473
00:30:22,920 --> 00:30:27,100
כי ראשון אתה בטח
מייד צריך הוא הפעלה.

474
00:30:27,100 --> 00:30:28,200
אז מה הפעל הולכים לעשות?

475
00:30:28,200 --> 00:30:30,910
זה הולך להתחיל התכנית שלנו.

476
00:30:30,910 --> 00:30:36,180
אז לרוץ, תכנית מתחילה, התכנית
שואל אותנו למספר שלם, 13.

477
00:30:36,180 --> 00:30:39,170
ואז זה לולאות אינסופיות
צפוי, חוץ מזה שהוצאתי את

478
00:30:39,170 --> 00:30:40,500
printfs, אז אנחנו אפילו לא רואים את זה.

479
00:30:40,500 --> 00:30:43,320

480
00:30:43,320 --> 00:30:44,600
יצא כרגיל.

481
00:30:44,600 --> 00:30:45,850
אה.

482
00:30:45,850 --> 00:30:48,570

483
00:30:48,570 --> 00:30:53,640
זה אפשרי, כי זה עטוף כל
להיפך, חזרה ל-- התעלמות ש.

484
00:30:53,640 --> 00:30:55,170
מניח שזה לא יצא באופן נורמלי.

485
00:30:55,170 --> 00:30:59,500

486
00:30:59,500 --> 00:31:03,370
יש תשובה מסובכת לזה.

487
00:31:03,370 --> 00:31:07,890
>> אז עכשיו, זה לא מאוד שימושי.

488
00:31:07,890 --> 00:31:11,480
אז פשוט רצתי התכנית שלנו בתוך
הבאגים זה לא עוזרים לנו בכל

489
00:31:11,480 --> 00:31:15,610
אגב, מאז שהיו יכול פשוט לעשות
נקודה לקצץ באגים מבחוץ GDB.

490
00:31:15,610 --> 00:31:21,250
אז פקודה אחת ש
אתה בטח -

491
00:31:21,250 --> 00:31:22,970
ואני אפסיק עם זה.

492
00:31:22,970 --> 00:31:25,850
Control-D או להפסיק, שניהם עובדים.

493
00:31:25,850 --> 00:31:29,550
אז בואו לפתוח אותו שוב.

494
00:31:29,550 --> 00:31:31,130
>> פקודה נוספת שאתה בטח
מייד רוצה

495
00:31:31,130 --> 00:31:33,600
להתרגל להיא הפסקה.

496
00:31:33,600 --> 00:31:37,120
כך תהיה לנו לשבור בעיקרי לעת עתה,
ואז אני אסביר לך את זה.

497
00:31:37,120 --> 00:31:41,010

498
00:31:41,010 --> 00:31:46,370
ובכן, הנה אנחנו רואים שאנחנו לקבוע נקודת עצירה
בשורה זו בdebug.c.

499
00:31:46,370 --> 00:31:50,160
אז מה פריצת הדרך היא שכאשר אני
הקלד ארוך, התכנית הולכת

500
00:31:50,160 --> 00:31:53,560
תמשיך עד
אני מכה נקודת עצירה.

501
00:31:53,560 --> 00:31:59,390
לכן, כאשר אני מכה ארוך, התכנית מתחילה,
ואז זה פורץ ברגע זה

502
00:31:59,390 --> 00:32:01,940
נכנס לתפקידו העיקרי.

503
00:32:01,940 --> 00:32:06,930
לשבור עיקרי הולך להיות משהו
אתה די נפוץ לעשות.

504
00:32:06,930 --> 00:32:11,340
>> ועכשיו, כדי להכיר לך
לחלק מפקודות יותר.

505
00:32:11,340 --> 00:32:14,330
שים לב כאן, שזה אומר שאנחנו
פרץ בקו 11, שהוא

506
00:32:14,330 --> 00:32:16,230
printf, הזן מספר שלם.

507
00:32:16,230 --> 00:32:21,260
אז את הפקודה הבאה הולכת להיות איך
אנחנו הולכים לשורה הבאה של קוד.

508
00:32:21,260 --> 00:32:24,810
זה הולך כדי לאפשר לנו לצעוד
דרך קו התכנית שלנו על ידי קו.

509
00:32:24,810 --> 00:32:26,260
אז הבא.

510
00:32:26,260 --> 00:32:29,820
>> עכשיו קו 12, אנחנו הולכים
כדי לקבל את המספר השלם.

511
00:32:29,820 --> 00:32:30,450
הבא.

512
00:32:30,450 --> 00:32:34,290
ואם אתה רק על Enter שוב, זה יהיה
לעשות שוב את הדבר האחרון שעשית.

513
00:32:34,290 --> 00:32:36,480
אז אני לא צריך להקליד
הבא בכל פעם.

514
00:32:36,480 --> 00:32:40,100
אז הכנס את מספר שלם, 13.

515
00:32:40,100 --> 00:32:46,940
אז עכשיו, קו 14, ואילו היא i גדולה יותר
מ -10, ואני אעשה הבא.

516
00:32:46,940 --> 00:32:48,685
ואנחנו רואים שאנחנו הולכים הפחת i.

517
00:32:48,685 --> 00:32:50,210
אז אנחנו הולכים להפחתי שוב.

518
00:32:50,210 --> 00:32:53,620
>> אז עכשיו, עוד שימושי
הפקודה הדפסה.

519
00:32:53,620 --> 00:32:55,750
אז הדפסה הולכת להדפיס
הערך של המשתנה.

520
00:32:55,750 --> 00:32:57,825
בואו להביא את הערך
שלי משתנה.

521
00:32:57,825 --> 00:32:58,705
בואו להדפיס i.

522
00:32:58,705 --> 00:33:00,910
זה הולך להגיד הוא שאני 11.

523
00:33:00,910 --> 00:33:03,330
עכשיו אנחנו שוב על הבא תוך
היא i גדולה מ 10.

524
00:33:03,330 --> 00:33:05,590
אז אני עדיין גדול מ
10, מכיוון שזה 11.

525
00:33:05,590 --> 00:33:06,920
אני מינוס מינוס.

526
00:33:06,920 --> 00:33:08,250
בואו להדפיס אני שוב.

527
00:33:08,250 --> 00:33:10,950
כצפוי, זה 10.

528
00:33:10,950 --> 00:33:12,510
>> אז עכשיו, הבא.

529
00:33:12,510 --> 00:33:16,250
זה חוזר למצב, הוא אני
יותר מ -10, אבל הוא עכשיו אני 10, כך

530
00:33:16,250 --> 00:33:20,040
זה לא יותר מאשר 10, ולכן אנו צופים
זה ליפול מתוך הלולאה.

531
00:33:20,040 --> 00:33:22,220
ועכשיו אנחנו מתחת לקו זה של קוד.

532
00:33:22,220 --> 00:33:28,750
ופקודה אחרת, רשימה, היא רק הולכת
כדי להציג את הקודם והבא

533
00:33:28,750 --> 00:33:31,240
כמה שורות של קוד, ב
למקרה שאיבדת את עצמך.

534
00:33:31,240 --> 00:33:35,420
אז אנחנו פשוט יצאנו ואילו לולאה זו,
ועכשיו יש לנו נכנסתי זה

535
00:33:35,420 --> 00:33:37,080
תוך לולאה, קו 18.

536
00:33:37,080 --> 00:33:39,860
אז בזמן שאני עושה לא שווה 0.

537
00:33:39,860 --> 00:33:46,570
ו, הבא, אני שווה אני מינוס 3, ואנחנו
שמתי לב, זה פשוט להמשיך.

538
00:33:46,570 --> 00:33:48,270
ואנחנו יכולים להדפיס לי.

539
00:33:48,270 --> 00:33:49,990
>> כל פקודה יש ​​סוג של קיצורי דרך.

540
00:33:49,990 --> 00:33:51,720
אז p הוא קיצור של הדפסה.

541
00:33:51,720 --> 00:33:53,400
אז אנחנו יכולים i p.

542
00:33:53,400 --> 00:33:57,550
רק לשמור מחזיק n,
או להמשיך לעשות הבא.

543
00:33:57,550 --> 00:33:58,340
הדפסה אני שוב.

544
00:33:58,340 --> 00:34:00,380
אתה רואה עכשיו זה שלילי 167.

545
00:34:00,380 --> 00:34:06,030
אז זה יימשך לנצח, אבל לא
באמת לנצח, מאז שראית, זה

546
00:34:06,030 --> 00:34:09,330
יהיה למעשה בסופו בשלב כלשהו.

547
00:34:09,330 --> 00:34:15,699
>> אז זה מתחיל GDB.

548
00:34:15,699 --> 00:34:19,504
אבל בואו נעשה עוד דבר אחד בGDB.

549
00:34:19,504 --> 00:34:20,754
אה, ניפוי שגיאות.

550
00:34:20,754 --> 00:34:23,540

551
00:34:23,540 --> 00:34:28,534
אז, במקרה הספציפי הזה,
לולאה אינסופית במקרה בתוך

552
00:34:28,534 --> 00:34:30,050
הפונקציה העיקרית.

553
00:34:30,050 --> 00:34:35,779
ולעת עתה, רק לקבל את זה שאני
הולך להעביר את הלולאה האינסופית לתוך

554
00:34:35,779 --> 00:34:37,029
פונקצית foo.

555
00:34:37,029 --> 00:34:40,679

556
00:34:40,679 --> 00:34:43,730
רק תזכור את זה, בסוף זה
תכנית, טוב, זה היה במקור

557
00:34:43,730 --> 00:34:46,210
קורא foo, שרק היה
הולך להדפיס לי.

558
00:34:46,210 --> 00:34:51,880
אבל עכשיו אנחנו קוראים foo, שהוא
הולך הפחה אני עד שזה 0, ו

559
00:34:51,880 --> 00:34:54,548
לאחר מכן להדפיס משתנה ש.

560
00:34:54,548 --> 00:34:55,469
על אישור.

561
00:34:55,469 --> 00:34:57,970
תשמור את זה.

562
00:34:57,970 --> 00:35:00,175
הפוך ניפוי שגיאות.

563
00:35:00,175 --> 00:35:03,310
ועכשיו, לאתר באגים gdb.

564
00:35:03,310 --> 00:35:04,090
על אישור.

565
00:35:04,090 --> 00:35:10,580
>> אז אם אני פשוט הפעל אז אני לא הולך ל
תוכל לשלב למעשה דרכי

566
00:35:10,580 --> 00:35:11,730
שורה אחר שורת תכנית.

567
00:35:11,730 --> 00:35:19,820
אז בואו לשבור בראשי,
ולאחר מכן הקלד ארוך.

568
00:35:19,820 --> 00:35:28,160
אז לעבור את זה, printf, הזן
מספר שלם, לקבל את המספר השלם, 13.

569
00:35:28,160 --> 00:35:34,180

570
00:35:34,180 --> 00:35:37,490
אז אנחנו הולכים לשמור decrementing
עד היא i גדולה מ 10.

571
00:35:37,490 --> 00:35:42,840
ואז אנחנו הולכים ליפול דרך
תוך לולאה, ולהגיע לקו -

572
00:35:42,840 --> 00:35:44,364
בואו לפתוח אותו בחלון נפרד.

573
00:35:44,364 --> 00:35:48,720

574
00:35:48,720 --> 00:35:53,300
אז אנחנו מופחתים עד שאני כבר לא היה
יותר מ -10, ואז אנחנו

575
00:35:53,300 --> 00:35:55,700
קרא לפונקציה, foo.

576
00:35:55,700 --> 00:36:01,340
>> אז מה קרה ברגע שאני מכה
foo פונקציה, טוב, אני נקרא foo, ו

577
00:36:01,340 --> 00:36:04,030
אז אני כבר לא היה שליטה על GDB.

578
00:36:04,030 --> 00:36:10,230
אז ברגע שאני מכה הבא בקו זה,
דברים נמשכו עד שזה קרה,

579
00:36:10,230 --> 00:36:12,400
שבו התכנית יצאה כאשר -

580
00:36:12,400 --> 00:36:14,450
מניח שזה לא היה קיים סופו של דבר.

581
00:36:14,450 --> 00:36:16,390
ראית שזה להשהות קצת.

582
00:36:16,390 --> 00:36:22,040
אז למה שאני לא מאבד את השליטה על
התכנית בשלב זה?

583
00:36:22,040 --> 00:36:27,540
ובכן, כשאני מקליד הבא, שהולך
השורה הבאה המילולית של קוד ש

584
00:36:27,540 --> 00:36:28,850
יבצע.

585
00:36:28,850 --> 00:36:35,950
אז אחרי השורה 21, את השורה הבאה של קוד
שיבצע הוא קו 22,

586
00:36:35,950 --> 00:36:38,520
אשר הוא, יציאה מראשית.

587
00:36:38,520 --> 00:36:43,810
אז אני לא רוצה סתם ללכת
לשורה הבאה של קוד.

588
00:36:43,810 --> 00:36:48,170
אני רוצה להיכנס לפונקציה, foo,
ולאחר מכן גם צעד דרך

589
00:36:48,170 --> 00:36:49,830
אלה שורות של קוד.

590
00:36:49,830 --> 00:36:53,726
>> אז בשביל זה, יש לנו אלטרנטיבה.

591
00:36:53,726 --> 00:36:56,770
בואו להפסיק את זה שוב.

592
00:36:56,770 --> 00:36:58,020
לשבור ראשי.

593
00:36:58,020 --> 00:37:00,520

594
00:37:00,520 --> 00:37:06,370
אה, 1, הבא, הבא, 13, הבא,
הבא, הבא, בזהירות,

595
00:37:06,370 --> 00:37:09,820
לפני שפגענו foo קו.

596
00:37:09,820 --> 00:37:10,520
על אישור.

597
00:37:10,520 --> 00:37:13,700
>> אז עכשיו, אנחנו בקו 21,
שבו אנחנו קוראים לfoo.

598
00:37:13,700 --> 00:37:17,100
אנחנו לא רוצים להקליד הבאים, מאז ש
יהיה פשוט להתקשר foo הפונקציה, ו

599
00:37:17,100 --> 00:37:18,710
תלך לשורה הבאה של קוד.

600
00:37:18,710 --> 00:37:20,840
מה שאנחנו רוצים להשתמש הוא שלב.

601
00:37:20,840 --> 00:37:25,690
אז יש הבדל בין שלב
והשלב הבא, שבו שלב צעדים לתוך

602
00:37:25,690 --> 00:37:28,190
לתפקד, ולאחר מכן הולך
על הפונקציה.

603
00:37:28,190 --> 00:37:32,830
זה פשוט מבצע את מכלול
הפונקציה וממשיך לנסוע.

604
00:37:32,830 --> 00:37:37,210
>> אז שלב הוא הולך להביא לנו
לפונקציה, foo.

605
00:37:37,210 --> 00:37:41,160
ואנו רואים כאן, עכשיו, אנחנו שוב ב
בעוד לולאה זה זה, בתאוריה,

606
00:37:41,160 --> 00:37:44,190
הולך להמשיך לנצח.

607
00:37:44,190 --> 00:37:50,420
ואם אתה מכה שלב, כשזה אפילו לא
פונקציה לקרוא, אז זה

608
00:37:50,420 --> 00:37:51,720
זהה לבא.

609
00:37:51,720 --> 00:37:55,320
אז זה רק כשאתה בקו
הוא קורא לפונקציה שהשלב

610
00:37:55,320 --> 00:37:56,970
הוא הולך להיות שונה מבא.

611
00:37:56,970 --> 00:37:57,930
אז צעד יביא אותנו לכאן.

612
00:37:57,930 --> 00:38:02,100
צעד, צעד, צעד, צעד, צעד, צעד, ו
אנחנו פשוט לולאה אינסופית לנצח.

613
00:38:02,100 --> 00:38:06,810
>> כך שאתה עלול להתרגל לכך כמו שלך
דרך של זיהוי לולאות אינסופיות, היא

614
00:38:06,810 --> 00:38:08,960
רק מחזיק את מקש Enter זה כדי
לראות איפה אתה נתקע.

615
00:38:08,960 --> 00:38:11,610

616
00:38:11,610 --> 00:38:14,780
ישנן דרכים טובות יותר לעשות את זה, אבל
לעת עתה, זה מספיק בהחלט.

617
00:38:14,780 --> 00:38:17,967
וסגנונית, כדי להתאים לסגנון
50, הייתי צריך לעשות את זה.

618
00:38:17,967 --> 00:38:21,550

619
00:38:21,550 --> 00:38:24,030
על אישור.

620
00:38:24,030 --> 00:38:28,400
>> אז פקודה אחת האחרונה כדי להציג.

621
00:38:28,400 --> 00:38:30,810
ובכן, בואו GDB באגים פנימה

622
00:38:30,810 --> 00:38:35,580
אז במקום לשבור בעיקרי, אם אני
יודע את פונקצית foo הוא גם

623
00:38:35,580 --> 00:38:39,230
בעיה, אז יש לי יכולים פשוט
אמר, לשבור בfoo, במקום.

624
00:38:39,230 --> 00:38:42,310
בואו נגיד שאני אשבור ב
שני עיקרי וfoo.

625
00:38:42,310 --> 00:38:45,390
אז אתה יכול להגדיר נקודות עצירה רבות
כמו שאתה רוצה.

626
00:38:45,390 --> 00:38:49,230
כשאני מקליד ארוך, זה קורה
לעצור ב--

627
00:38:49,230 --> 00:38:52,180
אוו, בואו להדר מחדש, שכן
שיניתי דברים.

628
00:38:52,180 --> 00:38:55,950
אתה תראה קו, אזהרה, מקור זה
קובץ מעדכן יותר מהפעלה.

629
00:38:55,950 --> 00:38:59,680
אז זה אומר שאני פשוט נכנסתי לכאן
ושינה את אלה כדי להתאים את הסגנון

630
00:38:59,680 --> 00:39:03,100
50, אבל אני לא הידור מחדש
את התכנית.

631
00:39:03,100 --> 00:39:04,870
אז GDB גורם לי מודע לכך.

632
00:39:04,870 --> 00:39:10,130
אני אפסיק, לעשות ניפוי שוב,
פגע באגים gdb.

633
00:39:10,130 --> 00:39:10,700
על אישור.

634
00:39:10,700 --> 00:39:12,800
>> אז עכשיו, בחזרה למה שאני עושה.

635
00:39:12,800 --> 00:39:15,720
לשבור foo העיקרי, הפסקה.

636
00:39:15,720 --> 00:39:20,680
עכשיו, אם אני מפעיל את התכנית, כך שזה
מתכוון להמשיך עד שיגיע

637
00:39:20,680 --> 00:39:21,320
נקודת עצירה.

638
00:39:21,320 --> 00:39:24,680
נקודת העצירה שקורה לי
להיות הראשון בראשי.

639
00:39:24,680 --> 00:39:28,630
עכשיו, במקום לעשות הבא, הבא, הבא,
הבא, הבא, עד שפגעתי foo, אני

640
00:39:28,630 --> 00:39:35,230
ניתן להקליד תמשיך, שימשיך
עד שתגיעו לנקודת עצירה הבאה.

641
00:39:35,230 --> 00:39:37,200
אני צריך להזין את המספר השלם ראשונה.

642
00:39:37,200 --> 00:39:40,570
תמשיך ימשיך עד שפגעתי
נקודת העצירה הבאה, שהוא ש

643
00:39:40,570 --> 00:39:43,320
פונקציה של foo.

644
00:39:43,320 --> 00:39:50,130
>> אז על הפעלה תרוץ עד שתגיע
נקודת עצירה, אבל אתה רק להקליד ריצה כש

645
00:39:50,130 --> 00:39:54,060
אתה מתחיל את התכנית, ולאחר מכן,
מכאן ואילך, זה ימשיך.

646
00:39:54,060 --> 00:40:01,950
אם אני רק עשיתי לשבור עיקרי ו
אז רץ, זה ישבור ב

647
00:40:01,950 --> 00:40:03,670
ראשי, ולאחר מכן להמשיך.

648
00:40:03,670 --> 00:40:10,050
מאז אין לי נקודת הפסקה בfoo,
הזן את המספר השלם, אז עכשיו אני

649
00:40:10,050 --> 00:40:11,380
לא הולך לשבור בfoo.

650
00:40:11,380 --> 00:40:16,318
זה רק הולך אינסופי
לולאה עד ש.

651
00:40:16,318 --> 00:40:17,568
על אישור.

652
00:40:17,568 --> 00:40:19,500

653
00:40:19,500 --> 00:40:24,420
>> אז זה פתיח לGDB.

654
00:40:24,420 --> 00:40:27,790
אתה צריך להתחיל להשתמש בו
בסטי הבעיה שלך.

655
00:40:27,790 --> 00:40:30,550
זה יכול להיות מאוד מועיל
לזהות באגים.

656
00:40:30,550 --> 00:40:35,280
אם אתה באמת פשוט, קו אחר קו, ללכת
באמצעות הקוד שלך, ולהשוות את מה שהוא

657
00:40:35,280 --> 00:40:39,740
למעשה קורה עם מה שאתה מצפה
לקרות, אז זה די

658
00:40:39,740 --> 00:40:41,060
קשה לפספס באגים שלך.

659
00:40:41,060 --> 00:40:45,280

660
00:40:45,280 --> 00:40:46,530
על אישור.

661
00:40:46,530 --> 00:40:48,310

662
00:40:48,310 --> 00:40:54,040
>> אז בשבוע שעבר דוד הביא את זה
דברים הצפנה סוד מפתח עבור

663
00:40:54,040 --> 00:40:59,350
בפעם ראשונה, שבו אנחנו לא רוצים
סיסמאות רק להיות מאוחסן עלינו

664
00:40:59,350 --> 00:41:03,210
מחשב בחלק בקובץ טקסט רגיל, שבו
מישהו יכול לבוא ופשוט

665
00:41:03,210 --> 00:41:04,660
לפתוח אותו ולקרוא אותם.

666
00:41:04,660 --> 00:41:07,530
באופן אידיאלי, הם היו מוצפנים
בדרך כלשהי.

667
00:41:07,530 --> 00:41:13,340
ובבעית הסט 2, אתה תהיה התמודדות
עם שיטה אחת של הצפנה,

668
00:41:13,340 --> 00:41:16,520
או, כן, בשתי שיטות, אבל
הם לא כל כך גדולים.

669
00:41:16,520 --> 00:41:20,050
אם אתה עושה את מהדורת ההאקר, אתה
גם הולך להיות התמודדות עם

670
00:41:20,050 --> 00:41:22,150
פענוח כמה דברים.

671
00:41:22,150 --> 00:41:29,770
>> אז הבעיה כרגע היא, ובכן, גם אם
יש לנו את ההצפנה החזקה ביותר

672
00:41:29,770 --> 00:41:34,830
אלגוריתם בעולם, אם תבחר
סיסמא עניות במיוחד, אז זה

673
00:41:34,830 --> 00:41:37,720
לא אעזור לך מאוד, שכן אנשים
עדיין יהיה מסוגל להבין את זה.

674
00:41:37,720 --> 00:41:41,530
גם אם רואה את המחרוזת מוצפנת ו
זה נראה כמו בלגן של זבל

675
00:41:41,530 --> 00:41:44,760
שלא מזיז להם, אם הם
עדיין רק צריך לנסות כמה סיסמאות

676
00:41:44,760 --> 00:41:50,560
כדי להבין את זה, אז אתה
הם לא מאוד בטוחים.

677
00:41:50,560 --> 00:41:55,890
אז צפה בסרטון וידאו ש
הופך לנקודה זו.

678
00:41:55,890 --> 00:41:59,587

679
00:41:59,587 --> 00:42:00,970
>> [וידאו השמעה]

680
00:42:00,970 --> 00:42:02,100
>> קסדה, אתה שד.

681
00:42:02,100 --> 00:42:03,370
מה קורה?

682
00:42:03,370 --> 00:42:05,170
מה אתה עושה לבת שלי?

683
00:42:05,170 --> 00:42:09,910
>> -הרשה לי להציג את מבריק
מנתח פלסטי צעיר, ד"ר פיליפ

684
00:42:09,910 --> 00:42:13,730
Schlotkin, האף הגדול
עבודת אדם בכל

685
00:42:13,730 --> 00:42:16,080
היקום, ובוורלי הילס.

686
00:42:16,080 --> 00:42:17,210
>> -הוד מעלתו.

687
00:42:17,210 --> 00:42:18,070
>> האף עבודה?

688
00:42:18,070 --> 00:42:18,670
אני לא מבין.

689
00:42:18,670 --> 00:42:20,090
כבר היה לה ניתוח פלסטי באף.

690
00:42:20,090 --> 00:42:21,910
זה היה שש עשרה בהווה מתוק.

691
00:42:21,910 --> 00:42:22,140
>> -No.

692
00:42:22,140 --> 00:42:23,690
זה לא מה שאתה חושב.

693
00:42:23,690 --> 00:42:25,420
זה הרבה יותר, הרבה יותר גרוע.

694
00:42:25,420 --> 00:42:30,300
אם אתה לא נותן לי את שילוב ל
מגן האוויר, ד"ר Schlotkin יהיה

695
00:42:30,300 --> 00:42:34,226
לתת לבת שלך בחזרה את אפה הישן.

696
00:42:34,226 --> 00:42:35,476
>> -No.

697
00:42:35,476 --> 00:42:38,712

698
00:42:38,712 --> 00:42:40,516
מאיפה לקחת את זה?

699
00:42:40,516 --> 00:42:41,440
>> -בסדר.

700
00:42:41,440 --> 00:42:42,180
אני אגיד לי.

701
00:42:42,180 --> 00:42:43,381
אני אגיד לי.

702
00:42:43,381 --> 00:42:44,263
לא, אבא.

703
00:42:44,263 --> 00:42:45,590
לא, אתה לא חייב.

704
00:42:45,590 --> 00:42:46,860
>> -אתה צודק, יקירתי.

705
00:42:46,860 --> 00:42:48,450
אני אתגעגע אל האף החדש שלך.

706
00:42:48,450 --> 00:42:52,090
אבל אני לא אספר לו את השילוב,
לא משנה מה.

707
00:42:52,090 --> 00:42:53,680
>> -טוב מאוד.

708
00:42:53,680 --> 00:42:55,685
ד"ר Schlotkin, לעשות הגרוע ביותר שלך.

709
00:42:55,685 --> 00:42:56,914
>> -הנאה.

710
00:42:56,914 --> 00:43:00,690
>> [כלים מתחדדים]

711
00:43:00,690 --> 00:43:01,910
>> -No.

712
00:43:01,910 --> 00:43:02,520
חכה.

713
00:43:02,520 --> 00:43:03,836
חכה.

714
00:43:03,836 --> 00:43:05,300
אני אגיד לי.

715
00:43:05,300 --> 00:43:06,880
אני אגיד לי.

716
00:43:06,880 --> 00:43:09,130
>> -ידעתי שזה יעבוד.

717
00:43:09,130 --> 00:43:09,900
בסדר.

718
00:43:09,900 --> 00:43:12,850
תן לי.

719
00:43:12,850 --> 00:43:16,918
>> -השילוב הוא אחד.

720
00:43:16,918 --> 00:43:17,406
>> -One.

721
00:43:17,406 --> 00:43:18,382
>> -One.

722
00:43:18,382 --> 00:43:19,358
>> ושתיים.

723
00:43:19,358 --> 00:43:19,846
>> ושתיים.

724
00:43:19,846 --> 00:43:20,822
>> ושתיים.

725
00:43:20,822 --> 00:43:21,310
>> ושלוש.

726
00:43:21,310 --> 00:43:21,798
>> ושלוש.

727
00:43:21,798 --> 00:43:22,774
>> ושלוש.

728
00:43:22,774 --> 00:43:23,262
>> ארבעה.

729
00:43:23,262 --> 00:43:23,750
>> ארבעה.

730
00:43:23,750 --> 00:43:26,150
>> ארבעה.

731
00:43:26,150 --> 00:43:27,010
>> חמש.

732
00:43:27,010 --> 00:43:27,670
>> חמש.

733
00:43:27,670 --> 00:43:29,010
>> חמש.

734
00:43:29,010 --> 00:43:34,770
>> -אז השילוב הוא אחד,
שתיים, שלוש, ארבעה, חמש.

735
00:43:34,770 --> 00:43:37,460
זה השילוב הכי הטיפשי
ששמעתי בחיים שלי.

736
00:43:37,460 --> 00:43:39,710
זה מסוג הדברים שאידיוט
היה על המטען שלו.

737
00:43:39,710 --> 00:43:42,000
>> -תודה לך, הוד מעלתך.

738
00:43:42,000 --> 00:43:43,530
>> מה עשית?

739
00:43:43,530 --> 00:43:44,490
>> -כיביתי את הקיר.

740
00:43:44,490 --> 00:43:45,420
>> -אין לך לא.

741
00:43:45,420 --> 00:43:45,840
אתה כיבית את הסרט כולו.

742
00:43:45,840 --> 00:43:46,930
>> -כנראה שלחצתי על הכפתור הלא נכון.

743
00:43:46,930 --> 00:43:48,265
>> ובכן, לשים אותו על גב.

744
00:43:48,265 --> 00:43:49,110
שים את הסרט על גב.

745
00:43:49,110 --> 00:43:49,510
>> -כן, אדוני.

746
00:43:49,510 --> 00:43:49,917
כן, אדוני.

747
00:43:49,917 --> 00:43:50,324
>> -בואו נלך, ארנולד.

748
00:43:50,324 --> 00:43:51,140
בואו, גרטשן.

749
00:43:51,140 --> 00:43:53,060
כמובן, אתה יודע שאני עדיין
צריך לחייב אותך על זה.

750
00:43:53,060 --> 00:43:53,440
>> [השמעת וידאו END]

751
00:43:53,440 --> 00:43:54,690
>> ROB בודן: בסדר.

752
00:43:54,690 --> 00:43:59,690

753
00:43:59,690 --> 00:44:08,430
אז עכשיו שאנחנו כבר מדברים על
ביטחון במובנים מסוימים, נחמד

754
00:44:08,430 --> 00:44:16,050
פוסטר סרט קטן, ולכן בשנים האחרונות
ימים, בנושאים אלה עם NSA

755
00:44:16,050 --> 00:44:17,300
ניטור כל דבר.

756
00:44:17,300 --> 00:44:21,840

757
00:44:21,840 --> 00:44:26,930
זה יכול להיות קשה להרגיש כמוך
יש איזשהו פרטיות ב

758
00:44:26,930 --> 00:44:34,540
עולם מקוון, אם כי אני לא יכול להגיד לי
אתה רוב הפרטים של פריזמה.

759
00:44:34,540 --> 00:44:42,130
אז נע מעבר PRISM, אנחנו לא מתכוונים
שמדבר על זה, עכשיו

760
00:44:42,130 --> 00:44:44,030
חושב על המחשב הנייד שלך.

761
00:44:44,030 --> 00:44:48,360
אז עד כאן, אני רוצה לעבור
לחשבון שלי בפועל,

762
00:44:48,360 --> 00:44:50,370
עם הפינגווין הקטן שלי.

763
00:44:50,370 --> 00:44:57,310
אז יש לי להגדיר סיסמא, וכי
סיסמא היא מה שאני רוצה שזה יהיה.

764
00:44:57,310 --> 00:45:02,430
>> אך יש לזכור כי מה שאני מתחבר
בעם, ולכן התחברות זו

765
00:45:02,430 --> 00:45:04,850
הפקודה, היא חלק מהתכנית.

766
00:45:04,850 --> 00:45:07,910
זה חלק מהתכנית שהייתה
נכתב על ידי אדם כלשהו.

767
00:45:07,910 --> 00:45:13,250
וכך, אותו אדם, אם הם
זדוני במיוחד, שביכולתם

768
00:45:13,250 --> 00:45:17,780
אמר, בסדר, אז אם הסיסמה
שאני נכנסתי שווה לשלי

769
00:45:17,780 --> 00:45:22,800
הסיסמה בפועל, או שזה שווה
כמה סיסמא מיוחדת -

770
00:45:22,800 --> 00:45:25,550
דוד הוא מדהים או משהו -

771
00:45:25,550 --> 00:45:27,190
לאחר מכן נתת להם להיכנס

772
00:45:27,190 --> 00:45:33,760
אז יש לי מתכנת זדוני יכול
גישה לכל מחשבי מקינטוש שלך, או

773
00:45:33,760 --> 00:45:36,150
Windows, או משהו כזה.

774
00:45:36,150 --> 00:45:41,980
>> אז זה לא הרבה של דאגה, שכן,
אני מתכוון, זה תכנית התחברות

775
00:45:41,980 --> 00:45:48,720
שסופק עם OS X, מאות
או שיש לי אלפי אנשים

776
00:45:48,720 --> 00:45:50,020
סקר את הקוד הזה.

777
00:45:50,020 --> 00:45:55,330
וכך, אם, בקוד שלך באיזה מקום, אתה
לומר אם מחרוזת זו שווה שווה

778
00:45:55,330 --> 00:45:58,860
דוד הוא מדהים, ההתחברות, ואז מישהו זה
הולך להיות, כמו, חכה.

779
00:45:58,860 --> 00:45:59,800
זה לא בסדר.

780
00:45:59,800 --> 00:46:01,790
זה לא צריך להיות כאן.

781
00:46:01,790 --> 00:46:06,650
אז זו דרך אחת אנחנו מקבלים דברים
להיות סוג של מאובטח.

782
00:46:06,650 --> 00:46:10,300
>> אבל תחשוב על תוכניות אפילו
שאתה כותב.

783
00:46:10,300 --> 00:46:13,000
בואו נגיד שאתה כתב את תכנית ההתחברות.

784
00:46:13,000 --> 00:46:20,440
אז תכנית התחברות זה שאתה כתב,
כל כך ברור, אתה טוב

785
00:46:20,440 --> 00:46:21,210
מתכנת.

786
00:46:21,210 --> 00:46:25,610
אתה לא הולך לשים את כל זדוני
אם x שווה שווה דוד הוא מדהים

787
00:46:25,610 --> 00:46:27,860
לקוד שלך.

788
00:46:27,860 --> 00:46:31,930
אבל התכנית הזו, מה אתה עושה
להשתמש בו כדי לקמפל תכנית זו?

789
00:46:31,930 --> 00:46:34,180
משהו כמו קלאנג.

790
00:46:34,180 --> 00:46:38,460
אז מה אם האדם שקרה לי
לכתוב מיוחד קלאנג בדק בקלאנג

791
00:46:38,460 --> 00:46:44,310
משהו כמו, אם אני קומפילציה
התחבר תכנית, ולאחר מכן להזין את הקוד הזה

792
00:46:44,310 --> 00:46:49,720
לתכנית ההתחברות שאומרת, אם
x שווה שווה דוד הוא מדהים?

793
00:46:49,720 --> 00:46:59,890
אז לא ממש, אבל יש לנו את אותו
בעיה כאן, שבו קלאנג, טוב,

794
00:46:59,890 --> 00:47:03,790
אלפים, אם לא עשרות אלפי
אנשים, בחנו קלאנג, יש לי

795
00:47:03,790 --> 00:47:07,160
הביט בשורותיה של קוד ואמר,
בסדר, אין שום דבר רע כאן.

796
00:47:07,160 --> 00:47:10,680
כמובן, אף אחד לא עושה
דבר זה זדוני.

797
00:47:10,680 --> 00:47:15,780
>> אבל מה הוא צלצול עצמו, כמו,
מה אם אני לקמפל קלאנג?

798
00:47:15,780 --> 00:47:20,900
מה אם יש לי כמה מהדר כי
הידור קלאנג שמוסיף לקלאנג

799
00:47:20,900 --> 00:47:25,610
זה גרזן מיוחד שאומר, בסדר,
כשאני לקמפל קלאנג, אז

800
00:47:25,610 --> 00:47:31,290
הפעלה אני מקבל צריך במיוחד לחפש
בתוך תכנית ההתחברות ולהכניס

801
00:47:31,290 --> 00:47:34,230
סיסמא זו, שווה שווה
דייב הוא מדהים?

802
00:47:34,230 --> 00:47:37,990
אז לזכור שהמהדר שלך עצמו
צריך להיות הידור בשלב כלשהו.

803
00:47:37,990 --> 00:47:42,810
אז אם מה שאתה בוחר לקמפל קלאנג
עם, עצמו הוא זדוני, אז אתה

804
00:47:42,810 --> 00:47:45,580
יכול להיות דפוק לגמרי
דרך לאורך הקו.

805
00:47:45,580 --> 00:47:49,630
>> אז הנה, יש לנו קן תומפסון
ודניס ריצ'י.

806
00:47:49,630 --> 00:47:53,780
אז זו תמונה איקונית.

807
00:47:53,780 --> 00:47:55,470
דניס ריצ'י הוא בצד הימין.

808
00:47:55,470 --> 00:47:58,740
הוא גדול -

809
00:47:58,740 --> 00:48:03,640
פחות או יותר כתב ג אז אתה יכול
מודה לו על זה בכיתה.

810
00:48:03,640 --> 00:48:04,840
קן תומסון זה בצד השמאל.

811
00:48:04,840 --> 00:48:07,780
שניים מהם בעצם כתבו UNIX.

812
00:48:07,780 --> 00:48:10,140
ובכן, הם היו תורמים עיקריים
בUNIX.

813
00:48:10,140 --> 00:48:11,310
היו שם עוד כמה אחרים.

814
00:48:11,310 --> 00:48:16,240
אז קן תומפסון, בשלב מסוים,
הוא זוכה בפרס טיורינג.

815
00:48:16,240 --> 00:48:20,860
ואת הפרס טיורינג, תמיד שמע
זה הפניה בדרך זו, זה

816
00:48:20,860 --> 00:48:23,100
פרס נובל במדעי מחשב.

817
00:48:23,100 --> 00:48:27,500
>> אז בפרס טיורינג, שיש לו
לתת נאום תודה שלו.

818
00:48:27,500 --> 00:48:31,790
והוא נותן מאוד מפורסם הנאום הזה
החברה, הנקרא הרהורים על אמון

819
00:48:31,790 --> 00:48:35,620
אמון, שיש לנו מקושר
באתר הקורס.

820
00:48:35,620 --> 00:48:41,670
ובנאום הזה, הוא אומר, בסדר,
אז כתבתי UNIX, ועכשיו כל

821
00:48:41,670 --> 00:48:43,320
שלך אנשים משתמשים UNIX.

822
00:48:43,320 --> 00:48:46,960
עכשיו, זוכר את היום שלינוקס היא
צאצא ישיר של UNIX.

823
00:48:46,960 --> 00:48:50,140
OS X ישירות משתמש UNIX.

824
00:48:50,140 --> 00:48:53,810
Windows לא כל כך הרבה, אבל הרבה
רעיונות נלקחו מUNIX.

825
00:48:53,810 --> 00:48:59,220
>> אז הוא עולה לבמה ואומר,
בסדר, אני כתבתי UNIX.

826
00:48:59,220 --> 00:49:03,940
ורק כדי שהחבר 'ה יודעת, אני
תוכל להתחבר לכל

827
00:49:03,940 --> 00:49:05,590
אחד מהמחשבים שלך.

828
00:49:05,590 --> 00:49:14,280
מאז שמתי אחד מיוחד אלה אם x
שווה שווה קן תומסון הוא מדהים,

829
00:49:14,280 --> 00:49:16,350
אז מותר לי להתחבר.

830
00:49:16,350 --> 00:49:18,370
אז אנשים אומר, גם,
איך עשיתי את זה?

831
00:49:18,370 --> 00:49:21,090
הסתכלנו על תכנית ההתחברות
ושום דבר שם.

832
00:49:21,090 --> 00:49:24,700
הוא כמו, ובכן, אני שונה מהדר
כדי להיכנס בתכנית ההתחברות

833
00:49:24,700 --> 00:49:30,490
כך שתכנית ההתחברות עכשיו תהיה לי
x ששווה שווה קן תומפסון

834
00:49:30,490 --> 00:49:31,700
הוא מדהים.

835
00:49:31,700 --> 00:49:33,120
>> והם אומרים, טוב, זה לא נכון.

836
00:49:33,120 --> 00:49:35,740
אנחנו מסתכלים על מהדר, ו
מהדר אין כל קווים

837
00:49:35,740 --> 00:49:36,400
קוד כזה.

838
00:49:36,400 --> 00:49:40,540
הוא כמו, בסדר, אבל מה אתה
קומפילציה מהדר עם?

839
00:49:40,540 --> 00:49:44,810
והם חושבים, והוא, כמו, ובכן,
אני זה שנתן לך את המהדר

840
00:49:44,810 --> 00:49:50,580
אתה משתמש כדי לקמפל את המהדר, כך
אתה להרכיב מהדר, כי

841
00:49:50,580 --> 00:49:56,390
עצמו הוא זדוני, ויהיה
לשבור את תכנית ההתחברות.

842
00:49:56,390 --> 00:49:59,360
אז בעצם, בשלב זה, אין
אין דרך בה אתה יכול להסתכל על המקור

843
00:49:59,360 --> 00:50:02,450
קוד של תכנית ההתחברות
כדי לראות מה לא בסדר.

844
00:50:02,450 --> 00:50:04,220
אתה לא יכול אפילו להסתכל ב
קוד מקור של קומפיילר

845
00:50:04,220 --> 00:50:06,790
כדי לראות מה לא בסדר.

846
00:50:06,790 --> 00:50:11,940
>> היית צריך להסתכל על המכונה
קוד, בינארי בפועל של

847
00:50:11,940 --> 00:50:16,760
מהדר הידור לראות, רגע, אלה
שורות של קוד לא צריכים להיות כאן.

848
00:50:16,760 --> 00:50:22,130
אבל קן תומפסון לקח את זה צעד אחד
עוד יותר ואמר, טוב, יש

849
00:50:22,130 --> 00:50:25,980
התוכניות המיוחדות הללו, שלמעשה
לעזור לך לקרוא בינאריות של תוכניות,

850
00:50:25,980 --> 00:50:29,340
ולכן אם מישהו השתמש בתכנית זו כדי
קראתי בינארי, הם היו רואים את אלה

851
00:50:29,340 --> 00:50:30,490
שורות של קוד.

852
00:50:30,490 --> 00:50:34,020
הוא הותאם תוכניות אלה לומר, כל
נכון, אם אתה מסתכל על

853
00:50:34,020 --> 00:50:38,460
מהדר, לא להראות את זה במיוחד
קבוצה של בינארי.

854
00:50:38,460 --> 00:50:42,830
>> אז אתה צריך לקחת את זה צעד אחד
, שיש להם עוד יותר ובעצם יכול

855
00:50:42,830 --> 00:50:46,210
מספר רמות נלקחו מבעקיפין,
ובשלב מסוים, אף אחד לא באמת

856
00:50:46,210 --> 00:50:47,990
הולך להיות בדיקה.

857
00:50:47,990 --> 00:50:52,590
אז מוסר ההשכל של הסיפור הוא, שאת
לא הולך לכתוב

858
00:50:52,590 --> 00:50:54,340
צלצול בכיתה זו.

859
00:50:54,340 --> 00:50:57,020
אתה הולך להיות באמצעות טיפוס
צלצול הרבה בכיתה זו.

860
00:50:57,020 --> 00:51:00,490
לכל מה שאתה יודע, קלאנג הוא זדוני
תכנית שמחבלת בכל

861
00:51:00,490 --> 00:51:03,520
תכנית אחת שנאספה אי פעם.

862
00:51:03,520 --> 00:51:08,206
וכדי להשאיר אותך על שמאוד מאיים
שים לב, לראות אותך ביום רביעי.

863
00:51:08,206 --> 00:51:10,030
>> [מחיאות כפות]

864
00:51:10,030 --> 00:51:12,935
>> SPEAKER 2: בCS50 הבא.

865
00:51:12,935 --> 00:51:14,580
>> SPEAKER 3: שלא יעז להגיד את זה.

866
00:51:14,580 --> 00:51:15,930
אתה יכול לעשות את זה.

867
00:51:15,930 --> 00:51:19,440
אתה כבר עשית את זה קודם, אתה יכול לעשות את זה
היום, אתה יכול לעשות את זה מחר.

868
00:51:19,440 --> 00:51:20,930
אתה כבר עושה את זה במשך שנים.

869
00:51:20,930 --> 00:51:22,790
פשוט ללכת לשם ולעשות את זה.

870
00:51:22,790 --> 00:51:24,310
אתה יכול לעשות את זה.

871
00:51:24,310 --> 00:51:26,102
>> [השמעת מוסיקה]