1
00:00:00,000 --> 00:00:05,640

2
00:00:05,640 --> 00:00:06,830
>> דאג LLOYD: כל GDB הנכון.

3
00:00:06,830 --> 00:00:08,480
מה זה בדיוק?

4
00:00:08,480 --> 00:00:11,310
אז GDB, העומד
לDebugger של גנו,

5
00:00:11,310 --> 00:00:15,040
הוא כלי מדהים באמת שאנחנו יכולים
להשתמש בו כדי לעזור לנו לאתר באגים התוכניות שלנו,

6
00:00:15,040 --> 00:00:18,210
או לגלות בו דברים הם
השתבש בתוכניות שלנו.

7
00:00:18,210 --> 00:00:22,590
GDB הוא חזק להפליא, אבל
הפלט ואינטראקציה עם זה

8
00:00:22,590 --> 00:00:23,830
יכול להיות קצת סתום.

9
00:00:23,830 --> 00:00:28,210
זה בדרך כלל כלי שורת הפקודה, ו
זה יכול לזרוק הרבה הודעות בך.

10
00:00:28,210 --> 00:00:31,144
וזה יכול קצת קשה
לנתח בדיוק מה קורה.

11
00:00:31,144 --> 00:00:33,560
צעדים למרבה המזל, אנחנו כבר נלקחו
כדי לתקן בעיה זו עבורך

12
00:00:33,560 --> 00:00:36,281
כפי שאתה עובד דרך CS50.

13
00:00:36,281 --> 00:00:39,030
אם אתה לא משתמש בגרפי
הבאגים, העמית שלי שדן

14
00:00:39,030 --> 00:00:41,570
Armandarse דיבר די
קצת על בוידאו ש

15
00:00:41,570 --> 00:00:44,740
צריך להיות כאן
עכשיו, ייתכן שתצטרך

16
00:00:44,740 --> 00:00:48,270
להשתמש שורת הפקודה הבאות
כלים לעבודה עם GDB.

17
00:00:48,270 --> 00:00:51,250
אם אתה עובד בCS50
IDE, אתה לא צריך לעשות את זה.

18
00:00:51,250 --> 00:00:53,550
אבל אם אתה לא
עובד בIDE CS50,

19
00:00:53,550 --> 00:00:55,750
אולי משתמש בגרסה
של CS50 Appliance,

20
00:00:55,750 --> 00:00:58,860
או הפעלה אחרת לינוקס
מערכת עם GDB מותקן עליה,

21
00:00:58,860 --> 00:01:00,980
ייתכן שתצטרך להשתמש ב
כלי שורת הפקודה הבאים.

22
00:01:00,980 --> 00:01:02,860
>> ומכיוון שאולי אתה
צריך לעשות את זה, זה

23
00:01:02,860 --> 00:01:06,280
שימושי רק כדי להבין כיצד
GDB עובד משורת הפקודה.

24
00:01:06,280 --> 00:01:09,650
אבל שוב, אם אתה
באמצעות IDE CS50,

25
00:01:09,650 --> 00:01:15,400
יכול להשתמש הבאגים הגרפיים
כי הוא מובנה בתוך IDE.

26
00:01:15,400 --> 00:01:18,750
אז כדי לקבל דברים הולכים עם
GDB, להתחיל באגים

27
00:01:18,750 --> 00:01:21,220
תהליך מסוים
תכנית, כל מה שאתה צריך לעשות

28
00:01:21,220 --> 00:01:23,810
הוא סוג GDB ואחרי
בשם התכנית.

29
00:01:23,810 --> 00:01:28,620
כך למשל, אם התכנית שלך היא
שלום, עליך להקליד שלום GDB.

30
00:01:28,620 --> 00:01:31,210
>> כאשר אתה עושה את זה, אתה הולך
כדי למשוך את סביבת GDB.

31
00:01:31,210 --> 00:01:33,800
הפקודה שלך תשתנה, ו
במקום להיות מה שהיא בדרך כלל

32
00:01:33,800 --> 00:01:35,841
כאשר אתה מקליד דברים
בLS line-- הפקודה,

33
00:01:35,841 --> 00:01:38,115
cd-- כל הטיפוסי שלך
פקודות לינוקס, הפקודה שלך

34
00:01:38,115 --> 00:01:42,200
ישתנה, כנראה, משהו
כמו סוגריים GDB סוגריים.

35
00:01:42,200 --> 00:01:46,630
זה הפקודה GDB החדשה שלך, בגלל ש
אתה בתוך סביבת GDB.

36
00:01:46,630 --> 00:01:49,830
ברגע שנכנס לסביבה ש,
יש שתי פקודות גדולות

37
00:01:49,830 --> 00:01:52,290
כי אתה בטח להשתמש
לפי הסדר הבא.

38
00:01:52,290 --> 00:01:55,200
>> הראשון הוא ב, ש
קצר להפסקה.

39
00:01:55,200 --> 00:01:58,690
ואחרי שאתה מקליד ב, אתה בדרך כלל
הקלד את השם של פונקציה,

40
00:01:58,690 --> 00:02:01,040
או אם אתה יודע במקרה
סביב מה קו מספר

41
00:02:01,040 --> 00:02:04,100
התכנית שלך מתחילה
להתנהג קצת מוזר,

42
00:02:04,100 --> 00:02:06,370
באפשרותך להקליד קו
מספר גם שם.

43
00:02:06,370 --> 00:02:09,660
מה ב, או הפסקה, עושה
זה מאפשר לך תכנית

44
00:02:09,660 --> 00:02:13,270
לרוץ עד לנקודה מסוימת,
כלומר, את השם של הפונקציה

45
00:02:13,270 --> 00:02:15,880
שציינת או הקו
מספר שציינת.

46
00:02:15,880 --> 00:02:18,590
>> ובשלב זה, זה
יקפיא ביצוע.

47
00:02:18,590 --> 00:02:21,670
זה דבר ממש טוב, כי
פעם אחת ביצוע הוקפא,

48
00:02:21,670 --> 00:02:25,214
אתה יכול להתחיל לאט לאט
צעד דרך התכנית שלך.

49
00:02:25,214 --> 00:02:28,130
בדרך כלל, אם אתה כבר פועל
התוכניות שלך, הם די קצרים.

50
00:02:28,130 --> 00:02:31,250
בדרך כלל, אתה מקליד קו נטוי נקודה מה ש
שמו של התכנית שלך, לוחץ על Enter,

51
00:02:31,250 --> 00:02:33,470
ולפני שאתה יכול למצמץ,
תכנית כבר נגמרה.

52
00:02:33,470 --> 00:02:36,620
זה לא ממש הרבה זמן כדי לנסות
ולהבין מה השתבש.

53
00:02:36,620 --> 00:02:40,920
אז זה באמת להיות מסוגל להאט דברים
על ידי הגדרת נקודת הפסקה עם ב,

54
00:02:40,920 --> 00:02:43,040
ולאחר מכן דריכה ב.

55
00:02:43,040 --> 00:02:46,169
>> ואז ברגע שהגדרת ההפסקה שלך
נקודה, אתה יכול להפעיל את התכנית.

56
00:02:46,169 --> 00:02:47,960
ואם יש לך
שורת פקודת טיעונים,

57
00:02:47,960 --> 00:02:51,610
אתה מציין אותם כאן, לא כש
אתה מקליד GDB שם התכנית שלך.

58
00:02:51,610 --> 00:02:55,980
אתה מציין את כל שורת הפקודה
טיעונים על ידי לקיחת r, או לרוץ,

59
00:02:55,980 --> 00:03:00,270
ולאחר מכן את טענות קו מה הפקודה
אתה צריך בתוך התכנית שלך.

60
00:03:00,270 --> 00:03:03,510
יש מספר אחר באמת
פקודות חשובות ושימושיות

61
00:03:03,510 --> 00:03:04,970
בתוך סביבת התמ"ג.

62
00:03:04,970 --> 00:03:07,540
אז תן לי רק במהירות
לעבור על כמה מהם.

63
00:03:07,540 --> 00:03:11,320
>> הראשון הוא n, שהוא קצר עבור הבא,
ואתה יכול להקליד הבא במקום n,

64
00:03:11,320 --> 00:03:12,304
שני יעבדו.

65
00:03:12,304 --> 00:03:13,470
וזה רק הקצרנות.

66
00:03:13,470 --> 00:03:17,540
וכמו שבטח קיבל כבר
משמש ל, להיות מסוגל להקליד דברים

67
00:03:17,540 --> 00:03:20,520
קצר יותר הוא בדרך כלל טוב יותר.

68
00:03:20,520 --> 00:03:24,100
ומה זה יעשה הוא שזה
צעד קדימה אחד בלוק של קוד.

69
00:03:24,100 --> 00:03:26,170
אז זה יהיה להתקדם
עד קריאה לפונקציה.

70
00:03:26,170 --> 00:03:28,350
ואז במקום
צלילה לתוך הפונקציה ש

71
00:03:28,350 --> 00:03:33,130
ועובר את כל פונקציות ש
קוד, זה יהיה רק ​​צריך לתפקד.

72
00:03:33,130 --> 00:03:34,400
>> הפונקציה תיקרא.

73
00:03:34,400 --> 00:03:35,733
זה יעשה כל מה העבודה שלה היא.

74
00:03:35,733 --> 00:03:38,870
זה יחזיר ערך ל
הפונקציה שקראה לזה.

75
00:03:38,870 --> 00:03:42,490
ואז אתה עובר ל
השורה הבאה של פונקציה שקוראות.

76
00:03:42,490 --> 00:03:44,555
אם אתה רוצה לשלב
בתוך הפונקציה,

77
00:03:44,555 --> 00:03:46,430
במקום רק שיש
זה לבצע, במיוחד

78
00:03:46,430 --> 00:03:50,004
אם אתה חושב שהבעיה
עלול לשקר פנימי של פונקציה ש,

79
00:03:50,004 --> 00:03:52,670
אתה יכול, כמובן, להגדיר הפסקה
להצביע בתוך הפונקציה ש.

80
00:03:52,670 --> 00:03:57,820
או אם אתה כבר פועל, אתה יכול
להשתמש של לצעוד קדימה שורה אחת של קוד.

81
00:03:57,820 --> 00:04:01,170
>> אז זה יהיה צעד ב
לצלול לתוך פונקציות,

82
00:04:01,170 --> 00:04:04,750
במקום רק צריכים לבצע
וממשיך בפונקציה

83
00:04:04,750 --> 00:04:07,380
כי אתה לניפוי.

84
00:04:07,380 --> 00:04:09,870
אם אי פעם אתה רוצה לדעת
הערך של משתנה,

85
00:04:09,870 --> 00:04:12,507
ניתן להקליד עמ ', או הדפסה,
ולאחר מכן את השם המשתנה.

86
00:04:12,507 --> 00:04:15,090
ושיהיה להדפיס לך,
בתוך סביבת GDB,

87
00:04:15,090 --> 00:04:19,110
השם המשתנה, שאתם--
סלח me-- הערך של המשתנה

88
00:04:19,110 --> 00:04:20,064
כי אתה כבר שם.

89
00:04:20,064 --> 00:04:23,230
אם אתה רוצה לדעת את ערכיו של כל
נגיש משתנה מקומי מהמקום שבי

90
00:04:23,230 --> 00:04:25,970
אתה נמצא כרגע בך
תכנית, באפשרותך להקליד המקומיים מידע.

91
00:04:25,970 --> 00:04:28,332
זה הרבה יותר מהר מ
הקלדת p ואז מה,

92
00:04:28,332 --> 00:04:30,540
רישום את כל
משתנים שאתה יודע קיים.

93
00:04:30,540 --> 00:04:34,370
ניתן להקליד המקומיים מידע, וזה
יהיה להדפיס את הכל בשבילך.

94
00:04:34,370 --> 00:04:37,770
בשלב הבא הוא BT, אשר הוא
קצר לחצר אחורית.

95
00:04:37,770 --> 00:04:41,680
עכשיו, בדרך כלל,
מוקדם במיוחד בCS50,

96
00:04:41,680 --> 00:04:44,450
אתה לא באמת יש לי אירוע
להשתמש BT, או חזרה Trace,

97
00:04:44,450 --> 00:04:47,860
בגלל שאתה לא נתקלת בפונקציות
כי לקרוא לפונקציות אחרות.

98
00:04:47,860 --> 00:04:50,450
>> אולי יש לך שיחה העיקרית
פונקציה, אבל זה כנראה זה.

99
00:04:50,450 --> 00:04:53,199
אין לך שפונקציה אחרת
קורא פונקציה אחרת, ש

100
00:04:53,199 --> 00:04:54,880
קורא פונקציה אחרת, וכן הלאה.

101
00:04:54,880 --> 00:04:57,550
אבל תוכניות שלך לקבל יותר
מורכב, ובמיוחד

102
00:04:57,550 --> 00:05:00,290
כאשר אתה מתחיל לעבוד
עם רקורסיה, עקבות בחזרה

103
00:05:00,290 --> 00:05:05,150
יכול להיות דרך שימושית באמת לתת לך
סוג של לקבל קצת הקשר לשם

104
00:05:05,150 --> 00:05:06,460
אני בתכנית שלי.

105
00:05:06,460 --> 00:05:10,590
אז אומר לך שכתבת את הקוד שלך, ו
אתה יודע שקורא עיקרי פונקציה

106
00:05:10,590 --> 00:05:14,720
F, שקורא לפונקציה
g, אשר קורא h פונקציה.

107
00:05:14,720 --> 00:05:17,650
אז יש לנו כמה שכבות
של קינון קורה כאן.

108
00:05:17,650 --> 00:05:19,440
>> אם אתה בתוך
סביבת GDB שלך,

109
00:05:19,440 --> 00:05:21,640
ואתה יודע בתוכך
של שעות, אבל אתה שוכח

110
00:05:21,640 --> 00:05:27,210
על מה יש לך למקום שבך
הן-- תוכל להקליד BT, או עקבות בחזרה,

111
00:05:27,210 --> 00:05:32,370
והוא יודפס h, g החוצה, ו עיקרי,
לצד חלק מהמידע אחר, ש

112
00:05:32,370 --> 00:05:35,984
נותן לך מושג ש, עיקרי על אישור
f נקראת, ו ז נקרא, גרם נקראת h,

113
00:05:35,984 --> 00:05:37,900
וזה המקום שבו
כרגע אני בתכנית שלי.

114
00:05:37,900 --> 00:05:41,380
אז זה יכול להיות שימושי מאוד,
במיוחד כסתום-נס של GDB

115
00:05:41,380 --> 00:05:45,667
הופך להיות קצת מכריע, ל
לברר בדיוק היכן נמצאים דברים.

116
00:05:45,667 --> 00:05:48,500
לבסוף, כאשר התכנית שלך נעשה,
או כשתסיים באגים זה

117
00:05:48,500 --> 00:05:50,125
ואתה רוצה להתרחק
מסביבת GDB,

118
00:05:50,125 --> 00:05:51,940
זה עוזר לדעת איך לצאת מזה.

119
00:05:51,940 --> 00:05:55,500
ניתן להקליד q, או צא, לצאת.

120
00:05:55,500 --> 00:05:59,220
עכשיו, לפני שהווידאו של היום
הכנתי תכנית מרכבה

121
00:05:59,220 --> 00:06:03,900
buggy1 נקרא, שאני הידור
מקובץ הידוע כbuggy1.c.

122
00:06:03,900 --> 00:06:06,500
כפי שאפשר לצפות, זה
תכנית היא בעגלת עובדה.

123
00:06:06,500 --> 00:06:08,990
משהו משתבש
כאשר אני מנסה ולהפעיל אותו.

124
00:06:08,990 --> 00:06:13,014
עכשיו, למרבה הצער, אני לא מדעת
נמחק קובץ buggy1.c,

125
00:06:13,014 --> 00:06:15,930
זאת על מנת לי להבין
מה השתבש עם תכנית זו,

126
00:06:15,930 --> 00:06:18,770
אני הולך צריך להשתמש
GDB סוג של עיוורון, מנסה

127
00:06:18,770 --> 00:06:22,372
כדי לנווט בתכנית זו ב
להבין בדיוק מה השתבש.

128
00:06:22,372 --> 00:06:24,580
אבל רק באמצעות הכלים
אנחנו כבר למדנו על,

129
00:06:24,580 --> 00:06:27,700
אנחנו יכולים פחות או יותר דמות
בדיוק מה שזה.

130
00:06:27,700 --> 00:06:30,740
אז בואו מעל הראש
יש לי CS50 IDE ומראה.

131
00:06:30,740 --> 00:06:33,155
אוקיי, אז אנחנו כאן בי
סביבת IDE CS50,

132
00:06:33,155 --> 00:06:35,697
ואני להתקרב קצת
כך שתוכל לראות קצת יותר.

133
00:06:35,697 --> 00:06:38,530
בחלון המסוף שלי, אם אני ברשימה
התוכן של המנהל הנוכחי שלי

134
00:06:38,530 --> 00:06:41,250
עם ls, נראה לי ש
יש לי כמה קבצי מקור

135
00:06:41,250 --> 00:06:44,982
כאן, כולל
דן בעבר buggy1.

136
00:06:44,982 --> 00:06:46,940
מה בדיוק קורה כש
אני מנסה ולהפעיל buggy1.

137
00:06:46,940 --> 00:06:47,773
ובכן בואו לגלות.

138
00:06:47,773 --> 00:06:52,510
אני מקליד קו נטוי נקודה,
מרכבה, ואני מכה על Enter.

139
00:06:52,510 --> 00:06:53,670
>> תקלות פילוח.

140
00:06:53,670 --> 00:06:55,000
זה לא טוב.

141
00:06:55,000 --> 00:06:57,180
אם אתה זוכר,
אשמת פילוח בדרך כלל

142
00:06:57,180 --> 00:07:01,540
מתרחש כאשר אנו ניגשים לזיכרון
שאסור לגעת.

143
00:07:01,540 --> 00:07:03,820
אנחנו כבר הגענו איכשהו
מחוץ לגבולות

144
00:07:03,820 --> 00:07:05,995
של מה בתכנית,
מהדר, נתן לנו.

145
00:07:05,995 --> 00:07:08,310
וכך כבר זה
רמז לשמור בארגז הכלים

146
00:07:08,310 --> 00:07:10,660
כפי שאנו מתחילים את תהליך הניפוי.

147
00:07:10,660 --> 00:07:13,620
משהו הלך קצת לא בסדר כאן.

148
00:07:13,620 --> 00:07:15,935
>> ההתחלה בסדר, אז בואו
את סביבת GDB

149
00:07:15,935 --> 00:07:19,030
ולראות אם אנחנו יכולים להבין
מה בדיוק הבעיה.

150
00:07:19,030 --> 00:07:21,674
אני הולך לנקות את המסך שלי,
ואני הולך להקליד GDB

151
00:07:21,674 --> 00:07:24,340
שוב, להיכנס לסביבת GDB,
והשם של התכנית

152
00:07:24,340 --> 00:07:27,450
שאני רוצה לאתר באגים, buggy1.

153
00:07:27,450 --> 00:07:30,182
אנחנו מקבלים הודעה קטנה, קריאה
סימנים מbuggy1, עשו.

154
00:07:30,182 --> 00:07:32,390
כל זה אומר שזה משך
יחד את כל הקוד,

155
00:07:32,390 --> 00:07:35,570
ועכשיו זה כבר הועמס
GDB, והוא מוכן ללכת.

156
00:07:35,570 --> 00:07:37,140
>> עכשיו, מה שאני רוצה לעשות?

157
00:07:37,140 --> 00:07:39,130
האם אתה זוכר מה
הצעד הראשון הוא בדרך כלל

158
00:07:39,130 --> 00:07:42,540
אחרי שאני בתוך סביבה זו?

159
00:07:42,540 --> 00:07:44,540
יש לקוות, שאמרת שנקבע
נקודת פריצה, כי

160
00:07:44,540 --> 00:07:46,240
בעובדה שזה מה שאני רוצה לעשות.

161
00:07:46,240 --> 00:07:47,990
עכשיו, אין לי
קוד מקור לזה

162
00:07:47,990 --> 00:07:50,948
מולי, שהוא כנראה
לא במקרה השימוש הטיפוסי, דרך אגב.

163
00:07:50,948 --> 00:07:52,055
אתה כנראה יהיה.

164
00:07:52,055 --> 00:07:52,680
אז זה טוב.

165
00:07:52,680 --> 00:07:55,790
אבל בהנחה שאתה לא, מה
פונקציה אחת שיודע

166
00:07:55,790 --> 00:07:58,880
קיים בכל אחד תכנית C?

167
00:07:58,880 --> 00:08:04,420
לא משנה כמה גדול או כמה מסובך
זה, בהחלט קיימת פונקציה זו.

168
00:08:04,420 --> 00:08:05,440
ראשי, נכון?

169
00:08:05,440 --> 00:08:08,870
>> אז אי לכל דבר אחר, אנחנו יכולים
להגדיר נקודת הפסקה בעיקרית.

170
00:08:08,870 --> 00:08:12,200
ושוב, אני יכול פשוט להקליד
לשבור עיקרי, במקום ב.

171
00:08:12,200 --> 00:08:14,650
ואם אתם סקרנים, אם אתה
אי פעם להקליד את הפקודה ארוכה

172
00:08:14,650 --> 00:08:16,800
ואז להבין שאתה
הקליד את הדבר הלא נכון,

173
00:08:16,800 --> 00:08:18,770
ואתה רוצה להיפטר
כל שאני פשוט עשיתי,

174
00:08:18,770 --> 00:08:22,029
אתה יכול לקחת את השליטה U, שיהיה
למחוק הכל ולהביא אותך בחזרה

175
00:08:22,029 --> 00:08:23,570
לתחילת קווי הסמן.

176
00:08:23,570 --> 00:08:26,569
הרבה יותר מהר מאשר רק החזק את
למחוק, או להכות אותו חבורת פעמים

177
00:08:26,569 --> 00:08:27,080
על.

178
00:08:27,080 --> 00:08:28,740
>> אז נגדיר נקודת הפסקה בעיקרית.

179
00:08:28,740 --> 00:08:32,970
וכמו שאתה יכול לראות, זה אומר שיש לנו
להגדיר נקודת הפסקה בbuggy1.c קובץ,

180
00:08:32,970 --> 00:08:36,330
וכנראה השורה הראשונה
קוד של עיקרי הוא קו שבעה.

181
00:08:36,330 --> 00:08:38,080
שוב, אין לנו
קובץ המקור כאן,

182
00:08:38,080 --> 00:08:40,429
אבל אני מניח שזה
אומר לי את האמת.

183
00:08:40,429 --> 00:08:44,510
ואז, אני רק מנסה
ולהפעיל את התכנית, r.

184
00:08:44,510 --> 00:08:45,360
הפעלת תכנית.

185
00:08:45,360 --> 00:08:48,160
בסדר, אז הודעה זו
הוא קצת סתום.

186
00:08:48,160 --> 00:08:50,160
אבל בעצם מה
קורה כאן הוא שזה פשוט

187
00:08:50,160 --> 00:08:53,350
אומר לי שאני פגע ההפסקה שלי
נקודה, נקודת מספר 1 הפסקה.

188
00:08:53,350 --> 00:08:55,877
>> ולאחר מכן, קו זה של קוד,
אין כזה קובץ או תקייה.

189
00:08:55,877 --> 00:08:57,710
הסיבה היחידה ש
אני רואה שהודעה

190
00:08:57,710 --> 00:09:00,800
כי אני בטעות
נמחק קובץ buggy.c.

191
00:09:00,800 --> 00:09:04,050
אם קובץ buggy1.c קיים
במדריך הנוכחי,

192
00:09:04,050 --> 00:09:06,920
כי זכות קו בעצם יש היית
תגיד לי מה את שורת קוד

193
00:09:06,920 --> 00:09:08,214
פשוטו כמשמעו קורא.

194
00:09:08,214 --> 00:09:09,380
לרוע המזל, אני מחקתי אותו.

195
00:09:09,380 --> 00:09:14,790
אנחנו הולכים צריכים לנווט סוג של
באמצעות זה קצת יותר באופן עיוור.

196
00:09:14,790 --> 00:09:17,330
>> אוקיי, אז בואו נראה, מה
אני רוצה לעשות כאן?

197
00:09:17,330 --> 00:09:21,770
ובכן, אני רוצה לדעת מה מקומי
משתנים אולי הם זמינים לי.

198
00:09:21,770 --> 00:09:23,570
אני כבר התחלתי התכנית שלי.

199
00:09:23,570 --> 00:09:28,515
בואו לראות מה יכול להיות
כבר אותחל עבורנו.

200
00:09:28,515 --> 00:09:31,430
אני מקליד המקומיים מידע, לא מקומי.

201
00:09:31,430 --> 00:09:33,960
בסדר, אז שלא
תן לי טונות של מידע.

202
00:09:33,960 --> 00:09:37,600
אני יכול לנסות ולהדפיס את משתנה,
אבל אני לא יודע כל שמות משתנים.

203
00:09:37,600 --> 00:09:39,930
אני יכול לנסות חצר אחורית,
אבל אני בתוך עיקרי,

204
00:09:39,930 --> 00:09:43,710
אז אני יודע שאני לא עשיתי
קריאה לפונקציה אחרת עכשיו.

205
00:09:43,710 --> 00:09:47,710
>> אז נראה כמו האפשרויות היחידה שלי הן
להשתמש n או כך ולהתחיל לצלול ב.

206
00:09:47,710 --> 00:09:49,630
אני הולך להשתמש n.

207
00:09:49,630 --> 00:09:51,180
אז אני מקליד n.

208
00:09:51,180 --> 00:09:53,060
אוי ואבוי, מה קורה כאן.

209
00:09:53,060 --> 00:09:56,260
תכנית קיבלה אותות,
אשמת פילוח SIGSEGV,

210
00:09:56,260 --> 00:09:57,880
ולאחר מכן חבורה של דברים כולה.

211
00:09:57,880 --> 00:09:58,880
אני כבר המום.

212
00:09:58,880 --> 00:10:00,980
ובכן, יש למעשה
הרבה מה ללמוד כאן.

213
00:10:00,980 --> 00:10:02,520
אז מה זה אומר לנו?

214
00:10:02,520 --> 00:10:09,180
מה זה אומר לנו הוא, תכנית זו היא
עומד, אבל עדיין לא, אשמת SEG.

215
00:10:09,180 --> 00:10:12,550
ובפרט, אני הולך
כדי להתקרב עוד יותר כאן,

216
00:10:12,550 --> 00:10:18,980
זה בערך לצינוק אשמה על
משהו שנקרא strcmp.

217
00:10:18,980 --> 00:10:22,705
>> עכשיו, ייתכן שלא דנו
פונקציה זו בהרחבה.

218
00:10:22,705 --> 00:10:25,580
אבל זה הוא-- כי אנחנו לא הולכים
לדבר על כל פונקציה ש

219
00:10:25,580 --> 00:10:28,610
קיים בתקן C library--
אבל הם כולם זמינים לך,

220
00:10:28,610 --> 00:10:32,110
במיוחד אם אתה לוקח
להסתכל reference.cs50.net.

221
00:10:32,110 --> 00:10:35,000
וstrcmp הוא באמת חזק
פונקציה שקיימת בתוך

222
00:10:35,000 --> 00:10:38,070
של כותרת string.h
קובץ, אשר היא כותרת

223
00:10:38,070 --> 00:10:41,970
קובץ שמוקדש לפונקציות
כי עבודה עם ולתפעל מחרוזות.

224
00:10:41,970 --> 00:10:49,830
>> ובפרט, מה שעושה הוא strcmp
הוא משווה את הערכים של שתי מחרוזות.

225
00:10:49,830 --> 00:10:54,160
אז אני עומד פילוח אשמה
בשיחה לstrcmp שזה נראה.

226
00:10:54,160 --> 00:10:58,530
אני מכה n, ולמעשה אני מקבל את ההודעה,
תכנית הסתיימה עם SIGSEGV אות

227
00:10:58,530 --> 00:11:01,370
אשמת פילוח. אז עכשיו
אני ממש פגמתי SEG,

228
00:11:01,370 --> 00:11:06,479
והתכנית שלי יש די
הרבה יעילות ויתר.

229
00:11:06,479 --> 00:11:07,770
זה הסוף של התכנית.

230
00:11:07,770 --> 00:11:10,370
זה נשבר, התרסק.

231
00:11:10,370 --> 00:11:14,740
אז לא היה הרבה, אבל אני
למעשה עשה ללמוד לא מעט

232
00:11:14,740 --> 00:11:16,747
מהניסיון הקטן הזה.

233
00:11:16,747 --> 00:11:17,580
מה למדתי?

234
00:11:17,580 --> 00:11:22,020
ובכן, התכנית שלי מתרסקת
פחות או יותר באופן מיידי.

235
00:11:22,020 --> 00:11:26,300
התכנית שלי מתרסקת על
קורא לstrcmp, אבל אני

236
00:11:26,300 --> 00:11:30,560
אין לי שום משתנים מקומיים בי
תכנית בזמן שהוא מתרסק.

237
00:11:30,560 --> 00:11:37,320
אז מה מחרוזת, או מחרוזות,
אני יכול אולי להיות השוואה.

238
00:11:37,320 --> 00:11:42,140
אם אין לי שום מקומי
משתנים, שאולי

239
00:11:42,140 --> 00:11:45,520
לשער שנו-- יש אולי הוא
משתנה גלובלי, שיכול להיות נכון.

240
00:11:45,520 --> 00:11:47,670
>> אבל בדרך כלל, זה נראה
כאילו אני משווה

241
00:11:47,670 --> 00:11:52,070
למשהו שאינו קיימים.

242
00:11:52,070 --> 00:11:54,130
אז בואו לחקור
כי עוד מעט.

243
00:11:54,130 --> 00:11:55,120
אז אני הולך לנקות את המסך שלי.

244
00:11:55,120 --> 00:11:57,536
אני הולך להיסגר מחוץ ל
סביבת GDB לשנייה.

245
00:11:57,536 --> 00:12:01,300
ואני חושב, בסדר, אז יש
אין משתנים מקומיים בתכנית שלי.

246
00:12:01,300 --> 00:12:06,444
אני תוהה אם אולי אני אמור לעבור
במחרוזת כטיעון שורת הפקודה.

247
00:12:06,444 --> 00:12:07,610
אז בואו פשוט לבדוק את זה.

248
00:12:07,610 --> 00:12:09,020
אני לא עשיתי את זה קודם.

249
00:12:09,020 --> 00:12:14,244
>> בואו אראה אם ​​אולי אם אני מפעיל תכנית זו
עם טיעון שורת הפקודה זה עובד.

250
00:12:14,244 --> 00:12:16,140
הא, לא באשמת פילוח שם.

251
00:12:16,140 --> 00:12:17,870
זה פשוט אמר לי שהבנתי את זה.

252
00:12:17,870 --> 00:12:19,170
אז אולי זה התיקון כאן.

253
00:12:19,170 --> 00:12:27,560
ואכן, אם אני חוזר ומסתכל
קוד המקור הממשי לbuggy1.c,

254
00:12:27,560 --> 00:12:31,180
זה נראה כאילו מה שאני עושה הוא
אני עושה שיחה לstrcmp ללא

255
00:12:31,180 --> 00:12:34,010
לבדוק אם אכן argv [1] קיים.

256
00:12:34,010 --> 00:12:36,730
זהו למעשה
קוד המקור לbuggy1.c.

257
00:12:36,730 --> 00:12:38,855
אז מה אני באמת צריכה
לעשות כאן כדי לתקן את התכנית שלי,

258
00:12:38,855 --> 00:12:40,835
בהנחה שיש לי
להגיש מולי, הוא

259
00:12:40,835 --> 00:12:44,740
רק להוסיף סימון כדי להפוך את
בטוח שargc הוא שווה ל 2.

260
00:12:44,740 --> 00:12:47,780
אז דוגמא זו, שוב, כמו שאמרתי,
זה קצת מאולץ, נכון?

261
00:12:47,780 --> 00:12:49,840
אתה לא בדרך כלל הולך ל
להסיר את קוד המקור שלך בטעות

262
00:12:49,840 --> 00:12:51,820
ולאחר מכן יש לנסות
ולאתר באגים בתכנית.

263
00:12:51,820 --> 00:12:53,120
אבל אני מקווה, זה נתן לי
אתה איור

264
00:12:53,120 --> 00:12:55,120
של מיני דברים ש
אתה יכול לחשוב על

265
00:12:55,120 --> 00:12:56,610
כפי שאתה באגים התכנית שלך.

266
00:12:56,610 --> 00:12:58,760
>> מה מצב עניינים כאן?

267
00:12:58,760 --> 00:13:00,510
מה לעשות אני משתנים
יש לי נגיש לי?

268
00:13:00,510 --> 00:13:03,600
איפה בדיוק התכנית שלי
מתרסק, על מה קו,

269
00:13:03,600 --> 00:13:05,240
על מה קריאה לפונקציה מה?

270
00:13:05,240 --> 00:13:06,952
איזה סוג של רמזים שאין לתת לי?

271
00:13:06,952 --> 00:13:08,910
וזה בדיוק
סוג של הלך רוח ש

272
00:13:08,910 --> 00:13:12,820
יש להיכנס לכאשר אתה
חושב על באגים התוכניות שלך.

273
00:13:12,820 --> 00:13:13,820
>> אני דאג לויד.

274
00:13:13,820 --> 00:13:16,140
זה CS50.

275
00:13:16,140 --> 00:15:08,642