1
00:00:00,000 --> 00:00:00,309

2
00:00:00,309 --> 00:00:02,350
[? DAN ARMADARAS:?] Здравейте,
Аз съм [? Dan Armadaras?].

3
00:00:02,350 --> 00:00:04,410
Днес, ние ще
да се търсят в отстраняване на грешки.

4
00:00:04,410 --> 00:00:06,697
Ние не само ще
поговорим за някои техники,

5
00:00:06,697 --> 00:00:09,280
но и ние ще разгледаме
някои от функциите, съдържаща

6
00:00:09,280 --> 00:00:14,170
в рамките на CS50 IDE, които позволяват
лесно да трасира програма.

7
00:00:14,170 --> 00:00:16,272
>> Само един пример за
нещо, което може да се обърка

8
00:00:16,272 --> 00:00:18,730
и това е всъщност нещо
че вече сте виждали преди.

9
00:00:18,730 --> 00:00:23,200
В този случай, това е програма, C
който приема цяло число от потребителя,

10
00:00:23,200 --> 00:00:27,580
тя се разделя на две, и осигурява
изхода обратно към потребителя.

11
00:00:27,580 --> 00:00:30,610
Сега от това, което сме виждали
рано в лекции,

12
00:00:30,610 --> 00:00:34,370
ние знаем, че това действително ще предизвика
специфични видове делене проблеми

13
00:00:34,370 --> 00:00:35,860
когато имаме нечетни числа.

14
00:00:35,860 --> 00:00:40,330
>> Конкретно, ние просто ще изхвърлим
нищо след десетичната запетая.

15
00:00:40,330 --> 00:00:43,170
Сега, ние знаем, че това
се случва да бъде случаят.

16
00:00:43,170 --> 00:00:47,430
И ако ние го изпълним, ние можем да потвърдим
подозренията ни, първо, чрез съставяне.

17
00:00:47,430 --> 00:00:50,460
И тогава, като бягане и
въвеждане нечетен брой.

18
00:00:50,460 --> 00:00:51,720
>> Това не е нищо ново.

19
00:00:51,720 --> 00:00:54,490
Но всъщност това е
Пример за бъг, който

20
00:00:54,490 --> 00:00:58,810
може да съществува в рамките на по-голяма програма
че става по-трудно да се проследят.

21
00:00:58,810 --> 00:01:02,640
Въпреки, че ние знаем какво въпроса
е, истинската основният проблем

22
00:01:02,640 --> 00:01:06,250
може да се опитва да се идентифицира
специално, когато грешката се появи,

23
00:01:06,250 --> 00:01:09,750
идентифициране на това, което този проблем
е, и след това да го отстраните.

24
00:01:09,750 --> 00:01:14,400
Така че предоставят тази като пример
от това, което може да е нещо

25
00:01:14,400 --> 00:01:19,030
че ние вече знаем, но може да бъде погребан
в рамките на други елементи от кода.

26
00:01:19,030 --> 00:01:23,090
>> Така че отварянето на този друг източник
код на файла, като пример,

27
00:01:23,090 --> 00:01:27,165
това разделение проблем сега е
част от по-голяма програма.

28
00:01:27,165 --> 00:01:29,040
Все пак може да е малко
битов скалъпен, и ние

29
00:01:29,040 --> 00:01:31,076
може да е в състояние лесно
го идентифицира, особено

30
00:01:31,076 --> 00:01:32,450
тъй като ние сме просто обсъждаме това.

31
00:01:32,450 --> 00:01:38,250
Но ние можем да разберем, че това
проблем може да съществува по-голям мащаб.

32
00:01:38,250 --> 00:01:45,450
>> Ако аз обобщава и сега
стартирайте го, въведете нечетно число,

33
00:01:45,450 --> 00:01:49,816
можем да видим, че ние не се получи точно
изхода, че ние може да се очаква.

34
00:01:49,816 --> 00:01:51,690
В този конкретен случай,
бихме могли да кажем, че сме

35
00:01:51,690 --> 00:01:56,060
искате да преброите всички номера
от една до някаква конкретна цифра.

36
00:01:56,060 --> 00:01:58,130
И ние можем да видим, че ние
имаме най-различни въпроси

37
00:01:58,130 --> 00:02:03,880
тук, ако ние сме извеждане, просто, 0
и 1, когато ние предлагаме един вход от 5.

38
00:02:03,880 --> 00:02:07,380
>> Така че ние вече знаем, че
има проблем тук.

39
00:02:07,380 --> 00:02:11,662
Но ние не може да знае точно
където този проблем не съществува в действителност.

40
00:02:11,662 --> 00:02:13,620
Сега един от начините, по които
можем да се опитаме да се определи това

41
00:02:13,620 --> 00:02:15,745
е нещо, което ние сме
вече са въведени, за да.

42
00:02:15,745 --> 00:02:18,880
Ние просто да го използвате по-голям мащаб.

43
00:02:18,880 --> 00:02:21,680
>> На линия 14, имаме
това ФОРМАТ функция,

44
00:02:21,680 --> 00:02:25,620
което ни позволява да разпечатате на държавата
на различни видове информация.

45
00:02:25,620 --> 00:02:28,880
И това е нещо, което ти
следва да се възползва в рамките на програма

46
00:02:28,880 --> 00:02:33,100
да се опита да разбера какво точно е
случва в различните реда код.

47
00:02:33,100 --> 00:02:36,350
Така че, дори и ако това не е
крайния изход, че ние всъщност

48
00:02:36,350 --> 00:02:39,830
искат да произвеждат от
тази програма, ние все още

49
00:02:39,830 --> 00:02:42,300
за да имам някой отстраняване на грешки
отчети къде сме

50
00:02:42,300 --> 00:02:46,970
може да се опитват да разбера какво точно
се случва вътре в нашия код.

51
00:02:46,970 --> 00:02:51,210
>> Така че в този случай, ще го направя
ФОРМАТ с маркер за отстраняване на грешки.

52
00:02:51,210 --> 00:02:53,540
В този случай, това е
просто низ отстраняване на грешки

53
00:02:53,540 --> 00:02:56,840
че съм в крак удар, така че тя се превръща
много ясно в продукцията на моя код

54
00:02:56,840 --> 00:02:59,200
какво е, че искам да покажа.

55
00:02:59,200 --> 00:03:04,410
И изход тук числото
че сме се изчислява.

56
00:03:04,410 --> 00:03:06,800
>> В този случай, бих могъл
Искам да знам точно

57
00:03:06,800 --> 00:03:11,380
какво се случва преди и
след някои специфични изчисления.

58
00:03:11,380 --> 00:03:16,224
Така че аз може да използва ФОРМАТ преди
и след това ред код.

59
00:03:16,224 --> 00:03:18,640
В този случай, бих могъл дори
да го направи малко по-ясно,

60
00:03:18,640 --> 00:03:21,960
като казва, отстраняване на грешки, преди да
и отстраняване на грешки след толкова

61
00:03:21,960 --> 00:03:26,540
че аз самият не бъркайте с
на няколко реда, които изглеждат идентични.

62
00:03:26,540 --> 00:03:32,290
>> Сега, ако ние компилирате и стартирате тази
тя, като въведете номер пет отново,

63
00:03:32,290 --> 00:03:35,090
можем да видим, че имаме
Сега изход преди и след

64
00:03:35,090 --> 00:03:40,670
и откриете, че не сме направили ясна
разделяне или ясно като на броя

65
00:03:40,670 --> 00:03:43,680
че ние действително искаме да направим.

66
00:03:43,680 --> 00:03:48,660
Сега в този случай, това е
не съвсем ясен изход.

67
00:03:48,660 --> 00:03:52,440
Всъщност не е ясен резултат, който
искаме от тази конкретна програма.

68
00:03:52,440 --> 00:03:54,427
>> И това е, отново, по-
малко скалъпен.

69
00:03:54,427 --> 00:03:57,510
Но, може би, едно от нещата, които
бихме могли да направим, ако в спецификацията каза

70
00:03:57,510 --> 00:04:01,900
че искаме да разделим тази от
2 и добавете 1-- така с други думи,

71
00:04:01,900 --> 00:04:04,550
ние искаме да се развие след up--
бихме могли да знаем, че бихме могли да

72
00:04:04,550 --> 00:04:08,060
направя това нещо специално, в този случай.

73
00:04:08,060 --> 00:04:14,010
Сега тук ние знаем, че ние ще бъдем
в състояние да добавите 1 в нашия наполовина номер.

74
00:04:14,010 --> 00:04:16,490
>> Нека да компилирате този
и потвърдите, че това

75
00:04:16,490 --> 00:04:18,860
се държи начинът, по който искаме да.

76
00:04:18,860 --> 00:04:21,980
Ние можем да видим, че сега, преди да
като имаме номер 5.

77
00:04:21,980 --> 00:04:26,620
След като имаме цифрата 3,
които според нашата спецификация,

78
00:04:26,620 --> 00:04:29,292
е това, което искахме да направим.

79
00:04:29,292 --> 00:04:31,000
Но ако се вгледаме в
изход тук, ние можем

80
00:04:31,000 --> 00:04:33,760
видим, че можем да имаме друг
грешка напълно, което е

81
00:04:33,760 --> 00:04:36,940
че ние започваме нашата броене от 0.

82
00:04:36,940 --> 00:04:39,390
>> Сега отново, това е нещо,
което сме виждали в миналото

83
00:04:39,390 --> 00:04:42,500
и ние можем да се определи съвсем лесно.

84
00:04:42,500 --> 00:04:44,790
Но в този случай, ние
също имаше полза

85
00:04:44,790 --> 00:04:48,940
за използване на отчета за ФОРМАТ
директно вътрешността на линия за

86
00:04:48,940 --> 00:04:52,930
да се знае точно къде
тази грешка се случва.

87
00:04:52,930 --> 00:04:55,150
Така ФОРМАТ твърдения са
много полезни в подпомагането

88
00:04:55,150 --> 00:04:57,940
да определите къде,
Именно в изходен код,

89
00:04:57,940 --> 00:05:00,620
конкретна грешка се случва.

90
00:05:00,620 --> 00:05:03,650
>> И това е също важно да се осъзнае
че като пишем код,

91
00:05:03,650 --> 00:05:06,052
можем да имаме предположения
за състоянието на дадена програма.

92
00:05:06,052 --> 00:05:08,510
Или можем да имаме предположения
за това, което е част от програмата

93
00:05:08,510 --> 00:05:13,020
всъщност е правилен или неправилен, когато
по-късно, тъй като ние се гради върху тази програма

94
00:05:13,020 --> 00:05:15,950
и да го направи част от
сложна и по-голяма програма

95
00:05:15,950 --> 00:05:19,700
че ние осъзнаваме, че някои аспекти
на която всъщност е бъгав.

96
00:05:19,700 --> 00:05:22,680
>> Използването ФОРМАТ наистина може да помогне
стесните и идентифициране

97
00:05:22,680 --> 00:05:26,430
районите на програма, която не може
да се държи точно така, че ние

98
00:05:26,430 --> 00:05:29,500
очаква въз основа на нашите предположения.

99
00:05:29,500 --> 00:05:31,460
Но има и други инструменти
разположение, както и,

100
00:05:31,460 --> 00:05:34,860
които ни позволяват да се опита да фигура
къде грешка се случва

101
00:05:34,860 --> 00:05:39,930
и да обърне специално, какви неща
се случва вътре на програмата.

102
00:05:39,930 --> 00:05:41,990
>> Така че, използвайки ФОРМАТ е много
полезно, когато искаме

103
00:05:41,990 --> 00:05:45,900
да се идентифицират специфични области на
програма, която има някакъв бъг.

104
00:05:45,900 --> 00:05:47,730
Но също така става
досаден след известно време.

105
00:05:47,730 --> 00:05:50,500
В този случай, това е
сравнително проста програма

106
00:05:50,500 --> 00:05:52,750
само с една или две променливи.

107
00:05:52,750 --> 00:05:57,260
И това става много лесно за нас, за да
разпечатате от стойността на тези променливи

108
00:05:57,260 --> 00:05:59,670
в рамките на по-голям програмата.

109
00:05:59,670 --> 00:06:02,670
>> Но ние може да има различна
програма, която има много променливи.

110
00:06:02,670 --> 00:06:06,530
И това не може да бъде доста
толкова лесен за използване ФОРМАТ

111
00:06:06,530 --> 00:06:10,120
да се опита да се оцени това, което се случва
на всеки един от тези променливи

112
00:06:10,120 --> 00:06:13,590
като програмата се изпълнява.

113
00:06:13,590 --> 00:06:16,960
Има една програма, която съществува
нарича програма корекция на грешки.

114
00:06:16,960 --> 00:06:20,320
В този случай, тази, която ние ще
използване е дебъгер GNU, или GDB,

115
00:06:20,320 --> 00:06:24,260
която ни позволява да се запознаят на вътрешния
изработки на програмата в много по-

116
00:06:24,260 --> 00:06:25,700
подробен начин.

117
00:06:25,700 --> 00:06:28,810
>> Ние всъщност може да се изпълни
GDB от командния ред

118
00:06:28,810 --> 00:06:35,370
тук, като просто напишете GDB и
команда, която ние искаме да трасира.

119
00:06:35,370 --> 00:06:37,550
В този случай, броят.

120
00:06:37,550 --> 00:06:41,650
Сега в този случай, ние можем да видим, че тя
ни води до бързо, че казва GDB.

121
00:06:41,650 --> 00:06:44,020
И ние можем действително
изпълнява команди на GDB

122
00:06:44,020 --> 00:06:48,260
действително да започне изпълнението на
програма, да го спре в определени точки,

123
00:06:48,260 --> 00:06:51,060
оценка на променливите и
инспектира променливи, които

124
00:06:51,060 --> 00:06:54,152
съществува в състояние на програма
в този момент,

125
00:06:54,152 --> 00:06:55,110
и така нататък и така нататък.

126
00:06:55,110 --> 00:06:57,240
Тя осигурява много енергия за нас.

127
00:06:57,240 --> 00:06:59,960
>> Но това просто така се случва
че IDE CS50 също

128
00:06:59,960 --> 00:07:05,870
осигурява GUI или потребител
интерфейс за GDB че

129
00:07:05,870 --> 00:07:11,120
ни позволява да направите това без да е необходимо
интерфейса на командния ред каквато

130
00:07:11,120 --> 00:07:13,560
или изобщо дори.

131
00:07:13,560 --> 00:07:16,930
Начинът, по който да отворя
е, като използвате бутона за отстраняване на грешки

132
00:07:16,930 --> 00:07:20,120
на самия връх на CS50 IDE.

133
00:07:20,120 --> 00:07:24,280
Сега в миналото, това, което имаме
видял е, че ние използваме командата

134
00:07:24,280 --> 00:07:27,660
линия, за да се съберат и след това стартирате програмата.

135
00:07:27,660 --> 00:07:29,790
>> Бутонът за отстраняване на грешки прави
тези две стъпки.

136
00:07:29,790 --> 00:07:34,380
Но тя също така ще пренесат
таб дебъгер в десния

137
00:07:34,380 --> 00:07:38,280
която ни позволява да се запознаят с различни
на свойствата на програмата

138
00:07:38,280 --> 00:07:40,500
тъй като се изпълнява.

139
00:07:40,500 --> 00:07:44,280
Ако щракнете върху отстраняване на грешки, в това
случай, това ще доведе до

140
00:07:44,280 --> 00:07:48,230
нов раздел в конзолата
прозорец на самото дъно.

141
00:07:48,230 --> 00:07:51,160
>> И вие можете да видите, че този раздел има
някаква информация на самия връх.

142
00:07:51,160 --> 00:07:52,670
И до голяма степен можем да пренебрегнем това.

143
00:07:52,670 --> 00:07:54,800
Но едно от нещата,
че искаме да забележите

144
00:07:54,800 --> 00:07:57,170
е, че да подава
едно и също нещо, че ние

145
00:07:57,170 --> 00:08:03,000
ще получите, ако се опитаме да тече направи по
програмата C в терминален прозорец.

146
00:08:03,000 --> 00:08:06,230
>> Тук можем да видим, той се движи трясък,
и тя разполага с разнообразие от знамена,

147
00:08:06,230 --> 00:08:12,660
и е съставянето на нашия count.c файл,
който е избран раздела в момента

148
00:08:12,660 --> 00:08:15,100
че ударих отстраняване на грешки.

149
00:08:15,100 --> 00:08:18,010
Така че това е много полезно, защото
Сега с помощта на този бутон, за отстраняване на грешки,

150
00:08:18,010 --> 00:08:23,280
ние може едновременно да съставят и след това
изпълнение на програмата, която ние всъщност

151
00:08:23,280 --> 00:08:24,460
искате да стартирате.

152
00:08:24,460 --> 00:08:27,880
>> Един от флаговете, че е
важно, в този случай,

153
00:08:27,880 --> 00:08:30,190
всъщност сме използвали
за най-дълго време

154
00:08:30,190 --> 00:08:32,450
но също така и просто направих някои ръка
къдрене [недоловим], които

155
00:08:32,450 --> 00:08:33,820
е това точно тук.

156
00:08:33,820 --> 00:08:35,790
В трясък, той казва -ggdb3.

157
00:08:35,790 --> 00:08:38,570

158
00:08:38,570 --> 00:08:41,250
В този случай, това, което сме
казвам трясък, нашия съставител,

159
00:08:41,250 --> 00:08:43,820
е, че искаме да се съставят нашата програма.

160
00:08:43,820 --> 00:08:46,810
Но също така предоставя това, което са
наречено информация символ

161
00:08:46,810 --> 00:08:50,940
така че всъщност има достъп компилатор
до много основната информация

162
00:08:50,940 --> 00:08:52,610
съдържащи се в програмата.

163
00:08:52,610 --> 00:08:55,260
>> По-специално, броят
на функции, които имам,

164
00:08:55,260 --> 00:08:58,000
имената на тези функции,
променливите, видовете

165
00:08:58,000 --> 00:09:01,730
че тези променливи са, както и разнообразие
други неща, които помагат на дебъгер

166
00:09:01,730 --> 00:09:04,350
изпълнява своята работа.

167
00:09:04,350 --> 00:09:06,600
Сега има и нещо друго
това е важно да се спомене

168
00:09:06,600 --> 00:09:10,280
когато ние обсъждаме бягане
програма по този начин.

169
00:09:10,280 --> 00:09:13,660
>> Забележете, че той има действително
възпитан нов раздел в нашата конзола

170
00:09:13,660 --> 00:09:14,780
по дъното.

171
00:09:14,780 --> 00:09:18,600
Ние вече не трябва да си взаимодействат
директно с терминален прозорец.

172
00:09:18,600 --> 00:09:21,420
Но този нов раздел е
всъщност терминален прозорец.

173
00:09:21,420 --> 00:09:26,710
Това просто е специфична за протичане
програма, която сме създали.

174
00:09:26,710 --> 00:09:29,270
>> Забележете, че в долната част, в
комбинация с някои изход

175
00:09:29,270 --> 00:09:33,500
от звън на компилатора и GDB,
които до голяма степен можем да пренебрегнем,

176
00:09:33,500 --> 00:09:37,570
тя всъщност показва изхода на
нашата програма на самото дъно.

177
00:09:37,570 --> 00:09:41,240
Сега е важно да се осъзнае
че това действително прозорец

178
00:09:41,240 --> 00:09:43,360
ще ти покажа
изход от програмата си

179
00:09:43,360 --> 00:09:47,190
но също така може да приеме вход
за тази програма, както и.

180
00:09:47,190 --> 00:09:49,260
>> Така предизвестие, което казва
Моля въведете номер,

181
00:09:49,260 --> 00:09:53,050
която е една и съща мощност, че трябва
имаше в терминален прозорец и преди.

182
00:09:53,050 --> 00:09:55,510
Но това вече е показано в този нов раздел.

183
00:09:55,510 --> 00:09:56,550
Не мога да вкара няколко.

184
00:09:56,550 --> 00:10:00,900
И това действително ще
функция, тъй като ние очакваме

185
00:10:00,900 --> 00:10:05,890
ни показва нашето отстраняване на грешки, продукцията,
продукцията, която може да е бъгав,

186
00:10:05,890 --> 00:10:07,010
както сме виждали преди.

187
00:10:07,010 --> 00:10:10,460
И на самото дъно, тя
действително има някаква допълнителна продукция

188
00:10:10,460 --> 00:10:14,550
от БВП просто казвам, че
тази програма е приключила.

189
00:10:14,550 --> 00:10:16,655
>> Сега като те видях в тази
специално чрез серия,

190
00:10:16,655 --> 00:10:19,370
не е особено
полезна, защото дори

191
00:10:19,370 --> 00:10:23,740
че имахме менюто дебъгер дойде
нагоре, това е все още работеща програма.

192
00:10:23,740 --> 00:10:26,790
В нито един момент го направих всъщност
пауза изпълнение за нас

193
00:10:26,790 --> 00:10:30,767
за да може да инспектира всички
променливите, които се съдържат в него.

194
00:10:30,767 --> 00:10:32,850
Има и още нещо
че ние трябва да направим, за да

195
00:10:32,850 --> 00:10:36,910
за да получите GDB да признае, че ние искаме
за пауза на изпълнение на програмата

196
00:10:36,910 --> 00:10:42,820
а не само да може да се пристъпи
Обикновено, колкото бихме във всеки друг случай.

197
00:10:42,820 --> 00:10:45,530
>> За да направите пауза на изпълнение,
в някакъв конкретен ред,

198
00:10:45,530 --> 00:10:47,830
ние трябва да се създаде това, което е
нарича критичната точка.

199
00:10:47,830 --> 00:10:52,670
И критичната точка е много лесно, създаден
в този CS50 IDE, като мишката

200
00:10:52,670 --> 00:10:57,090
и кликнете директно на ляво
на някои специфични линия номер.

201
00:10:57,090 --> 00:10:59,920
След като направите това, червена точка
появява, което показва,

202
00:10:59,920 --> 00:11:02,300
че тази линия е вече критичната точка.

203
00:11:02,300 --> 00:11:07,540
>> И следващия път, че аз тичам GDB него,
ще спре изпълнението по това брейк пойнт

204
00:11:07,540 --> 00:11:10,280
когато достигне тази линия на код.

205
00:11:10,280 --> 00:11:12,230
Сега това е важна
нещо, за да осъзнае

206
00:11:12,230 --> 00:11:16,140
че това не е непременно най-
случай, че всеки ред код

207
00:11:16,140 --> 00:11:17,880
всъщност е достъпен.

208
00:11:17,880 --> 00:11:23,780
Ако трябва да се създаде функция
тук, за example-- невалидни F--

209
00:11:23,780 --> 00:11:31,230
и просто да се направи печат линия here-- здравей
world-- ако никога не съм се обадя на тази функция,

210
00:11:31,230 --> 00:11:34,770
то ще се окаже, че,
ако задам критичната точка тук,

211
00:11:34,770 --> 00:11:36,220
функцията никога не ще се нарича.

212
00:11:36,220 --> 00:11:38,310
И поради това, този
специално брейк пойнт

213
00:11:38,310 --> 00:11:43,040
Никога няма действително пауза
изпълнение на програмата.

214
00:11:43,040 --> 00:11:48,020
>> Така че нека да кажа, че правилно се създаде
критичната точка на някой ред код

215
00:11:48,020 --> 00:11:50,340
че действително ще бъде изпълнена.

216
00:11:50,340 --> 00:11:53,470
Сега в този случай, това е най-
Първа линия на основната функция.

217
00:11:53,470 --> 00:11:56,630
Така че със сигурност ще се случи
че веднага след като започне изпълнението,

218
00:11:56,630 --> 00:11:58,580
най-първата линия ще бъде постигнато.

219
00:11:58,580 --> 00:12:00,230
GDB ще направи пауза изпълнение.

220
00:12:00,230 --> 00:12:04,100
И тогава, аз ще бъда в състояние да
взаимодействат с дебъгер.

221
00:12:04,100 --> 00:12:08,480
>> Можете да настроите няколко реда като
Гранични стойности, ако искате.

222
00:12:08,480 --> 00:12:11,365
Можем също така да се създаде линия
тук, в този сегмент на код

223
00:12:11,365 --> 00:12:12,490
че никога няма да се стигне.

224
00:12:12,490 --> 00:12:14,744
И ние също може да зададете една по-долу.

225
00:12:14,744 --> 00:12:16,660
Причината, че бихме
искате да направите това ние ще

226
00:12:16,660 --> 00:12:19,119
отидат в малко по-
подробно в един момент.

227
00:12:19,119 --> 00:12:21,660
Така че за сега, нека просто деактивирайте
тези допълнителни точки за пробив

228
00:12:21,660 --> 00:12:24,940
така че можем да погледнем какво се случва
когато имам една единствена почивка

229
00:12:24,940 --> 00:12:27,650
точка в програмата си.

230
00:12:27,650 --> 00:12:29,410
Аз направих някои
промени в тази програма.

231
00:12:29,410 --> 00:12:30,750
Така че аз трябва да го спаси.

232
00:12:30,750 --> 00:12:34,490
Аз ще кликнете отстраняване на грешки, така че аз мога
започне съставянето и след това

233
00:12:34,490 --> 00:12:36,880
изпълнение на дебъгер.

234
00:12:36,880 --> 00:12:40,632
>> Ние ще видим, че след моменти, най-
линия, която ние избрахме като на почивката

235
00:12:40,632 --> 00:12:43,360
точка е оцветена в жълто.

236
00:12:43,360 --> 00:12:47,440
Можем също така да се отбележи, че в
горния десен в отстраняване на грешки панел

237
00:12:47,440 --> 00:12:50,940
че иконата на пауза се е превърнал
в една малка икона на игра.

238
00:12:50,940 --> 00:12:54,710
Това означава, че ние имаме пауза
изпълнение, в този конкретен случай.

239
00:12:54,710 --> 00:12:57,840
И удря върху бутона за възпроизвеждане ще
ни позволи да възобнови изпълнението

240
00:12:57,840 --> 00:13:00,000
при тази конкретна точка.

241
00:13:00,000 --> 00:13:03,240
>> Забележете, че има няколко други
бутони на разположение за отстраняване на грешки в този панел,

242
00:13:03,240 --> 00:13:04,220
както добре.

243
00:13:04,220 --> 00:13:09,470
Стъпка над, което ми позволява да
изпълни, че един ред код

244
00:13:09,470 --> 00:13:14,030
и стъпка към тази линия на
Следващата една, която, в този случай,

245
00:13:14,030 --> 00:13:17,060
би означавало, че ФОРМАТ
се изпълнява оператор.

246
00:13:17,060 --> 00:13:22,310
И след това ще направи пауза
изпълнение на ред 13, като така.

247
00:13:22,310 --> 00:13:25,090
>> А има и една крачка
изпълнението на функциите, които

248
00:13:25,090 --> 00:13:28,950
Полезно е, ако съм създал друг
функции на други места в изходния код.

249
00:13:28,950 --> 00:13:31,420
И аз искам да се оттегли в
тези функции, а не

250
00:13:31,420 --> 00:13:33,050
изпълнява тази функция като цяло.

251
00:13:33,050 --> 00:13:37,279
Но ние ще разгледаме по-по стъпка
в функция в един момент.

252
00:13:37,279 --> 00:13:40,320
Сега забележите някои други неща, които
действително съществува в рамките на този панел за отстраняване на грешки.

253
00:13:40,320 --> 00:13:44,110
>> Ние имаме този панел наречен
обадете стак, което ни показва,

254
00:13:44,110 --> 00:13:45,300
къде точно се намираме.

255
00:13:45,300 --> 00:13:48,550
В този случай, ние сме вътре
на основната функция.

256
00:13:48,550 --> 00:13:50,880
Нашият сценарий се нарича count.c.

257
00:13:50,880 --> 00:13:53,820
И ние се случи да бъде на
ред 13, колона един, който

258
00:13:53,820 --> 00:13:58,950
Именно това се подчертава региона
на изходния код показва, както и.

259
00:13:58,950 --> 00:14:02,435
>> Сега забелязвам, че това показва също
под променливо сечение местно

260
00:14:02,435 --> 00:14:06,710
Всички променливи че
съществува в рамките на тази функция.

261
00:14:06,710 --> 00:14:08,930
Важно е да се отбележи,
че всички променливи

262
00:14:08,930 --> 00:14:12,580
ще се появи в тази локална променлива
вписванията в рамките на функция,

263
00:14:12,580 --> 00:14:14,380
дори преди да бъдат определени.

264
00:14:14,380 --> 00:14:19,160
Ние можем да видим, че тук имаме променлива
наречено бр, има стойност по подразбиране от 0,

265
00:14:19,160 --> 00:14:21,280
и е от тип Int.

266
00:14:21,280 --> 00:14:24,110
>> Сега, преди да можем действително се инициализира
всички тези променливи,

267
00:14:24,110 --> 00:14:26,685
ние не сме задължително
гарантирана, за да видите стойност 0.

268
00:14:26,685 --> 00:14:29,200
И в зависимост от други екзекуции
че сте извършили

269
00:14:29,200 --> 00:14:32,020
и състоянието на паметта си, когато
всъщност стартирате тази програма,

270
00:14:32,020 --> 00:14:34,605
може да откриете, че сте
не виждам стойности от 0

271
00:14:34,605 --> 00:14:36,550
и, вместо това, някои други луди номера.

272
00:14:36,550 --> 00:14:38,390
>> Но не се притеснявайте за това.

273
00:14:38,390 --> 00:14:44,610
Това няма да бъде от значение, докато
вие всъщност се инициализира стойността.

274
00:14:44,610 --> 00:14:49,630
Сега в този случай, ние можем да видим, че
I са извършили някои изходи.

275
00:14:49,630 --> 00:14:52,131
И аз, точно сега, спря екзекуция.

276
00:14:52,131 --> 00:14:53,880
Но в този случай, това, което
Аз наистина искам да правя

277
00:14:53,880 --> 00:14:58,060
е да се засили вече над тази линия
на код, така че мога действително

278
00:14:58,060 --> 00:15:04,390
заявката на потребителя за това, че инт
искаме да използваме в нашата програма.

279
00:15:04,390 --> 00:15:07,060
>> Сега в този случай, когато
Ударих прекрача, известие

280
00:15:07,060 --> 00:15:11,940
че Пауза или по-скоро на Резюмето
бутон се е променило към този бутон Pause

281
00:15:11,940 --> 00:15:14,022
защото този код е действително изпълнение.

282
00:15:14,022 --> 00:15:15,730
Какво се случва
точно сега е, че тя е

283
00:15:15,730 --> 00:15:21,630
ни чака да въведете някаква информация
както можем да видим от нашата продукция текст

284
00:15:21,630 --> 00:15:23,600
на самото дъно.

285
00:15:23,600 --> 00:15:25,787
>> Така че точно сега, това е
всъщност не спря,

286
00:15:25,787 --> 00:15:28,620
въпреки че, нещо се появява,
да бъде, защото нищо не се случва.

287
00:15:28,620 --> 00:15:32,360
Но това просто така се случва, че в
моя конкретен случай на ред 13,

288
00:15:32,360 --> 00:15:34,210
Аз чакам за приноса на потребителите.

289
00:15:34,210 --> 00:15:39,130
И така GDB не е в състояние да се запознаят
програма, както тя се изпълнява.

290
00:15:39,130 --> 00:15:43,370
>> Сега следващия път, че да въведа някои
input-- така че ще влиза, че номер 5,

291
00:15:43,370 --> 00:15:46,140
както сме виждали в
past-- удари Върни се, и ние

292
00:15:46,140 --> 00:15:51,430
забележите, че непосредствено, GDB паузи
и отново подчертава, на следващия ред.

293
00:15:51,430 --> 00:15:55,320
Но забележете, че сега, като
В резултат на нашите въвеждане на стойност,

294
00:15:55,320 --> 00:15:58,930
актуализирахме тази стойност вътре
на местните ни променливи, които

295
00:15:58,930 --> 00:16:05,560
Много е полезно да се знае точно
какво този брой е бил в паметта.

296
00:16:05,560 --> 00:16:10,650
>> Сега мога да се позволи на тази програма, за да продължите
играе до края на изпълнението й

297
00:16:10,650 --> 00:16:12,570
като натиснете Resume.

298
00:16:12,570 --> 00:16:16,410
Ние можем да видим, че много бързо
прави финала на програмата изпълняващата

299
00:16:16,410 --> 00:16:19,790
със същата мощност, която ние
имаше преди, дебъгер затваря,

300
00:16:19,790 --> 00:16:23,170
и сега тази програма
спре напълно.

301
00:16:23,170 --> 00:16:25,320
>> I показват, че само за
целите на това, което виждам

302
00:16:25,320 --> 00:16:27,280
се случва, когато ние действително удари Resume.

303
00:16:27,280 --> 00:16:30,640
Но ние всъщност ще
искам да се върна в тази програма

304
00:16:30,640 --> 00:16:33,820
така че можем да се опитаме да трасира
точно това, което се случва.

305
00:16:33,820 --> 00:16:37,980
Сега, аз съм с дебъгер, аз може
не се нуждаят от тези за отстраняване на грешки ФОРМАТ отчети.

306
00:16:37,980 --> 00:16:43,860
>> Така че бих могъл да ги премахнете, както аз ще направя
Сега, само за да се върнем към нашата опростена код

307
00:16:43,860 --> 00:16:45,950
че имахме преди малко.

308
00:16:45,950 --> 00:16:48,790
Сега, когато се запишете
програмирате и да го изпълни,

309
00:16:48,790 --> 00:16:53,700
тя ще, отново, отидете на тази първоначална
пробие точка, която имах по линия 11.

310
00:16:53,700 --> 00:16:57,700
И аз ще бъда в състояние да се запознаят
моите променливи, както аз искам да направя.

311
00:16:57,700 --> 00:17:00,695
>> Просто така се случи, че този
част не е много интересно,

312
00:17:00,695 --> 00:17:04,364
И знам, че аз ще съм
да отпечатате тази декларация.

313
00:17:04,364 --> 00:17:05,280
Моля въведете число.

314
00:17:05,280 --> 00:17:08,099
И след това, аз знам, че аз ще съм
да поиска от потребителя за това число.

315
00:17:08,099 --> 00:17:13,329
Така че може би, аз всъщност искате да преместите ми
пробие точка малко по-надолу.

316
00:17:13,329 --> 00:17:16,710
>> Можете да премахнете точки за пробив
като кликнете, отново, директно

317
00:17:16,710 --> 00:17:18,460
от лявата страна на този брой на линия.

318
00:17:18,460 --> 00:17:22,200
Това червена точка ще изчезне, което показва,
че този брейк пойнт сега е отишло.

319
00:17:22,200 --> 00:17:24,780
Сега в този случай,
изпълнение е на пауза.

320
00:17:24,780 --> 00:17:27,770
И така, това не е всъщност ще
възобнови в този конкретен случай.

321
00:17:27,770 --> 00:17:30,210
Но мога да зададете пауза
буква а малко по-късно.

322
00:17:30,210 --> 00:17:33,880
>> И когато аз сега възобновя
код, тя ще се възобнови и да каже

323
00:17:33,880 --> 00:17:36,190
точката на този брейк пойнт.

324
00:17:36,190 --> 00:17:37,374
Отново, аз удари Resume.

325
00:17:37,374 --> 00:17:39,040
Не изглежда като нещо се случва.

326
00:17:39,040 --> 00:17:41,450
Но това е, защото ми
код е в очакване на въвеждане.

327
00:17:41,450 --> 00:17:47,900
Аз ще въведете номер 5, удари Enter, и
Сега следващата почивка точката ще бъде хит.

328
00:17:47,900 --> 00:17:50,570
>> Сега в този случай, това
е линията на код

329
00:17:50,570 --> 00:17:53,820
че преди, ние знаехме
се случи да бъде бъги.

330
00:17:53,820 --> 00:17:57,590
Така че нека да се оцени това, което се случва
точно в този момент.

331
00:17:57,590 --> 00:18:02,620
Когато линията се освети, това
Онлайн все още не е изпълнена.

332
00:18:02,620 --> 00:18:06,490
Така че в този случай, ние можем да видим
че имам номер, който

333
00:18:06,490 --> 00:18:11,610
Имам цяло число, наречено
бр, че има стойност 5.

334
00:18:11,610 --> 00:18:15,090
И аз отивам да бъде извършване
някои математика на този номер.

335
00:18:15,090 --> 00:18:20,130
>> Ако аз прекрача, че можем
забележите, че стойността за бр

336
00:18:20,130 --> 00:18:23,780
се е променила в съответствие с
аритметиката, че всъщност сме направили.

337
00:18:23,780 --> 00:18:26,810
И сега, че ние сме
вътре в този цикъл за

338
00:18:26,810 --> 00:18:29,090
или сега, че за контур
Самата се освети,

339
00:18:29,090 --> 00:18:32,450
ние виждаме, че имаме нов
променлива, наречена аз, че

340
00:18:32,450 --> 00:18:35,370
ще се използва в тази за цикъл.

341
00:18:35,370 --> 00:18:38,230
>> Сега не забравяйте преди това
Споменахте, че понякога сте

342
00:18:38,230 --> 00:18:43,470
ще видим някакъв луд
номера по подразбиране, преди този брой

343
00:18:43,470 --> 00:18:45,530
или, че е променлива
всъщност инициализира.

344
00:18:45,530 --> 00:18:49,040
Ние можем да видим, че именно
тук, в тази променлива

345
00:18:49,040 --> 00:18:51,345
наречена I, което не е
Все още е инициализиран

346
00:18:51,345 --> 00:18:53,560
към момента на подчертаване.

347
00:18:53,560 --> 00:18:57,070
Но ние можем да видим, че има някакъв номер
че ние не би действително очаква.

348
00:18:57,070 --> 00:18:57,620
>> Това е добре.

349
00:18:57,620 --> 00:18:59,661
Не се притеснявайте за това
защото имаме всъщност не

350
00:18:59,661 --> 00:19:04,970
инициализира този номер, докато не
прекрача тази линия и стойността

351
00:19:04,970 --> 00:19:08,560
I е инициализиран на стойност 1.

352
00:19:08,560 --> 00:19:11,400
Така че, за да се види, че това е всъщност
случай, нека да прекрача.

353
00:19:11,400 --> 00:19:14,420
Сега можем да видим, че това
Онлайн е била изпълнена.

354
00:19:14,420 --> 00:19:17,000
И ние сега се подчертае
това ФОРМАТ линия.

355
00:19:17,000 --> 00:19:22,230
>> И сега можем да видим как нашите ценности
на аз и 3 са се променили с течение на времето.

356
00:19:22,230 --> 00:19:26,450
Това е много полезно да се направи, в действителност,
е да прекрача линии многократно.

357
00:19:26,450 --> 00:19:30,480
И вие можете да разберете какво всъщност
се случва вътре на вашия цикъл за

358
00:19:30,480 --> 00:19:33,660
и какво се случва с
променливи вътре на тази линия за

359
00:19:33,660 --> 00:19:39,200
като че изпълнението на програмата
възниква една стъпка в даден момент.

360
00:19:39,200 --> 00:19:41,110
>> Сега в този момент, аз
Прекрачи достатъчно само

361
00:19:41,110 --> 00:19:44,210
че аз сега съм в края на моята програма.

362
00:19:44,210 --> 00:19:46,980
Ако аз прекрача, че това ще стане
всъщност престава изпълнение

363
00:19:46,980 --> 00:19:48,860
както видяхме в миналото.

364
00:19:48,860 --> 00:19:52,110
Позволете ми да се рестартира това, но отново, така че
че мога да посоча нещо друго извън,

365
00:19:52,110 --> 00:19:53,320
както добре.

366
00:19:53,320 --> 00:19:55,350
>> В този случай, това е
Сега ме питате, отново,

367
00:19:55,350 --> 00:19:57,100
за номер, който
Ще отново влиза.

368
00:19:57,100 --> 00:20:00,300
Но този път, аз отивам да влиза в
по-голям брой, така че за контур

369
00:20:00,300 --> 00:20:02,540
ще обхождане повече пъти.

370
00:20:02,540 --> 00:20:06,090
В този случай, аз ще съм
да въведете стойност от 11.

371
00:20:06,090 --> 00:20:08,390
>> Сега отново, защото щях да зададете
критичната точка по линия 15,

372
00:20:08,390 --> 00:20:10,490
то се случва да се подчертае, че на линия.

373
00:20:10,490 --> 00:20:12,980
Ние можем да видим, че нашата
номер 11 е правилно

374
00:20:12,980 --> 00:20:15,560
представени в местните ни променливи.

375
00:20:15,560 --> 00:20:22,460
Засилване над това, ние можем сега
гледате какво се случва с нашата стойност и

376
00:20:22,460 --> 00:20:25,680
докато напредваме във вътрешността на този за контур.

377
00:20:25,680 --> 00:20:31,960
Той получава увеличава всеки път, когато
изкачат на върха на която за контур.

378
00:20:31,960 --> 00:20:35,110
>> Сега едно от нещата, които биха могли да
да бъде полезно да се направи по време на изпълнение

379
00:20:35,110 --> 00:20:40,490
на тази програма е за мен да всъщност
промяна на талвега променливи, за да видите

380
00:20:40,490 --> 00:20:42,450
какво се случва с моята програма.

381
00:20:42,450 --> 00:20:46,540
В този случай, аз мога действително
кликнете два пъти върху стойността.

382
00:20:46,540 --> 00:20:48,040
Забележете, че тя се превръща в текстово поле.

383
00:20:48,040 --> 00:20:50,280
>> Сега мога да въведете различна
ценим напълно

384
00:20:50,280 --> 00:20:55,700
да се види как се държи моята програма
когато съм променил тази променлива.

385
00:20:55,700 --> 00:20:59,560
Сега в този случай, променливата
аз сега съдържа стойността 10.

386
00:20:59,560 --> 00:21:02,810
Но програмата е все още
пауза в изпълнението.

387
00:21:02,810 --> 00:21:07,610
Когато прекрача, виждам, че
стойност аз, който съм влязъл като 10,

388
00:21:07,610 --> 00:21:12,170
е не по-голяма от стойността на бр,
което веднага кара за контур

389
00:21:12,170 --> 00:21:14,240
да спре изпълнение.

390
00:21:14,240 --> 00:21:16,210
>> Сега това не е единственото
причина, поради която бихте

391
00:21:16,210 --> 00:21:19,450
искате да модифицирате променливата на място.

392
00:21:19,450 --> 00:21:22,210
Вие всъщност може да искате
да се опита да го променят така,

393
00:21:22,210 --> 00:21:24,590
че можете да продължите
изпълнение на линия

394
00:21:24,590 --> 00:21:27,370
или, така че можете да модифицирате
някаква стойност, преди да го

395
00:21:27,370 --> 00:21:32,630
достига някакъв специфичен набор от аритметична
че сте на път да изпълни.

396
00:21:32,630 --> 00:21:36,210
>> Така че сега, че ние дори да промени
стойност и като програмата се изпълнява,

397
00:21:36,210 --> 00:21:39,540
той е причинил на линия да се откажат
преждевременно, защото, всички изведнъж, аз

398
00:21:39,540 --> 00:21:42,770
се случи да бъде по-голяма от стойността
на бр, което означава, че за линия

399
00:21:42,770 --> 00:21:45,410
вече не са необходими, за да бъде изпълнена.

400
00:21:45,410 --> 00:21:48,780
Освен това, това се е случило, за да бъде най-
случай, че сме се променили стойността на I

401
00:21:48,780 --> 00:21:53,270
когато линията 17 беше подчертано,
която беше моментът

402
00:21:53,270 --> 00:21:56,280
че за изпълнение линия
всъщност се оценява.

403
00:21:56,280 --> 00:22:00,210
>> Ако бях променил стойността на
аз на друга линия, да речем 19,

404
00:22:00,210 --> 00:22:03,360
щяхме да видим различен
поведение, защото линия 19 ще

405
00:22:03,360 --> 00:22:08,310
са изпълнени преди контура
състояние се преоцени.

406
00:22:08,310 --> 00:22:11,900
Сега в този момент, аз съм, отново,
в края на тази програма.

407
00:22:11,900 --> 00:22:15,707
И мога да позволим това да се пристъпи към
позволи ми програма да се откажат от по-естествено.

408
00:22:15,707 --> 00:22:18,290
Но има няколко неща,
които са важни, за да отнемат

409
00:22:18,290 --> 00:22:19,960
от този конкретен дискусия.

410
00:22:19,960 --> 00:22:22,490
Трябва да се оцени
Вашите собствени предположения

411
00:22:22,490 --> 00:22:24,710
за това как трябва да се държи кода.

412
00:22:24,710 --> 00:22:28,220
Всеки път, когато си мислиш, че някои парче
на код ли, че се случва да работи,

413
00:22:28,220 --> 00:22:30,940
че може да е червен флаг, за да отидете
назад и оценка, и бъдете сигурни,

414
00:22:30,940 --> 00:22:33,470
че вашето предположение за
как този код работи

415
00:22:33,470 --> 00:22:38,290
всъщност е вярно, да, как е
изразена в изходния си код.

416
00:22:38,290 --> 00:22:41,300
>> Но дори и повече, за да е точка,
когато ние сме с помощта на дебъгера,

417
00:22:41,300 --> 00:22:43,920
можете да поставите точки на прекъсване в
различни реда код,

418
00:22:43,920 --> 00:22:48,110
което ще доведе до дебъгер
пауза изпълнение на всяка една от тези линии

419
00:22:48,110 --> 00:22:52,210
така че можете да се оцени
памет или дори да го промените на място.

420
00:22:52,210 --> 00:22:55,630
И пак, не забравяйте, че можете да
създаване на множество точки на прекъсване, така че да

421
00:22:55,630 --> 00:23:00,390
също може да възобнови изпълнението, пропуснете
над големи части от код,

422
00:23:00,390 --> 00:23:04,790
и тя автоматично ще пауза
на следващото прекъсване точка.

423
00:23:04,790 --> 00:23:07,760
>> Има действително по-напреднали
Гостите на дебъгер, както и.

424
00:23:07,760 --> 00:23:10,170
Но ние ще трябва да ви насочи
до няколко последващи видеоклипове

425
00:23:10,170 --> 00:23:14,090
за да наистина дразни освен как
да използва тези конкретни функции.

426
00:23:14,090 --> 00:23:15,990
За сега, благодаря ти
много за гледане.

427
00:23:15,990 --> 00:23:18,080
И късмет отстраняване на грешки.