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

2
00:00:05,640 --> 00:00:06,830
>> ДАГ Lloyd: Ладно GDB.

3
00:00:06,830 --> 00:00:08,480
Что именно?

4
00:00:08,480 --> 00:00:11,310
Так, GDB, который стоит
для GNU Debugger,

5
00:00:11,310 --> 00:00:15,040
это действительно удивительный инструмент, который мы можем
использовать, чтобы помочь нам отладки наших программ,

6
00:00:15,040 --> 00:00:18,210
или узнать, где вещи
происходит не так в наших программах.

7
00:00:18,210 --> 00:00:22,590
GDB удивительно мощный, но
выход и взаимодействие с ним

8
00:00:22,590 --> 00:00:23,830
может быть немного загадочным.

9
00:00:23,830 --> 00:00:28,210
Это, как правило, это инструмент командной строки, и
он может бросить много сообщений на вас.

10
00:00:28,210 --> 00:00:31,144
А может это своего рода трудно
разобрать, что именно происходит.

11
00:00:31,144 --> 00:00:33,560
К счастью, мы предприняли шаги
чтобы исправить эту проблему для вас

12
00:00:33,560 --> 00:00:36,281
как вы работаете через CS50.

13
00:00:36,281 --> 00:00:39,030
Если вы не используете графический
отладчик, который мой коллега Дэн

14
00:00:39,030 --> 00:00:41,570
Armandarse говорил вполне
немного о в видео,

15
00:00:41,570 --> 00:00:44,740
должно быть здесь
Прямо сейчас, вы, возможно, потребуется

16
00:00:44,740 --> 00:00:48,270
использовать эти командную строку
инструменты для работы с GDB.

17
00:00:48,270 --> 00:00:51,250
Если вы работаете в CS50
IDE, вам не нужно делать это.

18
00:00:51,250 --> 00:00:53,550
Но если вы не
работает в CS50 IDE,

19
00:00:53,550 --> 00:00:55,750
возможно, с использованием версии
из CS50 Appliance,

20
00:00:55,750 --> 00:00:58,860
или эксплуатации другая Linux
Система с GDB установлен на нем,

21
00:00:58,860 --> 00:01:00,980
Вы можете нужно использовать
эти инструменты командной строки.

22
00:01:00,980 --> 00:01:02,860
>> И так как вы можете
нужно сделать это, это

23
00:01:02,860 --> 00:01:06,280
полезно просто чтобы понять, как
GDB работает из командной строки.

24
00:01:06,280 --> 00:01:09,650
Но, опять же, если вы
с помощью CS50 IDE, вы

25
00:01:09,650 --> 00:01:15,400
можно использовать графический отладчик
который построен в IDE.

26
00:01:15,400 --> 00:01:18,750
Таким образом, чтобы получить вещи, идущие с
GDB, чтобы начать отладку

27
00:01:18,750 --> 00:01:21,220
Процесс конкретный
Программа, все, что вам нужно сделать,

28
00:01:21,220 --> 00:01:23,810
это ввести GDB с последующим
по имени программы.

29
00:01:23,810 --> 00:01:28,620
Так, например, если ваша программа
привет, вы должны ввести GDB привет.

30
00:01:28,620 --> 00:01:31,210
>> Когда вы сделаете это, вы будете
подтянуть окружающей среды GDB.

31
00:01:31,210 --> 00:01:33,800
Ваш запрос будет изменить, и
вместо того, чтобы то, что его, как правило,

32
00:01:33,800 --> 00:01:35,841
когда вы набираете вещи
В командной line-- Ls,

33
00:01:35,841 --> 00:01:38,115
cd-- все ваш типичный
Линукс команд, ваш запрос

34
00:01:38,115 --> 00:01:42,200
изменится на, вероятно, что-то
как скобках GDB скобки.

35
00:01:42,200 --> 00:01:46,630
Это ваш новый быстрое GDB, потому что
Вы находитесь внутри среды GDB.

36
00:01:46,630 --> 00:01:49,830
После того, как внутри этой среды,
есть две основные команды

37
00:01:49,830 --> 00:01:52,290
что вы, вероятно, использовать
в следующем порядке.

38
00:01:52,290 --> 00:01:55,200
>> Во-первых, B, который
короткий для перерыва.

39
00:01:55,200 --> 00:01:58,690
И после того, как Type B, как правило, вы
введите имя функции,

40
00:01:58,690 --> 00:02:01,040
или если вы не знаете,
вокруг того, что номер строки

41
00:02:01,040 --> 00:02:04,100
Ваша программа начинает
вести себя немного странным,

42
00:02:04,100 --> 00:02:06,370
Вы можете ввести строку
Количество там также.

43
00:02:06,370 --> 00:02:09,660
Что б, или перерыв, делает
это позволяет вашу программу

44
00:02:09,660 --> 00:02:13,270
не подбежать до определенного момента,
а именно, имя функции

45
00:02:13,270 --> 00:02:15,880
что вы указать или линия
номер, который вы укажете.

46
00:02:15,880 --> 00:02:18,590
>> И в тот момент, это
будет заморозить выполнение.

47
00:02:18,590 --> 00:02:21,670
Это действительно хорошая вещь, потому что
когда исполнение было заморожено,

48
00:02:21,670 --> 00:02:25,214
Вы можете начать очень медленно
пошагово вашей программе.

49
00:02:25,214 --> 00:02:28,130
Как правило, если вы были работает
Ваши программы, они довольно короткие.

50
00:02:28,130 --> 00:02:31,250
Как правило, при вводе точка слэш все
имя вашей программы, хит Enter,

51
00:02:31,250 --> 00:02:33,470
и прежде чем вы можете мигать, ваш
Программа уже готова.

52
00:02:33,470 --> 00:02:36,620
Это на самом деле не очень много времени, чтобы попытаться
и выяснить, что происходит не так.

53
00:02:36,620 --> 00:02:40,920
Так что на самом деле, чтобы быть в состоянии замедлить вещи
вниз, установив точку останова с б,

54
00:02:40,920 --> 00:02:43,040
а затем вмешалась в.

55
00:02:43,040 --> 00:02:46,169
>> Тогда, как только вы установите ваш отдых
точка, вы можете запустить программу.

56
00:02:46,169 --> 00:02:47,960
И если у вас есть
Аргументы командной строки,

57
00:02:47,960 --> 00:02:51,610
указать их здесь, а не когда
вводе GDB ваше имя программы.

58
00:02:51,610 --> 00:02:55,980
Вы указываете все командную строку
Аргументы, принимая г, или бег,

59
00:02:55,980 --> 00:03:00,270
а затем аргументы командной строки все
Вы должны внутри вашей программы.

60
00:03:00,270 --> 00:03:03,510
Есть ряд других очень
важные и полезные команды

61
00:03:03,510 --> 00:03:04,970
внутри среды ВВП.

62
00:03:04,970 --> 00:03:07,540
Так позвольте мне быстро
перейти некоторые из них.

63
00:03:07,540 --> 00:03:11,320
>> Первый п, короткий на следующий,
и вы можете ввести следующий вместо п,

64
00:03:11,320 --> 00:03:12,304
как будет работать.

65
00:03:12,304 --> 00:03:13,470
И это только сокращение.

66
00:03:13,470 --> 00:03:17,540
И, как вы уже, наверное, получили
раньше, будучи в состоянии набрать вещи

67
00:03:17,540 --> 00:03:20,520
короче, как правило, лучше.

68
00:03:20,520 --> 00:03:24,100
И что он будет делать это буду
шаг вперед, один блок кода.

69
00:03:24,100 --> 00:03:26,170
Так что будем двигаться вперед
до вызова функции.

70
00:03:26,170 --> 00:03:28,350
И тогда вместо того,
дайвинг в этой функции

71
00:03:28,350 --> 00:03:33,130
и переживает все, что функции
Код, он просто будет иметь функцию.

72
00:03:33,130 --> 00:03:34,400
>> Функция будет называться.

73
00:03:34,400 --> 00:03:35,733
Он будет делать то, что его работа.

74
00:03:35,733 --> 00:03:38,870
Это вернет значение
функция, которая называется его.

75
00:03:38,870 --> 00:03:42,490
И тогда вы будете переходить к
Следующая строка этой вызывающей функции.

76
00:03:42,490 --> 00:03:44,555
Если вы хотите, чтобы шаг
внутри функции,

77
00:03:44,555 --> 00:03:46,430
а просто имея
это выполнить, особенно

78
00:03:46,430 --> 00:03:50,004
если вы думаете, что проблема
может лежать внутри этой функции,

79
00:03:50,004 --> 00:03:52,670
Вы могли бы, конечно, установить перерыв
точка внутри этой функции.

80
00:03:52,670 --> 00:03:57,820
Или, если вы уже работает, можно,
использовать S к шагу вперед одну строку кода.

81
00:03:57,820 --> 00:04:01,170
>> Так что это будет шаг в
и нырять в функции,

82
00:04:01,170 --> 00:04:04,750
а не просто иметь выполнить
и продолжая в функции

83
00:04:04,750 --> 00:04:07,380
что вы находитесь в для отладки.

84
00:04:07,380 --> 00:04:09,870
Если вы когда-нибудь хотели знать,
значение переменной,

85
00:04:09,870 --> 00:04:12,507
Вы можете ввести р, или печать,
а затем имя переменной.

86
00:04:12,507 --> 00:04:15,090
И это будет распечатать для вас,
внутри среды GDB,

87
00:04:15,090 --> 00:04:19,110
имя переменной, что you--
извините me-- значение переменной

88
00:04:19,110 --> 00:04:20,064
что вы назвали.

89
00:04:20,064 --> 00:04:23,230
Если вы хотите знать значения каждый
локальная переменная доступна, откуда

90
00:04:23,230 --> 00:04:25,970
Вы в настоящее время в вашей
Программа, вы можете ввести Информация местных жителей.

91
00:04:25,970 --> 00:04:28,332
Это намного быстрее, чем
набрав р, а затем все, что,

92
00:04:28,332 --> 00:04:30,540
список из всех из
переменные, которые вы знаете, существуют.

93
00:04:30,540 --> 00:04:34,370
Вы можете ввести Информация местных жителей, и это
выведет все для вас.

94
00:04:34,370 --> 00:04:37,770
Далее идет BT, которая
Короче для обратной трассировки.

95
00:04:37,770 --> 00:04:41,680
Теперь, как правило,,
особенно в начале CS50,

96
00:04:41,680 --> 00:04:44,450
вы не будете действительно иметь случай
использовать BT, или обратной трассировки,

97
00:04:44,450 --> 00:04:47,860
потому что вы, не имея функции
что вызывать другие функции.

98
00:04:47,860 --> 00:04:50,450
>> Вы, возможно, главный вызову
Функция, но это, вероятно, это.

99
00:04:50,450 --> 00:04:53,199
Вы не имеют, что другие функции
вызов другой функции, которая

100
00:04:53,199 --> 00:04:54,880
вызывает другую функцию, и так далее.

101
00:04:54,880 --> 00:04:57,550
Но, как ваши программы получить больше
Комплекс, в частности,

102
00:04:57,550 --> 00:05:00,290
когда вы начинаете работать
с рекурсией, назад след

103
00:05:00,290 --> 00:05:05,150
может быть действительно полезный способ, чтобы вы
получить вид некоторый контекст для того, где

104
00:05:05,150 --> 00:05:06,460
Я в моей программе.

105
00:05:06,460 --> 00:05:10,590
Так, вы написали код, и
Вы знаете, что основная вызывает функцию

106
00:05:10,590 --> 00:05:14,720
е, что вызывает функцию
г, что вызывает функцию час.

107
00:05:14,720 --> 00:05:17,650
Таким образом, мы имеем несколько слоев
гнездования здесь происходит.

108
00:05:17,650 --> 00:05:19,440
>> Если вы внутри
среда, GDB

109
00:05:19,440 --> 00:05:21,640
и вы знаете, ваш внутри
Н, но вы забыли

110
00:05:21,640 --> 00:05:27,210
о том, что есть ты, где вы
are-- вы можете ввести BT, или обратной трассировки,

111
00:05:27,210 --> 00:05:32,370
и это будет распечатать ч, г, е главный,
наряду некоторой другой информации, которая

112
00:05:32,370 --> 00:05:35,984
дает подсказку, что, главным ОК
называется F, F называется г, г называется ч,

113
00:05:35,984 --> 00:05:37,900
и это, где я
В настоящее время нахожусь в моей программе.

114
00:05:37,900 --> 00:05:41,380
Так что может быть очень полезно,
особенно загадочным-Несс в GDB

115
00:05:41,380 --> 00:05:45,667
становится немного подавляющим, чтобы
выяснить, где именно вещи.

116
00:05:45,667 --> 00:05:48,500
Наконец, когда ваша программа выполняется,
или когда вы закончите ее отладки

117
00:05:48,500 --> 00:05:50,125
и вы хотите, чтобы отойти
из окружающей среды GDB,

118
00:05:50,125 --> 00:05:51,940
он помогает узнать, как выйти из него.

119
00:05:51,940 --> 00:05:55,500
Вы можете ввести д или Выход, чтобы выйти.

120
00:05:55,500 --> 00:05:59,220
Теперь, прежде чем сегодня видео
Я подготовил программу багги

121
00:05:59,220 --> 00:06:03,900
называется buggy1, который я составил
из файла, известного как buggy1.c.

122
00:06:03,900 --> 00:06:06,500
Как вы могли бы ожидать, это
Программа на самом деле багги.

123
00:06:06,500 --> 00:06:08,990
Что-то идет не так
когда я пытаюсь и запустить его.

124
00:06:08,990 --> 00:06:13,014
Сейчас, к сожалению, я нечаянно
удален buggy1.c файл,

125
00:06:13,014 --> 00:06:15,930
так для меня, чтобы выяснить,
что происходит не так с этой программой,

126
00:06:15,930 --> 00:06:18,770
Я собираюсь должны использовать
GDB вид вслепую, пытаясь

127
00:06:18,770 --> 00:06:22,372
для навигации по этой программе
выяснить, что именно происходит не так.

128
00:06:22,372 --> 00:06:24,580
Но, используя только инструменты
мы уже узнали о,

129
00:06:24,580 --> 00:06:27,700
мы можем довольно много фигуру
что именно оно и есть.

130
00:06:27,700 --> 00:06:30,740
Итак, давайте над головой
CS50 IDE и посмотрите.

131
00:06:30,740 --> 00:06:33,155
ОК, так что мы здесь, в моем
CS50 IDE среда,

132
00:06:33,155 --> 00:06:35,697
и я буду увеличивать немного
так что вы можете увидеть немного больше.

133
00:06:35,697 --> 00:06:38,530
В моем окне терминала, если я перечисляю
содержимое моего нынешнего директора

134
00:06:38,530 --> 00:06:41,250
с Ls, мы увидим, что я
есть пара исходных файлов

135
00:06:41,250 --> 00:06:44,982
Здесь, в том числе
обсуждалось ранее buggy1.

136
00:06:44,982 --> 00:06:46,940
Что именно происходит, когда
Я стараюсь и запустите buggy1.

137
00:06:46,940 --> 00:06:47,773
Ну, давайте выясним.

138
00:06:47,773 --> 00:06:52,510
Я типа точка слэш,
багги, и я ударил Enter.

139
00:06:52,510 --> 00:06:53,670
>> Сегментирование неисправностей.

140
00:06:53,670 --> 00:06:55,000
Это не хорошо.

141
00:06:55,000 --> 00:06:57,180
Если вы Напомним,
Сегментация вина, как правило,

142
00:06:57,180 --> 00:07:01,540
происходит, когда мы получаем доступ к памяти
что мы не разрешается прикасаться.

143
00:07:01,540 --> 00:07:03,820
Мы как-то добраться
вне границ

144
00:07:03,820 --> 00:07:05,995
что программа, тем
компилятор, дал нам.

145
00:07:05,995 --> 00:07:08,310
И так уже, что это
ключ к держать в панели инструментов

146
00:07:08,310 --> 00:07:10,660
мы начинаем процесс отладки.

147
00:07:10,660 --> 00:07:13,620
Что-то пошло немного неправильно здесь.

148
00:07:13,620 --> 00:07:15,935
>> Ладно, так что давайте начнем
до среды GDB

149
00:07:15,935 --> 00:07:19,030
и посмотреть, если мы можем выяснить,
что именно проблема.

150
00:07:19,030 --> 00:07:21,674
Я собираюсь очистить экран,
и я собираюсь ввести GDB

151
00:07:21,674 --> 00:07:24,340
снова, чтобы войти в среду GDB,
и имя программы

152
00:07:24,340 --> 00:07:27,450
что я хочу, чтобы отладить, buggy1.

153
00:07:27,450 --> 00:07:30,182
Мы получаем небольшое сообщение, читая
, сделано символы из buggy1.

154
00:07:30,182 --> 00:07:32,390
Все это означает, что он вытащил это
вместе весь код,

155
00:07:32,390 --> 00:07:35,570
и теперь он был загружен в
GDB, и он готов к работе.

156
00:07:35,570 --> 00:07:37,140
>> Теперь, что я хочу сделать?

157
00:07:37,140 --> 00:07:39,130
Помнишь вам, что
Первый шаг, как правило, является

158
00:07:39,130 --> 00:07:42,540
после я внутри этой среды?

159
00:07:42,540 --> 00:07:44,540
Надеюсь, вы сказали, установить
точка разрыва, потому что

160
00:07:44,540 --> 00:07:46,240
в том, что то, что я хочу сделать.

161
00:07:46,240 --> 00:07:47,990
Теперь, я не имеют
Исходный код для этого

162
00:07:47,990 --> 00:07:50,948
передо мной, что, вероятно,
не типичный случай использования, кстати.

163
00:07:50,948 --> 00:07:52,055
Вы, наверное, будет.

164
00:07:52,055 --> 00:07:52,680
Так что это хорошо.

165
00:07:52,680 --> 00:07:55,790
Но если вы этого не сделаете, то, что
один функция, что вы знаете

166
00:07:55,790 --> 00:07:58,880
существует в каждой отдельной программе C?

167
00:07:58,880 --> 00:08:04,420
Независимо от того, насколько велика или насколько сложным
это, безусловно, эта функция существует.

168
00:08:04,420 --> 00:08:05,440
Главная, верно?

169
00:08:05,440 --> 00:08:08,870
>> Так неудачу всего, мы можем
установить точку останова на главной.

170
00:08:08,870 --> 00:08:12,200
И снова, я бы просто напечатать
разговора Основное, вместо б.

171
00:08:12,200 --> 00:08:14,650
А если вам интересно, если вы
либо введите длинную команду

172
00:08:14,650 --> 00:08:16,800
а затем осознать, что вас
набрали неправильную вещь,

173
00:08:16,800 --> 00:08:18,770
и вы хотите, чтобы избавиться
всего, как я только что сделал,

174
00:08:18,770 --> 00:08:22,029
Вы можете принять управление U, который будет
удалить все и вернуться обратно

175
00:08:22,029 --> 00:08:23,570
в начале линии курсора.

176
00:08:23,570 --> 00:08:26,569
Гораздо быстрее, чем просто держать вниз
удалять или наезд кучу раз

177
00:08:26,569 --> 00:08:27,080
на.

178
00:08:27,080 --> 00:08:28,740
>> Таким образом, мы установили точку останова на главной.

179
00:08:28,740 --> 00:08:32,970
И, как вы можете видеть, это говорит, что мы имею
установить точку останова на файл buggy1.c,

180
00:08:32,970 --> 00:08:36,330
и, видимо, первая линия
из кода главное, линия семь.

181
00:08:36,330 --> 00:08:38,080
Опять же, мы не должны
исходный файл здесь,

182
00:08:38,080 --> 00:08:40,429
но я буду считать, что это
говорит мне правду.

183
00:08:40,429 --> 00:08:44,510
И потом, я просто пытаюсь
и запустить программу, г.

184
00:08:44,510 --> 00:08:45,360
Начиная программу.

185
00:08:45,360 --> 00:08:48,160
Ладно, так что это сообщение
немного загадочными.

186
00:08:48,160 --> 00:08:50,160
Но в основном то, что
что здесь происходит, это просто

187
00:08:50,160 --> 00:08:53,350
говорит мне, что я ударил перерыв
Точка, точка разрыва номер 1.

188
00:08:53,350 --> 00:08:55,877
>> А потом, что строка кода,
Данный файл или каталог отсутствует.

189
00:08:55,877 --> 00:08:57,710
Единственная причина, что
Я вижу, что сообщение

190
00:08:57,710 --> 00:09:00,800
потому, что я невольно
удален buggy.c файл.

191
00:09:00,800 --> 00:09:04,050
Если мой buggy1.c файл существует
в текущем каталоге,

192
00:09:04,050 --> 00:09:06,920
что линия тут фактически
скажи мне, что строка кода

193
00:09:06,920 --> 00:09:08,214
буквально читает.

194
00:09:08,214 --> 00:09:09,380
К сожалению, я удалил его.

195
00:09:09,380 --> 00:09:14,790
Мы собираемся иметь, чтобы перемещаться вид
через это немного больше вслепую.

196
00:09:14,790 --> 00:09:17,330
>> Итак, давайте посмотрим, что
я хочу сделать здесь?

197
00:09:17,330 --> 00:09:21,770
Ну, я хотел бы знать, что местный
переменные, может быть, доступных мне.

198
00:09:21,770 --> 00:09:23,570
Я начал мою программу.

199
00:09:23,570 --> 00:09:28,515
Давайте посмотрим, что может быть
уже инициализирован для нас.

200
00:09:28,515 --> 00:09:31,430
Я печатаю информация местных жителей, ни местных жителей.

201
00:09:31,430 --> 00:09:33,960
Ладно, так что не
дать мне тонны информации.

202
00:09:33,960 --> 00:09:37,600
Я мог бы попробовать и распечатать переменную,
но я не знаю, какие имена переменных.

203
00:09:37,600 --> 00:09:39,930
Я мог бы попробовать назад след,
но я внутри основной,

204
00:09:39,930 --> 00:09:43,710
так что я знаю, что не сделал
другой вызов прямо сейчас функция.

205
00:09:43,710 --> 00:09:47,710
>> Так выглядит только мои варианты
использовать п или так и начать погружаться в.

206
00:09:47,710 --> 00:09:49,630
Я собираюсь использовать п.

207
00:09:49,630 --> 00:09:51,180
Так что я типа N.

208
00:09:51,180 --> 00:09:53,060
О, черт возьми, что здесь происходит.

209
00:09:53,060 --> 00:09:56,260
Программа получила сигналы,
SIGSEGV сегментация вина,

210
00:09:56,260 --> 00:09:57,880
а затем целая куча вещей.

211
00:09:57,880 --> 00:09:58,880
Я уже перегружены.

212
00:09:58,880 --> 00:10:00,980
Ну, на самом деле
можно многому научиться здесь.

213
00:10:00,980 --> 00:10:02,520
Итак, что же это нам говорит?

214
00:10:02,520 --> 00:10:09,180
Что это говорит нам о том, эта программа
о, но имеет еще нет, SEG вина.

215
00:10:09,180 --> 00:10:12,550
И в частности, я собираюсь
для увеличения еще дальше здесь,

216
00:10:12,550 --> 00:10:18,980
это собирается SEG неисправность о
то, что называется зЬгстр.

217
00:10:18,980 --> 00:10:22,705
>> Теперь, мы не можем обсудили
Эта функция широко.

218
00:10:22,705 --> 00:10:25,580
Но это потому, что is-- мы не собираемся
говорить о том, что все функции

219
00:10:25,580 --> 00:10:28,610
существует в стандарте C library--
но все они доступны для вас,

220
00:10:28,610 --> 00:10:32,110
особенно, если вы берете
посмотреть на reference.cs50.net.

221
00:10:32,110 --> 00:10:35,000
И зЬгстр это действительно мощный
функция, которая существует внутри

222
00:10:35,000 --> 00:10:38,070
в заголовке string.h
Файл, который представляет собой заголовок

223
00:10:38,070 --> 00:10:41,970
файл, который посвящен функций
что работа с и манипулировать строк.

224
00:10:41,970 --> 00:10:49,830
>> И в частности, то, что делает зЬгстр
он сравнивает значения двух строк.

225
00:10:49,830 --> 00:10:54,160
Так и я о сегментации вину
на призыв STRCMP кажется.

226
00:10:54,160 --> 00:10:58,530
Я ударил п, а на самом деле я получаю сообщение,
Программа завершается с сигналом SIGSEGV

227
00:10:58,530 --> 00:11:01,370
Сегментация вина. А сейчас
Я на самом деле SEG нарушенными,

228
00:11:01,370 --> 00:11:06,479
и моя программа имеет довольно
много эффективно отказали.

229
00:11:06,479 --> 00:11:07,770
Это конец программы.

230
00:11:07,770 --> 00:11:10,370
Это сломался, он разбился.

231
00:11:10,370 --> 00:11:14,740
Так что не было много, но я
на самом деле узнать совсем немного

232
00:11:14,740 --> 00:11:16,747
из этого мало опыта.

233
00:11:16,747 --> 00:11:17,580
Что я узнал?

234
00:11:17,580 --> 00:11:22,020
Ну, моя программа падает
в значительной степени немедленно.

235
00:11:22,020 --> 00:11:26,300
Моя программа не работает на
позвоните чтобы STRCMP, но я

236
00:11:26,300 --> 00:11:30,560
не имеют никаких локальных переменных в моем
Программа в то время, он падает.

237
00:11:30,560 --> 00:11:37,320
Так что строка или строки,
я мог бы сравнивая.

238
00:11:37,320 --> 00:11:42,140
Если я не любая локальная
переменные, вы можете

239
00:11:42,140 --> 00:11:45,520
предположить, что я, может быть, have-- есть это
глобальная переменная, которая может быть правдой.

240
00:11:45,520 --> 00:11:47,670
>> Но в целом, кажется,
как я сравниваю

241
00:11:47,670 --> 00:11:52,070
к чему-то, что не существует.

242
00:11:52,070 --> 00:11:54,130
Так что давайте исследовать
что немного дальше.

243
00:11:54,130 --> 00:11:55,120
Так что я собираюсь очистить экран.

244
00:11:55,120 --> 00:11:57,536
Я собираюсь бросить из ряда
GDB среда на секунду.

245
00:11:57,536 --> 00:12:01,300
И я думал, хорошо, так что
нет локальные переменные в моей программе.

246
00:12:01,300 --> 00:12:06,444
Интересно, если возможно, я должен пройти
в строке в качестве аргумента командной строки.

247
00:12:06,444 --> 00:12:07,610
Так что давайте просто проверить это.

248
00:12:07,610 --> 00:12:09,020
Я не сделал этого раньше.

249
00:12:09,020 --> 00:12:14,244
>> Давайте посмотрим, если возможно, если я запускаю эту программу
с аргументом командной строки работает.

250
00:12:14,244 --> 00:12:16,140
Да, нет ошибки сегментации там.

251
00:12:16,140 --> 00:12:17,870
Это просто сказал мне, что я понял это.

252
00:12:17,870 --> 00:12:19,170
Так, может быть, это исправление здесь.

253
00:12:19,170 --> 00:12:27,560
И в самом деле, если я иду назад и посмотреть на
фактический исходный код для buggy1.c,

254
00:12:27,560 --> 00:12:31,180
кажется, как будто то, что я делаю,
Я делаю вызов STRCMP без

255
00:12:31,180 --> 00:12:34,010
проверки, является ли ARGV [1] существует на самом деле.

256
00:12:34,010 --> 00:12:36,730
Это на самом деле
Исходный код для buggy1.c.

257
00:12:36,730 --> 00:12:38,855
Так что я действительно нужно
сделать здесь, чтобы исправить мою программу,

258
00:12:38,855 --> 00:12:40,835
предполагая, у меня есть
подать передо мной, является

259
00:12:40,835 --> 00:12:44,740
просто добавить проверку, чтобы
уверен, что ARGC равно 2.

260
00:12:44,740 --> 00:12:47,780
Так что это пример, опять же, как я уже сказал,
немного надуманный, верно?

261
00:12:47,780 --> 00:12:49,840
Вы обычно не собирается
случайно удалить исходный код

262
00:12:49,840 --> 00:12:51,820
а затем попробовать
и отладить программу.

263
00:12:51,820 --> 00:12:53,120
Но, надеюсь, это дало
Вы иллюстрацией

264
00:12:53,120 --> 00:12:55,120
из тех вещей, что
Вы могли бы думать о

265
00:12:55,120 --> 00:12:56,610
а вы отладки программы.

266
00:12:56,610 --> 00:12:58,760
>> Что состояние дел здесь?

267
00:12:58,760 --> 00:13:00,510
Какие переменные ли я
есть доступным для меня?

268
00:13:00,510 --> 00:13:03,600
Где именно моя программа
грохот, на какой линии,

269
00:13:03,600 --> 00:13:05,240
на то, что призыв к какой функции?

270
00:13:05,240 --> 00:13:06,952
Какие улики дает ли это мне?

271
00:13:06,952 --> 00:13:08,910
И это именно
вид мышления, что вам

272
00:13:08,910 --> 00:13:12,820
должны получать в когда вы
думать о отладки программ.

273
00:13:12,820 --> 00:13:13,820
>> Я Дуг Ллойд.

274
00:13:13,820 --> 00:13:16,140
Это CS50.

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