1
00:00:07,170 --> 00:00:12,630
[Powered by Google Translate] GDB, הפרויקט גנה Debugger, הוא כלי רב עצמה לאיתור באגים, C

2
00:00:12,630 --> 00:00:14,300
יחד עם שפות רבות אחרות.

3
00:00:14,300 --> 00:00:17,440
זה מאפשר לך לחטט בתוך תוכניות C שלך בזמן שהם מבצעים,

4
00:00:17,440 --> 00:00:20,880
וזה גם נותן לך את ההזדמנות לראות בדיוק מה קורה

5
00:00:20,880 --> 00:00:22,490
כאשר תכנית הקריסות שלך.

6
00:00:22,490 --> 00:00:24,690
זה די מגניב, נכון?

7
00:00:24,690 --> 00:00:27,980
GDB הוא תוכנה חופשיה, והיא מופעלת ברבי UNIX הפופולרי

8
00:00:27,980 --> 00:00:31,840
מערכות הפעלה מבוססת Windows, כך שזה כלי נפוץ מאוד.

9
00:00:31,840 --> 00:00:33,560
>> אתה צריך ללמוד לאהוב אותו.

10
00:00:33,560 --> 00:00:36,800
יתרונות GDB יש זמן הרבה יותר קל לאתר את הבאגים

11
00:00:36,800 --> 00:00:39,150
מאלו שלהסתדר איכשהו באמצעות ניחושים

12
00:00:39,150 --> 00:00:41,420
וכמויות אינסופיות הצהרות תדפיסים.

13
00:00:41,420 --> 00:00:45,810
GDB הוא כלי שורת פקודה, מה שאומר שאתה יכול לתקשר איתו במסוף

14
00:00:45,810 --> 00:00:49,720
הנפקה באמצעות פקודות המקלדת במקום כפתורי לחיצה עם העכבר.

15
00:00:49,720 --> 00:00:54,960
>> כדי להתחיל את GDB, אתה ממש ממש gdb סוג בשורת הפקודה וקש.

16
00:00:54,960 --> 00:00:58,230
אתה תראה כמה שורות המודפסות מחוץ למסך

17
00:00:58,230 --> 00:01:00,810
מראה לך את הגרסה של GDB שאתה מפעיל,

18
00:01:00,810 --> 00:01:07,890
המידע על זכויות היוצרים שלו, ובסופו של דבר תראה GDB פקודה: (gdb).

19
00:01:07,890 --> 00:01:10,770
זה מאפשר לך לדעת שGDB מוכן לפקודות.

20
00:01:10,770 --> 00:01:15,400
בנקודה זו, הדבר החשוב ביותר שיודע איך לעשות אותו להתפטר.

21
00:01:15,400 --> 00:01:17,790
למרבה המזל, זה די פשוט.

22
00:01:17,790 --> 00:01:19,840
הפקודה להפסיק עושה בדיוק את זה.

23
00:01:19,840 --> 00:01:23,090
כקיצור דרך, אתה יכול פשוט להשתמש q מדי.

24
00:01:23,090 --> 00:01:27,410
כיף כמו באתחול GDB ומייד עזיבה הוא,

25
00:01:27,410 --> 00:01:30,800
עכשיו בואו לדבר על שימוש GDB לעזור לדבג תכנית.

26
00:01:30,800 --> 00:01:34,630
>> כדי להתחיל, יש לי תכנית כאן בfactorial.c

27
00:01:34,630 --> 00:01:37,380
שמקבל int ומנסה לחשבו עצרת.

28
00:01:37,380 --> 00:01:41,270
במקרה שלא ראו את factorials לפני או לא זוכר אותם,

29
00:01:41,270 --> 00:01:47,840
העצרת של מספר n שווה למכפלה של n - (n - 1), (n - 2), וכן הלאה -

30
00:01:47,840 --> 00:01:49,230
עד שתגיע 1.

31
00:01:49,230 --> 00:01:54,550
לכן, העצרת של 3 היא 3 * 2 * 1, או 6,

32
00:01:54,550 --> 00:02:00,180
ואת העצרת של 4 היא 4 * 3 * 2 * 1, או 24.

33
00:02:00,180 --> 00:02:03,970
העצרת של אפס היא מקרה מוזר, זה 1,

34
00:02:03,970 --> 00:02:06,970
וfactorials של מספרים שלמים שלילי אינו מוגדר.

35
00:02:06,970 --> 00:02:10,280
בכל אופן, משהו על התכנית שלי הוא עצרת פאנקי.

36
00:02:10,280 --> 00:02:15,410
כאשר אני מפעיל אותו, זה מדפיס את מספרים מוזרים שאין לי מה לעשות עם factorials.

37
00:02:15,410 --> 00:02:19,030
>> לכן, אנו יכולים להשתמש GDB כדי לעזור להבין מה קורה.

38
00:02:19,030 --> 00:02:21,720
GDB פועל על קבצי הפעלה,

39
00:02:21,720 --> 00:02:24,910
אשר הם קבצים בינאריים המיוצרים על ידי תהליך ההידור.

40
00:02:24,910 --> 00:02:30,940
כלומר, אנחנו לא יכולים לרוץ על GDB. C שלנו או. קבצי קוד מקור h כמו factorial.c.

41
00:02:30,940 --> 00:02:34,650
אנחנו רוצים להפעיל אותו בעצרת בדיוק במקום.

42
00:02:34,650 --> 00:02:38,340
אם התכנית נדרשת כל טיעוני שורת פקודה,

43
00:02:38,340 --> 00:02:40,230
זה המקום שבו לציין אותם.

44
00:02:40,230 --> 00:02:44,050
במקרה זה, עצרת אינה דורשת כל טיעוני שורת פקודה,

45
00:02:44,050 --> 00:02:46,410
אז אנחנו פשוט הקלידו ריצה או r לקצר.

46
00:02:46,410 --> 00:02:50,440
>> זה יתחיל בהפעלת תכנית העצרת.

47
00:02:50,440 --> 00:02:53,940
כאשר התכנית מפסיקה לרוץ, אני אביא GDB לבקש בחזרה.

48
00:02:53,940 --> 00:02:58,130
אוקיי, בואו ננסה את אותו הדבר שוב, עצרת של 4.

49
00:02:58,130 --> 00:03:02,910
בסדר, אנחנו רואים שאנחנו מקבלים את אותו סוג של זבל כאן בGDB.

50
00:03:02,910 --> 00:03:04,850
עכשיו, אחרי שהתכנית הסתיימה,

51
00:03:04,850 --> 00:03:06,870
אנחנו לא יכולים להיכנס ולגשת לכל במדינתו,

52
00:03:06,870 --> 00:03:09,870
ולכן אנחנו צריכים להתחיל אותו לפעול שוב לפני שנוכל לראות מה קורה.

53
00:03:09,870 --> 00:03:13,570
עם זאת, אנחנו צריכים דרך לעצור את זה בזמן שהוא באמצע הטווח שלה.

54
00:03:13,570 --> 00:03:16,970
>> כדי לעשות זאת, אנחנו משתמשים במה שנקרא נקודת עצירה.

55
00:03:16,970 --> 00:03:21,880
נקודתי עצירה לספר GDB כדי להשהות את התכנית בפונקציה מסוימת או קו קוד מקור

56
00:03:21,880 --> 00:03:24,070
כדי שנוכל לבחון את מצב התכנית,

57
00:03:24,070 --> 00:03:27,380
הערכים של משתנים, המצב של זיכרון וכך, בשלב זה.

58
00:03:27,380 --> 00:03:30,750
מכיוון שאני לא באמת יודע לאן הדברים הולכים בסדר,

59
00:03:30,750 --> 00:03:33,510
>> אני רק רוצה להתחיל באגים ממש בהתחלה מאוד,

60
00:03:33,510 --> 00:03:36,510
נכון כאשר ראשי מתחיל.

61
00:03:36,510 --> 00:03:39,260
אנו נקבע את נקודת עצירה בתחילה עיקרית באמצעות פקודת ההפסקה.

62
00:03:39,260 --> 00:03:42,640
אנחנו יכולים גם להשתמש ב לקצר הפסקה.

63
00:03:42,640 --> 00:03:45,000
עכשיו בואו נתחיל את התכנית לפעול שוב.

64
00:03:45,000 --> 00:03:48,140
כאן אנו נמצאים בתחילתו של ראשי, בדיוק כמו GDB מספר לנו.

65
00:03:48,140 --> 00:03:51,970
שורת הקוד שעומדת לבצע, אך יש עדיין לא

66
00:03:51,970 --> 00:03:53,480
הוא קו printf.

67
00:03:53,480 --> 00:03:57,200
אנחנו יכולים לספר לי GDB לביצוע שורת קוד הזאת וללכת לשורה הבאה

68
00:03:57,200 --> 00:03:59,840
עם הפקודה הבאה או n.

69
00:03:59,840 --> 00:04:04,120
>> בסדר, עכשיו GDB אומר לנו שאנחנו בקו GetInt.

70
00:04:04,120 --> 00:04:06,630
אני יודע שזה נראה כמו שורת printf לא ברחה

71
00:04:06,630 --> 00:04:10,070
מכיוון שאנו לא רואים "זן חיובי שלמה" הדפסה על המסך,

72
00:04:10,070 --> 00:04:12,040
אבל זה ממש לא לרוץ.

73
00:04:12,040 --> 00:04:16,029
מה שאנו רואים הוא מערכת ההפעלה לדכא משהו כתיבה על המסך

74
00:04:16,029 --> 00:04:19,649
עד שאין ברירה אחרת, שסיבת ניפוי באגים עם תדפיסים

75
00:04:19,649 --> 00:04:21,730
יכול לפעמים נראה לא אמין.

76
00:04:21,730 --> 00:04:26,240
בכל מקרה, בואו נלך שוב לשורה הבאה של קוד ולהיכנס בint.

77
00:04:26,240 --> 00:04:30,070
שוב, בואו סוג 4.

78
00:04:30,070 --> 00:04:34,540
אז זה נראה מוזר. אנחנו בקו 12 על פי GDB,

79
00:04:34,540 --> 00:04:37,660
אבל השורה הבאה שעומדות לבצע היא רק סד מתולתל.

80
00:04:37,660 --> 00:04:42,110
>> זה רק אומר שאנחנו בסופו של לולאה, לעשות בזמן לולאה למעשה,

81
00:04:42,110 --> 00:04:46,710
וGDB אומר לנו שמצב הסיום, כלומר לא פחות מאפס,

82
00:04:46,710 --> 00:04:48,010
יבצע הבא.

83
00:04:48,010 --> 00:04:50,230
אם זה אי פעם נעשה קצת מבלבל,

84
00:04:50,230 --> 00:04:54,860
אנחנו יכולים למשוך את קוד המקור בGDB עם הרשימה או פקודת הליטר.

85
00:04:54,860 --> 00:04:56,880
זו מדפיסה את קוד המקור

86
00:04:56,880 --> 00:04:59,010
זה מרוכז סביב הקו שאנחנו נמצאים כעת.

87
00:04:59,010 --> 00:05:03,590
אם רשימה או הקלידו שוב אני, אנחנו נראה את הקבוצה הבאה של קווים להדפיס.

88
00:05:03,590 --> 00:05:06,070
אנחנו יכולים לעשות את זה עד שנגיע לסוף הקובץ.

89
00:05:06,070 --> 00:05:11,210
>> כדי לחזור למקום שבו היינו, אנו יכולים לספק רשימה עם מספר קו,

90
00:05:11,210 --> 00:05:14,120
במקרה זה, קו 12.

91
00:05:14,120 --> 00:05:16,040
בכל אופן, בואו נמשיך הלאה.

92
00:05:16,040 --> 00:05:18,240
עכשיו אנחנו על 4 לולאה.

93
00:05:18,240 --> 00:05:21,490
בואו נוודא שמשתנת num מכילה 4.

94
00:05:21,490 --> 00:05:26,170
אנו עושים זאת עם הדפסה, או p, פקודה.

95
00:05:26,170 --> 00:05:31,140
אז, GDB אומר לנו שאכן num אחסון 4, כפי שציפינו.

96
00:05:31,140 --> 00:05:35,180
1 $ GDB שמדפיס הוא משתנה GDB מיוחד

97
00:05:35,180 --> 00:05:37,720
שעכשיו מוגדר לאחסון 4 המספר גם כן.

98
00:05:37,720 --> 00:05:42,240
אתה יכול להתעלם מזה לעת עתה, אבל משתני GDB אלה באים בסופר שימושיים

99
00:05:42,240 --> 00:05:46,380
במקרים מתקדמים יותר כאשר ברצונך להיזכר במה שעשית בעבר.

100
00:05:46,380 --> 00:05:50,970
בכל אופן, תעברו לגור איתי הבא, אנחנו רואים שאנחנו מתחילים לנוע דרך ללולאה.

101
00:05:50,970 --> 00:05:54,790
בואו נשמור עובר כאן עם קצת n לאט.

102
00:05:54,790 --> 00:05:58,280
במקום להקליד n בכל פעם, אתה יכול גם פשוט הקש על Enter.

103
00:05:58,280 --> 00:06:03,710
כאשר אתה מקיש Enter ללא הקלדת כלום, פשוט חוזר על GDB הפקודה הקודמת.

104
00:06:03,710 --> 00:06:05,910
אז עכשיו שפגענו שיחת printf.

105
00:06:05,910 --> 00:06:09,520
זה נראה כמו מה שעברנו אכן דרכנו ללולאה 4 פעמים,

106
00:06:09,520 --> 00:06:13,750
וזה מה שאנחנו רוצים לעשות על מנת להכפיל 1, 2, 3, ו 4.

107
00:06:13,750 --> 00:06:15,870
>> הכל נראה כמו שזה עובד,

108
00:06:15,870 --> 00:06:19,680
למעט כאשר אנחנו פוגעים הבאים שוב אנחנו מקבלים מספר עצום זה במקום 24.

109
00:06:19,680 --> 00:06:23,100
אם להדפיס את הערך של p באמצעות עצרת,

110
00:06:23,100 --> 00:06:26,120
אנו רואים שעצרת אינה צריך מספר עצום זה בזה.

111
00:06:26,120 --> 00:06:28,740
משהו בהחלט לא תקין.

112
00:06:28,740 --> 00:06:31,960
בשלב זה, אם כי, אנחנו כמעט בסוף התכנית,

113
00:06:31,960 --> 00:06:34,610
וזה כבר מאוחר מדי לתקן כל דבר.

114
00:06:34,610 --> 00:06:39,750
>> עם זאת, אנו יכולים להפעיל מחדש את התכנית על ידי הקלדת r שוב ואז Y לאישור.

115
00:06:39,750 --> 00:06:43,460
עכשיו אנחנו שוב בנקודת העצירה שלנו בתחילה ראשית.

116
00:06:43,460 --> 00:06:46,600
אנחנו יודעים שהכל נראה בסדר גמור עם הקריאה בn.

117
00:06:46,600 --> 00:06:48,630
כדי שנוכל לקפוץ קדימה עם n.

118
00:06:48,630 --> 00:06:52,280
לחלופין, אנו יכולים להגדיר נקודת עצירה חדשה לאחר לעשות בזמן לולאה

119
00:06:52,280 --> 00:06:54,910
ולקפוץ לשם. בואו לעשות את זה.

120
00:06:54,910 --> 00:06:59,080
נראה כמו קו 14 מגיע רק אחרי הלולאה.

121
00:06:59,080 --> 00:07:01,070
בואו נקבענו נקודת עצירה שם.

122
00:07:01,070 --> 00:07:05,220
זה תרגול טוב כדי לציין את שם הקובץ בפקודת עצירה זו

123
00:07:05,220 --> 00:07:08,480
מאז GDB יכול להתבלבל אם אתה עובד עם קבצים מרובים.

124
00:07:08,480 --> 00:07:13,230
כדי להתקדם לנקודת עצירה זו, אנו נשתמש להמשיך או פקודת ג.

125
00:07:13,230 --> 00:07:16,570
>> אוקיי, הנה אנחנו בלולאה.

126
00:07:16,570 --> 00:07:19,060
בואו נלך לקו 1 יותר ללולאה,

127
00:07:19,060 --> 00:07:21,630
ואז תתחילו משתני הדפסה כדי לראות מה קורה.

128
00:07:21,630 --> 00:07:26,410
בואו נוודא שהוא אכן 1, כצפוי.

129
00:07:26,410 --> 00:07:28,300
כן, זה כל מה שטוב.

130
00:07:28,300 --> 00:07:30,270
מה לגבי עצרת ש?

131
00:07:30,270 --> 00:07:33,760
וואו, זה לא טוב.

132
00:07:33,760 --> 00:07:35,800
יש לנו מספר שלילי גדול כאן.

133
00:07:35,800 --> 00:07:38,190
איך זה קרה?

134
00:07:38,190 --> 00:07:40,040
ובכן, אם אנחנו מסתכלים אחורה בקוד,

135
00:07:40,040 --> 00:07:44,800
אנו רואים שמעולם לא אותחלנו את זה, אז רק שיש לנו זבל לשם.

136
00:07:44,800 --> 00:07:46,820
זה בהחלט יהיה לזרוק את החישוב שלנו.

137
00:07:46,820 --> 00:07:49,930
>> למרבה המזל, אין לנו לעזוב GDB כדי לתקן את זה.

138
00:07:49,930 --> 00:07:54,590
אנחנו יכולים לאתחל אותו ממש כאן ולתקן את זה בקוד מאוחר יותר באמצעות פקודת ההדפסה.

139
00:07:54,590 --> 00:07:59,500
אנחנו לאתחל אותו עד 1 מאז factorials של אפס ושניהם 1 1,

140
00:07:59,500 --> 00:08:03,940
ואם אנחנו לאתחל אותו לאפס, אז הייתי תמיד בסופו של דבר עם אפס כתוצאה שלנו.

141
00:08:03,940 --> 00:08:08,370
באפשרותך להגדיר כל משתנית בדרך זו, שהוא סופר שימושי.

142
00:08:08,370 --> 00:08:10,920
עכשיו, בואו נמשיך בתכנית שלנו.

143
00:08:10,920 --> 00:08:14,040
בואו נוודא שכל מה ששם זה אמור להיות.

144
00:08:14,040 --> 00:08:19,090
מס צריך להיות 4, אני צריך להיות 1, והעצרת אמורה להיות 1 מדי.

145
00:08:19,090 --> 00:08:23,990
אנחנו יכולים לקצר את התהליך הזה ולהדפיס את כל המשתנים המקומיים שלנו

146
00:08:23,990 --> 00:08:26,440
עם המקומיים מידע פיקוד סופר המועילים,

147
00:08:26,440 --> 00:08:29,190
אשר מדפיס את כל המשתנים המקומיים בהיקף שלנו.

148
00:08:29,190 --> 00:08:31,980
בכל אופן, זה נראה כאילו הכול טוב ללכת.

149
00:08:31,980 --> 00:08:34,700
>> בואו נעשה עוד ללכת סביב למעגל רק כדי לוודא.

150
00:08:34,700 --> 00:08:38,789
אוקיי, הכל נראה נהדר.

151
00:08:38,789 --> 00:08:41,659
עכשיו אנחנו יכולים להשתמש בפקודה להמשיך ללכת עד הסוף.

152
00:08:41,659 --> 00:08:46,170
מתוק! 4 עצרת הדפיס 24, כצפוי.

153
00:08:46,170 --> 00:08:48,690
עכשיו אנחנו יכולים ללכת לתקן את זה בקוד שלנו.

154
00:08:48,690 --> 00:08:53,710
במקום לפרוש מGDB, תשתמשו כרטיסיית מסוף אחר לעשות את זה.

155
00:08:53,710 --> 00:08:58,080
נחזור לכרטיסיית GDB, עכשיו אנחנו צריכים להדר ההפעלה שלנו.

156
00:08:58,080 --> 00:09:03,180
אחד הדברים הטובים ביותר על GDB הוא שאתה לא צריך לעזוב את GDB לרוץ לעשות.

157
00:09:03,180 --> 00:09:06,570
כך שאנחנו לא לשמור להכות את נקודתי עצירה הישנות,

158
00:09:06,570 --> 00:09:10,440
בואו להשבית אותם עם, נחשת נכון, לבטל פקודה.

159
00:09:10,440 --> 00:09:13,320
הפעולה זו תשבית את כל נקודתי העצירה שלנו.

160
00:09:13,320 --> 00:09:18,180
כעת, אנו יכולים להפעיל מחדש את התכנית עם r ולוודא שהכול בסדר.

161
00:09:18,180 --> 00:09:21,300
נראה כמו כל הדבר טוב ללכת.

162
00:09:21,300 --> 00:09:24,410
עצרת של 4 הדפסים מתוך 24, בדיוק כמו שחשבנו.

163
00:09:24,410 --> 00:09:28,830
GDB הוא האחד הכלים השימושיים ביותר שיש להם בארגז הכלים שלך.

164
00:09:28,830 --> 00:09:31,970
>> יש המון דברים נוספים שאתה יכול לעשות עם GDB,

165
00:09:31,970 --> 00:09:34,030
הרבה יותר ממה שאתה יכול לעשות עם הדפסים פשוטים.

166
00:09:34,030 --> 00:09:36,730
בפעם הבאה שהתכנית שלך לא עושה את מה שאתה רוצה,

167
00:09:36,730 --> 00:09:39,740
נסה להפעיל GDB כדי להבין מה קורה בפנים.

168
00:09:39,740 --> 00:09:44,380
עם קצת תרגול, תוכל לקדוח ישר על הבאג שלך בתוך זמן קצר.

169
00:09:44,380 --> 00:09:48,180
השם שלי הוא נייט Hardison. זה CS50.