1
00:00:07,170 --> 00:00:12,630
[Powered by Google Translate] GDB, GNU პროექტის Debugger, არის ძლიერი გამართვის ინსტრუმენტი C,

2
00:00:12,630 --> 00:00:14,300
ერთად ბევრი სხვა ენებზე.

3
00:00:14,300 --> 00:00:17,440
ეს გაძლევთ საშუალებას poke გარშემო შიგნით თქვენი 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
ეს საკმაოდ nifty, არა?

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 დადებითი აქვს ბევრად უფრო ადვილი დრო თვალთვალის ქვემოთ bugs

11
00:00:36,800 --> 00:00:39,150
ვიდრე მათ, ვისაც muddle გამოყენებით შთაბეჭდილებები

12
00:00:39,150 --> 00:00:41,420
და უსასრულო რაოდენობით ამონაწერი განცხადებებს.

13
00:00:41,420 --> 00:00:45,810
GDB არის command-line ინსტრუმენტი, რაც იმას ნიშნავს, თქვენ შეგიძლიათ ურთიერთქმედება ის ტერმინალში

14
00:00:45,810 --> 00:00:49,720
გაცემის ბრძანებებს მეშვეობით კლავიატურის ნაცვლად დაწკაპვით ღილაკები თქვენი მაუსი.

15
00:00:49,720 --> 00:00:54,960
>> დაიწყოს up 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
როგორც fun როგორც ჩატვირთვისას up 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 და ცდილობს გამოთვლაც მისი factorial.

28
00:01:37,380 --> 00:01:41,270
იმ შემთხვევაში თუ თქვენ არ მინახავს factorials ადრე ან არ მახსოვს მათ,

29
00:01:41,270 --> 00:01:47,840
Factorial რაოდენობის 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
ამიტომ, factorial 3 არის 3 * 2 * 1, ან 6,

32
00:01:54,550 --> 00:02:00,180
და factorial სულ 4 არის 4 * 3 * 2 * 1 ან 24.

33
00:02:00,180 --> 00:02:03,970
Factorial ნულოვანი არის უცნაური შემთხვევაში, ეს 1,

34
00:02:03,970 --> 00:02:06,970
და factorials უარყოფითი რიცხვებით არ არის გათვალისწინებული.

35
00:02:06,970 --> 00:02:10,280
ყოველ შემთხვევაში, რაღაც ჩემს factorial პროგრამის ხმაურიანი.

36
00:02:10,280 --> 00:02:15,410
როდესაც მე აწარმოებს, ეს ბეჭდავს out უცნაური ციფრები რომ აქვს საერთო არაფერი 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
რომლებიც ორობითი ფაილი მიერ წარმოებული compilation პროცესში.

40
00:02:24,910 --> 00:02:30,940
ანუ, ჩვენ შეგვიძლია არ აწარმოებს GDB ჩვენს. გ ან. თ კოდის ფაილი მოსწონს factorial.c.

41
00:02:30,940 --> 00:02:34,650
ჩვენ გვინდა, რომ გაუშვით მხოლოდ factorial ნაცვლად.

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
ამ შემთხვევაში, factorial არ საჭიროებს რაიმე ბრძანების ხაზი არგუმენტები,

45
00:02:44,050 --> 00:02:46,410
ამიტომ ჩვენ უნდა აკრიფოთ პერსპექტივაში ან R მოკლე.

46
00:02:46,410 --> 00:02:50,440
>> ეს დაიწყება factorial პროგრამა გაშვებული.

47
00:02:50,440 --> 00:02:53,940
როდესაც პროგრამა აჩერებს გაშვებული, მე კიდევ ჩემი GDB შეეკითხება უკან.

48
00:02:53,940 --> 00:02:58,130
Okay, მოდით ვცდილობთ იგივე ერთხელ, factorial of 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
>> ამისათვის, ჩვენ ვიყენებთ რასაც breakpoint.

55
00:03:16,970 --> 00:03:21,880
Breakpoints გითხრათ 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
ჩვენ მითითებული breakpoint დასაწყისში ძირითად გამოყენებით შესვენების ბრძანება.

62
00:03:39,260 --> 00:03:42,640
ჩვენ ასევე შეგიძლიათ ბ abbreviate შესვენების.

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
რადგან ჩვენ ვერ ვხედავთ "შეიყვანეთ მთელი რიცხვი დადებითი" ბეჭდვითი out ეკრანზე,

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
სანამ ის სრულიად უნდა, რომელიც რატომ გამართვის ერთად printouts

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
ასე რომ, ეს გამოიყურება უცნაური. ჩვენ on line 12 მიხედვით GDB,

79
00:04:34,540 --> 00:04:37,660
მაგრამ მეორე ხაზზე რომ უნდა შესრულდეს მხოლოდ Curly გაუწიოს.

80
00:04:37,660 --> 00:04:42,110
>> რომ მხოლოდ იმას ნიშნავს, ჩვენ დასასრულს მარყუჟის, ჩვენი გავაკეთოთ ხოლო loop ფაქტობრივად,

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
ჩვენ შეგვიძლია დახევის up კოდის in GDB ის სია ან ლ ბრძანება.

85
00:04:54,860 --> 00:04:56,880
ეს ბეჭდავს out კოდის

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 loop.

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 ბეჭდავს out არის სპეციალური 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
ყოველ შემთხვევაში, მოძრავი ერთად მომავალი, ჩვენ ვხედავთ, რომ ჩვენ დავიწყოთ მოძრავი მეშვეობით ამისთვის loop.

101
00:05:50,970 --> 00:05:54,790
მოდით შენარჩუნება გადის აქ N ნელ bit.

102
00:05:54,790 --> 00:05:58,280
იმის ნაცვლად აკრეფით N ყოველ ჯერზე, ასევე შეგიძლიათ მხოლოდ დააჭიროთ.

103
00:05:58,280 --> 00:06:03,710
როდესაც თქვენ დააჭიროთ გარეშე აკრეფით არაფერი, უბრალოდ 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
თუ ჩვენ ამობეჭდოთ ღირებულება factorial გამოყენებით P,

110
00:06:23,100 --> 00:06:26,120
ჩვენ ვხედავთ, რომ factorial აქვს ამ მასიური ნომერი.

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
ახლა ჩვენ უკან ჩვენი breakpoint დასაწყისში ძირითადი.

116
00:06:43,460 --> 00:06:46,600
ჩვენ ვიცით, რომ ყველაფერი, როგორც ჩანს, ჯარიმა კითხულობს in n.

117
00:06:46,600 --> 00:06:48,630
ამიტომ ჩვენ შეგვიძლია ხტომა დააჩქაროს n.

118
00:06:48,630 --> 00:06:52,280
გარდა ამისა, ჩვენ შეგვიძლია მითითებული ახალი breakpoint შემდეგ გააკეთებს ხოლო loop

119
00:06:52,280 --> 00:06:54,910
და ხტომა იქ. მოდით, რომ.

120
00:06:54,910 --> 00:06:59,080
როგორც ჩანს, ხაზი 14 მოდის მხოლოდ მას შემდეგ loop.

121
00:06:59,080 --> 00:07:01,070
მოდით მითითებული breakpoint არსებობს.

122
00:07:01,070 --> 00:07:05,220
კარგია პრაქტიკა დაზუსტება ფაილის სახელი ამ breakpoint ბრძანება

123
00:07:05,220 --> 00:07:08,480
მას შემდეგ, რაც GDB შეიძლება დაბნეული თუ თქვენ მუშაობის რამოდენიმე ფაილი.

124
00:07:08,480 --> 00:07:13,230
გადაადგილება ადრე ამ breakpoint, ჩვენ ვიყენებთ გაგრძელება ან გ ბრძანება.

125
00:07:13,230 --> 00:07:16,570
>> Okay, აქ ჩვენ ვიმყოფებით იმ loop.

126
00:07:16,570 --> 00:07:19,060
მოდით წავიდეთ 1 ვრცლად line შევიდა ამისთვის მარყუჟის,

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
Yup, რომ ყველა კარგი.

130
00:07:28,300 --> 00:07:30,270
რაც შეეხება factorial თუმცა?

131
00:07:30,270 --> 00:07:33,760
Whoa, რომ არ არის კარგი.

132
00:07:33,760 --> 00:07:35,800
გვაქვს დიდი რაოდენობის ნეგატიური აქ.

133
00:07:35,800 --> 00:07:38,190
How'd რომ მოხდეს?

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
რომ აუცილებლად გადაყარეთ off ჩვენი გაანგარიშებით.

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 და factorial უნდა იყოს 1 ძალიან.

145
00:08:19,090 --> 00:08:23,990
ჩვენ შეგვიძლია Shortcut ამ პროცესში და ბეჭდვა ყველა ჩვენი ადგილობრივი ცვლადები

146
00:08:23,990 --> 00:08:26,440
ერთად Super-გამოსადეგი ბრძანება ინფორმაცია ადგილობრივები,

147
00:08:26,440 --> 00:08:29,190
რომელიც ბეჭდავს ყველა ჩვენი in-ფარგლებს ადგილობრივი ცვლადები.

148
00:08:29,190 --> 00:08:31,980
ყოველ შემთხვევაში, როგორც ჩანს ყველაფერი კარგია წავიდეთ.

149
00:08:31,980 --> 00:08:34,700
>> მოდით სხვა GO-გარშემო მარყუჟის მხოლოდ დარწმუნდით.

150
00:08:34,700 --> 00:08:38,789
Okay, ყველაფერი გამოიყურება დიდი.

151
00:08:38,789 --> 00:08:41,659
ახლა ჩვენ შეგვიძლია გამოვიყენოთ გაგრძელდება ბრძანება წასვლა ბოლომდე.

152
00:08:41,659 --> 00:08:46,170
Sweet? 4 factorial ამობეჭდილი 24 როგორც მოსალოდნელი იყო.

153
00:08:46,170 --> 00:08:48,690
ახლა ჩვენ შეგვიძლია წავიდეთ დაფიქსირება ამ ჩვენს კოდი.

154
00:08:48,690 --> 00:08:53,710
იმის ნაცვლად, რომ დატოვა გარეთ GDB, ჩვენ შეცვალოთ ტერმინალის tab ამის გაკეთება.

155
00:08:53,710 --> 00:08:58,080
უკან ჩვენი GDB tab, ჩვენ ახლა უნდა recompile ჩვენი გაშვება.

156
00:08:58,080 --> 00:09:03,180
ერთი საუკეთესო რამ შესახებ GDB ის არის, რომ თქვენ არ გჭირდებათ დატოვონ GDB გასაშვებად მიიღოს.

157
00:09:03,180 --> 00:09:06,570
ასე, რომ ჩვენ არ ინახავს hitting წლის breakpoints,

158
00:09:06,570 --> 00:09:10,440
მოდით გამორთოთ მათ, თქვენ მიხვდა ეს, გამორთოთ ბრძანება.

159
00:09:10,440 --> 00:09:13,320
ეს იქნება გამორთოთ ყველა ჩვენი breakpoints.

160
00:09:13,320 --> 00:09:18,180
ახლა შეგვიძლია, გადატვირთეთ პროგრამა r და დარწმუნდით ყველაფერი okay.

161
00:09:18,180 --> 00:09:21,300
როგორც ჩანს, ყველაფერი კარგია წავიდეთ.

162
00:09:21,300 --> 00:09:24,410
Factorial 4 ბეჭდავს out 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
ბევრად უფრო ვიდრე შეგიძლიათ გააკეთოთ მარტივი printouts.

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
ჩემი სახელი არის Nate Hardison. ეს არის CS50.