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

2
00:00:00,309 --> 00:00:02,350
[? ДАН ARMADARAS:] Привет,
Я [? Дэн 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
В этом случае эта программа С
который принимает целое число от пользователя,

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, мы имеем
эта функция Printf,

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
>> Таким образом, в этом случае, я буду
PRINTF с отладки тега.

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
Так что я, возможно, использовать, прежде чем Printf
и после этого строки кода.

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
использования PRINTF о
непосредственно внутри для цикла

86
00:04:48,940 --> 00:04:52,930
чтобы точно знать, где
что ошибка происходила.

87
00:04:52,930 --> 00:04:55,150
Так PRINTF заявления
очень полезен в помощи

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
>> Использование Printf действительно может помочь
сузить и определить

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
>> Таким образом, используя Printf очень
полезна, когда мы хотим

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
И это может быть не совсем
настолько прост в использовании Printf

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
>> Но так уж случилось,
что CS50 IDE также

128
00:06:59,960 --> 00:07:05,870
предоставляет графический интерфейс пользователя или
интерфейс для 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
И нажав кнопку Play будет
позволяют возобновить выполнение

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
будет означать, что Printf
оператор выполняется.

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
В настоящее время в этом случае, мы можем видеть, что
Я выполнил некоторые выходы.

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
запросить пользователя для этого Int, что
мы хотим использовать в нашей программе.

279
00:15:04,390 --> 00:15:07,060
>> В настоящее время в этом случае, когда
Я ударил перешагнуть, уведомление

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

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-- удар Enter, и мы

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
нажав Резюме.

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
>> Я показываю, что только для
Цели, видя, что

302
00:16:25,320 --> 00:16:27,280
происходит, когда мы на самом деле удар Резюме.

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
Теперь, когда я с помощью отладчика, я могу
не нужны эти заявления отладки PRINTF.

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
Так что, возможно, я на самом деле хочу, чтобы пошевелить
Point Break немного дальше.

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
Опять же, я ударил Резюме.

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, нажмите Ввод и
Теперь следующий момент перерыва будет удар.

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
У меня есть целое число, называемое
Num, что имеет значение 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
мы видим, что у нас есть новый
Переменная называется I, что

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
не инициализирован это число до I
шаг на эту линию, а значение

351
00:19:04,970 --> 00:19:08,560
я был инициализирован к значению 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
И мы сейчас выделяя
это Printf линии.

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
Переступив через это, мы теперь можем
смотреть, что происходит с нашей стоимости I

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
И хорошо отладки удачи.