1
00:00:00,000 --> 00:00:06,180

2
00:00:06,180 --> 00:00:07,820
>> Джейсон Хиршхорн: Добро пожаловать
А5, все.

3
00:00:07,820 --> 00:00:11,270
У нас есть захватывающая неделя впереди нас,
в основном, потому что есть так много нового

4
00:00:11,270 --> 00:00:12,350
сталкивается в этой комнате.

5
00:00:12,350 --> 00:00:12,920
Это замечательно.

6
00:00:12,920 --> 00:00:15,740
Многие из вас здесь случайно,
который еще лучше.

7
00:00:15,740 --> 00:00:18,220
Так что, надеюсь вы будете держать присоединились к нам.

8
00:00:18,220 --> 00:00:20,220
>> На этой неделе мы собираемся потратить
основная часть разделе

9
00:00:20,220 --> 00:00:21,870
готовится к викторине.

10
00:00:21,870 --> 00:00:26,580
Так за нашей повестке дня, мы собираемся говорить
немного о ресурсах для класса,

11
00:00:26,580 --> 00:00:30,350
но и для викторины, а затем, опять же,
тратить большую часть класса разговора

12
00:00:30,350 --> 00:00:31,390
о вопросах.

13
00:00:31,390 --> 00:00:33,900
После того, как мы закончили отвечать на ваши
вопросы, или если ваши вопросы

14
00:00:33,900 --> 00:00:39,010
естественно, привести нас к некоторому кодирования, я
есть проблемы образцы из промежуточных выборах

15
00:00:39,010 --> 00:00:43,180
прошлое, которое мы будем кодировать живут в разделе
вместе, что также воспитывать некоторые другие

16
00:00:43,180 --> 00:00:45,420
хорошие темы для покрытия.

17
00:00:45,420 --> 00:00:48,280
>> Итак, сначала, как мы прошли через для
последние пару недель, чтобы напомнить вам,

18
00:00:48,280 --> 00:00:51,700
ребята, есть тонна ресурсов
по данному курсу.

19
00:00:51,700 --> 00:00:55,020
Многие из них будет невероятно полезным
для вас, как вы будете продолжать

20
00:00:55,020 --> 00:00:57,280
учиться на викторине 0, потому что
это во вторник днем.

21
00:00:57,280 --> 00:00:59,630
Так что все из вас были
учится на некоторое время.

22
00:00:59,630 --> 00:01:02,640
>> Есть конспекты лекций и источник
код, который вы должны

23
00:01:02,640 --> 00:01:04,050
обязательно проверить.

24
00:01:04,050 --> 00:01:05,019
Смотреть шорты.

25
00:01:05,019 --> 00:01:07,470
Проверьте study.cs50.net.

26
00:01:07,470 --> 00:01:11,770
А потом, перечислены ниже, ряд
других ресурсов.

27
00:01:11,770 --> 00:01:14,020
>> Опять же, викторина 0 завтра
на 1 час.

28
00:01:14,020 --> 00:01:18,230
Если вы еще не сделали этого, проверьте
вне О Викторина 0 документа о

29
00:01:18,230 --> 00:01:21,370
Домашняя страница Конечно, чтобы выяснить,
где вы принимая викторины.

30
00:01:21,370 --> 00:01:25,770
Викторина начинается в 1:10 и
заканчивается 70 минут спустя.

31
00:01:25,770 --> 00:01:29,610
Так что если вы только после 1:10, вы
собирается получить, что гораздо меньше минут

32
00:01:29,610 --> 00:01:30,940
чем 70 пройти тест.

33
00:01:30,940 --> 00:01:33,570
Поэтому убедитесь, что вы там на время.

34
00:01:33,570 --> 00:01:38,690
Если вы расширение студент или есть
некоторые другие соображения тестирования, это

35
00:01:38,690 --> 00:01:40,400
может быть не в 1:00 завтра.

36
00:01:40,400 --> 00:01:43,540
Но, опять же, проверить О Викторина 0
документ, чтобы убедиться, что вы знаете, когда

37
00:01:43,540 --> 00:01:44,760
вы принимаете викторину.

38
00:01:44,760 --> 00:01:46,440
Я написал 75 минут здесь.

39
00:01:46,440 --> 00:01:48,580
Я думаю, что это право, а не 70.

40
00:01:48,580 --> 00:01:53,420
>> Она охватывает весь материал от недели 0
лекцию на прошлой неделе в среду.

41
00:01:53,420 --> 00:01:59,350
И опять же, для этой викторине, за что
документ, вы получаете один двухсторонний и 8

42
00:01:59,350 --> 00:02:03,770
1/2 на 11 листе бумаги, который вы получаете
использовать в качестве заметок во время викторины.

43
00:02:03,770 --> 00:02:08,570
Многие люди, если не большинство людей, имеют
обнаружили, что единственный самый полезный способ

44
00:02:08,570 --> 00:02:11,970
учиться для викторины является
сделать исследование лист,

45
00:02:11,970 --> 00:02:13,730
один-тент, своих собственных.

46
00:02:13,730 --> 00:02:17,710
Так что смотрите на последние из них, если
вы видели в прошлом те.

47
00:02:17,710 --> 00:02:19,960
Обратитесь к друзьям, чтобы видеть то, что
они помещают на них.

48
00:02:19,960 --> 00:02:23,610
>> Но руки вниз, лучший способ вы можете
исследование, чтобы пройти через все, и

49
00:02:23,610 --> 00:02:26,530
свести его к тому, что должны или
не принадлежит на этом листе

50
00:02:26,530 --> 00:02:30,570
бумага, потому что это просто очень
полезный способ для вас, чтобы убедиться,

51
00:02:30,570 --> 00:02:33,620
вы собираетесь через все и
немного знакомы с ним.

52
00:02:33,620 --> 00:02:36,690
Большинство людей, мы находим, хотя они
уже лист бумаги сидит

53
00:02:36,690 --> 00:02:39,840
рядом с ними на викторине, не включайте
к нему, потому что, опять же, что очень

54
00:02:39,840 --> 00:02:43,290
Процесс прохождения информации
помогло им научиться.

55
00:02:43,290 --> 00:02:45,370
>> Кто-нибудь есть какие-либо вопросы
о викторине 0?

56
00:02:45,370 --> 00:02:50,120

57
00:02:50,120 --> 00:02:51,450
Имеет всех -

58
00:02:51,450 --> 00:02:53,230
Я не собираюсь делать поднятием рук.

59
00:02:53,230 --> 00:02:53,550
Не берите в голову.

60
00:02:53,550 --> 00:02:54,790
Я собирался спросить, кто
начал изучать.

61
00:02:54,790 --> 00:02:58,360
Но я не хочу, чтобы вас
все не поднять руки.

62
00:02:58,360 --> 00:03:01,290
Так как я уже сказал - да, Ави, идти вперед.

63
00:03:01,290 --> 00:03:04,205
>> AVI: Что будет полезная вещь
поставить на одну пейджер?

64
00:03:04,205 --> 00:03:05,875
>> СТУДЕНТ: Это зависит от вас.

65
00:03:05,875 --> 00:03:08,210
>> Джейсон Хиршхорн: Вы получаете
использовать свое суждение.

66
00:03:08,210 --> 00:03:13,220
Полезные вещи, чтобы положить на одну пейджер,
если вы не уверены о большом O

67
00:03:13,220 --> 00:03:17,510
выполнения различных видов поиска
и виды, считай это на там в

68
00:03:17,510 --> 00:03:18,760
удобно денди диаграммы.

69
00:03:18,760 --> 00:03:22,250
Таким образом, если вы попросили, чтобы на
викторина, вам не нужно, чтобы попытаться выяснить

70
00:03:22,250 --> 00:03:23,560
это вне или причина через выполнения.

71
00:03:23,560 --> 00:03:24,730
Вы можете просто скопировать его.

72
00:03:24,730 --> 00:03:28,320
Если вы посмотрите на викторина прошлом, много
раз, там работает времени вопросы.

73
00:03:28,320 --> 00:03:34,150
Так что было бы примером хорошей
вещь, чтобы поставить на свой одной пейджер.

74
00:03:34,150 --> 00:03:37,450
>> Другие хорошие вещи, чтобы надеть, если вы
путают о том, чтобы объявить

75
00:03:37,450 --> 00:03:40,570
Функция или то, что разные части
Объявление функции являются, написать

76
00:03:40,570 --> 00:03:43,400
что ни на есть, общая версия
а затем, возможно пример.

77
00:03:43,400 --> 00:03:47,290
Если вы смущены об указателях,
схема, как указатели работа

78
00:03:47,290 --> 00:03:48,660
вероятно, очень полезно.

79
00:03:48,660 --> 00:03:52,440
Если вы смущены о рекурсии, а
попробовать рекурсивную функцию там

80
00:03:52,440 --> 00:03:54,980
может также оказаться действительно полезными.

81
00:03:54,980 --> 00:03:57,290
Значит ли это, дать вам некоторые идеи?

82
00:03:57,290 --> 00:04:01,820
>> AVI: Вы должны понимать,
Весь процесс компиляции, как

83
00:04:01,820 --> 00:04:03,220
, как это все работает?

84
00:04:03,220 --> 00:04:06,620
>> Джейсон Хиршхорн: Все
, которая была покрыта мог

85
00:04:06,620 --> 00:04:08,060
показать на викторине.

86
00:04:08,060 --> 00:04:08,930
Вопросы -

87
00:04:08,930 --> 00:04:11,300
но опять же, некоторые вещи будут
взвешенный степени, чем другие.

88
00:04:11,300 --> 00:04:14,330
Некоторые вещи придумали снова
и снова в классе, в

89
00:04:14,330 --> 00:04:15,590
лекция, и раздел.

90
00:04:15,590 --> 00:04:17,220
Другие вещи не имеют
придумать, что часто.

91
00:04:17,220 --> 00:04:22,900
>> Мы много говорили о # включить и
-Л-то и то, что те, значит, в

92
00:04:22,900 --> 00:04:24,390
процесс компиляции.

93
00:04:24,390 --> 00:04:29,120
Мы много говорили о GDB, цепляться,
эти различные флаги, которые мы используем, когда

94
00:04:29,120 --> 00:04:33,100
мы собираем и то, и то, что
make15, например, действительно

95
00:04:33,100 --> 00:04:34,510
означает и действительно делает.

96
00:04:34,510 --> 00:04:38,110
Мы не будем говорить, как много о
каждый шаг в

97
00:04:38,110 --> 00:04:39,240
процесс компиляции.

98
00:04:39,240 --> 00:04:40,410
У нас еще говорили об этом.

99
00:04:40,410 --> 00:04:42,550
Так что это еще то, что вы
должны быть знакомы с.

100
00:04:42,550 --> 00:04:44,610
Но опять же, мы не собираемся быть -

101
00:04:44,610 --> 00:04:49,140
вещи, которые приходят чаще, в классе
, скорее всего, чтобы придумать более

102
00:04:49,140 --> 00:04:52,495
часто и более сильно
взвешенный на викторине.

103
00:04:52,495 --> 00:04:53,280
>> Круто.

104
00:04:53,280 --> 00:04:54,580
Любые другие вопросы о викторине 0?

105
00:04:54,580 --> 00:04:57,660

106
00:04:57,660 --> 00:05:00,050
>> ОК, так что я положил список
темы на доске.

107
00:05:00,050 --> 00:05:01,550
Я прошел через учебную программу.

108
00:05:01,550 --> 00:05:07,340
Я прошел через разделе обзора от
вчера вечером, и эти слайды придумать

109
00:05:07,340 --> 00:05:13,710
с неполного списка вопросов
, когда мы рассмотрели до сих пор в CS50

110
00:05:13,710 --> 00:05:16,800
и вещи, которые могли бы
появляются на викторине.

111
00:05:16,800 --> 00:05:19,900
Так что я не собираюсь пройти через
каждый из них.

112
00:05:19,900 --> 00:05:22,370
Это займет гораздо больше
времени, чем мы имеем сейчас.

113
00:05:22,370 --> 00:05:26,880
Но я поставить это здесь, мы надеемся пробежку
ваша память, как к вещам, которые могут

114
00:05:26,880 --> 00:05:28,420
быть или не быть так хорошо знакомы с вами.

115
00:05:28,420 --> 00:05:32,850
>> И я хотел бы провести большую часть
раздел отвечая на ваши вопросы о

116
00:05:32,850 --> 00:05:35,130
Эти темы, темы, которые
здесь не рассматриваются.

117
00:05:35,130 --> 00:05:36,130
Мы можем написать псевдокод.

118
00:05:36,130 --> 00:05:40,010
Мы можем написать реальный код
убедиться, что вы -

119
00:05:40,010 --> 00:05:44,280
Я могу ответить на ваш вопрос и помочь
все принципиально понять

120
00:05:44,280 --> 00:05:48,330
Многие из этих вопросов, так что вы будете чувствовать себя
подготовлены и комфортно будет в

121
00:05:48,330 --> 00:05:50,150
викторина завтра.

122
00:05:50,150 --> 00:05:52,300
Так что читайте по списку.

123
00:05:52,300 --> 00:05:54,780
Вы, надеюсь, пришли к разделу
с некоторыми вопросами, а также.

124
00:05:54,780 --> 00:05:58,480
Когда вы будете готовы, поднимите руку
и мы начнем.

125
00:05:58,480 --> 00:06:01,590

126
00:06:01,590 --> 00:06:05,200
>> Имейте в виду, вопросы у вас есть,
нет глупых вопросов.

127
00:06:05,200 --> 00:06:06,250
Мы слышали, что много.

128
00:06:06,250 --> 00:06:09,490
И вопросы у вас есть, я готов
сделать ставку, многим другим людям и

129
00:06:09,490 --> 00:06:11,740
сижу здесь и смотреть
онлайн есть также.

130
00:06:11,740 --> 00:06:13,770
Таким образом, вы можете только помочь людям
, задавая вопросы.

131
00:06:13,770 --> 00:06:15,070
Маркус.

132
00:06:15,070 --> 00:06:18,040
>> Маркус: Между стека и
куча, есть ли предварительно выделено

133
00:06:18,040 --> 00:06:22,880
процент памяти, который определяется как
это для стека или кучи?

134
00:06:22,880 --> 00:06:25,010
Или как это работает, точно?

135
00:06:25,010 --> 00:06:26,230
>> Джейсон Хиршхорн: Хороший вопрос.

136
00:06:26,230 --> 00:06:28,640
Я собираюсь обратно проследить немного.

137
00:06:28,640 --> 00:06:30,910
Ли всех -

138
00:06:30,910 --> 00:06:31,660
пожалуйста, будьте честными.

139
00:06:31,660 --> 00:06:34,130
Я знаю, я прошу вас, чтобы поднять ваш
рукой перед своими сверстниками.

140
00:06:34,130 --> 00:06:38,510
Но есть люди, которые считают,
неудобно со стеком и кучей

141
00:06:38,510 --> 00:06:42,980
и хотели бы перейти, что
и что те, значит?

142
00:06:42,980 --> 00:06:43,880
Поднимите руку, если -

143
00:06:43,880 --> 00:06:44,420
ОК.

144
00:06:44,420 --> 00:06:45,120
Спасибо.

145
00:06:45,120 --> 00:06:48,420
Таким образом, мы собираемся пойти стопку и
куча действительно быстро, а затем

146
00:06:48,420 --> 00:06:50,370
перейти в отвечая на ваш вопрос.

147
00:06:50,370 --> 00:06:58,250
>> Так что, если мы вытянуть коробку представлять
памяти на вашем компьютере, что некоторые

148
00:06:58,250 --> 00:07:02,160
вещи, которые идут в этом поле?

149
00:07:02,160 --> 00:07:03,630
Главная.

150
00:07:03,630 --> 00:07:04,020
Основная функция.

151
00:07:04,020 --> 00:07:05,890
Где главный идти?

152
00:07:05,890 --> 00:07:08,090
>> СТУДЕНТ: [неразборчиво].

153
00:07:08,090 --> 00:07:09,390
>> Джейсон Хиршхорн: Так мы будем
положить главный здесь.

154
00:07:09,390 --> 00:07:12,180

155
00:07:12,180 --> 00:07:13,430
Что еще идет в этом поле?

156
00:07:13,430 --> 00:07:16,000

157
00:07:16,000 --> 00:07:18,140
>> СТУДЕНТ: Функции, которые вы называете.

158
00:07:18,140 --> 00:07:19,020
>> Джейсон Хиршхорн: Функции
что мы называем.

159
00:07:19,020 --> 00:07:20,440
И куда они идут?

160
00:07:20,440 --> 00:07:21,300
>> СТУДЕНТ: В стеке.

161
00:07:21,300 --> 00:07:22,380
>> Джейсон Хиршхорн: Они
перейти в стеке.

162
00:07:22,380 --> 00:07:27,350
Так что мы собираемся называть это
вещь здесь стек.

163
00:07:27,350 --> 00:07:31,880
И наверху, у нас есть куча.

164
00:07:31,880 --> 00:07:35,450
Так память не коробка так же, как это.

165
00:07:35,450 --> 00:07:37,330
Но это на самом деле очень похожи.

166
00:07:37,330 --> 00:07:40,840
Это собирается быть много коробок над
и более, в зависимости от размера вашего

167
00:07:40,840 --> 00:07:43,730
компьютер или насколько велика ваша память.

168
00:07:43,730 --> 00:07:46,950
>> В котировок конец цитаты "дна"
это стек.

169
00:07:46,950 --> 00:07:50,880
И есть несколько вещей,
, которые идут в стек.

170
00:07:50,880 --> 00:07:53,840
А те, зависит от функций
у вас есть в вашем коде.

171
00:07:53,840 --> 00:07:57,780
У вас всегда есть одна функция в вашем
Код называют основным, так что всегда

172
00:07:57,780 --> 00:08:00,480
раздел здесь, в
стек посвящена основным.

173
00:08:00,480 --> 00:08:03,980
>> Эти разделы в стеке
называются кадры стека.

174
00:08:03,980 --> 00:08:09,580
При вызове другой функции, скажем основной
вызывает бинарную функцию поиска,

175
00:08:09,580 --> 00:08:11,075
мы ставим другую рамку в стеке.

176
00:08:11,075 --> 00:08:13,830

177
00:08:13,830 --> 00:08:17,320
В частности, мы собираемся
пожертвовать часть памяти на нашем

178
00:08:17,320 --> 00:08:22,960
компьютер для хранения бинарный поиск Часовой
переменные и запустить исполняемый файл

179
00:08:22,960 --> 00:08:24,150
Поиск кода.

180
00:08:24,150 --> 00:08:26,810
>> Так мы называем бинарный поиск.

181
00:08:26,810 --> 00:08:30,440

182
00:08:30,440 --> 00:08:33,340
В этом куске памяти, мы собираемся
для хранения своих локальных переменных.

183
00:08:33,340 --> 00:08:35,270
Мы собираемся хранить свои Printf звонки.

184
00:08:35,270 --> 00:08:38,159
Что бы ни случилось, что функция
будут храниться прямо там.

185
00:08:38,159 --> 00:08:40,350
Двоичного поиска собирается выполнять.

186
00:08:40,350 --> 00:08:42,210
Она собирается завершить выполнение.

187
00:08:42,210 --> 00:08:47,450
Что такое слово в C, что означает
что функция должна

188
00:08:47,450 --> 00:08:49,306
завершить ее выполнение?

189
00:08:49,306 --> 00:08:50,040
>> СТУДЕНТ: Возвращение.

190
00:08:50,040 --> 00:08:50,870
>> Джейсон Хиршхорн: Возвращение.

191
00:08:50,870 --> 00:08:53,230
Поэтому, когда вы видите оператор возврата,
концы функции

192
00:08:53,230 --> 00:08:54,350
когда она попадает, что.

193
00:08:54,350 --> 00:08:56,740
Так бинарный поиск ударит его возвращения.

194
00:08:56,740 --> 00:09:01,360
Эта часть памяти будет существенно
быть освобождены до.

195
00:09:01,360 --> 00:09:03,510
А главное вернется к исполнению.

196
00:09:03,510 --> 00:09:07,240
Так главный приостановит где бы было, вызов
бинарный поиск, получить возвращаемого значения,

197
00:09:07,240 --> 00:09:08,700
и продолжить выполнение.

198
00:09:08,700 --> 00:09:10,840
Этот стек кадра уйдет.

199
00:09:10,840 --> 00:09:14,810
>> Если мы называем рекурсивную функцию, которая
это функция, которая называет себя более

200
00:09:14,810 --> 00:09:18,480
и более, мы могли бы получить - сказать, что мы
сделал бинарный поиск рекурсивно.

201
00:09:18,480 --> 00:09:21,520
Мы могли бы получить бинарный поиск версию один,
бинарный поиск двух, бинарный поиск

202
00:09:21,520 --> 00:09:24,090
три, бинарный поиск четыре,
бинарный поиск пять.

203
00:09:24,090 --> 00:09:27,950
А потом эта последняя бинарный поиск пять
выйдет на базовый вариант, и стек

204
00:09:27,950 --> 00:09:31,010
кадры будут возвращаться и продолжать закрытие
пока мы не вернемся к основной.

205
00:09:31,010 --> 00:09:32,530
Мы можем пойти по рекурсии в немного.

206
00:09:32,530 --> 00:09:35,530
Но все это есть, если вы
вызова нескольких функций одновременно,

207
00:09:35,530 --> 00:09:39,250
там будет несколько стека
кадров в стеке.

208
00:09:39,250 --> 00:09:42,900
>> Куча, с другой стороны, до
здесь, не для функций,

209
00:09:42,900 --> 00:09:44,380
не для локальных переменных.

210
00:09:44,380 --> 00:09:48,920
Это для динамически распределяется
переменные.

211
00:09:48,920 --> 00:09:57,210
Таким образом, эти переменные, которые могут быть
инициализации в любой основной или

212
00:09:57,210 --> 00:09:58,640
функционировать, что основные вызовы.

213
00:09:58,640 --> 00:10:00,790
Нигде в коде, они
можно инициализировать.

214
00:10:00,790 --> 00:10:04,360
И для инициализации динамично
размещенная переменная.

215
00:10:04,360 --> 00:10:06,970
Какую функцию в C мы используем?

216
00:10:06,970 --> 00:10:07,600
>> СТУДЕНТ: Malloc.

217
00:10:07,600 --> 00:10:09,240
>> Джейсон Хиршхорн: Malloc.

218
00:10:09,240 --> 00:10:10,800
Вы называете таНос.

219
00:10:10,800 --> 00:10:12,260
Вы получаете пространство памяти.

220
00:10:12,260 --> 00:10:15,020
И это пространство памяти
является в куче.

221
00:10:15,020 --> 00:10:18,840
И это пространство памяти остается
там, пока не звонить бесплатно.

222
00:10:18,840 --> 00:10:22,670
>> Так динамически выделенные переменные в
куча будет существовать до тех пор, как вы

223
00:10:22,670 --> 00:10:25,250
хочу, чтобы они существуют, и они не будут
не пойду, пока вы явно

224
00:10:25,250 --> 00:10:26,760
сказать им, чтобы уйти.

225
00:10:26,760 --> 00:10:29,670
Вы можете создать их в одной функции.

226
00:10:29,670 --> 00:10:31,930
Стек, которые функционируют в
рамка уйдет.

227
00:10:31,930 --> 00:10:35,490
Но, что переменная будет по-прежнему существуют
в куче, пока не будет освобожден,

228
00:10:35,490 --> 00:10:39,650
потенциально той функцией, которая называется
бинарный поиск или любой другой.

229
00:10:39,650 --> 00:10:42,580
>> Так что те кучи переменные остаться там
так долго, как вы хотите

230
00:10:42,580 --> 00:10:43,490
им оставаться там.

231
00:10:43,490 --> 00:10:46,090
И они получают поставить здесь.

232
00:10:46,090 --> 00:10:47,450
А потом следующий получает положить там.

233
00:10:47,450 --> 00:10:50,210
Они держат наполняется в, и они
там оставайтесь, пока не звонить бесплатно.

234
00:10:50,210 --> 00:10:52,870
>> И по сути, куча и стек,
получать на вопрос Маркуса,

235
00:10:52,870 --> 00:10:54,500
расти навстречу друг другу.

236
00:10:54,500 --> 00:10:57,730
И если они бегут друг в друга, вы,
используется всю память в вашем

237
00:10:57,730 --> 00:11:01,330
компьютер, и ваша программа будет бросить
потому что вы не имеете больше памяти

238
00:11:01,330 --> 00:11:02,420
оставили в использовании.

239
00:11:02,420 --> 00:11:07,290
В промежутках между ними существует
потенциально другое.

240
00:11:07,290 --> 00:11:10,980
Но для рамки данного курса, вы
не нужно беспокоиться об этом.

241
00:11:10,980 --> 00:11:12,020
>> Так что был ответ
на ваш вопрос.

242
00:11:12,020 --> 00:11:13,520
Не беспокойтесь об этом.

243
00:11:13,520 --> 00:11:15,550
Но это было длинный ответ.

244
00:11:15,550 --> 00:11:17,800
Все, что вам нужно знать,
куча и стек будет -

245
00:11:17,800 --> 00:11:18,900
один начинается на дне.

246
00:11:18,900 --> 00:11:19,570
Стек делает.

247
00:11:19,570 --> 00:11:20,790
Куча там наверху.

248
00:11:20,790 --> 00:11:21,990
Они будут расти ближе друг к другу.

249
00:11:21,990 --> 00:11:23,110
>> И если они касаются, это проблема.

250
00:11:23,110 --> 00:11:24,500
Вы не хватило памяти.

251
00:11:24,500 --> 00:11:28,760
А кроме того, в дополнение к зная, где
они, что хранится в оба

252
00:11:28,760 --> 00:11:30,512
стека и кучи.

253
00:11:30,512 --> 00:11:31,410
Кертис.

254
00:11:31,410 --> 00:11:33,570
>> CURTIS: Когда они сталкиваются,
является то, что переполнение стека?

255
00:11:33,570 --> 00:11:35,670
>> Джейсон Хиршхорн: Когда они сталкиваются,
это не переполнение стека.

256
00:11:35,670 --> 00:11:38,340
Переполнение стека является другая область
что мы можем перейти, если вы хотите.

257
00:11:38,340 --> 00:11:40,020
Хорошо, мы еще вернемся к этому немного позже.

258
00:11:40,020 --> 00:11:42,730
>> СТУДЕНТ: Какое слово называется
когда они бьют друг друга,

259
00:11:42,730 --> 00:11:44,450
стек и куча?

260
00:11:44,450 --> 00:11:46,640
>> Джейсон Хиршхорн: В настоящее время,
не о чем беспокоиться.

261
00:11:46,640 --> 00:11:47,750
Просто знайте -

262
00:11:47,750 --> 00:11:50,530
Я отвечу на этот вопрос
после занятий.

263
00:11:50,530 --> 00:11:52,680
Если они сталкиваются друг с другом, у него кончились
памяти, потому что нет более

264
00:11:52,680 --> 00:11:53,330
пространство там.

265
00:11:53,330 --> 00:11:55,450
>> СТУДЕНТ: К сожалению, то, что вина сегмент?

266
00:11:55,450 --> 00:11:58,710
>> Джейсон Хиршхорн: Сегмент
Неисправность может быть вызвана для -

267
00:11:58,710 --> 00:12:02,240
это зависит, почему называется SEG вине автора.

268
00:12:02,240 --> 00:12:06,260
Иногда, ваш переполнение стека, оно будет
говорят сегмент обвинить как ошибки.

269
00:12:06,260 --> 00:12:08,180
>> СТУДЕНТ: А как насчет разыменования
нулевой переменной?

270
00:12:08,180 --> 00:12:10,040
Это ошибка сегмент?

271
00:12:10,040 --> 00:12:11,480
>> Джейсон Хиршхорн: Разыменование
пустой указатель -

272
00:12:11,480 --> 00:12:17,850
Итак, если у вас есть указатель, который вам
установить равен нулю, указатели, напомним,

273
00:12:17,850 --> 00:12:20,270
адреса памяти и не храните
как их значения.

274
00:12:20,270 --> 00:12:23,660
И пустой указатель, по существу,
хранение 0, 0-й

275
00:12:23,660 --> 00:12:26,670
обратиться в этой переменной.

276
00:12:26,670 --> 00:12:30,010
Так 0x, 0, 0, 0, 0, и так далее.

277
00:12:30,010 --> 00:12:35,030
Это 0-й адрес в памяти, что это не
в нашей картине, это там

278
00:12:35,030 --> 00:12:38,800
где-то, вот защищены
на компьютере.

279
00:12:38,800 --> 00:12:40,130
Нам не разрешают прикоснуться к ней.

280
00:12:40,130 --> 00:12:44,680
>> Так что, когда ваша программа это выполнение, если
что-то пытается пойти в памяти

281
00:12:44,680 --> 00:12:48,990
адрес 0, он знает, что
то есть пустое значение.

282
00:12:48,990 --> 00:12:50,820
Она знает, ничто не должно быть там.

283
00:12:50,820 --> 00:12:53,420
Так что, если вы пытаетесь использовать что-то есть
и лечить что-то вроде там или

284
00:12:53,420 --> 00:12:58,355
пытается идти в это место, вы
собирается получить вину сегм или ошибку.

285
00:12:58,355 --> 00:13:00,520
Я ответил на ваш вопрос?

286
00:13:00,520 --> 00:13:03,170
>> А теперь мы вернемся
к переполнению стека.

287
00:13:03,170 --> 00:13:09,560
Вещи в стеке, а вы, ребята,
видел, в - нарисуем близко

288
00:13:09,560 --> 00:13:11,966
план кадра стека.

289
00:13:11,966 --> 00:13:15,050
Все ли могут видеть, что?

290
00:13:15,050 --> 00:13:16,650
Так у нас есть фрейм стека.

291
00:13:16,650 --> 00:13:23,260
Мы экономим массив в качестве местного
переменная в этой функции.

292
00:13:23,260 --> 00:13:29,510
Так сказать, наш массив имеет пять мест.

293
00:13:29,510 --> 00:13:33,230
Все пять из них будут сохранены
в этом кадре стека.

294
00:13:33,230 --> 00:13:37,540
>> Если мы начнем писать за
Границы данного массива -

295
00:13:37,540 --> 00:13:43,990
поэтому, если мы начнем писать в,
скажем, что это 0.

296
00:13:43,990 --> 00:13:46,800
Таковы показатели пять
нашего массива.

297
00:13:46,800 --> 00:13:50,980
Если мы начнем писать в индекс 5, который
мы не имеем, когда у нас есть

298
00:13:50,980 --> 00:13:55,900
массив размером 5, мы начинаем писать в
индекс 6, 7, 8, 9, мы можем получить стек

299
00:13:55,900 --> 00:13:57,960
Ошибка переполнения.

300
00:13:57,960 --> 00:14:00,510
>> Вообще это не -

301
00:14:00,510 --> 00:14:04,910
вы, вероятно, попасть в беду
если вы идете на один.

302
00:14:04,910 --> 00:14:08,640
Но в целом, вы получите в
всего хлопот, если вы идете на себя много

303
00:14:08,640 --> 00:14:12,770
и вы идете до сих пор более, что вы пишете
над обратным адресом, что

304
00:14:12,770 --> 00:14:16,080
Функция, которая находится по адресу
Дно кадра стека.

305
00:14:16,080 --> 00:14:16,520
>> Потому что, не так ли?

306
00:14:16,520 --> 00:14:17,670
Вы - в - извините.

307
00:14:17,670 --> 00:14:18,550
Не "потому что прямо."

308
00:14:18,550 --> 00:14:20,470
>> В кадре стека, у вас есть
Ваши локальные переменные.

309
00:14:20,470 --> 00:14:27,090
В самом низу стека
кадр обратный адрес.

310
00:14:27,090 --> 00:14:28,790
Вот где функция
идет, когда все закончится.

311
00:14:28,790 --> 00:14:33,750
И если вы перезаписать, что возвращение
адрес, то, когда этот фрейм стека,

312
00:14:33,750 --> 00:14:36,680
когда вы собираетесь через стек
кадр и выполнения каждой строки, вы

313
00:14:36,680 --> 00:14:40,350
собирается идти на новый обратного адреса
что там написано, а не

314
00:14:40,350 --> 00:14:40,910
Фактический один.

315
00:14:40,910 --> 00:14:45,050
И вот как мы видели
некоторые нарушения правил безопасности

316
00:14:45,050 --> 00:14:46,780
может случиться с компьютерами.

317
00:14:46,780 --> 00:14:52,760
>> Так переполнения стека, короче говоря, это когда
Вы перезаписать участие в стеке

318
00:14:52,760 --> 00:14:55,440
вы должны использовать, местный
Переменная вы должны использовать, и

319
00:14:55,440 --> 00:14:58,070
в частности, когда вы начинаете перезаписи
важные вещи, как

320
00:14:58,070 --> 00:14:59,100
обратный адрес.

321
00:14:59,100 --> 00:15:00,090
И вот, когда вы получите сообщение об ошибке.

322
00:15:00,090 --> 00:15:03,980
Или, может быть, даже вы могли бы начать
даже писать в -

323
00:15:03,980 --> 00:15:05,370
говорят бинарный поиск был
прямо над основным.

324
00:15:05,370 --> 00:15:07,790
Если вы переписал много, вам
мог бы написать в основной.

325
00:15:07,790 --> 00:15:10,230
Но в целом, вы получаете сообщение об ошибке и
Затем, потому что компьютер знает

326
00:15:10,230 --> 00:15:12,270
Вы делаете то, что вы
не должны делать.

327
00:15:12,270 --> 00:15:12,560
Да.

328
00:15:12,560 --> 00:15:13,910
>> СТУДЕНТ: В чем разница
между переполнению стека

329
00:15:13,910 --> 00:15:16,940
и переполнение буфера?

330
00:15:16,940 --> 00:15:19,420
>> Джейсон Хиршхорн: Переполнение буфера
является более общим типом

331
00:15:19,420 --> 00:15:20,395
то, что я только что описал.

332
00:15:20,395 --> 00:15:22,610
>> СТУДЕНТ: Так переполнение стека является
пример переполнения буфера.

333
00:15:22,610 --> 00:15:23,420
>> Джейсон Хиршхорн: Совершенно верно.

334
00:15:23,420 --> 00:15:28,700
Это массив мы можем думать о качестве
буфера, пространство для вещей, чтобы входить

335
00:15:28,700 --> 00:15:30,600
Это переполнение буфера.

336
00:15:30,600 --> 00:15:33,210
Мы могли бы переполнение буфера.

337
00:15:33,210 --> 00:15:36,870
Если бы не было буфер, который там часто
является массивом куча, и мы

338
00:15:36,870 --> 00:15:40,600
переписал эти границы, то мы бы
есть переполнение буфера.

339
00:15:40,600 --> 00:15:44,870
>> И выходит за рамки этого курса,
они обнаружены немного по-другому.

340
00:15:44,870 --> 00:15:48,040
Компилятор имеет особое
способы обнаружения друг.

341
00:15:48,040 --> 00:15:50,660
Но переполнение буфера является более общим
тип, что я описал,

342
00:15:50,660 --> 00:15:54,090
который был переполнение буфера.

343
00:15:54,090 --> 00:15:56,240
Разве что ответить на ваш вопрос?

344
00:15:56,240 --> 00:15:57,910
Сладкий.

345
00:15:57,910 --> 00:16:01,850
>> Были ли другие вопросы, связанные
в стек или в куче?

346
00:16:01,850 --> 00:16:04,920

347
00:16:04,920 --> 00:16:05,510
Да.

348
00:16:05,510 --> 00:16:08,220
>> СТУДЕНТ: я знаю, у вас есть, чтобы освободить строк
потому что они в куче

349
00:16:08,220 --> 00:16:09,305
и вы не хотите, чтобы утечка памяти.

350
00:16:09,305 --> 00:16:12,240
Но у вас есть, чтобы освободить глобальные переменные
и все в таком духе?

351
00:16:12,240 --> 00:16:14,335
Или они автоматически освобождаются?

352
00:16:14,335 --> 00:16:15,700
>> Джейсон Хиршхорн: Хороший вопрос.

353
00:16:15,700 --> 00:16:22,340
Таким образом, в CS50.H, мы создаем эту вещь
ты звал строку.

354
00:16:22,340 --> 00:16:23,800
Строка действительно то, что?

355
00:16:23,800 --> 00:16:24,810
>> СТУДЕНТ: Чар звезда.

356
00:16:24,810 --> 00:16:29,180
>> Джейсон Хиршхорн: символ звезды, указатель
в символ, указатель на

357
00:16:29,180 --> 00:16:30,650
массив символов.

358
00:16:30,650 --> 00:16:32,210
Это то, что строка.

359
00:16:32,210 --> 00:16:36,050
Так что мы должны освободить его, так как
GetString, который мы использовали много -

360
00:16:36,050 --> 00:16:38,370
Строка имени равна GetString -

361
00:16:38,370 --> 00:16:43,560
что mallocs для нас некоторое количество памяти на
кучи, а затем возвращает указатель на

362
00:16:43,560 --> 00:16:47,230
Первый символ, что
строка, символ звезды.

363
00:16:47,230 --> 00:16:52,760
>> Так якобы, если вы не были
писать бесплатно на любом из ваших строк

364
00:16:52,760 --> 00:16:55,600
что вы назвали до сих пор, у вас есть
протекала некоторое количество памяти.

365
00:16:55,600 --> 00:16:57,430
Конечно, мы не говорили о
это, так что никто не добрался в

366
00:16:57,430 --> 00:16:58,520
Беда за это.

367
00:16:58,520 --> 00:16:59,980
Но идти вперед, да.

368
00:16:59,980 --> 00:17:03,990
При вызове GetString, вы
mallocing некоторое пространство в куче.

369
00:17:03,990 --> 00:17:07,640
И если вы не звоните бесплатно позже, что
Строка, у вас есть утечка памяти.

370
00:17:07,640 --> 00:17:09,440
Это ответ на ваш вопрос?

371
00:17:09,440 --> 00:17:10,606
>> Да

372
00:17:10,606 --> 00:17:15,020
>> СТУДЕНТ: Таким образом, чтобы сделать это, мы используем
бесплатно прямо перед возвращением?

373
00:17:15,020 --> 00:17:18,510
Мол, в рамках, я думаю, если
мы говорим, как, тап_п, в

374
00:17:18,510 --> 00:17:24,410
Объем кода, это в тех
фигурные скобки, прямо перед -

375
00:17:24,410 --> 00:17:26,140
Вы знаете, где вы бы
обычно ставят возвращение.

376
00:17:26,140 --> 00:17:27,950
Вы поставить бесплатно до этого?

377
00:17:27,950 --> 00:17:31,000
>> Джейсон Хиршхорн: Таким образом, вы можете поставить бесплатно
куда вы хотите поставить бесплатно.

378
00:17:31,000 --> 00:17:33,810
Потому что эти выделяются динамически
переменные, потому что они могут

379
00:17:33,810 --> 00:17:39,170
жить за рамки частности
Функция, если вы звоните таНос в

380
00:17:39,170 --> 00:17:44,140
отдельную функцию, например,
GetString, вы можете позвонить бесплатно в основной.

381
00:17:44,140 --> 00:17:46,050
Вам не нужно называть его
в конкретной функции

382
00:17:46,050 --> 00:17:47,570
где таНос называется.

383
00:17:47,570 --> 00:17:50,340
Но вы должны назвать его
до основных деклараций.

384
00:17:50,340 --> 00:17:51,120
>> И это действительно зависит.

385
00:17:51,120 --> 00:17:54,960
Это зависит от того, почему вы malloced, что
пространство в первую очередь.

386
00:17:54,960 --> 00:17:57,320
Некоторые люди будут называть
освободить довольно быстро.

387
00:17:57,320 --> 00:17:59,220
Некоторые люди никогда не будут звонить бесплатно до
конец своей программы.

388
00:17:59,220 --> 00:18:00,660
И они будут проходить через
и бесплатно все.

389
00:18:00,660 --> 00:18:03,597
Это зависит от того, почему вы назвали таНос.

390
00:18:03,597 --> 00:18:11,270
>> СТУДЕНТ: А что бы вы сказали,
если вы назвали использование GetString?

391
00:18:11,270 --> 00:18:13,320
Вы бы сказал, что бесплатно и что?

392
00:18:13,320 --> 00:18:20,040
>> Джейсон Хиршхорн: Так синтаксис бесплатно
просто бесплатно, открытые скобка, недалеко

393
00:18:20,040 --> 00:18:22,130
Парень, и имя указателя.

394
00:18:22,130 --> 00:18:26,410
Так что если вы пишете строку равных имя
GetString, вы ставите имя здесь.

395
00:18:26,410 --> 00:18:27,760
Это имя указателя.

396
00:18:27,760 --> 00:18:30,570
И он знает, чтобы освободить эту память.

397
00:18:30,570 --> 00:18:33,920
>> СТУДЕНТ: Так что, когда он освобождает эту память,
указатель-прежнему указывает на то место,

398
00:18:33,920 --> 00:18:34,970
в памяти?

399
00:18:34,970 --> 00:18:39,020
Или это указатель также освобождается от
адрес, который он указывает.

400
00:18:39,020 --> 00:18:40,290
>> Джейсон Хиршхорн: Мы должны попробовать это.

401
00:18:40,290 --> 00:18:41,430
Мы должны кодировать что.

402
00:18:41,430 --> 00:18:43,880
Давайте вернемся, когда мы доберемся до
кодирования, и давайте код, который.

403
00:18:43,880 --> 00:18:46,000
И если вы хотите, чтобы выяснить ответ
к тому, что вы также можете код, который

404
00:18:46,000 --> 00:18:46,690
в то же время.

405
00:18:46,690 --> 00:18:49,100
Но это большой вопрос.

406
00:18:49,100 --> 00:18:53,480
>> СТУДЕНТ: Можно ли
бесплатно что-то слишком рано?

407
00:18:53,480 --> 00:18:58,530
Таким образом, вы все еще это нужно для вашей программы,
и вы освободили, что объем памяти?

408
00:18:58,530 --> 00:18:59,200
>> Джейсон Хиршхорн: Да.

409
00:18:59,200 --> 00:19:03,020
Это возможно, если вы бесплатно что-то
и тогда вы использовать его снова, вы будете

410
00:19:03,020 --> 00:19:06,890
столкнетесь с ошибкой.

411
00:19:06,890 --> 00:19:10,810
Но это на вас, потому что вы освободили
что-то, а затем назвал его позже.

412
00:19:10,810 --> 00:19:13,940
Так, чтобы было ошибкой программиста.

413
00:19:13,940 --> 00:19:14,780
Но да.

414
00:19:14,780 --> 00:19:17,760
Вы могли бы написать, что.

415
00:19:17,760 --> 00:19:19,240
>> Есть еще вопросы по -

416
00:19:19,240 --> 00:19:19,760
Да.

417
00:19:19,760 --> 00:19:22,820
>> СТУДЕНТ: Так что если вы, как предполагается, только
освободить его в целом до

418
00:19:22,820 --> 00:19:25,490
Программа заканчивается, значит ли это, если
Программа заканчивается, и вы не освободить его,

419
00:19:25,490 --> 00:19:27,580
что память еще выделяется?

420
00:19:27,580 --> 00:19:31,330
>> Джейсон Хиршхорн: Если ваша программа заканчивается
и вы забудьте освободить что-то, то

421
00:19:31,330 --> 00:19:34,390
что память была выделена в течение
время жизни вашей программы.

422
00:19:34,390 --> 00:19:37,670
Когда ваша программа полностью закрывается,
что память не собирается

423
00:19:37,670 --> 00:19:39,490
чтобы остаться там навсегда.

424
00:19:39,490 --> 00:19:42,080
Компьютер достаточно умен, чтобы знать,
, что, когда программа закрывается, это

425
00:19:42,080 --> 00:19:46,440
должны избавиться от всех памяти, что
был связан с этой программой.

426
00:19:46,440 --> 00:19:51,240
>> Тем не менее, есть инструменты можно запускать
по программе для обнаружения, если, когда

427
00:19:51,240 --> 00:19:54,720
Программа завершена, вы забыли
чтобы освободить память.

428
00:19:54,720 --> 00:19:57,960
И для вашего следующего проблемы установить, где
вы будете использовать таНос и использование

429
00:19:57,960 --> 00:20:02,610
указатели, вы будете запускать этот
запрограммировать на вашу программу, чтобы увидеть, если,

430
00:20:02,610 --> 00:20:06,530
когда основные возвращается, вы были некоторые
вещи, которые остались unfreed.

431
00:20:06,530 --> 00:20:09,130
>> Так что они не собираются оставаться malloced
навсегда в вашем компьютере.

432
00:20:09,130 --> 00:20:11,720
Это было бы расточительно, потому что
очень быстро, компьютеры

433
00:20:11,720 --> 00:20:12,960
бы не хватить памяти.

434
00:20:12,960 --> 00:20:16,450
Но если они не работать до конца вашего
запрограммировать и они не освобождены и ваш

435
00:20:16,450 --> 00:20:20,260
Программа выходит, что по-прежнему является проблемой
что этот инструмент поможет вам в решении.

436
00:20:20,260 --> 00:20:21,520
>> СТУДЕНТ: Это Valgrind?

437
00:20:21,520 --> 00:20:22,910
>> Джейсон Хиршхорн: Это
называется Valgrind.

438
00:20:22,910 --> 00:20:23,520
И вы будете -

439
00:20:23,520 --> 00:20:25,780
>> СТУДЕНТ: Но мы не должны знать,
что для викторины, хотя?

440
00:20:25,780 --> 00:20:27,600
Я имею в виду, это было говорили о
немного в лекции.

441
00:20:27,600 --> 00:20:33,600
>> Джейсон Хиршхорн: Так Valgrind
это имя этого инструмента.

442
00:20:33,600 --> 00:20:37,180
Зная, что она делает это
достаточно для викторины.

443
00:20:37,180 --> 00:20:40,200
Но вы не использовали его еще на вашем
Проблема установить, потому что у нас не было

444
00:20:40,200 --> 00:20:43,520
Проблема набор, который явно имел дело
с таНос или вы используете таНос.

445
00:20:43,520 --> 00:20:45,330
Таким образом, вы еще не использовали Valgrind.

446
00:20:45,330 --> 00:20:47,760
Но вы будете использовать его рано
, чем позже.

447
00:20:47,760 --> 00:20:48,710
>> СТУДЕНТ: Можете ли вы повторить
что Valgrind является?

448
00:20:48,710 --> 00:20:49,190
>> Джейсон Хиршхорн: Извините?

449
00:20:49,190 --> 00:20:51,240
>> СТУДЕНТ: Можете ли вы повторить, что
Цель Valgring является?

450
00:20:51,240 --> 00:20:53,100
>> Джейсон Хиршхорн: Valgrind
это имя -

451
00:20:53,100 --> 00:20:59,890
как GDB помогает вам отладки программы,
Valgrind помогает вам понять, если

452
00:20:59,890 --> 00:21:03,210
вещи не были освобождены
когда закрывается ваша программа.

453
00:21:03,210 --> 00:21:05,110
Таким образом, вы будете запустить его на вашей программе.

454
00:21:05,110 --> 00:21:09,230
И ваша программа выходит, и он будет говорить,
ваша программа называется таНос это многие

455
00:21:09,230 --> 00:21:13,670
раз для этого много байт, и вы
только называется свободным это много раз.

456
00:21:13,670 --> 00:21:16,520
И так вы оставили эти много байт
без освобождения.

457
00:21:16,520 --> 00:21:18,050
Или это будет сказать, что вы освободили все.

458
00:21:18,050 --> 00:21:19,070
Хорошая работа.

459
00:21:19,070 --> 00:21:19,480
>> СТУДЕНТ: ОК.

460
00:21:19,480 --> 00:21:21,060
И это называется Valgring?

461
00:21:21,060 --> 00:21:24,940
>> ДЖЕЙСОН Hirschhorn: V-A-L-G-R-I-N-D.

462
00:21:24,940 --> 00:21:25,970
>> СТУДЕНТ: Вопрос об указателях.

463
00:21:25,970 --> 00:21:30,080
Так сказать, что вы н звезды
х равно что-то.

464
00:21:30,080 --> 00:21:33,330
Это равняется, что вы кладете
там, в том, что то, что будучи положить внутрь

465
00:21:33,330 --> 00:21:36,120
что х указывает на,
или указатель х?

466
00:21:36,120 --> 00:21:37,690
>> Джейсон Хиршхорн: Можете ли вы
повторить вопрос?

467
00:21:37,690 --> 00:21:39,340
Можем ли мы сделать это в то время вы это говорите?

468
00:21:39,340 --> 00:21:42,710
>> СТУДЕНТ: В викторине, на самом деле,
тот, который вы послали нас, как это было, символ

469
00:21:42,710 --> 00:21:46,520
звезды правда равна CS50 скалы, не так ли?

470
00:21:46,520 --> 00:21:52,190
Так это значит, что, что CS50 скалы
это то, что правда указывает на?

471
00:21:52,190 --> 00:21:55,810
>> Джейсон Хиршхорн: Так вы говорите
о сЬаг звезды в строку, как

472
00:21:55,810 --> 00:21:56,460
это работает?

473
00:21:56,460 --> 00:21:56,890
Да.

474
00:21:56,890 --> 00:21:57,700
ОК.

475
00:21:57,700 --> 00:21:59,140
Давайте нарисуем это здесь.

476
00:21:59,140 --> 00:22:07,100
>> [СТОРОНА РАЗГОВОР]

477
00:22:07,100 --> 00:22:11,130
>> Джейсон Хиршхорн: Так эта переменная
будет из символьного типа звезды.

478
00:22:11,130 --> 00:22:14,580
Насколько велика переменная
из символьного типа звезды?

479
00:22:14,580 --> 00:22:15,510
Сколько байт?

480
00:22:15,510 --> 00:22:16,450
>> СТУДЕНТЫ: Четыре.

481
00:22:16,450 --> 00:22:18,210
>> Джейсон Хиршхорн: Это четыре байта.

482
00:22:18,210 --> 00:22:21,420
Сколько права является переменной
из типа десятичного звезды?

483
00:22:21,420 --> 00:22:22,210
>> СТУДЕНТЫ: Четыре.

484
00:22:22,210 --> 00:22:24,910
>> Джейсон Хиршхорн: Четыре байта.

485
00:22:24,910 --> 00:22:28,280
Если это указатель, то это всегда
четыре байта, так как указатели, их

486
00:22:28,280 --> 00:22:30,070
значение является адрес памяти.

487
00:22:30,070 --> 00:22:35,160
И адреса памяти на CS50
Прибор четыре байта.

488
00:22:35,160 --> 00:22:42,900
Поэтому, когда мы называем GetString или когда мы
скажем, имя_строки равна, а затем в

489
00:22:42,900 --> 00:22:46,140
двойные кавычки поставить строку,
мы вкладываем -

490
00:22:46,140 --> 00:22:46,920
ну, это немного по-другому.

491
00:22:46,920 --> 00:22:48,630
Мы сделаем GetString в качестве примера.

492
00:22:48,630 --> 00:22:52,150
Или символ звезды что-то
равна строку.

493
00:22:52,150 --> 00:22:54,360
К сожалению, дать мне пример
которые вы прочитали?

494
00:22:54,360 --> 00:22:57,590
>> СТУДЕНТ: символ звезды правда равна
"CS50 камни" в двойные кавычки.

495
00:22:57,590 --> 00:23:02,260
>> Джейсон Хиршхорн: Так что это звезда, это
мы будем называть этот переменную х для нашего

496
00:23:02,260 --> 00:23:04,060
общие цели.

497
00:23:04,060 --> 00:23:05,970
Мы создали переменную х.

498
00:23:05,970 --> 00:23:07,610
Это тип символ звезды.

499
00:23:07,610 --> 00:23:10,950
Это указатель на серии
символов.

500
00:23:10,950 --> 00:23:12,200
Так здесь -

501
00:23:12,200 --> 00:23:23,710

502
00:23:23,710 --> 00:23:25,890
>> Так что это, как это будет
работать в памяти.

503
00:23:25,890 --> 00:23:27,410
Это будет хранить адрес памяти.

504
00:23:27,410 --> 00:23:31,770
Было бы хранить адрес памяти
первый символ в массиве.

505
00:23:31,770 --> 00:23:33,830
А потом, когда вы следовали
указатель, вы бы

506
00:23:33,830 --> 00:23:35,200
получить первый символ.

507
00:23:35,200 --> 00:23:38,780
>> И если вы читаете эту вещь, как
строка, ваш компьютер умный

508
00:23:38,780 --> 00:23:42,930
достаточно знать, читать все это дело
пока он не попадает в зазор 0.

509
00:23:42,930 --> 00:23:45,530
Но если вы читаете ему характер в
время, так что вы итерации

510
00:23:45,530 --> 00:23:49,910
эта строка, то вы только что прочитали
характер, в то время, пока вы не дойдете до

511
00:23:49,910 --> 00:23:50,850
обратный слеш 0.

512
00:23:50,850 --> 00:23:52,335
Это не может ответить на ваши
Вопрос, однако.

513
00:23:52,335 --> 00:23:55,610
>> СТУДЕНТ: Да, но у вас нет
malloced, что пространство

514
00:23:55,610 --> 00:23:58,400
но для этого указателя.

515
00:23:58,400 --> 00:24:02,510
>> Джейсон Хиршхорн: Так что я не совсем уверен,
именно то, что вы смотрите на,

516
00:24:02,510 --> 00:24:03,640
потому что я не делал, что викторину.

517
00:24:03,640 --> 00:24:06,370
Это должен был быть полезными
ресурсов из другого TF.

518
00:24:06,370 --> 00:24:11,380
Если вы создаете строку на
стек или в качестве локальной переменной, оно будет

519
00:24:11,380 --> 00:24:16,920
просто массив обвинений, а не
как правило, символ звезды указывая на

520
00:24:16,920 --> 00:24:18,600
другую строку.

521
00:24:18,600 --> 00:24:20,550
Но я не знаю.

522
00:24:20,550 --> 00:24:25,065
Это может быть указателем на другой
строка в стеке, а также.

523
00:24:25,065 --> 00:24:27,240
Да.

524
00:24:27,240 --> 00:24:31,116
>> СТУДЕНТ: я знаю, что вам нужно
выделить память, если указатель

525
00:24:31,116 --> 00:24:33,360
получать объявлен внутри
другой функции.

526
00:24:33,360 --> 00:24:36,740
Вы должны сделать то же самое, если это
был объявлен внутри основной,

527
00:24:36,740 --> 00:24:39,570
вы используете его внутри основной?

528
00:24:39,570 --> 00:24:43,590
>> Джейсон Хиршхорн: Так что, да.

529
00:24:43,590 --> 00:24:46,670
Вы можете объявить указатель на любой
адрес памяти в памяти.

530
00:24:46,670 --> 00:24:51,440
Это может быть адрес памяти местный
переменная, хотя зачастую,

531
00:24:51,440 --> 00:24:55,760
люди не заявляют адреса памяти
в локальных переменных, потому что они идут

532
00:24:55,760 --> 00:24:59,890
далеко, как только что функция возвращает, которые
Поэтому мы, как правило Malloc вещи.

533
00:24:59,890 --> 00:25:04,630
Но да, вы могли бы объявить указатель
в другой локальной переменной.

534
00:25:04,630 --> 00:25:06,360
Это просто правило, не делается.

535
00:25:06,360 --> 00:25:09,480
Но я могу взглянуть на что
определенная вещь после занятий.

536
00:25:09,480 --> 00:25:10,650
Да.

537
00:25:10,650 --> 00:25:12,350
>> СТУДЕНТ: Я думаю, что это своего рода
из того, что просят.

538
00:25:12,350 --> 00:25:16,930
Это кажется странным, чтобы быть инициализации
указатель не так

539
00:25:16,930 --> 00:25:20,760
адрес, но как то, что
кажется стоимости.

540
00:25:20,760 --> 00:25:25,970
Похоже, CS50 является то, что внутри
вещь будучи указал на и

541
00:25:25,970 --> 00:25:28,820
не фактический адрес, не так ли?

542
00:25:28,820 --> 00:25:30,520
>> Джейсон Хиршхорн: Так вот
не так, однако.

543
00:25:30,520 --> 00:25:32,470
Это не то, что происходит.

544
00:25:32,470 --> 00:25:35,910
При объявлении сЬаг звезду,
это адрес памяти.

545
00:25:35,910 --> 00:25:38,860
Указатели все адреса памяти
указывая на что-то другое.

546
00:25:38,860 --> 00:25:41,480
Это что-то еще может быть на
стек, но почти всегда находится на

547
00:25:41,480 --> 00:25:43,440
кучи, как мы увидим это используется.

548
00:25:43,440 --> 00:25:46,860

549
00:25:46,860 --> 00:25:53,500
Но имя_строки равна двойной кавычки
"GetString," мы видим, что и мы

550
00:25:53,500 --> 00:25:55,010
можете посмотреть, что и код, который.

551
00:25:55,010 --> 00:26:01,190
GetString строка не сохраняется в
эта переменная, или как строка

552
00:26:01,190 --> 00:26:04,580
имя не сохраняется в том, что
переменная, потому что это не так, как

553
00:26:04,580 --> 00:26:06,070
указатели работать.

554
00:26:06,070 --> 00:26:06,770
Имеет ли это смысл?

555
00:26:06,770 --> 00:26:07,170
>> СТУДЕНТ: Да.

556
00:26:07,170 --> 00:26:08,570
>> Джейсон Хиршхорн: ОК.

557
00:26:08,570 --> 00:26:11,690
Будем надеяться, что это не было
запутанной никому.

558
00:26:11,690 --> 00:26:15,732
Но если это так, мы можем посмотреть на нее еще раз
в немного, потому что мы на самом деле происходит

559
00:26:15,732 --> 00:26:19,240
кодировать то, что, мы надеемся,
работы со строками и поможет вам чувствовать себя

560
00:26:19,240 --> 00:26:22,170
более комфортно с ними.

561
00:26:22,170 --> 00:26:24,869
>> Любые другие вопросы, связанные с их
темы или другие темы, которые

562
00:26:24,869 --> 00:26:26,119
Я положу обратно?

563
00:26:26,119 --> 00:26:32,280

564
00:26:32,280 --> 00:26:34,840
И -

565
00:26:34,840 --> 00:26:36,310
Прямо сейчас.

566
00:26:36,310 --> 00:26:37,630
Да, Олден.

567
00:26:37,630 --> 00:26:39,860
>> ALDEN: Так что это не имеет никакого отношения,
но мы можем просто пойти на

568
00:26:39,860 --> 00:26:42,760
очень быстро, что мы должны знать,
о разнице между 32 и

569
00:26:42,760 --> 00:26:46,345
64-разрядная машина?

570
00:26:46,345 --> 00:26:47,740
>> Джейсон Хиршхорн: Да.

571
00:26:47,740 --> 00:26:52,111
Так 32 бита, сколько байт?

572
00:26:52,111 --> 00:26:53,060
>> ALDEN: Это четыре байта.

573
00:26:53,060 --> 00:26:54,360
>> Джейсон Хиршхорн: Это четыре байта.

574
00:26:54,360 --> 00:26:58,420
И 64 бита, сколько байт?

575
00:26:58,420 --> 00:26:59,112
>> СТУДЕНТ: Восемь.

576
00:26:59,112 --> 00:27:00,610
>> Джейсон Хиршхорн: Восемь байт.

577
00:27:00,610 --> 00:27:03,980
Итак, еще раз, восемь бит на один байт.

578
00:27:03,980 --> 00:27:08,340
Ваш CS50 прибор
32-разрядная машина.

579
00:27:08,340 --> 00:27:13,650
Так адреса памяти
четыре байта.

580
00:27:13,650 --> 00:27:17,460
Есть 2 к 32
адреса памяти.

581
00:27:17,460 --> 00:27:21,310
От 0 до 2 в 32 минус 1.

582
00:27:21,310 --> 00:27:27,630
И я не уверен, но это
вероятно, сфера, что вам нужно

583
00:27:27,630 --> 00:27:35,230
знаю для 32-битной машине, что память
адреса, опять же, долго четыре байта,

584
00:27:35,230 --> 00:27:39,620
и это максимальная сумма
адресов памяти.

585
00:27:39,620 --> 00:27:41,680
>> Кроме того, типы данных -

586
00:27:41,680 --> 00:27:45,020
это может быть что-то, как
хорошо, что это стоит отметить.

587
00:27:45,020 --> 00:27:49,610
Размер типа данных зависит от
машина вы работаете с.

588
00:27:49,610 --> 00:27:56,760
Так символ, один символ, то, как
количество байт на нашем CS50 прибора?

589
00:27:56,760 --> 00:27:57,980
Один байт.

590
00:27:57,980 --> 00:28:02,310
И это на самом деле один байт, как
хорошо на 64-битной машине.

591
00:28:02,310 --> 00:28:05,920
>> И большинство типы данных и тот же номер
байтов на обеих машинах.

592
00:28:05,920 --> 00:28:11,620
Но некоторые типы данных будут отличаться
на обеих машинах.

593
00:28:11,620 --> 00:28:14,590
Так что было бы потенциально
Единственное, что вам нужно знать.

594
00:28:14,590 --> 00:28:16,710
>> Но даже то, что, как мне кажется,
является за пределами -

595
00:28:16,710 --> 00:28:20,990
Я почти уверен,, если оглянуться назад
на старые викторины, он говорит, предположим, для

596
00:28:20,990 --> 00:28:24,090
проблемы вы с помощью кодирования
32-разрядная машина.

597
00:28:24,090 --> 00:28:26,620

598
00:28:26,620 --> 00:28:30,620
Но есть, чтобы идти вместе с, что в
если вам интересно, есть

599
00:28:30,620 --> 00:28:35,920
типы данных, которые аналогичны
Размер на всех машинах.

600
00:28:35,920 --> 00:28:42,670
>> Если вы видели что-то вроде
uint32_t, вы можете или

601
00:28:42,670 --> 00:28:43,260
не видели, что.

602
00:28:43,260 --> 00:28:44,290
Это тип данных.

603
00:28:44,290 --> 00:28:47,570
Это говорит, 32 бита независимо от того,
на какой машине это на.

604
00:28:47,570 --> 00:28:50,350
Поэтому, когда люди пишут портативный
Код, они, вероятно, не будет использовать целыми.

605
00:28:50,350 --> 00:28:53,260
Они вместо этого использовать эти другие данные
типы, что они знают, будет то же самое

606
00:28:53,260 --> 00:28:54,780
Размер на каждой машине.

607
00:28:54,780 --> 00:28:58,080

608
00:28:58,080 --> 00:28:58,250
Мадху.

609
00:28:58,250 --> 00:29:00,150
>> Мадху: у меня был вопрос о
процесс компиляции.

610
00:29:00,150 --> 00:29:04,110
Так что если вы пишете программу, которая использует
библиотека как CS50 или что-то

611
00:29:04,110 --> 00:29:06,840
так, я знаю, что эта библиотека
должен в какой-то момент, быть

612
00:29:06,840 --> 00:29:08,590
собрано и связано дюйма

613
00:29:08,590 --> 00:29:13,380
Но сколько из этого происходит во время
составление вашей программы?

614
00:29:13,380 --> 00:29:15,880
Какая часть этого процесса библиотеки
происходит, когда вы

615
00:29:15,880 --> 00:29:18,560
составления собственной программы?

616
00:29:18,560 --> 00:29:24,020
>> Джейсон Хиршхорн: Итак, давайте перейдем
Обычно шаги этого процесса.

617
00:29:24,020 --> 00:29:26,280
Вы пишете. C файл.

618
00:29:26,280 --> 00:29:33,530
В вашем. C File, вы # включить ваш
библиотеки заголовка, например, cs50.h.

619
00:29:33,530 --> 00:29:39,480
Что делает, что резкое включают
линия сделать для вашей программы?

620
00:29:39,480 --> 00:29:40,525
Akchar.

621
00:29:40,525 --> 00:29:43,350
>> AKCHAR: Он добавляет прототипы
функции из заголовка

622
00:29:43,350 --> 00:29:45,120
файлы в библиотеках.

623
00:29:45,120 --> 00:29:45,600
>> Джейсон Хиршхорн: Совершенно верно.

624
00:29:45,600 --> 00:29:49,870
Это добавляет эти прототипы функций
в код.

625
00:29:49,870 --> 00:29:55,230
Поэтому, когда ваш код составляется в
на ранних стадиях, компилятор знает

626
00:29:55,230 --> 00:29:59,250
что эти функции действительно существуют, и
что в другом месте они были определены.

627
00:29:59,250 --> 00:30:02,460
В. Ч файлы не включают
определения для этих функций или, как

628
00:30:02,460 --> 00:30:03,950
они действительно работают.

629
00:30:03,950 --> 00:30:07,960
Cs50.h просто включает что-то, что говорит
GetString реальная вещь, которая

630
00:30:07,960 --> 00:30:09,270
может случиться.

631
00:30:09,270 --> 00:30:14,240
И standardio.h говорит Е является
реальная вещь, которая может случиться.

632
00:30:14,240 --> 00:30:23,190
>> Так что ваша с языком с этим. Заголовка
файл запускается превратился в некоторые

633
00:30:23,190 --> 00:30:27,750
машиночитаемой код, который в конечном итоге
получает превратился в двоичный

634
00:30:27,750 --> 00:30:30,030
Код, 0 и 1 в.

635
00:30:30,030 --> 00:30:33,590
И это код, который в конечном счете
запускается на выполнение.

636
00:30:33,590 --> 00:30:38,550
-Л CS50 линии - например,
когда вы пишете Clang -

637
00:30:38,550 --> 00:30:41,830
а затем вы включаете-л CS50,
вводе, что дюйма

638
00:30:41,830 --> 00:30:42,180
И вы видите, что.

639
00:30:42,180 --> 00:30:43,890
Когда вы пишете сделать, вы будете
видеть, что линия здесь.

640
00:30:43,890 --> 00:30:47,740
И мы увидим, что через секунду, когда
мы кодировать или поздно, когда мы кода.

641
00:30:47,740 --> 00:30:50,390
>> Но что-л CS50 линия делает что-то
немного отличается от

642
00:30:50,390 --> 00:30:52,440
# включить cs50.h.

643
00:30:52,440 --> 00:30:56,300
Что это-л CS50 линии делать?

644
00:30:56,300 --> 00:30:56,820
Ави?

645
00:30:56,820 --> 00:31:00,310
>> AVI: Я хочу сказать, что она связывает
библиотека с функцией

646
00:31:00,310 --> 00:31:02,710
называть, как и. Ø файлов.

647
00:31:02,710 --> 00:31:08,200
>> Джейсон Хиршхорн: Итак, очень
близко, если не спот-он.

648
00:31:08,200 --> 00:31:16,220
-Л CS50 принимает двоичный файл и
объединяет его с вашим двоичный файл.

649
00:31:16,220 --> 00:31:21,410
Так cs50.h, нет никакого смысла в превращении
cs50.h от языка C в двоичную каждый

650
00:31:21,410 --> 00:31:23,130
раз, когда он используется.

651
00:31:23,130 --> 00:31:26,650
Это было бы глупо, потому что
будет тратить много времени.

652
00:31:26,650 --> 00:31:30,420
Так что уже составлен
и превратился в исполняемый файл.

653
00:31:30,420 --> 00:31:35,430
И теперь он собирается быть объединены
с файлом в конце.

654
00:31:35,430 --> 00:31:38,370
Так что те 1 и 0 собираетесь
слиться с вашим них

655
00:31:38,370 --> 00:31:39,150
и 0 в конце.

656
00:31:39,150 --> 00:31:43,670
Так что теперь вы будете на самом деле есть реальная
1 и 0, которые определяют, каким GetString,

657
00:31:43,670 --> 00:31:47,890
например, работает, или как Е,
например, работает.

658
00:31:47,890 --> 00:31:52,750
>> И для получения дополнительной информации, есть
короткие компиляторы, Нейт дает, что

659
00:31:52,750 --> 00:31:55,410
вы должны проверить, что идет
через эти шаги.

660
00:31:55,410 --> 00:31:56,050
Но -

661
00:31:56,050 --> 00:31:56,560
Да.

662
00:31:56,560 --> 00:32:01,700
>> СТУДЕНТ: Являются ли они всегда в уплотнительные файлы.
когда они в виде библиотеки,

663
00:32:01,700 --> 00:32:06,764
готов быть объединены, связаны - как
они в двоичном коде?

664
00:32:06,764 --> 00:32:07,600
>> Джейсон Хиршхорн: ОК.

665
00:32:07,600 --> 00:32:08,420
Что -

666
00:32:08,420 --> 00:32:11,780
>> СТУДЕНТ: Это всегда имеет место для
библиотеки, когда вы связать их?

667
00:32:11,780 --> 00:32:12,500
>> Джейсон Хиршхорн: Да.

668
00:32:12,500 --> 00:32:17,300
Так что есть. Ы файлы, которые будут
машинный код, который также будет

669
00:32:17,300 --> 00:32:17,975
загадочными для вас.

670
00:32:17,975 --> 00:32:19,410
Вам не нужно беспокоиться о них.

671
00:32:19,410 --> 00:32:24,930
Но в целом, да, они будут
быть в. о файлы готовы к работе.

672
00:32:24,930 --> 00:32:27,170
>> СТУДЕНТ: Итак, когда вы грузить к
библиотека, вы только грузим

673
00:32:27,170 --> 00:32:28,880
. ч и. о?

674
00:32:28,880 --> 00:32:32,210
Вы не грузим. Гр или. С.

675
00:32:32,210 --> 00:32:33,070
>> Джейсон Хиршхорн: Так -

676
00:32:33,070 --> 00:32:36,260
и это в этой короткой, а также, если
эта информация, кажется, приходит

677
00:32:36,260 --> 00:32:36,700
немного быстро.

678
00:32:36,700 --> 00:32:39,870
Но мало компиляторов
говорит об этом, а также.

679
00:32:39,870 --> 00:32:43,290
Когда вы грузите библиотеку, если вы поставляете
. ч, файл заголовка, тех,

680
00:32:43,290 --> 00:32:46,290
прототипы функций, а также 1-х и
0-х, это все, что нужно дать.

681
00:32:46,290 --> 00:32:50,640
Вам не нужно, чтобы дать как
Функция работает,. с файл.

682
00:32:50,640 --> 00:32:56,360
Так как точка абстракции, или
указать интерфейсы, точка, в этом SPL,

683
00:32:56,360 --> 00:32:59,650
переносимая библиотека Стэнфорд, это
для вас, чтобы не беспокоиться о том, как новые

684
00:32:59,650 --> 00:33:04,220
GRect работает, или как двигаться работ,
или как добавить работ.

685
00:33:04,220 --> 00:33:06,520
Все, что вам нужно знать, что добавить
является функцией, что вы можете

686
00:33:06,520 --> 00:33:08,880
использовать, и он делает это.

687
00:33:08,880 --> 00:33:12,760
Таким образом, вы действительно не нужно знать, как
это написано в C. нужно просто

688
00:33:12,760 --> 00:33:15,460
знаю, вот функции, то, что они
сделать, и вот'S 1 и 0

689
00:33:15,460 --> 00:33:18,870
когда вы действительно хотите их использовать.

690
00:33:18,870 --> 00:33:19,530
>> Круто.

691
00:33:19,530 --> 00:33:26,980
Есть еще вопросы по компиляторов
или другие темы на доске?

692
00:33:26,980 --> 00:33:30,300
>> СТУДЕНТ: У меня есть вопрос о
реализации рекурсивных функций.

693
00:33:30,300 --> 00:33:31,170
Вопрос о рекурсии.

694
00:33:31,170 --> 00:33:33,030
У меня было ощущение, что бы придумать.

695
00:33:33,030 --> 00:33:38,310
Так что давайте быстро пройти
рекурсия с определенным

696
00:33:38,310 --> 00:33:40,690
Например, факториал.

697
00:33:40,690 --> 00:33:44,920
Потому что это пример, который
часто появляется или используется

698
00:33:44,920 --> 00:33:46,170
чтобы проиллюстрировать рекурсию.

699
00:33:46,170 --> 00:33:52,390

700
00:33:52,390 --> 00:33:56,410
>> Таким образом, "4!" читается как 4 факториала.

701
00:33:56,410 --> 00:33:59,120
И что 4 факторный значит?

702
00:33:59,120 --> 00:34:00,696
Что это делать?

703
00:34:00,696 --> 00:34:02,235
Как рассчитать 4 факториала?

704
00:34:02,235 --> 00:34:05,250

705
00:34:05,250 --> 00:34:07,960
4 раза 3 раз 2 раз 1.

706
00:34:07,960 --> 00:34:11,889
>> Так еще один способ написать 4 факториала
является, чтобы написать это.

707
00:34:11,889 --> 00:34:16,780

708
00:34:16,780 --> 00:34:19,022
4 раза 3 факторный.

709
00:34:19,022 --> 00:34:22,080
Потому что 3 факториал
3 раза 2 раз 1.

710
00:34:22,080 --> 00:34:27,580
Так в 4 раза 3 факториал 4
раз 3 раз 2 раз 1.

711
00:34:27,580 --> 00:34:32,679
Вот почему факторный является отличным
кандидат на рекурсии, потому что это

712
00:34:32,679 --> 00:34:36,630
Понятно, что есть нечто, что
происходит снова и снова и снова на

713
00:34:36,630 --> 00:34:39,820
меньшее количество вещей до
вы дойдете до конца.

714
00:34:39,820 --> 00:34:42,570
Когда вы достигнете 1, 1 факториал 1.

715
00:34:42,570 --> 00:34:43,719
Вы не можете пойти гораздо дальше.

716
00:34:43,719 --> 00:34:47,219
0 факторный также определяется как 1.

717
00:34:47,219 --> 00:34:50,679
Поэтому, когда вы получаете 1 или 0, вы
в конце концов, и вы можете

718
00:34:50,679 --> 00:34:53,219
начать идти назад.

719
00:34:53,219 --> 00:34:59,540
Так что, если мы хотели написать рекурсивный
Функция для вычисления факториала,

720
00:34:59,540 --> 00:35:02,170
мы собираемся написать некоторые
псевдокод, что сейчас.

721
00:35:02,170 --> 00:35:03,300
Прежде, чем мы написать, что псевдокод -

722
00:35:03,300 --> 00:35:05,660
Я дам вам, ребята пару минут
написать псевдокод или просто думаю,

723
00:35:05,660 --> 00:35:09,600
об этом - Есть две вещи, каждые
рекурсивная функция нуждается.

724
00:35:09,600 --> 00:35:12,530
Каковы эти две вещи?

725
00:35:12,530 --> 00:35:13,220
>> Джек: Он должен называть себя.

726
00:35:13,220 --> 00:35:13,680
>> Джейсон Хиршхорн: Ной?

727
00:35:13,680 --> 00:35:14,460
О, Джек.

728
00:35:14,460 --> 00:35:15,100
Идем дальше.

729
00:35:15,100 --> 00:35:16,640
>> Джек: Он должен называть себя.

730
00:35:16,640 --> 00:35:19,220
>> Джейсон Хиршхорн: Так рекурсивный
функция должна рекурсивный вызов,

731
00:35:19,220 --> 00:35:20,220
позвонить в себе.

732
00:35:20,220 --> 00:35:20,770
Это одна.

733
00:35:20,770 --> 00:35:21,510
И то, что другое дело?

734
00:35:21,510 --> 00:35:22,250
>> Джек: базовый вариант.

735
00:35:22,250 --> 00:35:23,780
>> Джейсон Хиршхорн: базовый вариант.

736
00:35:23,780 --> 00:35:26,940
Базовая случай, вот, когда мы останавливаемся.

737
00:35:26,940 --> 00:35:29,510
Так что ваша функция вызывается.

738
00:35:29,510 --> 00:35:31,410
Базовый вариант стоит на первом месте.

739
00:35:31,410 --> 00:35:33,710
Вы хотите знать, если вы в конце.

740
00:35:33,710 --> 00:35:37,110
И если вы не в конце, вы
сделать свой рекурсивный вызов.

741
00:35:37,110 --> 00:35:39,880
И вы идете через эту функцию снова,
проверить базовый вариант снова.

742
00:35:39,880 --> 00:35:42,575
Если вы еще не конец, вы делаете
другой рекурсивный вызов,

743
00:35:42,575 --> 00:35:44,130
и так далее, и так далее.

744
00:35:44,130 --> 00:35:47,110
>> Вот почему рекурсивные функции всегда
нужны эти базовые случаи и те,

745
00:35:47,110 --> 00:35:48,210
рекурсивные вызовы.

746
00:35:48,210 --> 00:35:51,280
Если у вас нет рекурсивный вызов, это
не будет рекурсивная функция.

747
00:35:51,280 --> 00:35:53,210
Если у вас не было базовый вариант,
Вы пошли бы навсегда и

748
00:35:53,210 --> 00:35:54,780
там не было бы окончание.

749
00:35:54,780 --> 00:35:57,870
И базовый вариант всегда на первом месте,
потому что вы всегда хотите, чтобы проверить

750
00:35:57,870 --> 00:36:00,420
если вы в конце первого.

751
00:36:00,420 --> 00:36:04,770
Поэтому, прежде чем сделать некоторые псевдокод, почему
Вы не найдите минутку, чтобы подумать о

752
00:36:04,770 --> 00:36:09,360
как рекурсивный факториала
было бы написано?

753
00:36:09,360 --> 00:36:23,340

754
00:36:23,340 --> 00:36:26,010
>> Кроме того, как многие, как вы делаете, письмо
это на листе бумаги является

755
00:36:26,010 --> 00:36:27,960
то, что вы будете иметь, чтобы
сделать на викторине завтра.

756
00:36:27,960 --> 00:36:32,160
Так, вероятно, хорошая практика, чтобы сделать
что код вы пишете

757
00:36:32,160 --> 00:36:34,420
вниз на лист бумаги -

758
00:36:34,420 --> 00:36:35,160
или вы можете сделать это.

759
00:36:35,160 --> 00:36:36,710
Вы знаете, где точки с запятой.

760
00:36:36,710 --> 00:36:37,660
Вы помните синтаксис.

761
00:36:37,660 --> 00:36:40,400
Потому что вы не в состоянии иметь
компилятор сказать вы сделали ошибку.

762
00:36:40,400 --> 00:37:02,356

763
00:37:02,356 --> 00:37:07,240
>> Кроме того, в этом направлении, завтра, когда
Вы кодирования проблемы, если вы

764
00:37:07,240 --> 00:37:11,490
бросились за время, или если вы очень
путать, как вы, как предполагается,

765
00:37:11,490 --> 00:37:16,030
написать определенную вещь в с, это
надлежало бы вам написать псевдо-код

766
00:37:16,030 --> 00:37:18,160
или писать комментарии в а.

767
00:37:18,160 --> 00:37:21,940
Потому что есть частичное кредит на
Много вопросов по викторины.

768
00:37:21,940 --> 00:37:24,840
Так что вы можете быть спешки, или вы
может просто путать.

769
00:37:24,840 --> 00:37:28,030
Дать в комментариях или псевдо-код
часто способы, которые вы

770
00:37:28,030 --> 00:37:29,360
может получить частичный кредит.

771
00:37:29,360 --> 00:37:31,440
>> Так что не оставить что-то
пустой на викторине.

772
00:37:31,440 --> 00:37:33,490
Там нет наказания за
положить вещи дюйма

773
00:37:33,490 --> 00:37:37,650
В самом деле, полагая в псевдо-код или
комментарии собирается помочь грейдер

774
00:37:37,650 --> 00:37:40,410
выяснить, если вы на самом деле знаете, что
Вы говорите о, и, возможно, награду

775
00:37:40,410 --> 00:37:42,030
Вы некоторая частичная заслуга в этом.

776
00:37:42,030 --> 00:37:44,510
>> Также в этом направлении, писать ясно.

777
00:37:44,510 --> 00:37:47,650
Если мы можем на самом деле не то, что вы пишете,
мы не собираемся называть тебя

778
00:37:47,650 --> 00:37:49,900
в полночь завтра к фигуре
то, что вы написали.

779
00:37:49,900 --> 00:37:51,520
Мы просто собираемся снять очки.

780
00:37:51,520 --> 00:37:56,570
Пишите ясно, чтобы мы могли услышать, вернее,
мы можем прочитать, что вы написали.

781
00:37:56,570 --> 00:38:00,230
>> И если он говорит, два предложения,
не написать абзац.

782
00:38:00,230 --> 00:38:02,280
Следуйте инструкциям.

783
00:38:02,280 --> 00:38:03,500
Пишите ясно.

784
00:38:03,500 --> 00:38:07,720
И писать в этих замечаний или
псевдокод для вопросов, которые могли бы

785
00:38:07,720 --> 00:38:10,270
Награда частичное кредит.

786
00:38:10,270 --> 00:38:12,520
>> Хорошо, давайте вернемся к факториала.

787
00:38:12,520 --> 00:38:15,000
Поэтому у нас есть функция факториала.

788
00:38:15,000 --> 00:38:18,400

789
00:38:18,400 --> 00:38:21,550
Если бы я был на самом деле пишу это в C,
что мне нужно поставить перед именем

790
00:38:21,550 --> 00:38:22,800
функции?

791
00:38:22,800 --> 00:38:24,880

792
00:38:24,880 --> 00:38:30,060
Возвращаемый тип, который, в этом
так, мы дадим ему Int.

793
00:38:30,060 --> 00:38:35,450
А потом в фигурных скобках, является
то, что происходит в фигурных скобках для

794
00:38:35,450 --> 00:38:36,850
функция?

795
00:38:36,850 --> 00:38:37,950
>> СТУДЕНТЫ: Тип аргумента.

796
00:38:37,950 --> 00:38:39,150
>> Джейсон Хиршхорн: Ее аргументы.

797
00:38:39,150 --> 00:38:42,680
Так факторный, вероятно,
принимать аргумент.

798
00:38:42,680 --> 00:38:44,500
Это, наверное, только взять один аргумент.

799
00:38:44,500 --> 00:38:49,450
И мы скажем это займет
целое число, называемое х.

800
00:38:49,450 --> 00:38:52,770
И снова, при написании прототип
функция или записи функцию

801
00:38:52,770 --> 00:38:57,110
в коде перед его определения, вам
написать тип данных и имя

802
00:38:57,110 --> 00:39:01,370
эта переменная только для этой функции.

803
00:39:01,370 --> 00:39:06,350
Таким образом, вы можете передать некоторое количество в это
функция, она будет называться х

804
00:39:06,350 --> 00:39:07,340
внутри.

805
00:39:07,340 --> 00:39:08,755
>> У нас есть функцию факториала.

806
00:39:08,755 --> 00:39:12,030

807
00:39:12,030 --> 00:39:15,850
Нам нужно две вещи, базовый вариант
и рекурсивный вызов.

808
00:39:15,850 --> 00:39:20,900
Что такое базовый вариант для факториала?

809
00:39:20,900 --> 00:39:24,850
Кто-то, кто ее написал, и кто не имеет
говорят еще, что является базовым

810
00:39:24,850 --> 00:39:26,100
чехол для факториала?

811
00:39:26,100 --> 00:39:28,400

812
00:39:28,400 --> 00:39:30,930
>> СТУДЕНТ: Если п меньше
чем 2, вернуть 1.

813
00:39:30,930 --> 00:39:33,520
>> Джейсон Хиршхорн: Если п
меньше 2, вернуть 1.

814
00:39:33,520 --> 00:39:37,216
Мне это нравится, потому что это
заботится о 0 и 1.

815
00:39:37,216 --> 00:39:45,290
Так сделаем х <2, вернуть 1.

816
00:39:45,290 --> 00:39:47,870
Если нас прошло 0, если мы получим
прошло 1, эта функция будет

817
00:39:47,870 --> 00:39:49,790
немедленно вернуть 1.

818
00:39:49,790 --> 00:39:54,020
Если нас прошло некоторое число, большее
или равно 2, мы собираемся

819
00:39:54,020 --> 00:39:55,370
есть наш рекурсивный вызов.

820
00:39:55,370 --> 00:39:57,855
>> И так как это то, что будет работать?

821
00:39:57,855 --> 00:40:01,070
Может кто-то еще, кто работал над этим
которые пока не говорят, дайте мне

822
00:40:01,070 --> 00:40:07,380
рекурсивный вызов для этой функции
в псевдокоде?

823
00:40:07,380 --> 00:40:10,770
Если мы получить прошло в числа х
и это больше, чем 2, то

824
00:40:10,770 --> 00:40:13,370
мы хотим сделать?

825
00:40:13,370 --> 00:40:17,930
Мы также пример написано на
сторона, которая может дать вам подсказку.

826
00:40:17,930 --> 00:40:20,770
>> СТУДЕНТ: Позвоните х раз
Факториал х минус 1?

827
00:40:20,770 --> 00:40:22,020
>> Джейсон Хиршхорн: Совершенно верно.

828
00:40:22,020 --> 00:40:24,610

829
00:40:24,610 --> 00:40:37,750
Мы собираемся вернуться х раз
Факториал х минус 1.

830
00:40:37,750 --> 00:40:41,810
И, что, хотя я и написал,
в основном, то, что вы сказали, на английском языке,

831
00:40:41,810 --> 00:40:44,580
это факториала
будет вызван снова.

832
00:40:44,580 --> 00:40:46,320
Это будет выполняться на х минус 1.

833
00:40:46,320 --> 00:40:49,320
Это будет вернуться с некоторого целого, и
то он будет размножаться эти два

834
00:40:49,320 --> 00:40:52,050
вместе, и это значение будет
вернулся к тому, что называется это

835
00:40:52,050 --> 00:40:55,010
факториала, которые могли бы
еще один экземпляр

836
00:40:55,010 --> 00:40:58,420
это факториала.

837
00:40:58,420 --> 00:41:01,360
>> Так что это пример рекурсивной
Функция, очень

838
00:41:01,360 --> 00:41:02,530
просто рекурсивная функция.

839
00:41:02,530 --> 00:41:04,530
Но большинство из них будет так.

840
00:41:04,530 --> 00:41:11,170
Если вы хотели бы хорошую рекурсивным
вызов для викторины, попробуйте кодирования

841
00:41:11,170 --> 00:41:13,230
бинарный поиск рекурсивно.

842
00:41:13,230 --> 00:41:18,950
Потому что, если вы сделали бинарный поиск для
Проблема установить три, вы, вероятно, сделал это

843
00:41:18,950 --> 00:41:21,730
многократно в цикле.

844
00:41:21,730 --> 00:41:23,700
>> Но это также может быть записана
рекурсивно.

845
00:41:23,700 --> 00:41:26,310
Вы будете нуждаться, чтобы написать собственный
отдельная функция, которая принимает некоторые

846
00:41:26,310 --> 00:41:29,020
различные аргументы командной строки - или
не аргументы командной строки, некоторые

847
00:41:29,020 --> 00:41:30,910
разные только регулярные аргументы.

848
00:41:30,910 --> 00:41:33,870
Но вы могли бы написать бинарный поиск
рекурсивно, а также.

849
00:41:33,870 --> 00:41:36,190
>> СТУДЕНТ: Таким образом, вы, возможно, также написал,
вместо х минус 1, вы

850
00:41:36,190 --> 00:41:39,502
может также написал х минус
минус, или вы могли бы

851
00:41:39,502 --> 00:41:40,830
написано минус минус х.

852
00:41:40,830 --> 00:41:44,740
Вы можете просто объяснить очень быстро, почему
те были бы разные вещи,

853
00:41:44,740 --> 00:41:49,510
как то, что разница между
х минус минус и минус минус х?

854
00:41:49,510 --> 00:41:51,320
>> Джейсон Хиршхорн: Нет, я не
буду вдаваться в это.

855
00:41:51,320 --> 00:41:55,500
Но я буду говорить с вами об этом после того, как
класс. х минус минус, минус минус х

856
00:41:55,500 --> 00:41:57,780
уменьшения х на 1.

857
00:41:57,780 --> 00:41:59,090
Но они делают это немного по-другому.

858
00:41:59,090 --> 00:42:00,340
Но я не хочу вдаваться в это.

859
00:42:00,340 --> 00:42:04,330

860
00:42:04,330 --> 00:42:09,090
Другие вопросы о рекурсии
или эта функция?

861
00:42:09,090 --> 00:42:10,140
Это не совсем даже псевдокод.

862
00:42:10,140 --> 00:42:15,060
Вот в принципе и код в
C можно было бы написать для этого.

863
00:42:15,060 --> 00:42:19,393
>> OK, любые другие вопросы
о темах здесь?

864
00:42:19,393 --> 00:42:19,864
Да.

865
00:42:19,864 --> 00:42:23,130
>> СТУДЕНТ: У меня есть краткий список
с плавающей точкой и точность.

866
00:42:23,130 --> 00:42:24,260
>> Джейсон Хиршхорн: Плавающий
точки и точность.

867
00:42:24,260 --> 00:42:26,920
Может кто-то очень быстро
дать мне краткое изложение

868
00:42:26,920 --> 00:42:28,210
с плавающей точкой и точность?

869
00:42:28,210 --> 00:42:30,420
Вы все должны были сделать это для вашего
Проблема установить, так что вы все

870
00:42:30,420 --> 00:42:31,700
знакомы с ней.

871
00:42:31,700 --> 00:42:35,090
Или, может быть, не все из вас.

872
00:42:35,090 --> 00:42:36,602
Любой?

873
00:42:36,602 --> 00:42:39,530
Дайте мне начали пятно.

874
00:42:39,530 --> 00:42:40,750
С плавающей точкой и точность.

875
00:42:40,750 --> 00:42:42,380
В чем проблема?

876
00:42:42,380 --> 00:42:42,960
Да.

877
00:42:42,960 --> 00:42:43,680
Виктория?

878
00:42:43,680 --> 00:42:44,480
>> VANESSA: Ванесса.

879
00:42:44,480 --> 00:42:45,285
>> Джейсон Хиршхорн: Ванесса.

880
00:42:45,285 --> 00:42:45,680
Извините.

881
00:42:45,680 --> 00:42:51,550
>> VANESSA: Там только конечное число
чисел, которые могут быть представлены

882
00:42:51,550 --> 00:42:57,930
потому что вы находитесь на, в нашем
так, 32-разрядная система.

883
00:42:57,930 --> 00:43:03,080
Таким образом, вы отчасти должны
составляют некоторые цифры.

884
00:43:03,080 --> 00:43:03,910
>> Джейсон Хиршхорн: Так вот
Совершенно верно.

885
00:43:03,910 --> 00:43:08,110
Есть только определенное количество
числа, которые могут быть представлены.

886
00:43:08,110 --> 00:43:11,770
Если умножить два очень больших чисел,
это может переполнить количество

887
00:43:11,770 --> 00:43:13,950
пространств у вас есть, чтобы представлять
целым числом.

888
00:43:13,950 --> 00:43:17,930
Вот почему иногда мы используем
давным вместо Int.

889
00:43:17,930 --> 00:43:19,210
Это имеет больше пространства.

890
00:43:19,210 --> 00:43:21,210
Это может держать большее количество.

891
00:43:21,210 --> 00:43:24,310
>> Точности с плавающей запятой имеет отношение к
, но также имеет отношение к

892
00:43:24,310 --> 00:43:29,300
Дело в том, что десятичные цифры
не всегда представляется.

893
00:43:29,300 --> 00:43:29,540
Извините.

894
00:43:29,540 --> 00:43:31,280
Позвольте мне сказать это обратно вверх.

895
00:43:31,280 --> 00:43:36,610
Десятичное число 1.0 не всегда
представлены как вы ожидали бы,

896
00:43:36,610 --> 00:43:40,770
1,000000000.

897
00:43:40,770 --> 00:43:50,360
Это иногда представлен в виде
1,000000001 или 0,999999999.

898
00:43:50,360 --> 00:43:52,780
Это может быть даже 89 брошен
где-то там.

899
00:43:52,780 --> 00:43:56,560
Так что те десятичные числа не
представлены так же, как вы бы

900
00:43:56,560 --> 00:43:58,430
ожидать, что они должны быть представлены.

901
00:43:58,430 --> 00:44:00,010
>> Таким образом, в проблеме набор -

902
00:44:00,010 --> 00:44:00,860
это было два? -

903
00:44:00,860 --> 00:44:05,290
Проблема установить два, где мы имели дело с
числа с плавающей точкой, когда мы хотели

904
00:44:05,290 --> 00:44:08,690
им представлять именно то, что мы хотели
им представлять, число

905
00:44:08,690 --> 00:44:12,860
пенни, или количество центов,
умножим их на 100.

906
00:44:12,860 --> 00:44:14,750
Мы окружили их.

907
00:44:14,750 --> 00:44:18,660
А потом мы отрезали все
после запятой.

908
00:44:18,660 --> 00:44:22,020
Это было для того, чтобы они были бы
фактически равны именно то, что мы хотели

909
00:44:22,020 --> 00:44:22,410
им равняться.

910
00:44:22,410 --> 00:44:26,870
>> Потому что, когда вы берете то, что это
плавать и превратить его в междунар, вы

911
00:44:26,870 --> 00:44:29,860
отрезать все, чтобы права
десятичной точки.

912
00:44:29,860 --> 00:44:33,900
Потому что есть некоторые с плавающей точкой
неточность, 100.000 может быть

913
00:44:33,900 --> 00:44:37,440
представлен в виде +99,999999999.

914
00:44:37,440 --> 00:44:40,350
И если вы просто отрезать все, чтобы
право сразу же, вы собираетесь

915
00:44:40,350 --> 00:44:41,600
получить неправильный номер.

916
00:44:41,600 --> 00:44:44,050

917
00:44:44,050 --> 00:44:44,180
Да.

918
00:44:44,180 --> 00:44:45,290
>> СТУДЕНТ: У меня был вопрос
о приведении.

919
00:44:45,290 --> 00:44:47,500
Какой порядок это происходит в?

920
00:44:47,500 --> 00:44:54,480
Если вы хотите сделать поплавок, кронштейны, 1 разделен
на 10, она делает 1 делится на 10,

921
00:44:54,480 --> 00:44:58,910
затем получить 0,1, а затем включите
это в обращении?

922
00:44:58,910 --> 00:45:01,470
>> Джейсон Хиршхорн: Если вы делаете
плавать 1 делится на 10 -

923
00:45:01,470 --> 00:45:02,550
>> СТУДЕНТ: Да, а потом составляет -

924
00:45:02,550 --> 00:45:04,240
Ну, было бы нормально
есть его равным в -

925
00:45:04,240 --> 00:45:04,690
Да.

926
00:45:04,690 --> 00:45:06,760
Вы хотите, чтобы сделать его плавать, не так ли?

927
00:45:06,760 --> 00:45:12,790
>> Джейсон Хиршхорн: Итак, мы собираемся
использовать это, чтобы непосредственно перейти в выяснение того,

928
00:45:12,790 --> 00:45:15,390
ответы на эти вопросы
через кодирование.

929
00:45:15,390 --> 00:45:18,180
Потому что вы, вероятно, есть много
эти мельчайшие вопросы, и это хороший способ

930
00:45:18,180 --> 00:45:19,100
для их решения через кодирование.

931
00:45:19,100 --> 00:45:21,320
Так что мы собираемся, чтобы закодировать это прямо сейчас,
а затем мы собираемся вернуться и

932
00:45:21,320 --> 00:45:24,020
код на вопрос, вы должны были.

933
00:45:24,020 --> 00:45:24,950
>> Таким образом, первая строка -

934
00:45:24,950 --> 00:45:29,390
Я не должен был написать его - что это
Первое, что мы хотим сделать, когда мы

935
00:45:29,390 --> 00:45:32,250
открыть новый файл в Gedit?

936
00:45:32,250 --> 00:45:34,190
>> СТУДЕНТ: Включите.

937
00:45:34,190 --> 00:45:35,920
>> Джейсон Хиршхорн: Включите что?

938
00:45:35,920 --> 00:45:37,952
>> СТУДЕНТ: библиотека CS50.

939
00:45:37,952 --> 00:45:39,920
>> Джейсон Хиршхорн: ОК.

940
00:45:39,920 --> 00:45:42,590
Что еще мы должны включить?

941
00:45:42,590 --> 00:45:46,820
Мы просто собираемся, чтобы проверить, что происходит
, когда вы приводите что-то поплавком.

942
00:45:46,820 --> 00:45:48,605
Но то, что мы должны включить, если мы
собираюсь написать программу на С?

943
00:45:48,605 --> 00:45:49,300
>> СТУДЕНТ: Standard I / O.

944
00:45:49,300 --> 00:45:50,625
>> Джейсон Хиршхорн: stdio.h.

945
00:45:50,625 --> 00:45:54,880
Мы на самом деле не нужно, для этого
Программа, cs50.h, хотя это

946
00:45:54,880 --> 00:45:55,920
всегда полезно включить его.

947
00:45:55,920 --> 00:45:58,260
Но мы всегда должны stdio.h.

948
00:45:58,260 --> 00:45:59,660
>> СТУДЕНТ: При кодировании в С?

949
00:45:59,660 --> 00:46:15,770
>> Джейсон Хиршхорн: При кодировании в С.

950
00:46:15,770 --> 00:46:17,090
>> Так что я сохранить его, как это. Гр файла.

951
00:46:17,090 --> 00:46:18,590
Я получить некоторые интересные подсветку синтаксиса.

952
00:46:18,590 --> 00:46:22,890
Я написал пустоту внутри основной.

953
00:46:22,890 --> 00:46:24,792
Что недействительным в виду?

954
00:46:24,792 --> 00:46:26,740
>> СТУДЕНТ не несет никакой
аргументы командной строки.

955
00:46:26,740 --> 00:46:28,900
>> Джейсон Хиршхорн: отпадает средства, в этом
случай, главный не несет никакой

956
00:46:28,900 --> 00:46:29,700
аргументы командной строки.

957
00:46:29,700 --> 00:46:32,720
В других случаях, это означает, что функции
не принимает аргументы командной строки.

958
00:46:32,720 --> 00:46:36,560
Или функция, если бы мне пришлось писать пустоту
основных (недействительными), что бы сказал основные годов

959
00:46:36,560 --> 00:46:38,460
не возвращаются ничего.

960
00:46:38,460 --> 00:46:39,960
Так недействительными просто ничего не значит.

961
00:46:39,960 --> 00:46:42,510
Что бы я написать, если бы я
принимать аргументы командной строки?

962
00:46:42,510 --> 00:46:45,250

963
00:46:45,250 --> 00:46:47,150
>> СТУДЕНТ: внутр дуги с строка дуги против

964
00:46:47,150 --> 00:46:49,055
>> Джейсон Хиршхорн: внутр
агдс строка агду.

965
00:46:49,055 --> 00:46:54,050

966
00:46:54,050 --> 00:46:55,572
Так ли это?

967
00:46:55,572 --> 00:46:58,720
>> СТУДЕНТ: Это символьные звезда ARGV скобки.

968
00:46:58,720 --> 00:47:01,730
>> Джейсон Хиршхорн: Таким образом, вы могли бы написать
Строка ARGV кронштейны или символ звезды агду

969
00:47:01,730 --> 00:47:03,710
скобки, но вы должны скобки.

970
00:47:03,710 --> 00:47:06,290
Потому агду является массивом
строк, помню.

971
00:47:06,290 --> 00:47:07,360
Это не просто одна струна.

972
00:47:07,360 --> 00:47:10,350
Так строка агду есть, вот это
одну строку называется агду.

973
00:47:10,350 --> 00:47:13,630
Строка ARGV скобках, вот
массив строк.

974
00:47:13,630 --> 00:47:17,865
Так внутр агдс строка ARGV скобки
будет то, что я

975
00:47:17,865 --> 00:47:18,810
, вероятно, написать.

976
00:47:18,810 --> 00:47:23,050
>> Таким образом, вы хотели сохранить в виде целого числа?

977
00:47:23,050 --> 00:47:24,285
>> СТУДЕНТ: Да, целое число.

978
00:47:24,285 --> 00:47:25,840
Или в обращении.

979
00:47:25,840 --> 00:47:26,710
>> Джейсон Хиршхорн: В поплавком?

980
00:47:26,710 --> 00:47:30,790
Мол, поплавок х равна 1 делится на 10.

981
00:47:30,790 --> 00:47:32,040
>> Джейсон Хиршхорн: ОК.

982
00:47:32,040 --> 00:47:40,160

983
00:47:40,160 --> 00:47:42,240
Как мне распечатать поплавок в Printf?

984
00:47:42,240 --> 00:47:45,100

985
00:47:45,100 --> 00:47:46,714
Что?

986
00:47:46,714 --> 00:47:47,560
>> СТУДЕНТ% е.

987
00:47:47,560 --> 00:47:48,300
>> Джейсон Хиршхорн:% е.

988
00:47:48,300 --> 00:47:50,810
Что целое?

989
00:47:50,810 --> 00:47:52,110
г, или я.

990
00:47:52,110 --> 00:47:53,000
Что строка?

991
00:47:53,000 --> 00:47:54,240
>> СТУДЕНТ: с.

992
00:47:54,240 --> 00:47:56,140
>> Джейсон Хиршхорн: с.

993
00:47:56,140 --> 00:47:57,550
Как я могу получить новую линию?

994
00:47:57,550 --> 00:47:58,800
>> СТУДЕНТ: Обратная косая черта н.

995
00:47:58,800 --> 00:48:04,610

996
00:48:04,610 --> 00:48:07,100
>> Джейсон Хиршхорн: Что мне вернуться
если основные трассы правильно?

997
00:48:07,100 --> 00:48:08,360
>> СТУДЕНТ: 0.

998
00:48:08,360 --> 00:48:09,430
Нужно ли мне написать эту линию, хотя?

999
00:48:09,430 --> 00:48:10,170
>> СТУДЕНТ: Нет.

1000
00:48:10,170 --> 00:48:11,513
Хорошо, мы не будем писать, то.

1001
00:48:11,513 --> 00:48:16,450

1002
00:48:16,450 --> 00:48:17,190
Все ли могут прочитать, что?

1003
00:48:17,190 --> 00:48:18,485
Это выглядит немного мала.

1004
00:48:18,485 --> 00:48:20,160
Все ли могут увидеть, или должны
Я сделать его больше?

1005
00:48:20,160 --> 00:48:23,480

1006
00:48:23,480 --> 00:48:25,100
Я думаю, что для камеры, мы сделаем
это немного больше, однако.

1007
00:48:25,100 --> 00:48:35,750

1008
00:48:35,750 --> 00:48:38,410
>> Джейсон Хиршхорн: Если я хочу, чтобы превратить это
. C файл в исполняемый файл, что

1009
00:48:38,410 --> 00:48:39,260
я пишу?

1010
00:48:39,260 --> 00:48:41,610
>> СТУДЕНТ: Сделайте тест.

1011
00:48:41,610 --> 00:48:42,080
>> Джейсон Хиршхорн: Извините?

1012
00:48:42,080 --> 00:48:42,790
>> СТУДЕНТ: Сделайте тест.

1013
00:48:42,790 --> 00:48:44,040
>> Джейсон Хиршхорн: Сделайте тест.

1014
00:48:44,040 --> 00:48:46,700

1015
00:48:46,700 --> 00:48:48,410
Мы говорили о
эта линия раньше.

1016
00:48:48,410 --> 00:48:49,140
Clang.

1017
00:48:49,140 --> 00:48:51,270
Что лязг?

1018
00:48:51,270 --> 00:48:52,200
Название компилятором.

1019
00:48:52,200 --> 00:48:53,920
Что это линия?

1020
00:48:53,920 --> 00:48:55,580
>> СТУДЕНТ: Установка его на использование GDB.

1021
00:48:55,580 --> 00:48:59,230
>> Джейсон Хиршхорн: Наборы
это на использовании GDB.

1022
00:48:59,230 --> 00:49:02,338
Эта линия, что это такое?

1023
00:49:02,338 --> 00:49:03,290
>> СТУДЕНТ: Исходный код.

1024
00:49:03,290 --> 00:49:06,010
>> Джейсон Хиршхорн: Это
Исходный файл,. с файл.

1025
00:49:06,010 --> 00:49:08,150
Что означают эти две линии делать?

1026
00:49:08,150 --> 00:49:10,245
Или эти два не линии.

1027
00:49:10,245 --> 00:49:12,300
>> СТУДЕНТ: Он называет это тест.

1028
00:49:12,300 --> 00:49:15,410
>> Джейсон Хиршхорн: Так тире о говорит,
назвать его что-то по-другому.

1029
00:49:15,410 --> 00:49:16,790
И вот вы звоните его испытания.

1030
00:49:16,790 --> 00:49:18,900
Если у меня не было, что в,
что бы это назвать это?

1031
00:49:18,900 --> 00:49:20,260
>> СТУДЕНТ: a.out.

1032
00:49:20,260 --> 00:49:22,340
>> Джейсон Хиршхорн: a.out.

1033
00:49:22,340 --> 00:49:25,366
Что это делать?

1034
00:49:25,366 --> 00:49:27,670
>> СТУДЕНТ: Ссылки на математическую библиотеку.

1035
00:49:27,670 --> 00:49:29,550
>> Джейсон Хиршхорн: Он связывает
в математической библиотеки.

1036
00:49:29,550 --> 00:49:32,880
Мы не включали математическая библиотека, но
так как это настолько часто, они уже

1037
00:49:32,880 --> 00:49:35,780
написано марка всегда включать
математическая библиотека.

1038
00:49:35,780 --> 00:49:39,050
И так же, это включает в себя
библиотека CS50.

1039
00:49:39,050 --> 00:49:43,010
>> Итак, если мы перечислим, у нас теперь есть
исполняемый называемый тест.

1040
00:49:43,010 --> 00:49:45,150
Чтобы выполнить его, я пишу тест.

1041
00:49:45,150 --> 00:49:48,330
Я вижу, что мой плавающей точкой,
Как и ожидалось, равна 0.

1042
00:49:48,330 --> 00:49:50,890

1043
00:49:50,890 --> 00:49:51,590
Значит ли это, -

1044
00:49:51,590 --> 00:49:52,060
так -

1045
00:49:52,060 --> 00:49:55,210
>> СТУДЕНТ: Тогда, если вы положили плавать сейчас,
как вы привести его поплавка -

1046
00:49:55,210 --> 00:49:56,870
>> Джейсон Хиршхорн: Cast
от 1 до поплавка?

1047
00:49:56,870 --> 00:49:59,180
>> СТУДЕНТ: Нет, бросил полный вещь -

1048
00:49:59,180 --> 00:49:59,500
да.

1049
00:49:59,500 --> 00:50:02,460
Если вы только что сделали, что, бы
которые делают его 0,1?

1050
00:50:02,460 --> 00:50:07,170
>> Джейсон Хиршхорн: Хорошо, таким образом очень быстро,
1 делится на 10, те

1051
00:50:07,170 --> 00:50:08,690
целые разделена.

1052
00:50:08,690 --> 00:50:13,580
Поэтому, когда вы разделите целые, они
0, и вы экономите, что 0 в

1053
00:50:13,580 --> 00:50:17,170
плавать, потому что слэш
просто целочисленное деление.

1054
00:50:17,170 --> 00:50:19,180
Так что теперь мы поворота что-то
в обращении.

1055
00:50:19,180 --> 00:50:21,650
>> Давайте посмотрим, что произойдет.

1056
00:50:21,650 --> 00:50:22,900
Мы сделаем тест.

1057
00:50:22,900 --> 00:50:25,870

1058
00:50:25,870 --> 00:50:31,090
Так что теперь мы видим, что, что косая черта не было
целочисленное деление было плавающей

1059
00:50:31,090 --> 00:50:32,640
точка деления.

1060
00:50:32,640 --> 00:50:35,700
Потому что один из ее аргументов
был брошен в обращении.

1061
00:50:35,700 --> 00:50:38,380
Так что теперь это уже говорил, относиться к этому
разделение, как мы имеем дело с

1062
00:50:38,380 --> 00:50:40,140
плавающие точки, а не с целыми числами.

1063
00:50:40,140 --> 00:50:42,760
И таким образом мы получаем ответ мы ожидаем.

1064
00:50:42,760 --> 00:50:44,620
>> Давайте посмотрим, что происходит -

1065
00:50:44,620 --> 00:50:47,103
упс.

1066
00:50:47,103 --> 00:50:51,646
Если бы я хотел, чтобы напечатать больше десятичные
пятна, как я мог это сделать?

1067
00:50:51,646 --> 00:50:55,550
>> СТУДЕНТ: Точка точка е, или столько, сколько
знаков после запятой, как вы хотите.

1068
00:50:55,550 --> 00:51:02,280

1069
00:51:02,280 --> 00:51:04,440
>> Джейсон Хиршхорн: Так что я распечатать
10 десятичные пятна.

1070
00:51:04,440 --> 00:51:06,610
И теперь мы видим, что мы получаем
некоторые странные вещи.

1071
00:51:06,610 --> 00:51:09,650
И это восходит на ваш вопрос
о плавающей запятой неточность.

1072
00:51:09,650 --> 00:51:10,950
Там в странные вещи хранятся здесь.

1073
00:51:10,950 --> 00:51:13,650

1074
00:51:13,650 --> 00:51:15,275
>> ОК, значит ли это ответ на ваш вопрос?

1075
00:51:15,275 --> 00:51:18,550

1076
00:51:18,550 --> 00:51:20,200
Что еще вы хотите
быстро кодировать?

1077
00:51:20,200 --> 00:51:25,470
>> СТУДЕНТ: Я просто хотел, чтобы увидеть или
не, если вы освободили некоторое указатель,

1078
00:51:25,470 --> 00:51:30,410
еще что ли указатель хранили в
это также адрес, какой она была

1079
00:51:30,410 --> 00:51:32,170
указывая на ранее.

1080
00:51:32,170 --> 00:51:34,100
>> Джейсон Хиршхорн: ОК,
так давайте сделаем это.

1081
00:51:34,100 --> 00:51:38,030
Чара звезда PTR, это создает переменную
называется PTR из символьного типа звезды.

1082
00:51:38,030 --> 00:51:39,280
Как написать таНос?

1083
00:51:39,280 --> 00:51:40,550
Олден?

1084
00:51:40,550 --> 00:51:41,800
>> ALDEN: Просто таНос.

1085
00:51:41,800 --> 00:51:44,820

1086
00:51:44,820 --> 00:51:51,040
Но тогда он должен быть размер и
в этом случае, я думаю, вы бы

1087
00:51:51,040 --> 00:51:52,465
указывать на символ.

1088
00:51:52,465 --> 00:51:54,450
Так что это будет символ.

1089
00:51:54,450 --> 00:51:57,520
>> Джейсон Хиршхорн: ОК, так что больше
в общем, внутри -

1090
00:51:57,520 --> 00:51:58,770
давайте редактирования.

1091
00:51:58,770 --> 00:52:05,100

1092
00:52:05,100 --> 00:52:09,260
Внутри таНос, вы хотите, чтобы ряд
байтов в куче.

1093
00:52:09,260 --> 00:52:12,320
Как правило, то, что мы видели, что мы
делать это мы собираемся Malloc

1094
00:52:12,320 --> 00:52:14,940
строки, например, или
массивы целых чисел.

1095
00:52:14,940 --> 00:52:21,600
Так что если мы хотим 10 целых чисел, или 10
символы, 10 даст нам 10.

1096
00:52:21,600 --> 00:52:24,370
А потом размер символов даст
нам, что размер символов, которые в

1097
00:52:24,370 --> 00:52:25,120
этот случай 1 байт.

1098
00:52:25,120 --> 00:52:26,250
Мы получаем 10 байт.

1099
00:52:26,250 --> 00:52:28,540
Если бы мы должны были написать размер Int,
что даст нам 40 байт.

1100
00:52:28,540 --> 00:52:31,520
>> Так в более общем, внутри таНос
является количество байт вы хотите.

1101
00:52:31,520 --> 00:52:34,620
В этом случае мы получаем 1 байт.

1102
00:52:34,620 --> 00:52:36,900
Какие кажется странным использования
из таНос, но для нашего

1103
00:52:36,900 --> 00:52:38,470
цели имеет смысл.

1104
00:52:38,470 --> 00:52:40,420
Так что есть что.

1105
00:52:40,420 --> 00:52:43,420
>> Мы собираемся звонить бесплатно.

1106
00:52:43,420 --> 00:52:47,040
Мы от него избавиться, и мы используем PTR снова.

1107
00:52:47,040 --> 00:52:48,750
И что же вы хотите проверить?

1108
00:52:48,750 --> 00:52:50,550
>> СТУДЕНТ: Я просто хотел проверить, является ли
или нет, было ли что-нибудь

1109
00:52:50,550 --> 00:52:51,900
внутри него.

1110
00:52:51,900 --> 00:52:53,050
>> Джейсон Хиршхорн: Так ли
он указал ни к чему?

1111
00:52:53,050 --> 00:52:57,740
>> СТУДЕНТ: Да, точно, является ли
он по-прежнему был адрес памяти.

1112
00:52:57,740 --> 00:53:02,220
>> Джейсон Хиршхорн: Итак, вы хотите
чтобы проверить значение PTR?

1113
00:53:02,220 --> 00:53:03,470
>> СТУДЕНТ: Да, именно так.

1114
00:53:03,470 --> 00:53:07,940

1115
00:53:07,940 --> 00:53:10,160
>> Джейсон Хиршхорн: Что я пишу здесь
если я хочу проверить значение

1116
00:53:10,160 --> 00:53:11,880
точка - что это, Иордания
сказал, значение?

1117
00:53:11,880 --> 00:53:13,720
Или то, что хранится внутри PTR?

1118
00:53:13,720 --> 00:53:14,620
>> СТУДЕНТ: адрес памяти.

1119
00:53:14,620 --> 00:53:16,330
>> Джейсон Хиршхорн: адрес памяти.

1120
00:53:16,330 --> 00:53:20,520
Так что если я пишу только в этом, оно будет
дайте мне значение PTR.

1121
00:53:20,520 --> 00:53:22,800
И как я могу распечатать
адрес памяти?

1122
00:53:22,800 --> 00:53:26,470
Что строка формата
для адреса памяти?

1123
00:53:26,470 --> 00:53:27,430
>> СТУДЕНТ% р.

1124
00:53:27,430 --> 00:53:28,050
>> Джейсон Хиршхорн:% р.

1125
00:53:28,050 --> 00:53:29,500
% С является строкой.

1126
00:53:29,500 --> 00:53:30,750
% Р для указателя.

1127
00:53:30,750 --> 00:53:40,820

1128
00:53:40,820 --> 00:53:43,540
Так ли это?

1129
00:53:43,540 --> 00:53:44,790
Это правильно.

1130
00:53:44,790 --> 00:53:49,450

1131
00:53:49,450 --> 00:53:51,040
Так PTR равно -

1132
00:53:51,040 --> 00:53:53,350
она до сих пор что-то в нем.

1133
00:53:53,350 --> 00:53:56,110

1134
00:53:56,110 --> 00:53:57,645
Это, вероятно, более
интересный вопрос.

1135
00:53:57,645 --> 00:53:59,198
Что это линия делать?

1136
00:53:59,198 --> 00:54:00,830
>> СТУДЕНТ: Seg неисправности.

1137
00:54:00,830 --> 00:54:01,310
>> Джейсон Хиршхорн: Что?

1138
00:54:01,310 --> 00:54:02,678
>> СТУДЕНТ: Я думаю, что SEG недостатки.

1139
00:54:02,678 --> 00:54:03,574
>> Джейсон Хиршхорн: Хм?

1140
00:54:03,574 --> 00:54:04,920
>> СТУДЕНТ: Я думаю, что это SEG неисправность.

1141
00:54:04,920 --> 00:54:08,265
>> Джейсон Хиршхорн: Так эта линия
из кода, звезды PTR, что

1142
00:54:08,265 --> 00:54:10,152
делает звезда в виду?

1143
00:54:10,152 --> 00:54:11,240
>> СТУДЕНТ: Содержание.

1144
00:54:11,240 --> 00:54:11,560
>> Джейсон Хиршхорн: Да.

1145
00:54:11,560 --> 00:54:13,910
К получить содержимое.

1146
00:54:13,910 --> 00:54:16,830
Так что это будет идти в память
обратиться туда и дать мне это.

1147
00:54:16,830 --> 00:54:21,030
Я использовал% о прямо здесь, потому что
там хранятся символы.

1148
00:54:21,030 --> 00:54:23,390
Таким образом, мы собираемся пойти на этот адрес мы
только что видел - или это, вероятно, будет

1149
00:54:23,390 --> 00:54:25,190
немного отличается в этом
раз, когда мы запустить программу.

1150
00:54:25,190 --> 00:54:28,010
Но мы пойдем по этому адресу
которые мы знаем все еще существует

1151
00:54:28,010 --> 00:54:29,260
и посмотреть, что там.

1152
00:54:29,260 --> 00:54:35,640

1153
00:54:35,640 --> 00:54:37,110
>> Так что не SEG неисправность.

1154
00:54:37,110 --> 00:54:38,970
Это просто не дают нам ничего.

1155
00:54:38,970 --> 00:54:43,350
Это, возможно, на самом деле дает нам
что-то, мы просто не можем увидеть его.

1156
00:54:43,350 --> 00:54:45,110
И это восходит к этой идее -

1157
00:54:45,110 --> 00:54:47,270
и мы не собираемся, чтобы получить слишком много в
это, потому что это за пределами

1158
00:54:47,270 --> 00:54:48,460
Объем этого курса.

1159
00:54:48,460 --> 00:54:51,260
Но мы говорили о прямо здесь, если мы
вышел за границы массива на

1160
00:54:51,260 --> 00:54:54,890
1, мы не могли бы попасть в беду.

1161
00:54:54,890 --> 00:54:58,550
>> Иногда, когда вы просто уйти на 1,
вы делаете что-то неправильно, и вы

1162
00:54:58,550 --> 00:54:59,220
может попасть в беду.

1163
00:54:59,220 --> 00:55:00,820
Но вы не всегда попадают в неприятности.

1164
00:55:00,820 --> 00:55:05,170
Это зависит, сколько о плохой вещи вы
делаете, вы собираетесь попасть в беду.

1165
00:55:05,170 --> 00:55:07,790
Который не должен сказать, быть неаккуратным
с вашим кодом.

1166
00:55:07,790 --> 00:55:12,080
Но это сказать, программа не будет
всегда бросить курить, даже если вы идете куда-нибудь

1167
00:55:12,080 --> 00:55:14,130
ты не должен идти.

1168
00:55:14,130 --> 00:55:18,170
>> Хорошим примером этого является, много
люди в их проблемы набор 3, которые

1169
00:55:18,170 --> 00:55:22,350
был 15, не проверял
Границы борту.

1170
00:55:22,350 --> 00:55:25,860
Таким образом, вы смотрели налево, посмотрел на
Хорошо, посмотрел на вершину, посмотрел

1171
00:55:25,860 --> 00:55:27,000
на дно.

1172
00:55:27,000 --> 00:55:31,540
Но вы не убедитесь в том, верхняя
был на самом деле происходит, чтобы быть на борту.

1173
00:55:31,540 --> 00:55:35,220
И много людей, которые сделали это, и
Оказалось, что в их программа работала

1174
00:55:35,220 --> 00:55:38,960
отлично, потому что, где, что доска была
хранятся в памяти, если вы пошли один

1175
00:55:38,960 --> 00:55:42,300
над ним или проверить, что память
адрес, не было ничего,

1176
00:55:42,300 --> 00:55:44,870
особенно ужасно об этом,
так что ваша программа не была

1177
00:55:44,870 --> 00:55:45,970
собирается кричать на вас.

1178
00:55:45,970 --> 00:55:48,870
>> Но мы все равно снять очки, если
вы не убедитесь, что, так как вам

1179
00:55:48,870 --> 00:55:50,850
делали то, что вы не были
должен делать, и вы могли бы

1180
00:55:50,850 --> 00:55:51,860
получили в беде.

1181
00:55:51,860 --> 00:55:54,040
Разногласия, тем не менее, вы, вероятно, этого не сделали.

1182
00:55:54,040 --> 00:55:57,790
Так что это, чтобы показать, что, да,
мы все еще можем идти к ней.

1183
00:55:57,790 --> 00:55:59,010
И мы не получаем в
Беда в этом случае.

1184
00:55:59,010 --> 00:56:04,000
Если бы мы попытались сделать читать
Следующие 100 символов, мы бы

1185
00:56:04,000 --> 00:56:06,000
вероятно, попасть в беду.

1186
00:56:06,000 --> 00:56:09,400
И вы можете написать чтение следующего 100
символы, если вы хотите, делая некоторые

1187
00:56:09,400 --> 00:56:10,110
рода цикл.

1188
00:56:10,110 --> 00:56:10,850
Да.

1189
00:56:10,850 --> 00:56:16,250
>> СТУДЕНТ: Так как мы были назначены, что
пространство фактическое значение, мы не были бы

1190
00:56:16,250 --> 00:56:17,050
на самом деле быть в состоянии видеть ничего.

1191
00:56:17,050 --> 00:56:21,740
Может быть, попробовать его с установкой, что
равно как и в С или еще что-нибудь?

1192
00:56:21,740 --> 00:56:22,640
>> Джейсон Хиршхорн: Хороший вопрос.

1193
00:56:22,640 --> 00:56:25,340
Как мне установить это значение -

1194
00:56:25,340 --> 00:56:28,980
что строка кода я пишу на линии
семь делать то, что вы сказали?

1195
00:56:28,980 --> 00:56:34,040
>> СТУДЕНТ: Звезда PTR равна одной
цитата C конец одинарные кавычки.

1196
00:56:34,040 --> 00:56:36,970
>> Джейсон Хиршхорн: Так это положить
персонаж, с, в этом месте,

1197
00:56:36,970 --> 00:56:40,200
потому что снова, что звезда
означает пойти в туда.

1198
00:56:40,200 --> 00:56:43,320
И при использовании на левой стороне
Оператор присваивания, что составляет

1199
00:56:43,320 --> 00:56:47,270
подписать, мы не собираемся, чтобы получить, что
значение так как установлено, что значение.

1200
00:56:47,270 --> 00:56:48,520
Теперь давайте посмотрим, что произойдет.

1201
00:56:48,520 --> 00:56:54,700

1202
00:56:54,700 --> 00:56:56,770
>> Мы положить что-то есть
и это было там.

1203
00:56:56,770 --> 00:56:58,000
Мы назвали бесплатно.

1204
00:56:58,000 --> 00:57:00,100
Некоторые вещи, вероятно, произошло
в куче.

1205
00:57:00,100 --> 00:57:01,890
Так что это не там больше.

1206
00:57:01,890 --> 00:57:07,440
Но опять же, мы не получаем
в проблему идти туда.

1207
00:57:07,440 --> 00:57:10,260
>> Я делаю это в коде, чтобы проиллюстрировать
что многие из них

1208
00:57:10,260 --> 00:57:12,410
вопросы, которые у вас есть, что они
действительно интересно

1209
00:57:12,410 --> 00:57:13,650
отвечает много времени.

1210
00:57:13,650 --> 00:57:15,260
И они действительно хорошие вопросы.

1211
00:57:15,260 --> 00:57:19,010
И вы можете понять их на
свой собственный, если, например,

1212
00:57:19,010 --> 00:57:19,990
мы не в разделе.

1213
00:57:19,990 --> 00:57:20,940
Да.

1214
00:57:20,940 --> 00:57:24,430
>> СТУДЕНТ: Потому что ты не посылает
указатель в любом месте, вы должны

1215
00:57:24,430 --> 00:57:26,530
использовать таНос?

1216
00:57:26,530 --> 00:57:28,400
>> Джейсон Хиршхорн: Так это восходит
на ваш первоначальный вопрос.

1217
00:57:28,400 --> 00:57:28,620
[? ?]

1218
00:57:28,620 --> 00:57:29,980
Неужели это всего лишь локальная переменная?

1219
00:57:29,980 --> 00:57:32,280
Malloc здесь не то, что убедительными.

1220
00:57:32,280 --> 00:57:35,260
Использование таНос здесь не
что убедительным, потому что это

1221
00:57:35,260 --> 00:57:36,500
просто локальная переменная.

1222
00:57:36,500 --> 00:57:40,970
>> СТУДЕНТ: Так не могли бы вы сделать символ
звезды PTR равна Привет?

1223
00:57:40,970 --> 00:57:41,400
>> Джейсон Хиршхорн: Ох.

1224
00:57:41,400 --> 00:57:43,300
Так что мы собираемся теперь вернуться
на ваш первоначальный вопрос.

1225
00:57:43,300 --> 00:57:46,885
Я думаю, что вы не были удовлетворены
с моим ответом.

1226
00:57:46,885 --> 00:57:48,220
ОК?

1227
00:57:48,220 --> 00:57:49,226
Как это?

1228
00:57:49,226 --> 00:57:49,682
>> СТУДЕНТ: Да.

1229
00:57:49,682 --> 00:57:50,932
Подождите.

1230
00:57:50,932 --> 00:57:54,090

1231
00:57:54,090 --> 00:57:57,850
>> Джейсон Хиршхорн: А где
Вы хотите распечатать?

1232
00:57:57,850 --> 00:58:00,026
Таким образом мы будем распечатать строку, как это?

1233
00:58:00,026 --> 00:58:06,380

1234
00:58:06,380 --> 00:58:07,630
>> СТУДЕНТ: Интересно.

1235
00:58:07,630 --> 00:58:09,900

1236
00:58:09,900 --> 00:58:14,285
>> Джейсон Хиршхорн: Так что это говорит, что это
Аргумент имеет тип характера.

1237
00:58:14,285 --> 00:58:17,200

1238
00:58:17,200 --> 00:58:18,620
Так это должно быть характер.

1239
00:58:18,620 --> 00:58:25,170

1240
00:58:25,170 --> 00:58:26,280
>> СТУДЕНТ: Просто берет первый.

1241
00:58:26,280 --> 00:58:28,610
>> Джейсон Хиршхорн: Так что это
это то, что я сказал прежде.

1242
00:58:28,610 --> 00:58:34,240
Как я уже сказал, это не хранения
строка внутри переменной указателя.

1243
00:58:34,240 --> 00:58:35,120
Это хранения -

1244
00:58:35,120 --> 00:58:36,350
>> СТУДЕНТ: Первое значение
строки.

1245
00:58:36,350 --> 00:58:40,810
>> Джейсон Хиршхорн: адрес
первое значение строки.

1246
00:58:40,810 --> 00:58:46,940
Если бы мы должны были распечатать это, мы
получение значения внутри указатель.

1247
00:58:46,940 --> 00:58:51,005
И мы будем видеть, что это, в самом деле,
адрес памяти.

1248
00:58:51,005 --> 00:58:53,595

1249
00:58:53,595 --> 00:58:56,440
>> Имеет ли это смысл?

1250
00:58:56,440 --> 00:58:56,940
Извините.

1251
00:58:56,940 --> 00:58:58,996
Подождите, Я ответил на ваш
Вопрос, однако?

1252
00:58:58,996 --> 00:58:59,790
>> СТУДЕНТ: Да.

1253
00:58:59,790 --> 00:59:05,830
>> Джейсон Хиршхорн: Эта строка кода является
создания строку и затем еще один

1254
00:59:05,830 --> 00:59:09,115
переменная-указатель, который указывает
в этой строке, что массив.

1255
00:59:09,115 --> 00:59:14,320

1256
00:59:14,320 --> 00:59:14,980
Да.

1257
00:59:14,980 --> 00:59:19,200
>> СТУДЕНТ: Так что, если мы пошли одно воспоминание
обратиться дальше, будет получаем ч?

1258
00:59:19,200 --> 00:59:21,990

1259
00:59:21,990 --> 00:59:23,150
Была ли она хранится в виде строки?

1260
00:59:23,150 --> 00:59:24,400
>> Джейсон Хиршхорн: Мол, мы сделали -

1261
00:59:24,400 --> 00:59:28,540

1262
00:59:28,540 --> 00:59:30,790
так что это ценный сделать.

1263
00:59:30,790 --> 00:59:33,780
Это арифметика, которые вы, ребята,
видели раньше, и должны быть

1264
00:59:33,780 --> 00:59:35,550
относительно комфортно.

1265
00:59:35,550 --> 00:59:36,905
Это сродни тому, писать -

1266
00:59:36,905 --> 00:59:41,980

1267
00:59:41,980 --> 00:59:46,350
если мы должны были написать эту строку кода,
мы видели нотации массива раньше.

1268
00:59:46,350 --> 00:59:55,900
Это должно дать нам второй
Значение в этом массиве, ч.

1269
00:59:55,900 --> 01:00:05,010
>> Если бы мы сделали это, это должно также дать
нам второе значение в этом массиве.

1270
01:00:05,010 --> 01:00:08,320
Потому что это будет не в память
адрес первого вещь, но

1271
01:00:08,320 --> 01:00:10,530
адрес памяти вещи один старше.

1272
01:00:10,530 --> 01:00:14,360
И тогда звезда оператор разыменовывает
что указатель.

1273
01:00:14,360 --> 01:00:16,940
И опять же, давайте посмотрим.

1274
01:00:16,940 --> 01:00:18,664
Мы получаем ч снова.

1275
01:00:18,664 --> 01:00:20,980
>> СТУДЕНТ: Что именно делает
разыменовать значит?

1276
01:00:20,980 --> 01:00:23,650
>> Джейсон Хиршхорн: Dereference
является причудливое слово для пойти.

1277
01:00:23,650 --> 01:00:26,390
К, что и получить то, что там
является разыменовывать указатель.

1278
01:00:26,390 --> 01:00:28,240
Это просто причудливое слово для этого.

1279
01:00:28,240 --> 01:00:29,986
>> СТУДЕНТ: Если бы мы хотели печати
вся строка, мог мы

1280
01:00:29,986 --> 01:00:31,930
сделать амперсанд указатель?

1281
01:00:31,930 --> 01:00:33,490
>> Джейсон Хиршхорн: Хорошо, мы
собирается останавливаться здесь.

1282
01:00:33,490 --> 01:00:35,480
Мы собираемся заканчивается.

1283
01:00:35,480 --> 01:00:41,760
Ampersand дает адрес
расположение, поэтому, когда вы делаете амперсанд из

1284
01:00:41,760 --> 01:00:44,080
переменная, это дает вам адрес
где хранится эта переменная.

1285
01:00:44,080 --> 01:00:48,580
Ampersand указатель даст вам
адрес PTR где PTR находится в памяти.

1286
01:00:48,580 --> 01:00:50,140
>> Мы не собираемся идти на
с этим примером.

1287
01:00:50,140 --> 01:00:52,640
Вы можете выяснить это
вещи по своему усмотрению.

1288
01:00:52,640 --> 01:00:55,740
Но опять же, это может быть даже на грани
немного сверх того, что вам нужно знать для

1289
01:00:55,740 --> 01:00:58,000
объем этого среднесрочной перспективе -

1290
01:00:58,000 --> 01:00:59,070
или этот тест, а.

1291
01:00:59,070 --> 01:01:00,270
Извините.

1292
01:01:00,270 --> 01:01:03,770
>> Мы собираемся двигаться дальше, потому что я бы
нравится делать одну проблему кодирования

1293
01:01:03,770 --> 01:01:05,100
перед время истекло.

1294
01:01:05,100 --> 01:01:09,340
И мы собираемся запрограммировать то, что я думаю,
является наиболее убедительным из них

1295
01:01:09,340 --> 01:01:11,020
примеры, atoi.

1296
01:01:11,020 --> 01:01:14,520
Так что это был вопрос о
викторина два года назад.

1297
01:01:14,520 --> 01:01:17,810
И у меня есть его на доске здесь.

1298
01:01:17,810 --> 01:01:20,680
>> Люди спросили относительно викторины -

1299
01:01:20,680 --> 01:01:23,640
им дали немного больше tesxt в
вопрос, но я устранены

1300
01:01:23,640 --> 01:01:26,640
Текст, потому что это было ненужным
для наших целей сейчас.

1301
01:01:26,640 --> 01:01:29,180
Это было лишь некоторые фон
от того, что atoi сделал.

1302
01:01:29,180 --> 01:01:31,425
Но вы все знаете, и очень
знакомы с atoi.

1303
01:01:31,425 --> 01:01:35,620
>> Я предлагаю вам закодировать это
на листе бумаги.

1304
01:01:35,620 --> 01:01:39,310
Я также предлагаю вам использовать стратегию
что мы перешли

1305
01:01:39,310 --> 01:01:41,040
много в нашем разделе.

1306
01:01:41,040 --> 01:01:44,130
Во-первых, убедитесь, что вы понимаете,
что atoi делает.

1307
01:01:44,130 --> 01:01:47,580
Нарисуйте или придумать некоторые
мысленный образ него в голове.

1308
01:01:47,580 --> 01:01:51,120
Далее, выписать псевдокод для этого.

1309
01:01:51,120 --> 01:01:53,120
На викторине, если все, что вы получаете,
псевдокод, по крайней мере, вы

1310
01:01:53,120 --> 01:01:54,550
положить что-то вниз.

1311
01:01:54,550 --> 01:02:00,070
А потом отобразить эту псевдокод на
С. Если у вас есть чек в вашем

1312
01:02:00,070 --> 01:02:03,760
псевдокод, как проверить, если что-то
является 1, что отображается на, если

1313
01:02:03,760 --> 01:02:05,750
состояние и так далее.

1314
01:02:05,750 --> 01:02:07,850
И, наконец, код программы в С.

1315
01:02:07,850 --> 01:02:15,000
>> Так вернемся к atoi и занять пять минут
закодировать это на листе

1316
01:02:15,000 --> 01:02:19,480
бумага, которая, вероятно, о
количество времени, вы бы взять на

1317
01:02:19,480 --> 01:02:21,260
викторина для кодирования atoi.

1318
01:02:21,260 --> 01:02:27,060
От пяти до 15 минут, от пяти до 12, от пяти до
10 минут, о размере

1319
01:02:27,060 --> 01:02:30,150
раз, когда вы потратили бы на это
Вопрос в викторине.

1320
01:02:30,150 --> 01:02:31,670
Так что берите пять минут, пожалуйста.

1321
01:02:31,670 --> 01:02:35,957
И если у вас есть какие-либо вопросы, поднять
ваша рука, и я приду вокруг.

1322
01:02:35,957 --> 01:06:39,570

1323
01:06:39,570 --> 01:06:41,066
>> [SIDE БЕСЕДЫ]

1324
01:06:41,066 --> 01:08:35,279

1325
01:08:35,279 --> 01:08:37,580
>> Джейсон Хиршхорн: Итак,
что было пять минут.

1326
01:08:37,580 --> 01:08:39,880
Это было, вероятно, около размере
раз, когда вы потратили бы на том, что на викторине,

1327
01:08:39,880 --> 01:08:42,120
может быть, нижний предел того времени.

1328
01:08:42,120 --> 01:08:44,010
Мы будем Напомним в немного.

1329
01:08:44,010 --> 01:08:45,740
Начнем кодирования это.

1330
01:08:45,740 --> 01:08:49,479
И если мы не получаем все путем,
Ответы на этот и этот

1331
01:08:49,479 --> 01:08:54,189
вопрос викторины доступны, опять же,
Осень 2011, когда этот вопрос

1332
01:08:54,189 --> 01:08:54,913
появился на викторине.

1333
01:08:54,913 --> 01:08:57,830
>> И это стоило восемь очков
на викторине то.

1334
01:08:57,830 --> 01:09:01,140
Восемь очков находится на высоком конце
количество точек что-то стоит.

1335
01:09:01,140 --> 01:09:04,790
Большинство вопросов находятся в диапазоне
от одного до шести очков.

1336
01:09:04,790 --> 01:09:08,500
Так что это более сложным
Вопрос, конечно.

1337
01:09:08,500 --> 01:09:09,750
Кто-нибудь может начинайте меня?

1338
01:09:09,750 --> 01:09:13,260

1339
01:09:13,260 --> 01:09:15,380
>> Как правило, то, что мы собираемся
хотеть сделать с этим

1340
01:09:15,380 --> 01:09:17,550
функционировать atoi, логически?

1341
01:09:17,550 --> 01:09:19,569
Что мы хотим сделать?

1342
01:09:19,569 --> 01:09:22,279
Так что мы собираемся написать
некоторые псевдокод.

1343
01:09:22,279 --> 01:09:24,090
>> СТУДЕНТ: Преобразование символов
в целых числах.

1344
01:09:24,090 --> 01:09:26,700
>> Джейсон Хиршхорн: Преобразование символов
в целых числах.

1345
01:09:26,700 --> 01:09:27,479
ОК.

1346
01:09:27,479 --> 01:09:30,870
Так сколько символов мы
будете нуждаться, чтобы пройти?

1347
01:09:30,870 --> 01:09:32,295
>> СТУДЕНТ: Все из них.

1348
01:09:32,295 --> 01:09:34,100
>> СТУДЕНТ: Все персонажи
в строке.

1349
01:09:34,100 --> 01:09:35,540
>> Джейсон Хиршхорн: Все
символы в строке.

1350
01:09:35,540 --> 01:09:42,180
Так что, если мы хотели пойти через каждый
символ в строке, что это вещь,

1351
01:09:42,180 --> 01:09:44,560
в С мы видели, что позволило
нам пройти через каждый

1352
01:09:44,560 --> 01:09:45,939
символ в строке?

1353
01:09:45,939 --> 01:09:46,819
>> СТУДЕНТЫ: для петли.

1354
01:09:46,819 --> 01:09:48,069
>> Джейсон Хиршхорн: для петли.

1355
01:09:48,069 --> 01:09:52,020

1356
01:09:52,020 --> 01:09:55,330
Так что мы собираемся для перебора
каждый символ в с.

1357
01:09:55,330 --> 01:10:00,940
>> Тогда что мы будем хотеть сделать
когда мы получаем специфический характер?

1358
01:10:00,940 --> 01:10:02,480
Скажем, у нас вы получаете принял 90.

1359
01:10:02,480 --> 01:10:03,460
Мы получаем 9.

1360
01:10:03,460 --> 01:10:04,240
Это символ.

1361
01:10:04,240 --> 01:10:07,440
Что мы хотим сделать с
что характер 9?

1362
01:10:07,440 --> 01:10:10,082
>> СТУДЕНТ: вычесть его из характера 0?

1363
01:10:10,082 --> 01:10:11,860
>> СТУДЕНТ: Добавить 0?

1364
01:10:11,860 --> 01:10:13,350
>> Джейсон Хиршхорн: Вычтите
это от характера 0?

1365
01:10:13,350 --> 01:10:13,800
>> СТУДЕНТ: Да.

1366
01:10:13,800 --> 01:10:15,573
>> Джейсон Хиршхорн: Почему
Вы хотите это сделать?

1367
01:10:15,573 --> 01:10:16,560
>> СТУДЕНТ: [неразборчиво]

1368
01:10:16,560 --> 01:10:17,010
значение.

1369
01:10:17,010 --> 01:10:18,380
Его внутр значение.

1370
01:10:18,380 --> 01:10:21,580
>> Джейсон Хиршхорн: Итак, мы берем
характер 9, вычесть его из

1371
01:10:21,580 --> 01:10:25,820
характер 0, чтобы получить
фактическое целое 9.

1372
01:10:25,820 --> 01:10:27,070
Сладкий.

1373
01:10:27,070 --> 01:10:31,255

1374
01:10:31,255 --> 01:10:37,000
И как вы знаете, что характер
9 минус 0 персонаж 9?

1375
01:10:37,000 --> 01:10:39,222
Что диаграмма ты смотреть?

1376
01:10:39,222 --> 01:10:43,130
>> СТУДЕНТ: Есть логически девять
места между 9 и 0.

1377
01:10:43,130 --> 01:10:44,620
Или вы могли бы посмотреть на таблицу ASCII.

1378
01:10:44,620 --> 01:10:45,120
>> Джейсон Хиршхорн: таблица ASCII.

1379
01:10:45,120 --> 01:10:46,490
Но да, вы правы, а также.

1380
01:10:46,490 --> 01:10:47,780
Таким образом, мы вычитаем 0.

1381
01:10:47,780 --> 01:10:49,010
Так что теперь у нас есть целое 9.

1382
01:10:49,010 --> 01:10:49,970
И то, что мы хотим делать с этим?

1383
01:10:49,970 --> 01:10:54,970
Если у нас есть 90, это первое целое
мы, что мы хотим сделать?

1384
01:10:54,970 --> 01:10:58,180
>> СТУДЕНТ: я бы поставил во временном целого
массив, то сделать математику к нему

1385
01:10:58,180 --> 01:11:02,088
позже, чтобы сделать его в конце.

1386
01:11:02,088 --> 01:11:03,020
>> Джейсон Хиршхорн: ОК.

1387
01:11:03,020 --> 01:11:06,990
>> СТУДЕНТ: Вы можете начать в конце
массив, а затем двигаться вперед так

1388
01:11:06,990 --> 01:11:10,350
что каждый раз, когда вы двигаться вперед,
умножить его на 10.

1389
01:11:10,350 --> 01:11:10,830
>> Джейсон Хиршхорн: ОК.

1390
01:11:10,830 --> 01:11:12,250
Это звучит, как довольно
убедительные идея.

1391
01:11:12,250 --> 01:11:16,040
Мы можем начать в конце нашего массива,
и мы можем использовать strleng.

1392
01:11:16,040 --> 01:11:17,030
Мы можем использовать strleng здесь.

1393
01:11:17,030 --> 01:11:18,870
Мы получим длину нашей строки.

1394
01:11:18,870 --> 01:11:20,100
Мы начинаем в конце.

1395
01:11:20,100 --> 01:11:29,170
И + первый, мы просто считать, что
целое число, и, возможно, мы создаем как

1396
01:11:29,170 --> 01:11:32,270
Новый целая переменная наверху, где
мы сохраняем все.

1397
01:11:32,270 --> 01:11:37,340
Таким образом, мы петля через каждый символ вход с с
задом наперед, мы вычитаем 0, и

1398
01:11:37,340 --> 01:11:42,790
то возьмем его, и в зависимости от
где он находится, мы умножаем его

1399
01:11:42,790 --> 01:11:45,860
на степень 10.

1400
01:11:45,860 --> 01:11:50,644
Потому что первый, что мы
умножить крайнюю правую цифру по?

1401
01:11:50,644 --> 01:11:51,440
>> СТУДЕНТ: 10 к 0.

1402
01:11:51,440 --> 01:11:53,170
>> Джейсон Хиршхорн: 10 к 0.

1403
01:11:53,170 --> 01:11:56,010
Что Умножим второе
правый характер по?

1404
01:11:56,010 --> 01:11:57,450
>> СТУДЕНТ: [неразборчиво].

1405
01:11:57,450 --> 01:11:57,960
>> Джейсон Хиршхорн: Что?

1406
01:11:57,960 --> 01:11:59,150
>> СТУДЕНТ: 10 к 1.

1407
01:11:59,150 --> 01:12:00,420
>> Джейсон Хиршхорн: 10 к 1.

1408
01:12:00,420 --> 01:12:03,754
Третий-правый персонаж?

1409
01:12:03,754 --> 01:12:04,580
>> СТУДЕНТ: 10 к 2.

1410
01:12:04,580 --> 01:12:05,350
>> Джейсон Хиршхорн: 10 к 2.

1411
01:12:05,350 --> 01:12:07,200
>> СТУДЕНТ: Извините, я не понимаю,
что мы делаем здесь.

1412
01:12:07,200 --> 01:12:08,640
>> Джейсон Хиршхорн: ОК,
давайте вернемся, то.

1413
01:12:08,640 --> 01:12:12,500
Так что мы собираемся, чтобы получить
прошло в строке.

1414
01:12:12,500 --> 01:12:14,470
Потому что мы пишем atoi.

1415
01:12:14,470 --> 01:12:15,260
Таким образом, мы получить прошло в строке.

1416
01:12:15,260 --> 01:12:17,640
Скажем, у нас вы получаете прошло
в строке 90.

1417
01:12:17,640 --> 01:12:19,930
>> Первое, что мы собираемся сделать, это установить
новый целая переменная, что мы

1418
01:12:19,930 --> 01:12:22,150
просто хочу, чтобы создать
в качестве нашего нового целого числа.

1419
01:12:22,150 --> 01:12:24,630
Это то, что мы собираемся
вернуться в конце.

1420
01:12:24,630 --> 01:12:30,110
Мы должны пройти через каждый символ в
строка, потому что мы решили,

1421
01:12:30,110 --> 01:12:34,430
что мы должны коснуться каждого и
затем добавить его в наш новый целого числа.

1422
01:12:34,430 --> 01:12:36,330
>> Но мы не можем просто добавить его в виде числа.

1423
01:12:36,330 --> 01:12:38,270
Мы не можем просто взять 9 и
добавить 9 до нашей целого числа.

1424
01:12:38,270 --> 01:12:40,560
Это зависит от того, какое место
это в строке.

1425
01:12:40,560 --> 01:12:42,960
Мы собираемся нужно умножить
это на степень 10.

1426
01:12:42,960 --> 01:12:45,580
Потому что, как база 10 работ.

1427
01:12:45,580 --> 01:12:49,050
>> Так что мы собираемся, чтобы получить фактическое
характер, или фактический целое

1428
01:12:49,050 --> 01:12:53,860
число, путем вычитания характер 0
от характера 9, как мы сделали с

1429
01:12:53,860 --> 01:12:57,560
вычитания символов капитала из
любого характера мы имели в одном из

1430
01:12:57,560 --> 01:12:58,120
эти проблемы.

1431
01:12:58,120 --> 01:13:04,190
Поэтому мы на самом деле получить число от 0 до
9 сохранен как вещественное число, и мы будем

1432
01:13:04,190 --> 01:13:07,590
умножить его на степень 10 в зависимости
от того, где мы находимся в строку.

1433
01:13:07,590 --> 01:13:19,430

1434
01:13:19,430 --> 01:13:22,575
А потом мы собираемся добавить его обратно
в наш новый целой переменной.

1435
01:13:22,575 --> 01:13:32,840

1436
01:13:32,840 --> 01:13:37,890
>> Так что же это будет выглядеть будет
быть - мы будем рисовать здесь.

1437
01:13:37,890 --> 01:13:40,086
Если нас передаются в строке 90 -

1438
01:13:40,086 --> 01:13:41,336
>> СТУДЕНТ: [неразборчиво].

1439
01:13:41,336 --> 01:13:43,190

1440
01:13:43,190 --> 01:13:45,540
>> Джейсон Хиршхорн: Но
atoi принимает строку.

1441
01:13:45,540 --> 01:13:46,350
Так что мы собираемся пройти через
проведение.

1442
01:13:46,350 --> 01:13:49,900
Мы будем получить прошло 90.

1443
01:13:49,900 --> 01:13:51,540
Мы идем от задней к передней.

1444
01:13:51,540 --> 01:13:53,920
Берем 0.

1445
01:13:53,920 --> 01:13:55,080
>> СТУДЕНТ: Мне очень жаль.

1446
01:13:55,080 --> 01:13:55,880
Может быть, это глупо.

1447
01:13:55,880 --> 01:13:59,440
Если мы становимся прошло в строке,
почему 90 то, что мы

1448
01:13:59,440 --> 01:14:00,260
получать переданы в?

1449
01:14:00,260 --> 01:14:03,160
Поскольку 90 является целым числом.

1450
01:14:03,160 --> 01:14:06,820
>> Джейсон Хиршхорн: Потому что atoi берет
строка и превращает его в целое

1451
01:14:06,820 --> 01:14:08,320
представление этой строки.

1452
01:14:08,320 --> 01:14:13,650
Но строка 90 не целое число
90 или № 90.

1453
01:14:13,650 --> 01:14:17,920
Строка 90 является массивом из двух, или
три символа, скорее, 9

1454
01:14:17,920 --> 01:14:22,740
характер, 0 характер, и
обратный слеш 0 характер.

1455
01:14:22,740 --> 01:14:26,260
>> И мы пишем atoi потому, что для
Например, когда вы берете на себя команду

1456
01:14:26,260 --> 01:14:30,230
Аргумент линия, и она сохраняется в
агду, он сохраняется в виде строки.

1457
01:14:30,230 --> 01:14:32,940
Но если вы хотите, чтобы рассматривать его как числа,
вам нужно преобразовать его в

1458
01:14:32,940 --> 01:14:34,700
Фактическое число.

1459
01:14:34,700 --> 01:14:37,210
Который мы сделали одну из наших проблемных множеств.

1460
01:14:37,210 --> 01:14:38,800
Который мы сделали в ряде
из наших проблемных множеств.

1461
01:14:38,800 --> 01:14:41,690
Все, что взял целое
как аргумент командной строки.

1462
01:14:41,690 --> 01:14:46,490
Так вот почему наша функция atoi
принимает строку.

1463
01:14:46,490 --> 01:14:51,910
>> Итак, еще раз, в нашем примере, мы
собирается взять последний.

1464
01:14:51,910 --> 01:14:55,050
Мы собираемся вычесть характер
0 из него, потому что персонажи 0

1465
01:14:55,050 --> 01:14:58,810
вычитается по характеру 0 дает
фактическое число 0, в соответствии с

1466
01:14:58,810 --> 01:15:00,950
ASCII математика, что мы делаем.

1467
01:15:00,950 --> 01:15:04,870
>> Потому что персонажи представлены в виде
отличается от их фактическое -

1468
01:15:04,870 --> 01:15:08,830
характер, например,
в нижнем регистре 97.

1469
01:15:08,830 --> 01:15:10,260
Это не - ой!

1470
01:15:10,260 --> 01:15:13,290
Это не все, что можно было бы ожидать
чтобы это было, 0, например.

1471
01:15:13,290 --> 01:15:16,200
Таким образом, вы должны вычесть
характер, чтобы получить 0.

1472
01:15:16,200 --> 01:15:18,950
>> Так что мы собираемся сделать, что здесь
чтобы получить реальное число.

1473
01:15:18,950 --> 01:15:22,560
А потом мы собираемся умножить его на
степенью 10 в зависимости от того, где

1474
01:15:22,560 --> 01:15:27,030
находится в строку, а затем принять, что
и добавить его в наш заполнителя

1475
01:15:27,030 --> 01:15:32,520
переменная, чтобы мы могли придумать
наша окончательная новая целое.

1476
01:15:32,520 --> 01:15:35,080
Значит ли это, имеет смысл для всех?

1477
01:15:35,080 --> 01:15:37,730
>> Так что мы не собираемся, чтобы закодировать это
прямо сейчас, потому что мы

1478
01:15:37,730 --> 01:15:38,830
получать мало времени.

1479
01:15:38,830 --> 01:15:40,860
Я прошу прощения за сроках, что.

1480
01:15:40,860 --> 01:15:44,620
Но это то, что, как мы надеемся, вы бы
быть в состоянии сделать на викторине - на

1481
01:15:44,620 --> 01:15:47,710
крайней мере, получить этот псевдокод
выписали.

1482
01:15:47,710 --> 01:15:50,840
>> И потом, если бы мы должны были написать
псевдокод, на самом деле, мы могли бы сделать это

1483
01:15:50,840 --> 01:15:51,490
довольно быстро.

1484
01:15:51,490 --> 01:15:55,230
Каждая строка комментариев, которые мы мы писали
здесь переводится как о

1485
01:15:55,230 --> 01:15:56,970
одна линия C кода.

1486
01:15:56,970 --> 01:16:01,780
Объявление новую переменную, письма
петля, некоторые вычитание, некоторые

1487
01:16:01,780 --> 01:16:07,070
умножение, а некоторые назначение.

1488
01:16:07,070 --> 01:16:09,020
Мы бы, вероятно, также хотят, чтобы
написать обратную линию.

1489
01:16:09,020 --> 01:16:12,040
Мы могли бы также хочу поставить
некоторые проверки в здесь.

1490
01:16:12,040 --> 01:16:12,655
Да.

1491
01:16:12,655 --> 01:16:15,720
>> СТУДЕНТ: Так можем ли мы рассматривать
с как реальную строку?

1492
01:16:15,720 --> 01:16:18,730
Потому что я знаю, что это просто адрес.

1493
01:16:18,730 --> 01:16:22,090
Мол, как бы вы получить длину
строка передается через?

1494
01:16:22,090 --> 01:16:25,310
>> Джейсон Хиршхорн: Так как же
Длина строки?

1495
01:16:25,310 --> 01:16:25,830
STRLEN.

1496
01:16:25,830 --> 01:16:26,660
>> СТУДЕНТ: STRLEN, да.

1497
01:16:26,660 --> 01:16:30,550
Но вы можете положить сек как
Аргумент для этого?

1498
01:16:30,550 --> 01:16:34,620
>> Джейсон Хиршхорн: Так STRLEN
принимает символ звезду.

1499
01:16:34,620 --> 01:16:38,090
И следует, что сЬаг звезду, и это
продолжает отсчет, пока он не попадает в

1500
01:16:38,090 --> 01:16:41,865
обратный слеш 0. STRLEN было на самом деле
один из других программ, которые мы

1501
01:16:41,865 --> 01:16:42,850
собирались кода.

1502
01:16:42,850 --> 01:16:44,560
Вот еще один хороший один для кода.

1503
01:16:44,560 --> 01:16:47,270
Это один немного легче, потому что, если
Вы будете думать о том, что

1504
01:16:47,270 --> 01:16:47,830
концептуально -

1505
01:16:47,830 --> 01:16:51,620
Я только что сказал это вслух - STRLEN следующим
указатель и продолжает идти и

1506
01:16:51,620 --> 01:16:54,210
считая и не отслеживать до
вы достигнете обратную косую черту 0.

1507
01:16:54,210 --> 01:16:56,530
>> СТУДЕНТ: ОК, получил его.

1508
01:16:56,530 --> 01:17:00,200
>> Джейсон Хиршхорн: Так лучше
удачи на викторине 0 завтра.

1509
01:17:00,200 --> 01:17:03,170
Если у вас есть какие-либо вопросы, я буду
быть вне после этого.

1510
01:17:03,170 --> 01:17:05,610
Не стесняйтесь, пишите мне.

1511
01:17:05,610 --> 01:17:08,480
Обратитесь к вашему собственному TF, если вы
не в моем разделе, или получить мой

1512
01:17:08,480 --> 01:17:10,005
по электронной почте, если вы хотите его.

1513
01:17:10,005 --> 01:17:13,140
>> Если вы хотите волноваться и просто отправить
мне по электронной почте, Freakout письмо, я буду

1514
01:17:13,140 --> 01:17:16,710
отправить тебя обратно, как, улыбающееся лицо,
или, как, шутка или что-то.

1515
01:17:16,710 --> 01:17:18,190
Так что не стесняйтесь сделать это также.

1516
01:17:18,190 --> 01:17:20,750
Удачи снова, и я буду
видеть вас всех на следующей неделе.

1517
01:17:20,750 --> 01:17:23,435