1
00:00:00,000 --> 00:00:07,070
[Powered by Google Translate] [♪ ♪ Гуда]

2
00:00:07,070 --> 00:00:10,380
Таким образом, чтобы познакомить вас с того, что я встал на экране;

3
00:00:10,380 --> 00:00:12,710
это один из инструментов, которые мы разработали в течение лета;

4
00:00:12,710 --> 00:00:15,530
это называется CS50 пространства,

5
00:00:15,530 --> 00:00:18,860
и это наш совместный применения кодирования

6
00:00:18,860 --> 00:00:20,180
что мы собираемся использовать в секциях.

7
00:00:20,180 --> 00:00:22,470
Это очень здорово.

8
00:00:22,470 --> 00:00:26,040
Кто-нибудь из вас видел CS50 перспективе еще?

9
00:00:26,040 --> 00:00:29,760
Позвольте мне тянуть, что в другой вкладке.

10
00:00:29,760 --> 00:00:33,440
Run.cs50.net

11
00:00:33,440 --> 00:00:36,230
Так

12
00:00:36,230 --> 00:00:39,700
если вы идете в run.cs50.net,

13
00:00:39,700 --> 00:00:43,030
Вы можете увидеть это в Вашем браузере способом

14
00:00:43,030 --> 00:00:45,940
на самом деле код - написать код C,

15
00:00:45,940 --> 00:00:47,460
, а затем запустить его,

16
00:00:47,460 --> 00:00:50,960
так как компилирует его, запускает его, а затем возвращает результат для вас,

17
00:00:50,960 --> 00:00:53,350
так это вроде хороший способ, чтобы эксперимент

18
00:00:53,350 --> 00:00:56,060
с некоторыми из кода, что Дэвид переходит в лекциях

19
00:00:56,060 --> 00:00:58,640
и мы даем на вас по проблеме наборы

20
00:00:58,640 --> 00:01:01,900
, фактически не имея, чтобы запустить прибор.

21
00:01:01,900 --> 00:01:04,489
>> Так что пространства делает это отличается от

22
00:01:04,489 --> 00:01:07,450
если бы я вернуться к этой вкладке,

23
00:01:07,450 --> 00:01:11,580
Пространствах CS50 перспективе, как вы видите здесь,

24
00:01:11,580 --> 00:01:15,380
Но если мы прокручиваем снова и посмотреть на другую сторону окна,

25
00:01:15,380 --> 00:01:18,130
Вы видите право Я единственный человек в этом пространстве,

26
00:01:18,130 --> 00:01:21,030
но то, что я собираюсь сделать, это спросить вас, ребята присоединиться к этой космической со мной

27
00:01:21,030 --> 00:01:24,590
и мы все добраться до кода в том же окошке,

28
00:01:24,590 --> 00:01:26,070
совместно использовать код друг с другом,

29
00:01:26,070 --> 00:01:28,900
и говорить о различиях между нашим кодом.

30
00:01:28,900 --> 00:01:31,530
Так это вроде классная вещь -

31
00:01:31,530 --> 00:01:35,770
таким образом, чтобы присоединиться, если вы посетите эту ссылку прямо здесь, в верхнем

32
00:01:35,770 --> 00:01:38,980
что я выделил,

33
00:01:38,980 --> 00:01:53,860
Вы можете просто ввести в apps.cs50.net/spaces/vqcspSnO.

34
00:01:53,860 --> 00:01:56,610
>> Ладно, для начала,

35
00:01:56,610 --> 00:01:59,720
Я собираюсь дать вам немного тура этого.

36
00:01:59,720 --> 00:02:01,720
Мы собираемся сделать некоторые глупые кодирование с ним на первый,

37
00:02:01,720 --> 00:02:06,200
просто так, что всем становится своего рода почувствовать, что это такое,

38
00:02:06,200 --> 00:02:09,000
но то, что я сделал -

39
00:02:09,000 --> 00:02:11,830
или то, что я собираюсь сделать прямо здесь -

40
00:02:11,830 --> 00:02:13,480
Я собираюсь взять код, который я написал здесь,

41
00:02:13,480 --> 00:02:15,800
который, как вы видите прямо сейчас пусто;

42
00:02:15,800 --> 00:02:17,090
она ничего не делает.

43
00:02:17,090 --> 00:02:21,080
Это просто код плите котла, мы будем называть его.

44
00:02:21,080 --> 00:02:23,820
С небольшой список дел комментарий.

45
00:02:23,820 --> 00:02:27,850
Я собираюсь сохранить его, нажав эту кнопку Сохранить.

46
00:02:27,850 --> 00:02:30,190
И что, что делает это

47
00:02:30,190 --> 00:02:34,400
подчеркнул он здесь недолго - что пересмотр сохранить зеленое поле,

48
00:02:34,400 --> 00:02:37,570
А теперь, если вы будете искать меня в пространстве,

49
00:02:37,570 --> 00:02:40,340
нажатии мое имя,

50
00:02:40,340 --> 00:02:43,370
Вы можете видеть, что я получил этот пересмотр прямо здесь,

51
00:02:43,370 --> 00:02:45,490
и если вы щелкните по этой ревизии,

52
00:02:45,490 --> 00:02:48,240
она будет загрузить код в ваш пространства, тоже.

53
00:02:50,510 --> 00:02:54,160
>> Так уж все загружается код, что в свою пространства?

54
00:02:54,160 --> 00:02:57,810
Хорошо, если у вас еще нет, идти вперед и делать то,

55
00:02:57,810 --> 00:03:01,120
и то, что я хочу, чтобы вы парни делать в этом мало, чтобы делать-раздел

56
00:03:01,120 --> 00:03:05,940
это написать немного использовании Printf о себе,

57
00:03:05,940 --> 00:03:08,310
Так, например, я хотел бы написать

58
00:03:08,310 --> 00:03:12,270
Е ("Меня зовут Нейт");

59
00:03:15,140 --> 00:03:17,700
а потом я напишу

60
00:03:17,700 --> 00:03:21,660
"Я закончил в 2009 году

61
00:03:21,660 --> 00:03:24,440
Стэнфордский "

62
00:03:26,050 --> 00:03:28,390
и я хотел бы услышать о

63
00:03:28,390 --> 00:03:30,270
в каком году вы находитесь в школе,

64
00:03:30,270 --> 00:03:33,910
ли вы в колледже или школе бизнеса

65
00:03:33,910 --> 00:03:36,130
или другой школы Гарварда,

66
00:03:36,130 --> 00:03:39,200
то, что вы изучаете, если она неизвестна;

67
00:03:39,200 --> 00:03:41,290
если оно не известно, что это абсолютно здорово.

68
00:03:41,290 --> 00:03:45,170
Я не решить, пока я был в конце моего второго года.

69
00:03:46,910 --> 00:03:49,210
и тогда я бы также хотел знать

70
00:03:49,210 --> 00:03:51,610
ничего сумасшедшего вы хотите сказать мне, или

71
00:03:51,610 --> 00:03:54,790
что-то о классе или просто что-нибудь еще.

72
00:03:56,930 --> 00:04:00,370
Когда вы закончите писать, что с вашей маленькой Printf,

73
00:04:00,370 --> 00:04:03,480
если вы будете экономить пересмотре или, скорее,

74
00:04:03,480 --> 00:04:06,080
Сначала убедитесь, что вы можете запустить его

75
00:04:06,080 --> 00:04:10,640
и что она выдает именно то, что вы хотите, чтобы распечатать,

76
00:04:14,050 --> 00:04:16,399
, а затем, если вы идете дальше и сохранить эту ревизию

77
00:04:16,399 --> 00:04:21,600
с помощью кнопки Save Редакция, это первый маленький парень здесь,

78
00:04:24,080 --> 00:04:27,340
и мы любопытное пройти и сделать небольшое введение так.

79
00:04:27,340 --> 00:04:30,150
Поэтому вы должны достаточно лишь нажать кнопку воспроизведения,

80
00:04:30,150 --> 00:04:32,550
который здесь, на левом верхнем углу,

81
00:04:32,550 --> 00:04:35,340
так что эта кнопка Play в левом верхнем углу будет

82
00:04:35,340 --> 00:04:39,050
Написать код от нашего сервера, на котором он будет составлен, а затем запустить.

83
00:04:40,600 --> 00:04:43,300
Так что же любопытное ума от этого

84
00:04:43,300 --> 00:04:46,550
Этот код на самом деле не работает на Вашем компьютере;

85
00:04:46,550 --> 00:04:49,290
это на самом деле направляются через Интернет.

86
00:04:49,290 --> 00:04:51,240
>> Как дела, Шарлотта?

87
00:04:51,240 --> 00:04:54,810
>> Я - нормально. I'm - Я думаю, что я

88
00:04:54,810 --> 00:04:57,330
с трудностями сохранения

89
00:04:57,330 --> 00:05:00,530
на сервере так, что он может - я могу запустить программу.

90
00:05:02,090 --> 00:05:05,780
А потом, когда я пытаюсь запустить его, он говорит, что нет ошибки.

91
00:05:05,780 --> 00:05:08,850
Заявленный как вирус, который не находится в там больше.

92
00:05:08,850 --> 00:05:11,860
Ну, давайте посмотрим, можете ли вы ударить Сохранить снова?

93
00:05:11,860 --> 00:05:13,770
Я вижу его на экране.

94
00:05:13,770 --> 00:05:15,120
>> Право, хорошо, так это то, что у меня есть.

95
00:05:15,120 --> 00:05:19,430
И я не знаю, почему она не дает мне запустить его.

96
00:05:22,990 --> 00:05:24,990
Ну, ладно, прости.

97
00:05:27,930 --> 00:05:31,220
Можете ли вы объяснить, почему - то, что было не так - то, что не работает с ним?

98
00:05:31,220 --> 00:05:34,760
>> Да, потому что я не видел, что было последней строке, где еще есть переменные

99
00:05:34,760 --> 00:05:37,700
что я не объявил, что я не собирался за это время там.

100
00:05:37,700 --> 00:05:38,730
Да, отлично!

101
00:05:38,730 --> 00:05:40,390
>> Теперь, если я сохранить его, я думаю, он должен работать.

102
00:05:40,390 --> 00:05:42,970
Теперь, когда вы сохранили его, он работает; удивительным.

103
00:05:42,970 --> 00:05:44,570
>> Так что да, поскольку мы проходим -

104
00:05:44,570 --> 00:05:46,690
Так что же происходит,

105
00:05:46,690 --> 00:05:49,130
Я просто хочу повторить это на камеру.

106
00:05:49,130 --> 00:05:51,760
Происходящее было, что эта переменная с

107
00:05:51,760 --> 00:05:54,310
осталось после - Я предполагаю, что вы удалили некоторые другие вещи

108
00:05:54,310 --> 00:05:56,670
где вы объявлена,

109
00:05:56,670 --> 00:05:59,560
и таким образом, это было бросать вещи и не позволяя запустить его.

110
00:05:59,560 --> 00:06:02,540
Так что это именно то, что мы хотим сделать в разделе

111
00:06:02,540 --> 00:06:05,690
это были люди пытаются написания различных частей кода,

112
00:06:05,690 --> 00:06:08,490
компиляции, посмотреть, что работает, посмотрим, что нет,

113
00:06:08,490 --> 00:06:10,730
, а затем любопытное говорить об этих вещах, потому что эти отключения точек,

114
00:06:10,730 --> 00:06:12,850
Я до сих пор сталкиваемся,

115
00:06:12,850 --> 00:06:15,470
Я до сих пор - я делаю много глупых вещей все время,

116
00:06:15,470 --> 00:06:17,820
и я не знаю, почему он не работает,

117
00:06:17,820 --> 00:06:22,960
так что давайте подтянуть пересмотра Шарлотта 3,

118
00:06:23,980 --> 00:06:25,380
и мы будем его запуска.

119
00:06:25,380 --> 00:06:28,950
>> Поэтому, когда я бегу, теперь, когда я получила свой код сюда,

120
00:06:28,950 --> 00:06:31,450
Я могу увеличить, нажмите кнопку Выполнить,

121
00:06:31,450 --> 00:06:33,680
загружает его, строит, управляет им,

122
00:06:33,680 --> 00:06:36,980
говорит, что с успехом прошла, и если я прокрутите вниз,

123
00:06:36,980 --> 00:06:39,440
см. Шарлотта Адамс младший в доме,

124
00:06:39,440 --> 00:06:42,720
психология, вторичный в экономике; удивительным.

125
00:06:42,720 --> 00:06:44,310
Великий встретиться с вами!

126
00:06:44,310 --> 00:06:46,550
Awesome.

127
00:06:46,550 --> 00:06:49,670
Ладно, идем дальше, давайте пойдем к Даниилу,

128
00:06:49,670 --> 00:06:52,710
перейти к пересмотру 3,

129
00:06:52,710 --> 00:06:54,180
компилировать, запускать;

130
00:06:54,180 --> 00:06:56,680
Почему бы вам не рассказать нам немного о себе, Даниил?

131
00:06:56,680 --> 00:06:59,380
>> Позвони мне дан.

132
00:06:59,380 --> 00:07:01,920
Я иду в бизнес-школу через дорогу от вас, ребята,

133
00:07:01,920 --> 00:07:05,020
и я был в морской пехоте, прежде чем здесь,

134
00:07:05,020 --> 00:07:08,020
и это все ново для меня, так что да.

135
00:07:08,020 --> 00:07:11,060
Не чувствуйте себя плохо, мне 30 и я не знаю ни одной из этих вещей.

136
00:07:11,060 --> 00:07:13,800
Высокий, спасибо, Dan!

137
00:07:13,800 --> 00:07:17,300
Все в порядке, мы получили другой Даниила.

138
00:07:17,300 --> 00:07:20,930
Вы идете Даниэль - вы представить себе, Даниэль?

139
00:07:20,930 --> 00:07:22,260
>> >> Конечно, я Даниил.

140
00:07:22,260 --> 00:07:24,330
Я на втором курсе Mather прямо сейчас.

141
00:07:24,330 --> 00:07:25,840
Я сосредоточен на правительство,

142
00:07:25,840 --> 00:07:28,760
Но я хотел взять CS50, потому что я слышал отличные отзывы о классе

143
00:07:28,760 --> 00:07:30,750
и я никогда не пробовал CS раньше.

144
00:07:30,750 --> 00:07:34,680
Выделите сюда и показать это - круто.

145
00:07:36,330 --> 00:07:39,090
Двигаемся дальше, Джаред.

146
00:07:39,090 --> 00:07:41,990
Как дела?

147
00:07:41,990 --> 00:07:43,430
>> Хорошо, как вы?

148
00:07:43,430 --> 00:07:47,520
Как вы можете видеть, я младший концентратор философии в Элиот,

149
00:07:47,520 --> 00:07:50,260
родом из южной Калифорнии,

150
00:07:50,260 --> 00:07:53,100
и я заинтересован в принятии CS50 потому что мне нравится логика его,

151
00:07:53,100 --> 00:07:57,420
и, кажется, действительно здорово сделать что-то на компьютере, так.

152
00:07:57,420 --> 00:07:59,570
Высокий, где в южной Калифорнии вы?

153
00:07:59,570 --> 00:08:02,340
>> О часе езды от [неразборчиво], небольшом городе [неразборчиво].

154
00:08:02,340 --> 00:08:04,850
О, да, мой отец из Redlands.

155
00:08:04,850 --> 00:08:07,060
Прикольных вещей.

156
00:08:07,060 --> 00:08:12,130
>> Ладно, Джимми, как дела, Джимми?

157
00:08:12,130 --> 00:08:15,130
>> Хорошо, как вы?

158
00:08:15,130 --> 00:08:16,040
Делая очень хорошо!

159
00:08:16,040 --> 00:08:17,710
Расскажите нам о себе.

160
00:08:17,710 --> 00:08:20,840
>> Я новичок, и я не совсем уверен, что я по специальности

161
00:08:20,840 --> 00:08:22,820
но я своего рода склоняется к экономике.

162
00:08:22,820 --> 00:08:25,680
Как Daniel до меня, я никогда не делал никаких CS, но звучит круто.

163
00:08:25,680 --> 00:08:28,120
Я родом из Чикаго.

164
00:08:28,120 --> 00:08:31,640
Awesome. Так проверьте его распечатки здесь.

165
00:08:31,640 --> 00:08:34,630
Я хотел спросить, сделали это печать, как вы ожидали?

166
00:08:34,630 --> 00:08:37,650
>> Нет, я забыл распечатать новую строку.

167
00:08:37,650 --> 00:08:41,270
Я на самом деле забыл, что, когда я писал свое дело

168
00:08:41,270 --> 00:08:43,090
в первый раз, тоже.

169
00:08:43,090 --> 00:08:46,330
Это своего рода боль, чтобы не забудьте положить эти вручную.

170
00:08:46,330 --> 00:08:50,560
Было бы неплохо, если бы он просто знаю, что то, что Вы хотели.

171
00:08:50,560 --> 00:08:53,630
>> Хорошо, Келли.

172
00:08:53,630 --> 00:08:56,050
Ничего себе, у нас есть 2 Kellys, 2 Daniels, 2 Kellys.

173
00:08:56,050 --> 00:09:00,490
Так Kelly - вы идете Келли Ren?

174
00:09:00,490 --> 00:09:03,870
Хорошо, удивительный.

175
00:09:03,870 --> 00:09:07,270
Или Келли, я имею в виду.

176
00:09:07,270 --> 00:09:10,260
>> Так что да, поэтому я Келли.

177
00:09:10,260 --> 00:09:12,930
Я на втором курсе Pfoho.

178
00:09:12,930 --> 00:09:17,000
Я получил электронную почту сегодня, что меня все еще есть 7 недель объявить мою концентрацию,

179
00:09:17,000 --> 00:09:20,940
поэтому я стараюсь не думать об этом,

180
00:09:20,940 --> 00:09:24,090
и мне нравится выпечка, работает, и Craisins.

181
00:09:24,090 --> 00:09:29,110
У меня нет опыта с большинством CS;

182
00:09:29,110 --> 00:09:32,700
Я сам научился создавать веб-сайты, когда я был очень молод,

183
00:09:32,700 --> 00:09:35,750
Но я думаю, что я, вероятно, научил себя неправильно много раз.

184
00:09:35,750 --> 00:09:39,260
Надеюсь, я буду учиться немного больше

185
00:09:39,260 --> 00:09:41,450
и - да.

186
00:09:41,450 --> 00:09:44,100
>> Высокий, хорошо, спасибо.

187
00:09:44,100 --> 00:09:47,190
Пойдем в другую Келли;

188
00:09:47,190 --> 00:09:48,880
Я ничего не имею - ты сказал что-то здесь?

189
00:09:48,880 --> 00:09:51,880
>> [Неразборчиво]

190
00:09:51,880 --> 00:09:56,180
Там это!

191
00:09:56,180 --> 00:09:58,120
Sweet!

192
00:09:58,120 --> 00:10:01,400
>> Ладно, так что я Келли.

193
00:10:01,400 --> 00:10:03,980
Я первый год аспирант.

194
00:10:03,980 --> 00:10:05,560
Я по специальности разума, мозга и образования.

195
00:10:05,560 --> 00:10:07,940
Я закончил в Franklin & Marshall College в 2008 году

196
00:10:07,940 --> 00:10:10,840
со специализацией в области психологии и социологии

197
00:10:10,840 --> 00:10:13,120
и незначительное по-французски.

198
00:10:13,120 --> 00:10:15,330
Я беру CS50

199
00:10:15,330 --> 00:10:18,080
потому что я заинтересован в том, чтобы кандидат в неврологии

200
00:10:18,080 --> 00:10:21,220
и я чувствую, что это поможет мне понять, используемых технологий.

201
00:10:21,220 --> 00:10:23,150
Awesome.

202
00:10:26,980 --> 00:10:29,390
Двигаемся дальше, Микаэла.

203
00:10:29,390 --> 00:10:31,640
Это правильное произношение?

204
00:10:31,640 --> 00:10:32,990
Хорошо, удивительный.

205
00:10:32,990 --> 00:10:34,640
>> >> Я Михаила.

206
00:10:34,640 --> 00:10:36,870
Я на втором курсе в Kirkland House,

207
00:10:36,870 --> 00:10:39,950
и я сосредоточен в области машиностроения.

208
00:10:39,950 --> 00:10:43,180
Мне очень нравится езда на велосипеде, построенный на велосипеде летом этого года.

209
00:10:43,180 --> 00:10:46,140
Я беру CS, на самом деле,

210
00:10:46,140 --> 00:10:48,350
как концентрация требование,

211
00:10:48,350 --> 00:10:52,550
Но вы знаете, я думаю, это еще прохладно рода инженерные класса.

212
00:10:52,550 --> 00:10:55,150
Awesome - Вы построили велосипед этим летом?

213
00:10:55,150 --> 00:10:56,730
>> Да.

214
00:10:56,730 --> 00:10:58,900
Ух ты, как рама и все такое?

215
00:10:58,900 --> 00:11:00,120
>> Э-э-hunh (положительный).

216
00:11:00,120 --> 00:11:01,530
Ничего себе, это действительно здорово.

217
00:11:01,530 --> 00:11:06,370
>> [Неразборчиво кадром чат]

218
00:11:06,370 --> 00:11:10,000
[Смех]

219
00:11:12,640 --> 00:11:14,200
Да, это было так давно.

220
00:11:14,200 --> 00:11:16,730
Вы никогда не знаете, верно?

221
00:11:16,730 --> 00:11:19,420
Ну, прохладном, хорошо, спасибо, Михаила.

222
00:11:19,420 --> 00:11:21,390
>> Ладно, Мисси.

223
00:11:21,390 --> 00:11:23,280
>> Меня зовут Мисси, я на первом курсе,

224
00:11:23,280 --> 00:11:25,500
так, значит, я ничего не знаю!

225
00:11:25,500 --> 00:11:29,180
Я хочу сконцентрироваться в астрофизике.

226
00:11:29,180 --> 00:11:31,220
В CS50,

227
00:11:31,220 --> 00:11:33,350
Я чувствую, что, безусловно, поможет в этом.

228
00:11:33,350 --> 00:11:37,750
Странный факт обо мне, я национальном сертифицированный пожарный.

229
00:11:37,750 --> 00:11:39,960
Вот это да!

230
00:11:39,960 --> 00:11:42,440
Как это случилось?

231
00:11:42,440 --> 00:11:45,570
>> Я посетил Академию

232
00:11:45,570 --> 00:11:49,000
и прошел через ад для многих недель

233
00:11:49,000 --> 00:11:51,200
и получил сертификацию.

234
00:11:51,200 --> 00:11:54,090
Ого, поздравляю!

235
00:11:54,090 --> 00:11:57,280
Это не маленький подвиг, конечно.

236
00:11:57,280 --> 00:11:59,070
Итак, теперь мы будем делать мне.

237
00:11:59,070 --> 00:12:01,290
Я следующий в ряду.

238
00:12:01,290 --> 00:12:04,510
I'm - запустите его.

239
00:12:04,510 --> 00:12:07,580
>> Так меня зовут Нейт.

240
00:12:07,580 --> 00:12:11,160
Я был класс 2009 года в Стэнфорде.

241
00:12:11,160 --> 00:12:13,840
Я был символических систем крупных,

242
00:12:13,840 --> 00:12:17,370
который похож на разум, мозг, поведение концентрации здесь,

243
00:12:17,370 --> 00:12:19,300
но это своего рода смесь

244
00:12:19,300 --> 00:12:22,350
информатики, лингвистики, психологии и философии.

245
00:12:22,350 --> 00:12:26,600
Вид - Да, много странных вещей, но это было здорово,

246
00:12:26,600 --> 00:12:29,880
а потом я сделал магистра в области компьютерных наук там, как хорошо.

247
00:12:29,880 --> 00:12:33,250
Так что я новичок в Гарварде в этом году.

248
00:12:33,250 --> 00:12:35,750
Я действительно хотел, чтобы попасть в обучении.

249
00:12:35,750 --> 00:12:39,860
Я провел последние 4 года в Стэнфордском TA-ING классы информатики

250
00:12:39,860 --> 00:12:43,370
и так Дэвидом позвольте мне давай,

251
00:12:43,370 --> 00:12:45,550
и я собираюсь быть помочь с CS50,

252
00:12:45,550 --> 00:12:47,890
так я делаю это полная, я не в аспирантуру.

253
00:12:47,890 --> 00:12:50,330
Это было весело.

254
00:12:50,330 --> 00:12:53,130
Надеемся, что она будет продолжать быть весело, и я уверен, что это будет.

255
00:12:53,130 --> 00:12:56,040
>> Все в порядке, Сэм.

256
00:13:01,910 --> 00:13:05,470
>> Меня зовут Сэм, я на втором курсе в колледже, в законе конкретно.

257
00:13:05,470 --> 00:13:10,110
Моя главная будет история науки, наверное, и VES вторичные,

258
00:13:10,110 --> 00:13:13,240
и мой любимый цвет желтый.

259
00:13:18,790 --> 00:13:21,100
Не нужно судить или что-нибудь, но это хороший цвет!

260
00:13:21,100 --> 00:13:24,780
И Стелла.

261
00:13:24,780 --> 00:13:26,980
>> Привет, я Стелла, я новичок в серых.

262
00:13:26,980 --> 00:13:30,070
Я понятия не имею, что я сосредоточен в ранее,

263
00:13:30,070 --> 00:13:32,500
так CS50 была просто какая-то случайная,

264
00:13:32,500 --> 00:13:34,220
что интересно.

265
00:13:34,220 --> 00:13:36,080
Интересный факт, Джимми был первым другом Гарвардского мой,

266
00:13:36,080 --> 00:13:38,360
потому что мы оба из Чикаго.

267
00:13:38,360 --> 00:13:42,450
Cool, и грация - который должен быть действительно хорошим, правильно?

268
00:13:42,450 --> 00:13:45,220
>> Я думал, [неразборчиво].

269
00:13:45,220 --> 00:13:46,690
О, да.

270
00:13:46,690 --> 00:13:51,210
[Неразборчиво / выключения камеры чат]

271
00:13:51,210 --> 00:13:54,420
Ладно, я все еще учусь, все еще учусь.

272
00:13:54,420 --> 00:13:57,800
>> Таким образом, у нас есть кое-что еще, что это довольно интересно здесь.

273
00:13:59,600 --> 00:14:02,870
Да, мне просто интересно, у вас есть идея, что здесь происходит?

274
00:14:02,870 --> 00:14:05,890
Вы знаете, как это интерпретировать?

275
00:14:05,890 --> 00:14:13,340
>> Я должен был поставить точку с запятой после каждой строки.

276
00:14:13,340 --> 00:14:16,370
Это своего рода боль.

277
00:14:16,370 --> 00:14:19,100
Иногда эти точки с запятой может быть реальной боли отследить.

278
00:14:19,100 --> 00:14:21,420
Таким образом, получается, что

279
00:14:21,420 --> 00:14:22,820
специальной программы мы используем в этом году

280
00:14:22,820 --> 00:14:26,670
скомпилировать код C называется Clang,

281
00:14:26,670 --> 00:14:29,460
и по этой причине мы начали использовать Clang в этом году -

282
00:14:29,460 --> 00:14:32,030
потому что мы не использовали эту программу в прошлом;

283
00:14:32,030 --> 00:14:35,710
Мы использовали другой называется GCC, что это действительно популярным -

284
00:14:35,710 --> 00:14:38,420
Clang самом деле дает вам сообщения об ошибках, которые имеют смысл.

285
00:14:38,420 --> 00:14:41,420
Это один говорит: "ожидается"; "после выражения",

286
00:14:41,420 --> 00:14:45,260
и он даже говорит вам, выражения, после чего вам нужна точка с запятой.

287
00:14:45,260 --> 00:14:47,830
Так вы ее исправление?

288
00:14:47,830 --> 00:14:48,930
>> Да, прямо сейчас.

289
00:14:48,930 --> 00:14:52,040
Высокий, дайте мне знать, и мы будем потяните его вверх, и мы будем его запуска.

290
00:14:52,040 --> 00:14:55,830
Но да, положив эти точки с запятой в это вид боли.

291
00:14:55,830 --> 00:14:59,580
>> Я установил его, так что я думаю, что это должно работать.

292
00:14:59,580 --> 00:15:02,760
Awesome - пересмотр 3.

293
00:15:02,760 --> 00:15:05,250
Это похоже на это.

294
00:15:05,250 --> 00:15:08,580
Ладно, так что теперь, если мы запустим его,

295
00:15:08,580 --> 00:15:11,020
там она идет.

296
00:15:11,020 --> 00:15:13,830
Прикольных вещей.

297
00:15:13,830 --> 00:15:15,340
>> Хорошо.

298
00:15:15,340 --> 00:15:18,230
Так что спасибо за это.

299
00:15:18,230 --> 00:15:20,210
Это здорово встретиться с вами, ребята.

300
00:15:20,210 --> 00:15:22,880
То, что мы собираемся сделать сейчас, это провести следующий немного

301
00:15:22,880 --> 00:15:24,740
своего рода погружение в разделе проблемы

302
00:15:24,740 --> 00:15:27,550
, которые приходят от поставленной задачи из этой неделе

303
00:15:27,550 --> 00:15:29,920
и мы сделаем все, что для большинства из разделов

304
00:15:29,920 --> 00:15:32,110
за оставшуюся часть срока,

305
00:15:32,110 --> 00:15:35,580
и тогда мы спасем последние 15, 20 минут или около того

306
00:15:35,580 --> 00:15:38,490
говорить о проблеме ставит перед собой

307
00:15:38,490 --> 00:15:41,420
, а затем просто любые другие вопросы вы имеете в целом о классе.

308
00:15:43,380 --> 00:15:45,670
Тем не менее, то, что мы действительно хотим сделать

309
00:15:45,670 --> 00:15:49,390
это было всем участвующим

310
00:15:49,390 --> 00:15:51,500
использование пространства материал,

311
00:15:51,500 --> 00:15:53,500
бросали в коде, бросая в предложения,

312
00:15:53,500 --> 00:15:56,500
и говорить о том, когда такие вещи перерыв

313
00:15:56,500 --> 00:15:58,360
или не работают, только потому, что эти вещи, которые

314
00:15:58,360 --> 00:16:00,870
Я знаю, я наткнулся на

315
00:16:00,870 --> 00:16:03,180
Когда я начал кодирования,

316
00:16:03,180 --> 00:16:05,490
и были действительно любопытное разочарование в разы

317
00:16:05,490 --> 00:16:08,690
потому что, если это как 2 утра перед проблемой набора объясняется,

318
00:16:08,690 --> 00:16:11,330
так что - только для раскрытия,

319
00:16:11,330 --> 00:16:14,590
Я не начать программирование, пока я был на втором курсе в колледже.

320
00:16:14,590 --> 00:16:17,360
Это была какая-то странная, неизвестная вещь

321
00:16:17,360 --> 00:16:20,360
что я услышал, было круто

322
00:16:20,360 --> 00:16:23,590
и я также слышал, это может быть реальная боль в приклад

323
00:16:23,590 --> 00:16:27,610
если вы пропустили точку с запятой, и это только ошибка сохранения вашей программы от работы

324
00:16:27,610 --> 00:16:30,890
и держать вас в спящий режим,

325
00:16:30,890 --> 00:16:32,650
так определенно,

326
00:16:32,650 --> 00:16:34,020
если у вас есть вопросы, как, что,

327
00:16:34,020 --> 00:16:37,060
если у вас есть проблемы, как, что, дайте мне знать,

328
00:16:37,060 --> 00:16:40,050
потому что я хочу, чтобы это хороший опыт для вас, ребята.

329
00:16:40,050 --> 00:16:44,620
>> Так что вы, ребята, все загруженные задачу, поставленную еще?

330
00:16:44,620 --> 00:16:47,160
Своего рода знаете, где это? Хорошо.

331
00:16:47,160 --> 00:16:51,490
Таким образом, мы поедем в cs50.net, потому что я его не имеют на этот счет,

332
00:16:51,490 --> 00:16:54,110
подтянуть проблемы наборы,

333
00:16:54,110 --> 00:16:57,940
подтянуть проблема набора 2, и мы будем смотреть на стандартное издание Сегодня.

334
00:16:57,940 --> 00:17:01,190
Мы будем тянуть до спецификация здесь.

335
00:17:02,640 --> 00:17:04,420
Прокрутка вниз.

336
00:17:06,790 --> 00:17:11,109
Таким образом, мы собираемся начать смотреть на эту часть вопроса.

337
00:17:14,069 --> 00:17:16,710
Разве вы, ребята, смотрели эти шорты еще?

338
00:17:16,710 --> 00:17:18,329
Хорошо.

339
00:17:18,329 --> 00:17:21,329
Таким образом, есть шорты на петлях,

340
00:17:21,329 --> 00:17:24,700
которая осуществляется путем Томми, один из парней голова обучения.

341
00:17:24,700 --> 00:17:27,230
Там один на область,

342
00:17:27,230 --> 00:17:30,530
Я считаю, сделано еще одно учение парень по имени Дэвид

343
00:17:30,530 --> 00:17:33,400
, а затем один на Caesar Cipher также сделал Дэвид.

344
00:17:33,400 --> 00:17:35,550
Они довольно прохладно.

345
00:17:35,550 --> 00:17:37,770
Разве вы, ребята наблюдали за свои шорты до сих пор?

346
00:17:37,770 --> 00:17:39,270
Кстати, как они были?

347
00:17:39,270 --> 00:17:41,490
Полезные? Ладно, хорошо знаю.

348
00:17:41,490 --> 00:17:44,210
Если это не так, можно сказать и так.

349
00:17:46,290 --> 00:17:49,870
Но прежде чем вы это сделаете,

350
00:17:49,870 --> 00:17:52,600
вы, ребята посмотрели на эти вопросы

351
00:17:52,600 --> 00:17:55,430
на всех?

352
00:17:55,430 --> 00:17:57,480
>> Давайте поговорим об этом немного.

353
00:17:57,480 --> 00:18:00,600
Таким образом, мы ввели за последние пару недель

354
00:18:00,600 --> 00:18:02,480
В лекции

355
00:18:02,480 --> 00:18:04,910
количество различных циклов.

356
00:18:04,910 --> 00:18:06,140
Там в цикл,

357
00:18:06,140 --> 00:18:09,570
время цикла, а затем сделай то время как цикл,

358
00:18:09,570 --> 00:18:13,100
и в лекции, мы много говорили о

359
00:18:13,100 --> 00:18:16,010
как эти петли все

360
00:18:16,010 --> 00:18:18,320
довольно похожи во многих отношениях

361
00:18:18,320 --> 00:18:21,210
и вы можете многое сделать то же самое с какое-то время цикла

362
00:18:21,210 --> 00:18:23,260
что вы можете с цикла.

363
00:18:23,260 --> 00:18:26,300
Вы просто должны вида использования правильных комбинаций переменных и тому подобное.

364
00:18:26,300 --> 00:18:28,680
и так на самом деле

365
00:18:28,680 --> 00:18:31,200
реальное различие между всеми петель является то, что

366
00:18:31,200 --> 00:18:33,620
Иногда они более полезны

367
00:18:33,620 --> 00:18:36,930
использовать их в одно время, чем в другое время.

368
00:18:36,930 --> 00:18:39,340
>> Так, например,

369
00:18:39,340 --> 00:18:42,260
в то время как цикл отличается от DO-цикла.

370
00:18:42,260 --> 00:18:45,680
Все ли чувствуют, что они имеют хорошие ручки, когда

371
00:18:45,680 --> 00:18:48,650
Сделай то время как цикл более

372
00:18:48,650 --> 00:18:50,990
полезно или в чем разница?

373
00:18:50,990 --> 00:18:53,410
>> Я думаю, что разница сделай то время как цикл

374
00:18:53,410 --> 00:18:56,960
работает - я не знаю совсем то, что терминология,

375
00:18:56,960 --> 00:18:59,750
но ряд функций внутри цикла.

376
00:18:59,750 --> 00:19:02,020
Они автоматически - он делает свою выполняется по крайней мере

377
00:19:02,020 --> 00:19:05,390
Перед проверяет состояние, или в то время как цикл будет работать только, когда

378
00:19:05,390 --> 00:19:08,290
он постоянно работает - или нет условие удовлетворяется.

379
00:19:08,290 --> 00:19:11,010
Да, не в этом смысл?

380
00:19:11,010 --> 00:19:14,200
>> Давайте посмотрим на немного кода.

381
00:19:14,200 --> 00:19:16,930
Так что просто повторить вопрос,

382
00:19:16,930 --> 00:19:19,230
или ответ, а;

383
00:19:19,230 --> 00:19:22,050
Ответ был, что

384
00:19:22,050 --> 00:19:25,850
время цикла будет проверять, если условие

385
00:19:25,850 --> 00:19:27,440
что вы указали, встретились

386
00:19:27,440 --> 00:19:31,320
перед выполнением тела цикла в первый раз,

387
00:19:31,320 --> 00:19:35,000
а сделай то время как цикл будет автоматически запускаться тело цикла,

388
00:19:35,000 --> 00:19:38,450
Мы называем его - это странно терминологии,

389
00:19:38,450 --> 00:19:41,460
но если я когда-нибудь говорил, что не имеет смысла, дайте мне знать -

390
00:19:41,460 --> 00:19:45,360
Тело цикла является то, что вещи, которые вы положите между фигурными скобками.

391
00:19:45,360 --> 00:19:47,840
И сделай то время как цикл,

392
00:19:47,840 --> 00:19:50,220
, что тело получают бежать по меньшей мере один раз,

393
00:19:50,220 --> 00:19:54,460
и тогда условие получает проверил перед выполнением каждого последующего времени.

394
00:19:54,460 --> 00:19:56,580
>> Таким образом, на самом деле, Сэм,

395
00:19:56,580 --> 00:20:00,820
Вы не возражаете написание простого в то время как петля

396
00:20:00,820 --> 00:20:02,840
в пространствах?

397
00:20:02,840 --> 00:20:05,600
>> Как вы вроде как

398
00:20:05,600 --> 00:20:07,060
сделать новую ...?

399
00:20:07,060 --> 00:20:09,220
Я просто удалить все, что вы там.

400
00:20:09,220 --> 00:20:11,300
Да, просто снимите ее.

401
00:20:11,300 --> 00:20:14,510
>> Ну, я считаю, у меня это -

402
00:20:14,510 --> 00:20:16,640
какой из них вы хотите, в то время как, или вы хотите ...?

403
00:20:16,640 --> 00:20:19,350
Да, просто в то время как истинные, распечатать что-то.

404
00:20:21,050 --> 00:20:23,140
И давайте посмотрим.

405
00:20:23,140 --> 00:20:25,850
Александр, я понял, что мы никогда не познакомили вас.

406
00:20:25,850 --> 00:20:27,510
>> О, это прекрасно.

407
00:20:27,510 --> 00:20:30,760
Вы - можете ли вы код до сделай то время как цикл для нас?

408
00:20:30,760 --> 00:20:32,520
>> Да, я попробую.

409
00:20:32,520 --> 00:20:34,370
Все в порядке, мы просто тянуть эти на экране,

410
00:20:34,370 --> 00:20:38,240
так что вы вроде есть ручка, что различия.

411
00:20:38,240 --> 00:20:41,280
>> Итак, вот что Сэм сделал.

412
00:20:41,280 --> 00:20:44,460
У него есть целое число, называемое я

413
00:20:44,460 --> 00:20:47,480
что он инициализирован до 17 лет.

414
00:20:47,480 --> 00:20:51,570
Затем он говорит, в то время как (INT я = 17)

415
00:20:51,570 --> 00:20:54,230
Е ("Меня зовут Сэм.");

416
00:20:54,230 --> 00:20:57,300
Так что же происходит, когда мы запустим этот код?

417
00:20:57,300 --> 00:21:00,340
Там в ошибке, что же ошибки сказать?

418
00:21:00,340 --> 00:21:02,890
Давайте потяните его вверх, и говорить об этом.

419
00:21:02,890 --> 00:21:05,040
Произошла ошибка, он говорит.

420
00:21:05,040 --> 00:21:07,400
Давайте прокрутки вниз.

421
00:21:07,400 --> 00:21:09,460
Таким образом, он дал нам эту ошибку, и она сказала:

422
00:21:09,460 --> 00:21:12,690
"Эй, я ожидал выражения".

423
00:21:12,690 --> 00:21:16,180
Это своего рода загадочным.

424
00:21:19,160 --> 00:21:23,140
Да, именно так - и снова,

425
00:21:23,140 --> 00:21:27,140
там будет еще одна маленькая ошибка, что мы будем ловить только в секунду.

426
00:21:27,140 --> 00:21:31,800
Но это еще один из тех странные вещи терминологии,

427
00:21:31,800 --> 00:21:36,150
так что это Int я = 17

428
00:21:36,150 --> 00:21:39,290
не является выражением.

429
00:21:39,290 --> 00:21:41,220
Что, похоже, он делает, это

430
00:21:41,220 --> 00:21:43,410
объявив целое число, называемое я

431
00:21:43,410 --> 00:21:45,540
и установив его равным до 17

432
00:21:45,540 --> 00:21:48,780
или, скорее, положив 17 в, что называется Int я.

433
00:21:50,560 --> 00:21:53,350
И это не имеет смысла

434
00:21:53,350 --> 00:21:55,790
В контексте этого цикла.

435
00:21:55,790 --> 00:21:58,190
Это не имеет смысла, как мы увидим,

436
00:21:58,190 --> 00:22:01,250
в контексте цикла, потому что для этого цикла деклараций начать

437
00:22:01,250 --> 00:22:05,800
с, что для внутр равно я что-то

438
00:22:05,800 --> 00:22:07,830
и идет дальше.

439
00:22:07,830 --> 00:22:09,500
>> Так же вы -

440
00:22:09,500 --> 00:22:12,630
что-то исправить, все в порядке.

441
00:22:12,630 --> 00:22:15,270
Вот он идет, удивительный.

442
00:22:15,270 --> 00:22:17,920
Так что теперь все выглядит немного иначе.

443
00:22:17,920 --> 00:22:19,030
Несколько вещей изменилось.

444
00:22:19,030 --> 00:22:21,300
Можете ли вы рассказать нам, что все изменилось?

445
00:22:21,300 --> 00:22:24,950
>> Я достал INT, так что нет никакой декларации [неразборчиво], а не назначение.

446
00:22:24,950 --> 00:22:28,770
Тот знак равенства, я поставил 2 равные знаки, что означает равные.

447
00:22:28,770 --> 00:22:30,560
Awesome.

448
00:22:30,560 --> 00:22:33,320
Да, так, что Сэм был так он вынул Int

449
00:22:33,320 --> 00:22:35,770
, который был здесь раньше,

450
00:22:35,770 --> 00:22:39,340
так что если я просто смотрю на это - это то, что было раньше, он сказал, INT,

451
00:22:39,340 --> 00:22:41,970
который был объявить его - таким образом, мы вынули типа.

452
00:22:41,970 --> 00:22:44,710
Там в Int, Char, String, короче говоря,

453
00:22:44,710 --> 00:22:47,380
Это называется типов.

454
00:22:47,380 --> 00:22:49,510
Таким образом, вы вынули типа

455
00:22:49,510 --> 00:22:51,580
и ранее,

456
00:22:51,580 --> 00:22:54,190
он только одного знака равенства

457
00:22:54,190 --> 00:22:57,300
и то, что он сказал, было проблематично об этом было

458
00:22:57,300 --> 00:22:59,580
когда у вас есть 1 знак равенства,

459
00:22:59,580 --> 00:23:01,780
это оператор присваивания.

460
00:23:01,780 --> 00:23:04,930
Это не проверка ли не 2 вещи равны.

461
00:23:04,930 --> 00:23:07,920
Это на самом деле установка нечто равное что-то.

462
00:23:07,920 --> 00:23:11,110
Мы работаем № 17 в переменную я.

463
00:23:11,110 --> 00:23:13,850
Таким образом, чтобы сделать такое сравнение,

464
00:23:13,850 --> 00:23:16,430
Вы должны использовать двойные равных,

465
00:23:16,430 --> 00:23:19,640
которая является своеобразной странные вещи

466
00:23:19,640 --> 00:23:22,760
но это довольно распространенная ошибка.

467
00:23:23,980 --> 00:23:27,830
Таким образом, еще одна вещь, которую я укажу, если вы не возражаете,

468
00:23:27,830 --> 00:23:30,610
является то, что в

469
00:23:30,610 --> 00:23:33,210
наша функция здесь, в Int основной,

470
00:23:33,210 --> 00:23:36,740
Вы видите, что тело наше функции

471
00:23:36,740 --> 00:23:39,810
смещен с левой стороны

472
00:23:39,810 --> 00:23:42,400
на 4 пробела или табуляции.

473
00:23:42,400 --> 00:23:44,730
Поэтому мы делаем это

474
00:23:44,730 --> 00:23:47,000
только для чтения.

475
00:23:47,000 --> 00:23:51,620
Как вы можете видеть, в то время как цикл Сэма здесь,

476
00:23:51,620 --> 00:23:53,120
он не отступ на всех,

477
00:23:53,120 --> 00:23:55,390
и это не влияет на функциональность кода.

478
00:23:55,390 --> 00:23:57,860
Он будет работать точно так же.

479
00:23:57,860 --> 00:24:00,950
>> Так, например, если мы придем к верхней здесь

480
00:24:00,950 --> 00:24:02,680
и нажать кнопку воспроизведения наш, он будет строить,

481
00:24:02,680 --> 00:24:04,470
она будет запустить его,

482
00:24:04,470 --> 00:24:06,700
и то, что произойдет?

483
00:24:06,700 --> 00:24:08,360
Почему он до сих пор говорят работаете?

484
00:24:08,360 --> 00:24:10,560
>> Потому что он будет повторять привет.

485
00:24:10,560 --> 00:24:12,900
Именно так, и почему это повторять привет?

486
00:24:12,900 --> 00:24:15,850
>> Потому что целое никогда не меняется, так что всегда 17.

487
00:24:15,850 --> 00:24:18,030
Да, точно, так

488
00:24:18,030 --> 00:24:20,970
Давайте посмотрим, после - напоминают мне тебя зовут?

489
00:24:20,970 --> 00:24:24,020
Джимми. Так Джимми сказал, что

490
00:24:24,020 --> 00:24:27,340
Причина этого не устает повторять, привет снова и снова

491
00:24:27,340 --> 00:24:30,510
потому, что это условие всегда истинно.

492
00:24:30,510 --> 00:24:33,270
Мы никогда не изменить значение я.

493
00:24:33,270 --> 00:24:36,170
Мы никогда не изменять содержание того, что хранится в этой переменной.

494
00:24:36,170 --> 00:24:39,180
Таким образом, на данный момент мы получили эту ошибку,

495
00:24:39,180 --> 00:24:42,170
Ваша программа генерируется слишком много выходных,

496
00:24:42,170 --> 00:24:45,100
и если мы прокрутите вниз и вид взгляда на то, что здесь происходит,

497
00:24:45,100 --> 00:24:49,160
Вы можете видеть, что это привет, привет, привет, привет, привет, привет, привет все путем.

498
00:24:49,160 --> 00:24:51,200
Awesome.

499
00:24:51,200 --> 00:24:53,750
>> Так вида вернуться к исходной точке

500
00:24:53,750 --> 00:24:57,020
что наличие отступов здесь

501
00:24:57,020 --> 00:25:00,110
в теле в то время как цикл не влияет.

502
00:25:00,110 --> 00:25:03,050
Программа по-прежнему бежал очень хорошо.

503
00:25:03,050 --> 00:25:06,790
Как правило, для хорошего стиля -

504
00:25:06,790 --> 00:25:10,210
и это то, что мы ищем в вашем множества проблем -

505
00:25:10,210 --> 00:25:13,930
мы просим вас отступ этом на 4 пространств, которые вы можете сделать

506
00:25:13,930 --> 00:25:16,440
, просто нажав клавишу табуляции

507
00:25:16,440 --> 00:25:18,860
или вручную положить в 4 пробела себя.

508
00:25:21,880 --> 00:25:25,050
Cool, нормально так давайте вернемся и посмотрим на

509
00:25:25,050 --> 00:25:30,460
Александр делать-то время.

510
00:25:30,460 --> 00:25:32,980
>> Просто своего рода небольшие проблемы.

511
00:25:32,980 --> 00:25:34,390
Хорошо, ну давайте работать через него.

512
00:25:34,390 --> 00:25:36,400
Разве это круто?

513
00:25:36,400 --> 00:25:37,430
>> Да.

514
00:25:37,430 --> 00:25:39,200
>> Итак, здесь мы идем.

515
00:25:39,200 --> 00:25:41,010
Это код, который написал Александр.

516
00:25:41,010 --> 00:25:43,410
Вы идете Алекс - нормально.

517
00:25:43,410 --> 00:25:46,380
Так вот код, что Алекс написал.

518
00:25:46,380 --> 00:25:50,500
Итак, мы получили нашу декларацию основных прав здесь,

519
00:25:50,500 --> 00:25:54,410
а потом мы получили это число переменной я

520
00:25:54,410 --> 00:25:57,320
были объявлены прямо здесь.

521
00:25:57,320 --> 00:26:01,060
У нас есть сделай заявление

522
00:26:01,060 --> 00:26:04,600
, а затем тело снова с этими скобками,

523
00:26:04,600 --> 00:26:06,520
так что это тело DO-а -

524
00:26:06,520 --> 00:26:09,210
Позвольте мне приблизить это так, это более удобным для чтения -

525
00:26:09,210 --> 00:26:12,730
и в теле, мы пытаемся печатать "это тело",

526
00:26:12,730 --> 00:26:14,300
я + +,

527
00:26:14,300 --> 00:26:17,710
таким образом увеличить содержание я и сделать это

528
00:26:17,710 --> 00:26:19,470
пока я не добирается, чтобы быть 3,

529
00:26:19,470 --> 00:26:22,440
и тогда наша программа заканчивается.

530
00:26:22,440 --> 00:26:24,680
>> Так что же происходит, когда мы запустим эту программу?

531
00:26:24,680 --> 00:26:27,580
>> Я ожидал идентификатор.

532
00:26:27,580 --> 00:26:32,070
Итак, создавать, запускать, ошибка.

533
00:26:32,070 --> 00:26:34,820
Что происходит?

534
00:26:34,820 --> 00:26:37,060
Мы прокрутите вниз здесь,

535
00:26:37,060 --> 00:26:40,260
Мы получим это несколько загадочно глядя вещь,

536
00:26:40,260 --> 00:26:43,930
Ожидается запятой после верхнего уровня декларацию.

537
00:26:43,930 --> 00:26:46,620
Это своего рода странным.

538
00:26:46,620 --> 00:26:50,990
Кто-нибудь есть идея, что может быть дело?

539
00:26:53,080 --> 00:26:54,640
Своего рода странно, да.

540
00:26:54,640 --> 00:26:57,640
>> [Неразборчиво] быть объявлены вне скобок?

541
00:26:57,640 --> 00:27:03,480
Так что это не применяется тогда, когда вы используете скобки?

542
00:27:03,480 --> 00:27:07,390
Так он заявил, что этот парень, вне которого скобки?

543
00:27:09,670 --> 00:27:12,240
Ох, уж эти парни - фигурные скобки?

544
00:27:12,240 --> 00:27:13,850
>> Да.

545
00:27:13,850 --> 00:27:15,310
Да, именно так.

546
00:27:15,310 --> 00:27:17,120
Таким образом, получается, что

547
00:27:17,120 --> 00:27:21,550
Вы не можете фактически объявить переменную прямо здесь, как это.

548
00:27:23,750 --> 00:27:26,690
Что вы могли бы пытались сделать, -

549
00:27:26,690 --> 00:27:30,110
сократить его оттуда -

550
00:27:30,110 --> 00:27:34,330
Вы можете положить его в фигурные скобки здесь

551
00:27:34,330 --> 00:27:37,400
или другая альтернатива

552
00:27:37,400 --> 00:27:40,350
это поставить его полностью снаружи.

553
00:27:42,480 --> 00:27:46,610
И вот эти - в зависимости от того, где вы на самом деле положил заявление

554
00:27:46,610 --> 00:27:48,550
этой целой переменной,

555
00:27:48,550 --> 00:27:53,540
Вы можете получить 2 очень разных видов переменных;

556
00:27:53,540 --> 00:27:55,100
когда он находится вне основного,

557
00:27:55,100 --> 00:27:58,240
это то, что мы называем глобальной переменной.

558
00:27:58,240 --> 00:28:00,070
Это выходит за рамки любой из функций -

559
00:28:00,070 --> 00:28:03,420
это не в пределах функции -

560
00:28:03,420 --> 00:28:07,050
а если положить его внутрь главного,

561
00:28:07,050 --> 00:28:10,000
хотелось прямо здесь, то это называется локальной переменной,

562
00:28:10,000 --> 00:28:13,830
потому что это локальные рамки основной.

563
00:28:13,830 --> 00:28:16,720
И мы поговорим немного о том, что различия

564
00:28:16,720 --> 00:28:20,970
между 2 типами и почему вы используете различные виды переменных,

565
00:28:20,970 --> 00:28:23,040
но сейчас,

566
00:28:23,040 --> 00:28:25,070
Вы можете просто сохранить все локальные переменные,

567
00:28:25,070 --> 00:28:28,320
потому что у нас нет никакой необходимости для глобальных переменных.

568
00:28:28,320 --> 00:28:31,390
>> Итак, это одно дело прямо там.

569
00:28:31,390 --> 00:28:34,680
Давайте попробуем запустить этот раз, посмотреть, что происходит.

570
00:28:37,420 --> 00:28:40,270
Выполнить, получить другую ошибку.

571
00:28:40,270 --> 00:28:43,320
Увеличить немного, что мы получаем?

572
00:28:45,110 --> 00:28:50,000
Мы получаем эту ожидается скобках после сделать / время.

573
00:28:53,660 --> 00:28:55,260
Любые идеи, что происходит? Дэн?

574
00:28:55,260 --> 00:28:58,880
>> Есть время, то скобку, а затем -

575
00:28:58,880 --> 00:29:01,990
Я не знаю, если вам нужно переопределить INT,

576
00:29:01,990 --> 00:29:04,980
но сделать в то время (я <3).

577
00:29:04,980 --> 00:29:06,930
Точно, да.

578
00:29:06,930 --> 00:29:08,830
Вот и получается, что Дэн Совершенно верно.

579
00:29:08,830 --> 00:29:11,230
Нам не нужно, чтобы поставить этот тип здесь снова.

580
00:29:11,230 --> 00:29:14,440
Мы можем вместо этого убил типа

581
00:29:14,440 --> 00:29:17,220
и просто сделать это.

582
00:29:19,270 --> 00:29:21,640
Хорошо.

583
00:29:21,640 --> 00:29:24,950
Я масштаб, попробуйте его еще раз.

584
00:29:26,360 --> 00:29:29,580
Посмотрите на это, она работает успешно.

585
00:29:29,580 --> 00:29:33,260
Если мы прокрутить вниз, "это тело" распечатал 3 раза.

586
00:29:33,260 --> 00:29:35,820
Это очень сладкий.

587
00:29:35,820 --> 00:29:38,670
Молодцы, молодцы, ребята.

588
00:29:38,670 --> 00:29:41,080
Молодцы.

589
00:29:41,080 --> 00:29:43,250
Как это происходит до сих пор?

590
00:29:43,250 --> 00:29:46,200
Достойный темп?

591
00:29:46,200 --> 00:29:49,200
Хорошо, прохладно.

592
00:29:49,200 --> 00:29:52,590
>> Так что, как мы отчасти вернуться к первоначальному вопросу,

593
00:29:52,590 --> 00:29:55,430
Мы - и теперь, если мы видим разницу,

594
00:29:55,430 --> 00:29:58,240
Вы видите, что в этом сделай то время как цикл,

595
00:29:58,240 --> 00:30:00,030
Условие приходит последним.

596
00:30:00,030 --> 00:30:02,530
Так как компьютер считывает программу

597
00:30:02,530 --> 00:30:06,050
С C программы выполняются вид в этом последовательном порядке,

598
00:30:06,050 --> 00:30:09,450
где они в буквальном смысле начать с первой линии главного,

599
00:30:09,450 --> 00:30:13,450
, а затем выполнить линию 6, строка 7, строка 8, строка 9,

600
00:30:13,450 --> 00:30:16,150
строка 10, строка 11,

601
00:30:16,150 --> 00:30:18,440
все эти вещи в правом верхнем здесь

602
00:30:18,440 --> 00:30:20,020
собирается выполнить один раз

603
00:30:20,020 --> 00:30:23,350
прежде, чем мы когда-либо проверить это условие, чтобы увидеть

604
00:30:23,350 --> 00:30:26,240
я или нет - или содержимого я, скорее -

605
00:30:26,240 --> 00:30:29,750
меньше, чем число 3.

606
00:30:29,750 --> 00:30:33,300
И только тогда, когда мы получим на линии 12,

607
00:30:33,300 --> 00:30:36,260
Содержание я менее 3

608
00:30:36,260 --> 00:30:39,150
мы на самом деле вернуться назад к линии 7

609
00:30:39,150 --> 00:30:41,140
, а затем повторить процесс,

610
00:30:41,140 --> 00:30:44,620
, а затем мы проверяем состояние снова и снова и снова.

611
00:30:44,620 --> 00:30:47,440
>> Так что мы можем противопоставить этому

612
00:30:47,440 --> 00:30:50,240
с - масштабирование обратно,

613
00:30:50,240 --> 00:30:56,500
прокрутите вниз до версии Сэма,

614
00:30:56,500 --> 00:31:00,760
мы будем смотреть на это, немного изменен так, что это уже не бесконечный цикл -

615
00:31:00,760 --> 00:31:03,570
где, если мы увеличить,

616
00:31:03,570 --> 00:31:06,300
мы видим, что эта программа выполняется,

617
00:31:06,300 --> 00:31:09,120
она собирается сначала объявить Int я,

618
00:31:09,120 --> 00:31:12,030
установить содержание я бы 0,

619
00:31:12,030 --> 00:31:15,820
а затем он попадает в состояние в то время как петля первого,

620
00:31:15,820 --> 00:31:19,210
поэтому в данном случае, это тело, этот Е ("привет") и я + +

621
00:31:19,210 --> 00:31:21,630
даже не будет выполнять

622
00:31:21,630 --> 00:31:24,310
если я на самом деле меньше или равно 2.

623
00:31:24,310 --> 00:31:26,750
Так что, если я 3, например,

624
00:31:26,750 --> 00:31:28,840
если мы положим этому прямо здесь

625
00:31:28,840 --> 00:31:32,160
равна 4 - или я сделаю 3, потому что я сказал 3 -

626
00:31:32,160 --> 00:31:34,890
, а затем запустить его,

627
00:31:34,890 --> 00:31:38,320
он будет строить, она будет работать в полном порядке,

628
00:31:38,320 --> 00:31:40,530
но он не будет на самом деле распечатать что-либо,

629
00:31:40,530 --> 00:31:43,030
потому что не смогла это испытание для первого случая.

630
00:31:44,780 --> 00:31:47,530
Таким образом, в классе, мы как-то говорили о том, почему эти сделай то время как петли

631
00:31:47,530 --> 00:31:49,800
это иногда полезно

632
00:31:49,800 --> 00:31:53,140
и почему мы должны использовать его, в отличие от цикла.

633
00:31:53,140 --> 00:31:56,450
>> Есть - вы, ребята, есть какие-либо предложения

634
00:31:56,450 --> 00:31:59,090
, почему сделай то время как цикл может быть более полезным?

635
00:31:59,090 --> 00:32:02,560
>> Ну, я думаю, что делать, в то время как петли, если вы хотите пользовательского ввода,

636
00:32:02,560 --> 00:32:05,020
потому что таким образом вы можете позволить им

637
00:32:05,020 --> 00:32:07,780
положить что-то в один раз, если это правильно,

638
00:32:07,780 --> 00:32:09,300
мы можем перейти к остальной части программы,

639
00:32:09,300 --> 00:32:11,250
Но если это не правильно, то вы продолжаете запроса пользователя

640
00:32:11,250 --> 00:32:13,250
пока вы не положите правую вход.

641
00:32:13,250 --> 00:32:14,260
Да, точно - точно,

642
00:32:14,260 --> 00:32:16,840
так делают, в то время как цикл полезен

643
00:32:16,840 --> 00:32:18,930
потому что, когда запросы на ввод данных пользователем

644
00:32:18,930 --> 00:32:23,000
потому что вы должны получить ввод пользователя, прежде чем вы действительно можете это проверить.

645
00:32:23,000 --> 00:32:27,330
Таким образом, в PSET 1, в PSET 2,

646
00:32:27,330 --> 00:32:29,650
где вы запроса на ввод данных пользователем много,

647
00:32:29,650 --> 00:32:31,200
это удобная вещь, чтобы использовать

648
00:32:31,200 --> 00:32:33,740
в отличие от простой цикл время.

649
00:32:33,740 --> 00:32:36,780
Если вы используете какое-то время цикла, вы можете сделать то же самое -

650
00:32:36,780 --> 00:32:38,750
Вы можете сделать то же самое с какое-то время цикла

651
00:32:38,750 --> 00:32:40,580
как вы делаете с DO-цикла.

652
00:32:40,580 --> 00:32:43,380
Вы просто должны иметь вид этого дубликата процесса

653
00:32:43,380 --> 00:32:47,010
где вы получите вход, а затем начать свой цикл.

654
00:32:47,010 --> 00:32:49,800
Принимая во внимание, сделай то время как цикл, вы просто должны написать его один раз

655
00:32:49,800 --> 00:32:52,430
и это намного чище.

656
00:32:52,430 --> 00:32:54,650
>> Хорошо.

657
00:32:55,970 --> 00:32:57,330
Есть вопросы?

658
00:32:59,350 --> 00:33:01,380
Смысл?

659
00:33:01,380 --> 00:33:06,200
>> Возвращение 0 - это просто вид кабины или это -?

660
00:33:06,200 --> 00:33:08,960
Да, так что мы можем -

661
00:33:08,960 --> 00:33:11,960
Ну, мы рассмотрим это немного более позднее

662
00:33:11,960 --> 00:33:13,290
но оказывается, что

663
00:33:13,290 --> 00:33:15,720
это возвращение 0, положим

664
00:33:15,720 --> 00:33:19,090
В конце основного все время -

665
00:33:19,090 --> 00:33:21,980
Вы можете любопытное просто принять это как то, что мы делаем

666
00:33:21,980 --> 00:33:24,930
в настоящее время.

667
00:33:24,930 --> 00:33:28,860
То, что мы начали говорить с функциями

668
00:33:28,860 --> 00:33:31,600
вид в конце прошлой недели, а затем снова на этой неделе

669
00:33:31,600 --> 00:33:33,550
является то, что функция

670
00:33:33,550 --> 00:33:37,680
имеет входы, которые эти вещи в скобках;

671
00:33:37,680 --> 00:33:41,690
эти 2 входа, наши аргументы или параметры,

672
00:33:41,690 --> 00:33:44,540
что они также называются к нашей основной функции,

673
00:33:44,540 --> 00:33:48,510
, а затем функция формирует выходной

674
00:33:48,510 --> 00:33:51,290
, который мы называем возвращаемого значения.

675
00:33:51,290 --> 00:33:56,260
И возвращаемого значения в случае главное, это INT,

676
00:33:56,260 --> 00:33:58,320
это число,

677
00:33:58,320 --> 00:34:01,160
и то, как вы говорите функции: "Эй, это то, что ваши выходные

678
00:34:01,160 --> 00:34:05,840
будет "С этим словом« возвращение »,

679
00:34:05,840 --> 00:34:07,960
это ключевое слово, скорее,

680
00:34:07,960 --> 00:34:11,000
и поэтому основная возвращается 0

681
00:34:11,000 --> 00:34:13,389
или главный вывод 0

682
00:34:13,389 --> 00:34:15,139
является стандартным для программ C

683
00:34:15,139 --> 00:34:18,110
потому что возвращение 0 из основных средств, что

684
00:34:18,110 --> 00:34:21,600
"Эй, все выполнено с моей программой просто отлично."

685
00:34:21,600 --> 00:34:24,639
Если бы мы могли поставить что-то отличное от 0,

686
00:34:24,639 --> 00:34:27,440
как 1, например,

687
00:34:27,440 --> 00:34:31,080
который используется, чтобы сообщить, кто запустил эту программу

688
00:34:31,080 --> 00:34:33,540
, что что-то пошло не так.

689
00:34:35,739 --> 00:34:39,989
Так как мы получаем более сложный с вещами в течение семестра,

690
00:34:39,989 --> 00:34:42,670
если вы когда-либо нуждается сказать,

691
00:34:42,670 --> 00:34:46,650
"Ой, вы знаете, что-то пошло не так с этой программой",

692
00:34:46,650 --> 00:34:49,409
вместо того, чтобы моя программа аварии, я хочу предупредить

693
00:34:49,409 --> 00:34:52,310
бегун из моей программы, что что-то пошло не так,

694
00:34:52,310 --> 00:34:54,530
Вы можете использовать возвращаемое значение,

695
00:34:54,530 --> 00:34:57,230
как мы его называем, это не 0.

696
00:35:00,180 --> 00:35:02,240
>> Таким образом, мы расскажем, что немного больше

697
00:35:02,240 --> 00:35:05,480
Как только мы попадаем в функциях.

698
00:35:05,480 --> 00:35:09,030
Такого рода имеет смысл?

699
00:35:09,030 --> 00:35:11,240
Хорошо.

700
00:35:11,240 --> 00:35:13,530
Функции являются своего рода странным -

701
00:35:13,530 --> 00:35:17,270
Я думаю, что для людей, которые имеют много математики фона,

702
00:35:17,270 --> 00:35:20,100
речь идет немного легче,

703
00:35:20,100 --> 00:35:22,540
Особенно если у вас есть немного более абстрактным математическим образованием

704
00:35:22,540 --> 00:35:24,240
и вы привыкли говорить о функциях

705
00:35:24,240 --> 00:35:27,370
и все в таком же роде.

706
00:35:28,590 --> 00:35:30,610
Но мы постараемся охватить их

707
00:35:30,610 --> 00:35:33,280
и идти красиво и медленно, как они приходят.

708
00:35:34,730 --> 00:35:37,870
Кроме того, весь этот агдс INT,

709
00:35:37,870 --> 00:35:41,090
символ * ARGV [],

710
00:35:41,090 --> 00:35:44,960
для прямо сейчас, Вы также можете принять это как плите котла.

711
00:35:46,650 --> 00:35:49,050
Мы начали охватывать тех, кто немного в лекции

712
00:35:49,050 --> 00:35:53,060
когда мы говорим о аргументов, которые получают перешла в программах командной строки,

713
00:35:53,060 --> 00:35:55,700
но в вашей проблеме множеств и ваших программ,

714
00:35:55,700 --> 00:35:58,760
это совершенно нормально только писать недействительным и держать его проста.

715
00:35:58,760 --> 00:36:01,490
И то, что эта пустота означает, что

716
00:36:01,490 --> 00:36:04,630
"Эй, основной не собирается принимать никаких входов;

717
00:36:04,630 --> 00:36:07,440
это всего лишь программа, которую мы собираемся просто запустить.

718
00:36:07,440 --> 00:36:09,320
Мы не собираемся дать ему любую дополнительную информацию

719
00:36:09,320 --> 00:36:12,420
каждый раз, когда мы начинаем его выполнении ».

720
00:36:14,730 --> 00:36:16,600
Таким образом, на данный момент, вы можете сделать это;

721
00:36:16,600 --> 00:36:19,710
Вы также можете даже опустить возврат 0

722
00:36:19,710 --> 00:36:22,650
В конце вашей программы, и они будут работать нормально,

723
00:36:22,650 --> 00:36:26,150
но я рекомендую просто держать, что дюйм

724
00:36:26,150 --> 00:36:28,320
Через пару недель мы начнем вид

725
00:36:28,320 --> 00:36:31,340
потяните крышку немного и понять больше о

726
00:36:31,340 --> 00:36:34,380
все эти разные мало движущихся частей.

727
00:36:34,380 --> 00:36:38,160
>> Хорошо, теперь давайте поговорим о нашей второй вопрос.

728
00:36:38,160 --> 00:36:43,190
Итак, что же "необъявленный идентификатор" обычно указывают на

729
00:36:43,190 --> 00:36:46,040
если выдаваемых Clang?

730
00:36:46,040 --> 00:36:49,290
Я думаю, что мы, возможно, видели, что уже сегодня.

731
00:36:51,170 --> 00:36:54,370
Может кто-нибудь дать резюме, что это значит?

732
00:36:54,370 --> 00:36:57,680
Давайте посмотрим, Келли - один из Kellys.

733
00:37:02,580 --> 00:37:05,300
>> Так что -

734
00:37:05,300 --> 00:37:07,080
Да, то, что делает -

735
00:37:07,080 --> 00:37:10,140
>> Я думаю, когда вы, например, не объявить переменные, и вы пытаетесь использовать его.

736
00:37:10,140 --> 00:37:13,310
Да, точно, точно.

737
00:37:13,310 --> 00:37:15,250
Так что если вы когда-нибудь видели этот выход

738
00:37:15,250 --> 00:37:17,690
когда вы пытаетесь скомпилировать программу,

739
00:37:17,690 --> 00:37:19,470
как сказал Келли,

740
00:37:19,470 --> 00:37:24,210
это означает, что вы использовали переменную, что вы не заявляем,

741
00:37:24,210 --> 00:37:28,460
так что если я вернусь в наше пространство,

742
00:37:28,460 --> 00:37:31,150
и я делаю что-то вроде

743
00:37:31,150 --> 00:37:34,800
Е (

744
00:37:34,800 --> 00:37:38,260
"Привет% S")

745
00:37:40,070 --> 00:37:42,440
и попытаться заполнить этот% с

746
00:37:42,440 --> 00:37:45,640
с переменным том, что я не заявили о любом

747
00:37:45,640 --> 00:37:48,330
и я стараюсь, чтобы запустить его,

748
00:37:48,330 --> 00:37:51,330
Вы увидите, что я спускаюсь в этой правом нижнем здесь:

749
00:37:51,330 --> 00:37:54,010
"Использование необъявленный идентификатор 'S'";

750
00:37:54,010 --> 00:37:57,710
это просто означает, что вы не объявите переменную.

751
00:37:57,710 --> 00:38:00,750
То же самое происходит, если

752
00:38:00,750 --> 00:38:05,240
у вас есть х, и вы пытаетесь и хранить 7 в это

753
00:38:05,240 --> 00:38:08,720
и я не заявляю X.

754
00:38:08,720 --> 00:38:10,200
Я понимаю, что же ошибку:

755
00:38:10,200 --> 00:38:13,480
"Использование" х "необъявленный идентификатор".

756
00:38:16,390 --> 00:38:18,250
>> Все в порядке,

757
00:38:18,250 --> 00:38:21,720
так шифр Цезаря, не будучи очень надежной,

758
00:38:21,720 --> 00:38:24,590
Я сообщу вам, ребята смотреть этот короткий, вроде понимаю, почему,

759
00:38:24,590 --> 00:38:27,590
и, надеюсь, после выполнения задачи на этой неделе установлены

760
00:38:27,590 --> 00:38:29,270
где вы на самом деле писать шифр Цезаря, вы поймете, немного больше

761
00:38:29,270 --> 00:38:32,600
о том, что значит быть безопасным и небезопасным -

762
00:38:36,180 --> 00:38:38,960
или не безопасно, я думаю, - небезопасный немного отличается.

763
00:38:40,560 --> 00:38:43,140
Другая вещь была у нас есть эти другие вопросы здесь

764
00:38:43,140 --> 00:38:45,470
О функциях

765
00:38:45,470 --> 00:38:47,330
и то, что функции,

766
00:38:47,330 --> 00:38:52,820
и мы как-то говорили о том, что некоторое время, когда мы говорили о возвращении ценностей;

767
00:38:52,820 --> 00:38:54,560
для кого-то, кто был на лекции,

768
00:38:54,560 --> 00:38:57,790
Вы можете резюмировать, кто был читать лекцию на сегодняшний день?

769
00:38:57,790 --> 00:38:59,670
Хорошо.

770
00:39:01,210 --> 00:39:04,320
Давайте посмотрим, давайте - может кто-нибудь сказать нам, какие функции?

771
00:39:04,320 --> 00:39:06,060
Келли?

772
00:39:07,800 --> 00:39:11,260
>> >> Основном то, что вы опираться на то, что написано в библиотеке, что это

773
00:39:11,260 --> 00:39:14,460
более сложная там, а затем вы просто написать короткую форму его,

774
00:39:14,460 --> 00:39:17,360
так как вы имеете в виду, что обратно в библиотеку, используя

775
00:39:17,360 --> 00:39:19,650
все, что длинный код и [неразборчиво].

776
00:39:19,650 --> 00:39:22,680
Да, точно, а затем вы хотите что-то добавить к этому?

777
00:39:22,680 --> 00:39:27,050
>> Да, я думаю о нем, как похоже на понятие формулы по математике

778
00:39:27,050 --> 00:39:30,130
где вы просто написать формулу, а затем вы можете подключить переменных в

779
00:39:30,130 --> 00:39:32,660
и вот что функция [неразборчиво].

780
00:39:32,660 --> 00:39:35,390
>> Да, таким образом, мы получили несколько ответов здесь

781
00:39:35,390 --> 00:39:38,080
, которые одновременно являются действительно хорошим и правильным на.

782
00:39:38,080 --> 00:39:43,040
Там имеет в виду код, который был записан в библиотеку где-то

783
00:39:43,040 --> 00:39:45,390
, что является более сложной

784
00:39:45,390 --> 00:39:47,130
а затем вы можете опираться на этот код

785
00:39:47,130 --> 00:39:50,480
и фактически использовать его, просто пишу краткой форме это -

786
00:39:50,480 --> 00:39:54,060
или, скорее, ее название -

787
00:39:54,060 --> 00:39:57,590
и тогда есть также это сравнение с формулой в математике

788
00:39:57,590 --> 00:40:00,400
или физике, все в таком же роде

789
00:40:00,400 --> 00:40:02,980
где у вас есть формула

790
00:40:02,980 --> 00:40:05,690
а затем вы можете подключить

791
00:40:05,690 --> 00:40:08,100
переменных, что формула

792
00:40:08,100 --> 00:40:11,130
, чтобы затем получить результат формулы,

793
00:40:11,130 --> 00:40:14,580
так что вы думаете о нем, как как квадратное уравнение.

794
00:40:14,580 --> 00:40:17,690
Представьте, если бы вместо того, чтобы узнать о

795
00:40:17,690 --> 00:40:21,310
что квадратичная формула в математическом классе,

796
00:40:21,310 --> 00:40:24,610
Вы просто была маленькая программа калькулятор, который сделал это за вас.

797
00:40:24,610 --> 00:40:28,930
Кто-нибудь использовании калькулятор программы в математические классы в средней школе?

798
00:40:28,930 --> 00:40:31,020
Да, физика классов?

799
00:40:31,020 --> 00:40:34,670
Где вы можете просто сказать: "Эй, квадратичной формулы.

800
00:40:34,670 --> 00:40:37,740
Эти переменные, которые я хочу входа.

801
00:40:37,740 --> 00:40:40,250
Теперь дайте мне ответ ".

802
00:40:40,250 --> 00:40:42,170
Это вроде того, что функция.

803
00:40:42,170 --> 00:40:44,850
Это способ для нас

804
00:40:44,850 --> 00:40:47,720
вид записи, как маленькие подпрограммы

805
00:40:47,720 --> 00:40:51,700
в пределах нашей большой программы

806
00:40:51,700 --> 00:40:55,090
и использовать его снова и снова

807
00:40:55,090 --> 00:40:58,380
так что мы не должны скопировать и вставить код,

808
00:40:58,380 --> 00:41:04,220
мы можем дать ему различные входы и получить различные выходы,

809
00:41:04,220 --> 00:41:07,090
это супер удобно

810
00:41:07,090 --> 00:41:11,420
когда вы пытаетесь писать различные программы в разное время.

811
00:41:11,420 --> 00:41:14,580
>> Так, например, функции, которые мы используем снова и снова и снова

812
00:41:14,580 --> 00:41:17,310
на протяжении всего курса является Printf.

813
00:41:17,310 --> 00:41:19,680
Printf само по себе является функцией

814
00:41:19,680 --> 00:41:23,360
и оказывается, что на самом деле это довольно долгий и сложный,

815
00:41:23,360 --> 00:41:26,420
противный взгляд, функцию записи.

816
00:41:26,420 --> 00:41:29,590
Так же просто, как нам кажется,

817
00:41:29,590 --> 00:41:31,810
печатать вещи из на экран,

818
00:41:31,810 --> 00:41:34,820
потому что все мы только что сделали, что в начале раздела сегодня,

819
00:41:34,820 --> 00:41:36,870
Оказывается, что это на самом деле, вы знаете,

820
00:41:36,870 --> 00:41:39,900
хорошая пара сотен строк кода.

821
00:41:42,030 --> 00:41:45,620
Это не то, что я никогда не хочу писать, конечно,

822
00:41:45,620 --> 00:41:47,480
но мы получаем, чтобы использовать его каждый день, это круто,

823
00:41:47,480 --> 00:41:49,020
таким образом, мы получим поделиться друг с другом,

824
00:41:49,020 --> 00:41:51,790
с различными программами,

825
00:41:51,790 --> 00:41:54,520
так что мы будем дайвинга больше в функции;

826
00:41:54,520 --> 00:41:56,090
на данный момент, мы не -

827
00:41:56,090 --> 00:41:59,150
Единственная функция, мы собираемся писать является основной.

828
00:41:59,150 --> 00:42:01,570
Главное сама по себе также функции,

829
00:42:01,570 --> 00:42:04,270
и вы можете видеть он получил свою продукцию,

830
00:42:04,270 --> 00:42:06,610
его входов, как мы говорили,

831
00:42:06,610 --> 00:42:08,930
и затем его имя, которое является основным.

832
00:42:08,930 --> 00:42:11,800
Главное это своего рода - это особая функция есть.

833
00:42:11,800 --> 00:42:14,800
В программе C, там должен быть основной функцией,

834
00:42:14,800 --> 00:42:17,900
и поэтому сейчас, у нас вроде опущены письменной

835
00:42:17,900 --> 00:42:21,400
прототип, или декларация, основной.

836
00:42:21,400 --> 00:42:23,050
Мы, учитывая, что для вас,

837
00:42:23,050 --> 00:42:25,650
и мы только что бы вы заполните в виде заготовок.

838
00:42:25,650 --> 00:42:29,120
>> >> Так что для второго набора проблемы, мы не должны

839
00:42:29,120 --> 00:42:31,350
написать его во второй функции?

840
00:42:31,350 --> 00:42:34,200
Я не верю в это.

841
00:42:34,200 --> 00:42:37,600
Я считаю, что все здесь.

842
00:42:37,600 --> 00:42:41,710
Да, так Caesar Cipher,

843
00:42:41,710 --> 00:42:45,000
Вам не нужно, это не похоже,

844
00:42:48,740 --> 00:42:53,150
и Vigenere, вы не знаете как,

845
00:42:53,150 --> 00:42:56,400
так - и оказывается, что вы никогда не на самом деле нужно написать

846
00:42:56,400 --> 00:42:58,250
Функция, правильно?

847
00:42:58,250 --> 00:43:01,950
Вы называете всегда ставить весь свой код в главном,

848
00:43:01,950 --> 00:43:04,500
и многие программисты делают это.

849
00:43:04,500 --> 00:43:07,130
Как мы двигаться дальше,

850
00:43:07,130 --> 00:43:09,480
мы начинаем внедрение функций в качестве способа

851
00:43:09,480 --> 00:43:11,530
, чтобы очистить ваш код,

852
00:43:11,530 --> 00:43:13,380
чтобы сделать его более элегантным,

853
00:43:13,380 --> 00:43:16,890
в случае, если у вас есть задачи - вроде как когда мы говорили о петлях,

854
00:43:16,890 --> 00:43:20,400
как иногда есть вещи, которые вы хотите сделать снова и снова, и снова,

855
00:43:20,400 --> 00:43:23,510
и у вас есть вид наивный способ -

856
00:43:23,510 --> 00:43:26,360
или то, что мы часто называем «соломенное чучело» решения,

857
00:43:26,360 --> 00:43:29,390
это просто скопируйте и вставьте снова и снова -

858
00:43:29,390 --> 00:43:31,000
Вы можете сделать то же самое с функциями, где вы просто скопировать и вставить

859
00:43:31,000 --> 00:43:33,360
тот же код снова и снова,

860
00:43:33,360 --> 00:43:35,750
но раздувает код -

861
00:43:35,750 --> 00:43:38,550
он заканчивает делает код очень долго -

862
00:43:38,550 --> 00:43:41,550
и это также становится немного запутанным,

863
00:43:41,550 --> 00:43:43,470
и это означает, что вы не в состоянии любить -

864
00:43:43,470 --> 00:43:45,250
если вы хотите использовать этот код еще раз в другой программе,

865
00:43:45,250 --> 00:43:48,610
Вы также застрял копирование и вставка его снова,

866
00:43:48,610 --> 00:43:51,170
так что одна из вещей, мы будем говорить о том,

867
00:43:51,170 --> 00:43:54,960
вид дизайна и стиля вашей программы,

868
00:43:54,960 --> 00:43:57,010
и поэтому, когда имеет смысл вид

869
00:43:57,010 --> 00:43:59,800
Пакет что-то и положил его в качестве отдельной функции,

870
00:43:59,800 --> 00:44:02,080
Мы рекомендуем вам сделать это,

871
00:44:02,080 --> 00:44:04,700
и это то, что, опять же,

872
00:44:04,700 --> 00:44:07,790
нет жестких правил.

873
00:44:07,790 --> 00:44:11,540
Мы редко говорим, что вы должны написать функцию с именем этого

874
00:44:12,870 --> 00:44:16,320
но это скорее одна из тех вещей, которые вы только что с течением времени

875
00:44:16,320 --> 00:44:19,470
как вы пишете больше и больше программ.

876
00:44:21,940 --> 00:44:24,790
>> Есть еще вопросы?

877
00:44:26,340 --> 00:44:30,610
Итак, давайте теперь

878
00:44:30,610 --> 00:44:34,750
Вернуться к этому парню прямо здесь,

879
00:44:34,750 --> 00:44:37,800
так что я еще в этом разделе вопросов.

880
00:44:37,800 --> 00:44:39,900
Мы говорили обо всех этих разных,

881
00:44:39,900 --> 00:44:42,050
что функция, поэтому писать функции,

882
00:44:42,050 --> 00:44:44,700
когда вы можете просто скопировать и вставить?

883
00:44:44,700 --> 00:44:47,700
Надеюсь, мы убедили вас, что написание функций является хорошей вещью.

884
00:44:47,700 --> 00:44:50,870
Итак, теперь давайте перейдем к этой программе MySpace,

885
00:44:50,870 --> 00:44:53,080
и мы будем потратить немного времени делать это.

886
00:44:54,600 --> 00:44:56,480
>> Итак, давайте посмотрим,

887
00:44:56,480 --> 00:45:00,230
может я кого-то читать это для меня?

888
00:45:02,640 --> 00:45:04,660
Давайте Михаила - вы будете читать это для нас?

889
00:45:07,660 --> 00:45:08,890
>> Ты имеешь в виду назад, когда MySpace -

890
00:45:08,890 --> 00:45:10,920
Назад, когда MySpace было прохладно.

891
00:45:10,920 --> 00:45:12,070
>> "Назад, когда MySpace была прохладной,

892
00:45:12,070 --> 00:45:14,900
он был в моде, чтобы тип вроде этого.

893
00:45:14,900 --> 00:45:17,320
Может быть, еще есть? Я не совсем уверен.

894
00:45:17,320 --> 00:45:19,990
В любом случае, используя CS50 Appliance,

895
00:45:19,990 --> 00:45:22,600
CS50 Run, или CS50 пространства,

896
00:45:22,600 --> 00:45:25,370
написать программу, которая запрашивает у пользователя сообщение

897
00:45:25,370 --> 00:45:29,350
и затем выводит сообщение с первой буквой,

898
00:45:29,350 --> 00:45:31,800
со всеми другими буквами в переменном случае,

899
00:45:31,800 --> 00:45:34,010
в соответствии с образцом выхода ниже,

900
00:45:34,010 --> 00:45:37,060
где жирными текст представляет собой вход некоторых пользователей.

901
00:45:37,060 --> 00:45:39,800
Для простоты можно считать, что пользователь

902
00:45:39,800 --> 00:45:42,810
будет только вход строчные буквы и пробелы.

903
00:45:42,810 --> 00:45:45,900
Рассмотрим эту проблему возможность на практике;

904
00:45:45,900 --> 00:45:48,640
Вам не будет предложено представить эту программу ".

905
00:45:48,640 --> 00:45:51,640
>> Awesome, спасибо.

906
00:45:51,640 --> 00:45:54,750
Так как Михаила сказали,

907
00:45:54,750 --> 00:45:58,850
Мы собираемся написать программу, которая MySpaces код.

908
00:45:58,850 --> 00:46:02,230
Так же любой из вас, ребята используют MySpace?

909
00:46:02,230 --> 00:46:04,100
Любой из вас MySpace счета?

910
00:46:04,100 --> 00:46:05,920
Ах, да, да!

911
00:46:05,920 --> 00:46:08,300
Это было довольно прохладно.

912
00:46:08,300 --> 00:46:09,950
[Смех]

913
00:46:09,950 --> 00:46:12,060
Я знаю.

914
00:46:12,060 --> 00:46:14,500
Знакомства себя.

915
00:46:15,490 --> 00:46:18,300
Итак, что мы пытаемся сделать, это написать программу

916
00:46:18,300 --> 00:46:21,110
, которая проходит через

917
00:46:21,110 --> 00:46:24,490
и капитализирует первые буквы

918
00:46:24,490 --> 00:46:27,140
, а затем каждую букву после этого -

919
00:46:27,140 --> 00:46:29,350
или любого другого письма после этого, мне очень жаль.

920
00:46:29,350 --> 00:46:32,910
>> Так что - и вы можете видеть в данном примере,

921
00:46:32,910 --> 00:46:35,260
это то, как мы запустили программу,

922
00:46:35,260 --> 00:46:38,780
и так это просто говорит: "Мы работает программа под названием a.out.

923
00:46:41,490 --> 00:46:44,630
Вход, который мы собираемся придав ему

924
00:46:44,630 --> 00:46:47,090
это будет предложено.

925
00:46:47,090 --> 00:46:51,150
Мы не собираемся поставлять входа в командной строке ".

926
00:46:51,150 --> 00:46:54,100
Если вы следили все лекции

927
00:46:54,100 --> 00:46:56,710
и слух о аргументов командной строки,

928
00:46:57,810 --> 00:47:00,080
это отчасти от того, где те - что напуганные синтаксиса

929
00:47:00,080 --> 00:47:04,530
на главной приходит с внутр агдс, все эти вещи,

930
00:47:04,530 --> 00:47:07,630
так что здесь мы не используем, что, мы имеем дело не с любым из этого.

931
00:47:09,400 --> 00:47:12,650
Мы просто собираюсь получить эту типизированных в пользователем,

932
00:47:12,650 --> 00:47:15,700
и тогда эта вторая линия с фанки капитализации

933
00:47:15,700 --> 00:47:18,550
то, что мы хотим, чтобы наши программы на выход.

934
00:47:19,790 --> 00:47:22,860
>> Таким образом, вместо использования прибора или Run, мы будем использовать пробелы,

935
00:47:22,860 --> 00:47:25,360
потому что у нас пространствах,

936
00:47:25,360 --> 00:47:28,640
и поэтому, если бы вы, ребята,

937
00:47:28,640 --> 00:47:32,380
получить код, чтобы выглядеть так,

938
00:47:32,380 --> 00:47:35,930
так что я собираюсь сохранить этот пересмотр

939
00:47:35,930 --> 00:47:38,390
просто так у тебя на плите котла прямо здесь

940
00:47:38,390 --> 00:47:42,840
, что выглядит так, Int основных (недействительными), ничего в ней.

941
00:47:44,480 --> 00:47:48,460
На самом деле, то, что мы будем делать это мы будем просто удалить все, все вместе.

942
00:47:48,460 --> 00:47:50,330
Мы хотим чистого листа,

943
00:47:50,330 --> 00:47:52,470
потому что мы не собираемся приступить к написанию кода;

944
00:47:52,470 --> 00:47:55,380
Скорее всего, мы будем стараться писать некоторые псевдокод

945
00:47:55,380 --> 00:47:58,580
который на самом деле просто означает, что мы собираемся написать то, что не код

946
00:47:58,580 --> 00:48:01,010
такой описывает то, что мы хотим сделать,

947
00:48:01,010 --> 00:48:05,180
вроде как сделал Давид, в первый день лекций,

948
00:48:05,180 --> 00:48:08,310
или я предполагаю, что это был второй день лекции, когда он сделал все демо носки.

949
00:48:08,310 --> 00:48:10,990
Вы, ребята, помните, что - видя носки?

950
00:48:10,990 --> 00:48:13,300
Иосиф был там вид набрав на английском языке?

951
00:48:13,300 --> 00:48:16,300
Так что мы собираемся сделать то же самое.

952
00:48:16,300 --> 00:48:18,380
>> Так что, когда я начинаю писать псевдокод,

953
00:48:18,380 --> 00:48:22,640
Я хотел бы начать, глядя на то, что вход будет.

954
00:48:22,640 --> 00:48:24,950
И я даю себе образца случае,

955
00:48:24,950 --> 00:48:28,780
так как "спасибо за дополнения!"

956
00:48:35,030 --> 00:48:38,010
А потом я также пишу, что я хочу быть выход,

957
00:48:38,010 --> 00:48:42,210
который в данном случае что-то вроде этого.

958
00:48:53,790 --> 00:48:56,050
И такая дает мне хороший, как, начиная с места, чтобы думать,

959
00:48:56,050 --> 00:48:59,730
"Хорошо, я хочу взять линию 1

960
00:48:59,730 --> 00:49:03,560
и я хочу, чтобы превратить его в строке 2 "

961
00:49:03,560 --> 00:49:06,570
и такого рода помогает направлять мое мышление.

962
00:49:06,570 --> 00:49:09,990
Это хорошее место для начала.

963
00:49:09,990 --> 00:49:12,190
Другой способ думать об этом, тоже, как мы любопытное двигаться дальше

964
00:49:12,190 --> 00:49:15,020
и как вы делаете это в ваших собственных программ, заключается в

965
00:49:15,020 --> 00:49:18,530
думать о вроде как, каковы крайние случаи на это?

966
00:49:18,530 --> 00:49:20,740
Какие виды странные сценарии?

967
00:49:20,740 --> 00:49:23,660
Какие странные материалы, которые мы могли бы получить?

968
00:49:23,660 --> 00:49:26,550
А что, если эти выходы выглядеть?

969
00:49:26,550 --> 00:49:29,670
Например, один странный вход

970
00:49:29,670 --> 00:49:33,200
бы этого,

971
00:49:33,200 --> 00:49:35,630
создание абсолютно ничего,

972
00:49:35,630 --> 00:49:37,840
как то, что мы должны выводить в таком случае?

973
00:49:37,840 --> 00:49:40,530
То, что мы хотим, чтобы думать, тоже.

974
00:49:40,530 --> 00:49:44,450
>> Так же, как вопрос,

975
00:49:44,450 --> 00:49:46,870
что может мы хотим выход?

976
00:49:46,870 --> 00:49:50,740
Если мы не получим любого входа на все, что должно быть нашей программы вывода?

977
00:49:53,740 --> 00:49:54,860
>> Ничего.

978
00:49:54,860 --> 00:49:57,340
Ничего? Звучит неплохо.

979
00:49:57,340 --> 00:49:59,280
Таким образом, мы хотим убедиться, что мы не пишем ничего из

980
00:49:59,280 --> 00:50:01,500
если мы ничего не получаем дюйма

981
00:50:01,500 --> 00:50:04,320
Cool. Хорошо.

982
00:50:04,320 --> 00:50:07,370
Так

983
00:50:07,370 --> 00:50:09,380
Я собираюсь позвонить на пару людей, как мы проходим

984
00:50:09,380 --> 00:50:12,790
и просто выяснить, вроде как, что общий алгоритм

985
00:50:12,790 --> 00:50:15,250
и мы будем рода начать работать через это вместе.

986
00:50:16,240 --> 00:50:19,710
>> Итак, давайте посмотрим. Мисси.

987
00:50:19,710 --> 00:50:21,220
Как вы думаете, мы бы начать?

988
00:50:21,220 --> 00:50:24,830
Что бы быть хорошим местом, чтобы начать здесь

989
00:50:24,830 --> 00:50:27,900
если мы хотим преобразовать, скажем, линия 1

990
00:50:27,900 --> 00:50:29,440
в строке 2?

991
00:50:29,440 --> 00:50:32,650
Можете ли вы как-то просто объясните мне, на английском языке, о чем ты думаешь?

992
00:50:32,650 --> 00:50:34,770
Даже не беспокоиться о коде.

993
00:50:34,770 --> 00:50:38,250
>> Первая вещь, которую я хотел бы сделать,

994
00:50:38,250 --> 00:50:41,170
вид прямых пользователей, чтобы сказать им, что вы хотите.

995
00:50:41,170 --> 00:50:44,730
Хорошо, так, скажем,

996
00:50:44,730 --> 00:50:47,450
"Эй, пользователь. Хочу

997
00:50:47,450 --> 00:50:50,560
Строка "- удивительный.

998
00:50:50,560 --> 00:50:52,990
Так что давайте это записать.

999
00:50:52,990 --> 00:50:56,140
Подскажите у пользователя строку.

1000
00:50:56,140 --> 00:50:59,270
Это звучит, как хороший старт.

1001
00:51:03,920 --> 00:51:06,460
Хорошо.

1002
00:51:06,460 --> 00:51:09,750
Давайте спросим у Келли Ren это время.

1003
00:51:09,750 --> 00:51:11,580
Что бы мы тогда хотим делать дальше?

1004
00:51:11,580 --> 00:51:14,220
Что вроде нашего следующего -

1005
00:51:14,220 --> 00:51:18,080
>> Соберите свой вклад и хранить его в качестве переменной.

1006
00:51:18,080 --> 00:51:20,470
Великий.

1007
00:51:20,470 --> 00:51:24,280
Так что собирать строки,

1008
00:51:25,450 --> 00:51:27,880
хранить его в переменной.

1009
00:51:34,840 --> 00:51:36,460
Так есть ничего особенного, мы хотим сделать здесь?

1010
00:51:36,460 --> 00:51:39,700
Хотим ли мы, чтобы проверить их вклад

1011
00:51:39,700 --> 00:51:42,260
раньше -?

1012
00:51:42,260 --> 00:51:43,790
>> Да.

1013
00:51:43,790 --> 00:51:46,330
Что может мы хотим, чтобы проверить?

1014
00:51:46,330 --> 00:51:48,980
>> Ну, вы сказали, что мы не должны проверить, если он рядом, верно?

1015
00:51:48,980 --> 00:51:52,400
Потому что будем считать, что это строчная?

1016
00:51:52,400 --> 00:51:55,650
Да.

1017
00:51:56,380 --> 00:51:58,920
>> Вот и получается, что - да.

1018
00:51:58,920 --> 00:52:01,850
Так GetString гарантированно возвращает нам строку.

1019
00:52:01,850 --> 00:52:05,050
Он не собирается возвращать число к нам или что-нибудь подобное.

1020
00:52:05,050 --> 00:52:09,140
Там могут быть цифры символов в этой строке, однако.

1021
00:52:09,140 --> 00:52:13,460
И те, можно пренебречь, как мы делали капитализации.

1022
00:52:13,460 --> 00:52:16,620
Но пустая строка совершенно нормально,

1023
00:52:16,620 --> 00:52:19,900
так что дело здесь, на линии 4 и 5,

1024
00:52:19,900 --> 00:52:22,020
Право, где нет входа,

1025
00:52:22,020 --> 00:52:25,190
и мы ничего не положил, как наш выход.

1026
00:52:25,190 --> 00:52:28,730
Мы не должны беспокоиться о том, чтобы убедиться, что есть что-то в строку

1027
00:52:28,730 --> 00:52:31,840
или что строки не менее 4 символов;

1028
00:52:31,840 --> 00:52:34,190
все в порядке.

1029
00:52:34,190 --> 00:52:38,270
Так что это контрастирует, например, с подобными программами гроши, что вы написали

1030
00:52:38,270 --> 00:52:42,340
где вы должны были убедиться, что вы получаете неотрицательных чисел;

1031
00:52:42,340 --> 00:52:46,430
Вы должны были убедиться, что вы получаете правильное количество дней в месяце.

1032
00:52:46,430 --> 00:52:49,630
А как вы, ребята, делаете?

1033
00:52:49,630 --> 00:52:51,470
Как бы вы это сделать тест?

1034
00:52:51,470 --> 00:52:54,090
Что это требуется использовать?

1035
00:52:54,090 --> 00:52:55,650
>> Сделай то время как петли.

1036
00:52:55,650 --> 00:53:00,840
Сделай то время как петли, другие виды петель тоже, да.

1037
00:53:02,190 --> 00:53:04,520
Таким образом, оказывается, что мы не должны использовать цикл, в данном случае,

1038
00:53:04,520 --> 00:53:07,360
когда мы запросом строку, которая является отчасти хорошо.

1039
00:53:08,280 --> 00:53:10,620
>> Ладно, как двигаться дальше.

1040
00:53:12,410 --> 00:53:14,270
Таким образом, Стелла.

1041
00:53:14,270 --> 00:53:17,530
Можете ли Вы рассказать нам немного о том, что мы должны делать дальше?

1042
00:53:17,530 --> 00:53:20,270
Так что теперь у нас есть строка, что у нас есть оно хранится в переменной;

1043
00:53:20,270 --> 00:53:23,360
Что мы должны делать со строкой?

1044
00:53:26,790 --> 00:53:33,530
>> Мы должны -

1045
00:53:33,530 --> 00:53:36,550
определить 2 -

1046
00:53:36,550 --> 00:53:39,290
Да, просто сказать, что это на английском языке, что является удивительным.

1047
00:53:39,290 --> 00:53:42,670
Определить >> [неразборчиво] столиц - или, в верхнем регистре.

1048
00:53:44,420 --> 00:53:48,130
Да, так что вам определить, какие из них являются прописными и строчными буквами.

1049
00:53:50,020 --> 00:53:54,180
Мы не можем верхний или нижний регистр них, пока мы определили, какие именно.

1050
00:54:03,790 --> 00:54:06,350
Таким образом, мы положим, что в здесь.

1051
00:54:06,350 --> 00:54:10,210
>> Так что, просто думая об этом процессе,

1052
00:54:10,210 --> 00:54:13,200
как мы делаем это отождествление?

1053
00:54:13,200 --> 00:54:15,050
Знаете ли вы, Дэн?

1054
00:54:15,050 --> 00:54:18,120
Вид того, что мы - то, что инструмент, который мы должны были бы использовать из наших инструментов?

1055
00:54:18,120 --> 00:54:22,500
>> Я бы поставил его в чем-то, как в массиве или каждую линию

1056
00:54:22,500 --> 00:54:24,240
является его собственной маленькой коробке,

1057
00:54:24,240 --> 00:54:27,240
, а затем верхний его оттуда или нет.

1058
00:54:27,240 --> 00:54:30,440
Итак, один инструмент, мы можем использовать массив.

1059
00:54:30,440 --> 00:54:33,760
Что мы должны смотреть на в строке,

1060
00:54:33,760 --> 00:54:36,680
хотя, чтобы выяснить - у нас было смотреть на символы.

1061
00:54:36,680 --> 00:54:40,890
>> Так что у вас есть, чтобы посмотреть на длину строки?

1062
00:54:40,890 --> 00:54:43,880
Да, таким образом, часть, которая становится длину строки.

1063
00:54:50,450 --> 00:54:54,150
Просто из любопытства, что же мы используем, чтобы получить длину строки?

1064
00:54:54,150 --> 00:54:58,080
>> StrLen?

1065
00:54:58,080 --> 00:55:02,870
Да, StrLen, мы называем это "StrLen"

1066
00:55:04,180 --> 00:55:08,620
Все эти строки функции, так StrLen является функцией,

1067
00:55:08,620 --> 00:55:10,670
и это супер удобно, потому что мы можем использовать его, чтобы просто сказать:

1068
00:55:10,670 --> 00:55:13,430
Эй, StrLen: Вот строки, скажите мне, как долго это.

1069
00:55:13,430 --> 00:55:17,350
В сегодняшней лекции, Дэвид много говорили о том, как StrLen будет реализован,

1070
00:55:17,350 --> 00:55:20,370
что на самом деле происходит за кулисами.

1071
00:55:20,370 --> 00:55:25,450
Но это одна из самых супер удобная них.

1072
00:55:25,450 --> 00:55:29,170
Есть другие, которые также находятся в строке библиотеку,

1073
00:55:29,170 --> 00:55:34,690
таких как STRCMP, которая пишется "STRCMP»,

1074
00:55:34,690 --> 00:55:38,010
который используется для сравнения строк друг с другом.

1075
00:55:41,220 --> 00:55:45,020
Другой те, которые вы будете использовать, как strstr,

1076
00:55:45,020 --> 00:55:48,770
и это хорошо для нахождения под струны и так далее.

1077
00:55:48,770 --> 00:55:53,380
По большей части, все они начинаются с ул а затем идти дальше быть что-то еще.

1078
00:55:53,380 --> 00:55:57,080
Поэтому они на самом деле не записать их как строки и т. д.

1079
00:55:57,080 --> 00:56:00,260
Потому как еще в первые дни C,

1080
00:56:00,260 --> 00:56:04,100
когда люди впервые были письменно и все такое,

1081
00:56:04,100 --> 00:56:07,580
у них были ограничения на количество символов, которые можно использовать

1082
00:56:07,580 --> 00:56:09,950
для имен функций и переменных имена,

1083
00:56:09,950 --> 00:56:12,620
таким образом, все, как супер конденсированных.

1084
00:56:12,620 --> 00:56:15,750
Но в любое время вы видите то, что начинается с ул

1085
00:56:15,750 --> 00:56:18,600
Обычно это означает, что это имеет какое-то отношение к строке.

1086
00:56:20,990 --> 00:56:23,350
>> Итак, у вас есть, чтобы получить длину строки,

1087
00:56:23,350 --> 00:56:27,110
а затем, что мы будем делать с героями?

1088
00:56:27,110 --> 00:56:29,020
Знаете ли вы, Сэм?

1089
00:56:29,020 --> 00:56:32,410
>> Я понятия не имею, я пытался выяснить это.

1090
00:56:32,410 --> 00:56:35,410
Я действительно не знаю, - я хотел было каким-то образом -

1091
00:56:35,410 --> 00:56:38,990
Я имею в виду, я думаю, может быть, мы могли бы сделать что-то с четные и нечетные,

1092
00:56:38,990 --> 00:56:40,860
Но я не знаю ни одной функции, как, что.

1093
00:56:40,860 --> 00:56:42,240
Да.

1094
00:56:43,160 --> 00:56:45,200
>> Но что - это не обязательно будет работать,

1095
00:56:45,200 --> 00:56:48,690
потому что тогда вы получите пространство, чтобы быть -

1096
00:56:48,690 --> 00:56:51,130
Вы должны были бы иметь место, чтобы получить советы о том, как -

1097
00:56:51,130 --> 00:56:54,310
Хорошо.

1098
00:56:54,310 --> 00:56:56,490
>> Я не знаю - я бы потерял в этой точке.

1099
00:56:56,490 --> 00:56:58,120
Да - нет, нет, нет, это хорошие очки.

1100
00:56:58,120 --> 00:57:00,420
Итак, что мы должны сделать, это, как сказал Сэм,

1101
00:57:00,420 --> 00:57:02,970
мы должны отслеживать, какие письма являются нечетными буквами,

1102
00:57:02,970 --> 00:57:05,540
и какие из них даже буквы.

1103
00:57:06,650 --> 00:57:09,090
Но мы хотим убедиться, что мы не просто ищет

1104
00:57:09,090 --> 00:57:12,110
на четные и нечетные

1105
00:57:12,110 --> 00:57:14,030
Индексы в строку,

1106
00:57:14,030 --> 00:57:17,660
а глядя на четных и нечетных букв в строке,

1107
00:57:17,660 --> 00:57:20,190
поэтому мы должны иметь своего рода это различие между

1108
00:57:20,190 --> 00:57:25,190
букв - как то, что на самом деле A, B, C, D, или так далее,

1109
00:57:25,190 --> 00:57:29,090
и то, что вещи не являются буквами, но по-прежнему в наших строку.

1110
00:57:29,090 --> 00:57:32,390
Например, здесь, как это восклицательный знак не является буквой,

1111
00:57:32,390 --> 00:57:36,060
но это все еще часть нашей строк, это по-прежнему символ.

1112
00:57:36,060 --> 00:57:38,820
Кроме того, все эти пространства -

1113
00:57:38,820 --> 00:57:41,710
это не имеет смысла для своей выгоды пространстве, не так ли?

1114
00:57:41,710 --> 00:57:46,160
Таким образом, мы хотим убедиться, что мы каким-то образом пропустить те,

1115
00:57:46,160 --> 00:57:49,410
в то же время отслеживания четные и нечетные.

1116
00:57:50,900 --> 00:57:54,990
>> Так вроде в нашем программирования инструментов

1117
00:57:54,990 --> 00:57:57,270
до сих пор, если хотите,

1118
00:57:57,270 --> 00:58:01,310
у нас есть целый ряд различных инструментов, которые мы уже обсуждали.

1119
00:58:01,310 --> 00:58:04,640
Так что, например, являются переменными,

1120
00:58:04,640 --> 00:58:07,120
как мы уже говорили здесь.

1121
00:58:07,120 --> 00:58:10,730
Другим инструментом, мы говорили о функции.

1122
00:58:10,730 --> 00:58:15,800
Итак, мы говорили о переменных в нашем псевдокоде здесь

1123
00:58:15,800 --> 00:58:19,760
как то, что мы собираемся использовать для хранения нашу строку.

1124
00:58:19,760 --> 00:58:24,630
Мы говорили о функциях, чтобы получить длину строки, как StrLen.

1125
00:58:28,510 --> 00:58:31,170
Мы говорили о чем-то другом, и мы говорили об этом

1126
00:58:31,170 --> 00:58:34,850
на много выше в разделе Сегодня: петли.

1127
00:58:39,390 --> 00:58:42,030
>> Что вы, ребята, думаете об использовании петли в этой программе?

1128
00:58:42,030 --> 00:58:44,110
Джаред, что ты думаешь?

1129
00:58:47,150 --> 00:58:50,030
Будем ли мы использовать цикл в этой программе?

1130
00:58:50,030 --> 00:58:52,500
>> Наверное, нет, нет, потому что вам не придется пройти через это несколько раз.

1131
00:58:52,500 --> 00:58:55,260
Ладно, вы не должны пройти через то, что более одного раза?

1132
00:58:55,260 --> 00:58:57,190
>> Всю строку.

1133
00:58:57,190 --> 00:59:00,660
Право, так что вам не придется пройти через всю строку сразу.

1134
00:59:00,660 --> 00:59:03,330
Извините, что имело абсолютно никакого смысла!

1135
00:59:03,330 --> 00:59:06,360
Вам не придется пройти через всю строку несколько раз.

1136
00:59:06,360 --> 00:59:08,660
Хорошо.

1137
00:59:09,790 --> 00:59:11,920
Что вы думаете?

1138
00:59:11,920 --> 00:59:14,110
>> Я думаю, что лучше их использовать

1139
00:59:14,110 --> 00:59:16,640
так что мы можем сделать, как капитализировать в то время как

1140
00:59:16,640 --> 00:59:19,750
расположение это [неразборчиво] числа.

1141
00:59:19,750 --> 00:59:22,940
Великий, и поэтому выгоды и что?

1142
00:59:22,940 --> 00:59:25,200
Итак, мы говорим, что

1143
00:59:25,200 --> 00:59:28,130
Мы должны использовать цикл, потому что мы хотим

1144
00:59:28,130 --> 00:59:32,550
заглавной буквы, хотя это не число.

1145
00:59:35,130 --> 00:59:37,140
Так что - извините, вы хотите добавить?

1146
00:59:37,140 --> 00:59:39,340
>> Я хочу сказать, что, как вы относитесь строкой

1147
00:59:39,340 --> 00:59:42,290
и это [неразборчиво] отдельные [неразборчиво] на символы?

1148
00:59:42,290 --> 00:59:43,710
Да.

1149
00:59:43,710 --> 00:59:45,850
>> И тогда мы можем присвоить номера -

1150
00:59:45,850 --> 00:59:47,780
или на основе расположения букв в строке?

1151
00:59:47,780 --> 00:59:49,720
Да.

1152
00:59:49,720 --> 00:59:53,640
>> А определить, является ли это четное или нечетное и воспользоваться само письмо

1153
00:59:53,640 --> 00:59:57,750
в то время как расположение письмо [неразборчиво] - извините.

1154
00:59:57,750 --> 01:00:00,150
Великий.

1155
01:00:00,150 --> 01:00:03,430
>> Так что резюме.

1156
01:00:03,430 --> 01:00:05,840
Можете ли вы напоминаете мне вашего имени еще раз - простите.

1157
01:00:05,840 --> 01:00:06,900
>> Шарлотта.

1158
01:00:06,900 --> 01:00:08,490
Шарлотта, все в порядке.

1159
01:00:08,490 --> 01:00:11,130
Так что Шарлотта говорит:

1160
01:00:11,130 --> 01:00:14,950
который полностью правы - боже, это любит авто отступ на меня -

1161
01:00:14,950 --> 01:00:17,770
является то, что если мы посмотрим на строку

1162
01:00:17,770 --> 01:00:19,160
таких как этот вверху -

1163
01:00:19,160 --> 01:00:21,590
"Спасибо за дополнения", -

1164
01:00:21,590 --> 01:00:24,790
в виде последовательности символов

1165
01:00:24,790 --> 01:00:29,010
где находится в положении 0,

1166
01:00:29,010 --> 01:00:32,260
ч находится в положении 1.

1167
01:00:32,260 --> 01:00:36,880
А на 2, то мы получили 3, 4, 5;

1168
01:00:36,880 --> 01:00:40,830
пространство находится в положении 6.

1169
01:00:42,380 --> 01:00:45,300
Принимая во внимание, - то, что позиция е?

1170
01:00:45,300 --> 01:00:47,610
7!

1171
01:00:47,610 --> 01:00:49,300
O? 8.

1172
01:00:49,300 --> 01:00:52,070
R? 9.

1173
01:00:52,070 --> 01:00:54,340
И тогда у нас 10, а затем я не могу писать без него

1174
01:00:54,340 --> 01:00:57,430
своего рода получение грязно на экране.

1175
01:00:57,430 --> 01:01:02,340
Но это на самом деле, как мы можем говорить о строках в памяти.

1176
01:01:02,340 --> 01:01:04,660
Это строки

1177
01:01:04,660 --> 01:01:07,920
представляет собой последовательность символов,

1178
01:01:07,920 --> 01:01:12,430
и когда мы говорим об отдельных символов в строке,

1179
01:01:12,430 --> 01:01:15,280
Мы часто делают это, ссылаясь на позицию, что персонаж

1180
01:01:15,280 --> 01:01:17,620
в строке,

1181
01:01:17,620 --> 01:01:19,910
Вероятно, так же, как мы говорим о сентябре

1182
01:01:19,910 --> 01:01:22,870
девятый месяц года

1183
01:01:22,870 --> 01:01:27,730
или в понедельник как первый день недели.

1184
01:01:29,280 --> 01:01:33,070
Таким образом, это дает нам возможность

1185
01:01:33,070 --> 01:01:37,030
выяснить, какие из них являются нечетными даже по сравнению с

1186
01:01:37,030 --> 01:01:39,540
потому что вы можете увидеть здесь,

1187
01:01:39,540 --> 01:01:43,640
если мы сопоставляем его с этой T,

1188
01:01:46,310 --> 01:01:49,360
Вы можете видеть, что все те, капитализированные

1189
01:01:49,360 --> 01:01:53,040
находятся на четных позициях,

1190
01:01:53,040 --> 01:01:55,880
по крайней мере, первое слово,

1191
01:01:55,880 --> 01:01:59,080
а потом все становится сбросил раз мы попали, что пространство,

1192
01:01:59,080 --> 01:02:02,460
потому что мы не считаем это пространство как письмо,

1193
01:02:02,460 --> 01:02:05,150
так что это как если бы мы начали

1194
01:02:05,150 --> 01:02:08,930
и пошли 0, 1, 2, 3, 4, 5,

1195
01:02:08,930 --> 01:02:12,600
пространстве, 6, 7, 8, пространство,

1196
01:02:12,600 --> 01:02:16,440
9, а затем 10, 11, 12, и так далее.

1197
01:02:19,300 --> 01:02:22,910
>> Cool, так что мы определенно хотим использовать какой-то цикл

1198
01:02:22,910 --> 01:02:27,760
перейти на каждого из персонажей по очереди.

1199
01:02:31,330 --> 01:02:34,580
Таким образом, на данный момент,

1200
01:02:36,490 --> 01:02:38,360
мы вернемся к нашему старому псевдокод здесь.

1201
01:02:40,970 --> 01:02:42,650
В рамках этого определения, какие из них

1202
01:02:42,650 --> 01:02:45,350
в верхнем регистре, а какие строчными буквами,

1203
01:02:45,350 --> 01:02:48,340
мы хотим сделать это в какой-то цикл.

1204
01:02:51,080 --> 01:02:53,390
Loop, толстой кишки.

1205
01:02:55,070 --> 01:03:01,220
Какие петли, из видов петель, которые у нас есть,

1206
01:03:01,220 --> 01:03:03,670
кажется хорошим, чтобы использовать в этом случае?

1207
01:03:03,670 --> 01:03:05,610
>> Я думал цикла.

1208
01:03:05,610 --> 01:03:07,500
А почему вы думаете для цикла?

1209
01:03:07,500 --> 01:03:10,000
>> Потому что он начинается с нуля, а затем

1210
01:03:10,000 --> 01:03:13,000
когда мы достигаем длины строки,

1211
01:03:13,000 --> 01:03:16,170
, а затем каждой итерации можно [неразборчиво], тоже?

1212
01:03:16,170 --> 01:03:18,260
Да, именно так.

1213
01:03:18,260 --> 01:03:21,490
Так, из различных вариантов петель,

1214
01:03:21,490 --> 01:03:25,350
у нас есть для петель, а петли, и делать-то время петель.

1215
01:03:25,350 --> 01:03:28,550
Где цикла особенно полезно

1216
01:03:28,550 --> 01:03:32,120
когда вы хотите знать,

1217
01:03:32,120 --> 01:03:34,940
вид, где вы находитесь в цикле,

1218
01:03:34,940 --> 01:03:38,520
сколько раз цикл был выполнен до сих пор.

1219
01:03:38,520 --> 01:03:42,490
Какие именно то, что мы хотим знать, в этой ситуации,

1220
01:03:42,490 --> 01:03:44,640
как сказал Келли,

1221
01:03:44,640 --> 01:03:47,400
основаны от ранних комментариев Шарлотты, что мы хотим знать положение

1222
01:03:47,400 --> 01:03:49,900
символа в строке,

1223
01:03:49,900 --> 01:03:51,750
и цикл даст нам только, что,

1224
01:03:51,750 --> 01:03:54,680
потому что, если мы начнем вид оглядываясь на нашу строку,

1225
01:03:54,680 --> 01:03:57,140
если мы начнем наш цикл на 0,

1226
01:03:57,140 --> 01:04:00,350
и идем вверх по длине всей строки,

1227
01:04:00,350 --> 01:04:04,740
Затем можно сопоставить букву Т

1228
01:04:04,740 --> 01:04:08,110
с 0 в наш цикл,

1229
01:04:09,950 --> 01:04:13,080
Письмо с H 1 в нашем цикл, и так далее,

1230
01:04:13,080 --> 01:04:16,600
пройдя весь путь до конца строки.

1231
01:04:18,810 --> 01:04:21,890
>> Итак, давайте начнем кодирования это просто немного

1232
01:04:21,890 --> 01:04:24,930
только так вы, ребята, почувствовать, на что это похоже.

1233
01:04:24,930 --> 01:04:27,980
Я собираюсь сохранить,

1234
01:04:27,980 --> 01:04:31,230
таким образом, мы получили наши псевдо-код здесь,

1235
01:04:33,490 --> 01:04:38,120
и я хочу удалить все.

1236
01:04:38,120 --> 01:04:42,210
Так что у меня чистого листа.

1237
01:04:42,210 --> 01:04:45,910
Я собираюсь начать с написания Int основных (недействительными)

1238
01:04:45,910 --> 01:04:48,440
{

1239
01:04:48,440 --> 01:04:51,380
Я собираюсь поставить возвращение 0 в

1240
01:04:51,380 --> 01:04:53,320
, а затем}.

1241
01:04:53,320 --> 01:04:56,130
Так что обычно, когда я начинаю программу, это то, что я начинаю с.

1242
01:04:56,130 --> 01:04:59,370
Я спасу его так, что вы, ребята, есть.

1243
01:05:06,290 --> 01:05:08,440
Таким образом, одна из первых вещей, о которых мы говорили было

1244
01:05:08,440 --> 01:05:10,920
получения входных данных от пользователя

1245
01:05:10,920 --> 01:05:13,740
и хранить его в строку.

1246
01:05:13,740 --> 01:05:16,420
Как мы можем получить ввод от пользователя?

1247
01:05:16,420 --> 01:05:19,640
>> GetString.

1248
01:05:19,640 --> 01:05:21,870
GetString, все в порядке.

1249
01:05:23,150 --> 01:05:26,820
Так что, если я печатаю GetString ()

1250
01:05:26,820 --> 01:05:32,150
и точка с запятой.

1251
01:05:32,150 --> 01:05:36,630
Давайте попробуем запустить этот, это будет перспективе, в первую очередь?

1252
01:05:36,630 --> 01:05:38,430
А почему не будет этого бежать?

1253
01:05:38,430 --> 01:05:40,090
>> Вы должны объявить переменную.

1254
01:05:40,090 --> 01:05:43,040
Я должен объявить переменную. Хорошо.

1255
01:05:43,040 --> 01:05:45,700
>> Так как я могу это сделать?

1256
01:05:45,700 --> 01:05:48,400
Вы не возражаете, что-то писал, разделяя его?

1257
01:05:48,400 --> 01:05:51,270
И тогда мы можем потяните его вверх.

1258
01:05:51,270 --> 01:05:54,630
Давайте посмотрим, Дэн, право, хорошо.

1259
01:05:54,630 --> 01:05:59,100
Или Даниил. Скопируйте что в России, строка ввода = GetString ().

1260
01:05:59,100 --> 01:06:01,340
Awesome.

1261
01:06:01,340 --> 01:06:02,890
Будет ли это работать?

1262
01:06:02,890 --> 01:06:05,210
Давайте попробуем.

1263
01:06:05,210 --> 01:06:08,890
Меткость перспективе, загрузки исходного кода, строительство, произошла ошибка.

1264
01:06:08,890 --> 01:06:11,040
Хорошо.

1265
01:06:11,040 --> 01:06:14,950
Так, что здесь происходит?

1266
01:06:14,950 --> 01:06:18,700
Использование 'строка' необъявленный идентификатор.

1267
01:06:18,700 --> 01:06:22,840
>> Мы должны включить библиотеки?

1268
01:06:22,840 --> 01:06:25,130
Да, так что Дэн говорит, что мы должны включать библиотеки.

1269
01:06:25,130 --> 01:06:28,270
Это то, что вы собираетесь сказать, Стелла? Awesome.

1270
01:06:29,450 --> 01:06:31,430
Это потрясающе, поэтому Стелла, ты можешь

1271
01:06:31,430 --> 01:06:34,800
скопируйте код из космического Даниила?

1272
01:06:34,800 --> 01:06:37,580
Если вы нажмете на Daniel Roland Ги, скопируйте его,

1273
01:06:37,580 --> 01:06:41,360
и тогда вы сможете поставить включают линейный вход, а затем сохранить его?

1274
01:06:46,580 --> 01:06:49,360
Дайте мне знать, когда вы будете готовы.

1275
01:06:57,160 --> 01:06:59,490
Так что этот синтаксис включает также виды фанк;

1276
01:06:59,490 --> 01:07:02,210
там все равно, что хэш-тег,

1277
01:07:02,210 --> 01:07:05,760
и там включать, и тогда эти угловые скобки.

1278
01:07:12,490 --> 01:07:15,360
Вы помните, как это работает, или я должен положить его на этот код прямо здесь?

1279
01:07:15,360 --> 01:07:17,850
>> Я в порядке.

1280
01:07:17,850 --> 01:07:19,810
Хорошо.

1281
01:07:19,810 --> 01:07:23,260
>> Я напечатал его - я не был уверен, какой библиотекой, однако.

1282
01:07:23,260 --> 01:07:25,570
Ну, ладно - да, так что это CS50 библиотеки.

1283
01:07:25,570 --> 01:07:27,660
>> О, я положил STDIO библиотеки.

1284
01:07:27,660 --> 01:07:30,950
>> Ах, он получил - да, Нет, это -

1285
01:07:30,950 --> 01:07:34,380
так получается, что строка на самом деле то, что является особенным для CS50.

1286
01:07:36,590 --> 01:07:41,240
Там на самом деле не является истинным типом строка

1287
01:07:41,240 --> 01:07:45,000
, потому что именно здесь, строка в тип позиции, -

1288
01:07:45,000 --> 01:07:49,140
Мы объявлении переменной называется входом типа строка -

1289
01:07:49,140 --> 01:07:53,320
и мы помещаем внутрь вход

1290
01:07:53,320 --> 01:07:58,440
значение, которое получает вернулся к нам: выход этого GetString вызова функции.

1291
01:07:58,440 --> 01:08:02,910
Вы можете сказать, что это вызов функции, потому что у него есть скобки, как Printf делает,

1292
01:08:02,910 --> 01:08:05,920
как StrLen делает.

1293
01:08:05,920 --> 01:08:09,860
Но строка на самом деле не настоящая типа

1294
01:08:09,860 --> 01:08:11,760
В языке Си.

1295
01:08:11,760 --> 01:08:15,710
Мы сделали это в тип, и мы будем принимать нечто большее, то, что есть на самом деле

1296
01:08:15,710 --> 01:08:19,000
В C, потому что есть способ работы со строками;

1297
01:08:19,000 --> 01:08:22,479
мы только что сделали что-то, чтобы он выглядел немного лучше.

1298
01:08:22,479 --> 01:08:25,240
>> Таким образом, здесь мы идем.

1299
01:08:25,240 --> 01:08:28,439
Вот код Стеллы.

1300
01:08:28,439 --> 01:08:32,470
Она получила # включить <cs50.h>.

1301
01:08:32,470 --> 01:08:36,390
Другие люди будут называть это как хэш иногда включать или резкое включить.

1302
01:08:36,390 --> 01:08:39,580
Теперь мы можем запустить его, запустить его,

1303
01:08:39,580 --> 01:08:43,649
и мы все еще получаете сообщение об ошибке.

1304
01:08:43,649 --> 01:08:46,290
Давайте посмотрим, что происходит.

1305
01:08:48,069 --> 01:08:50,569
"Неиспользуемые переменные" вход ".

1306
01:08:50,569 --> 01:08:53,350
Итак, это круто, это круто.

1307
01:08:53,350 --> 01:08:55,859
Я имею в виду, это не очень здорово,

1308
01:08:55,859 --> 01:08:57,930
потому что мы получаю сообщение об ошибке, и он не работает,

1309
01:08:57,930 --> 01:09:00,410
но то, что это говорит, что

1310
01:09:00,410 --> 01:09:03,130
мы не использовали наши переменной, которая имеет смысл.

1311
01:09:03,130 --> 01:09:06,090
Мы не пытались ничего сделать с ним.

1312
01:09:07,819 --> 01:09:10,490
Это так, что

1313
01:09:10,490 --> 01:09:14,170
Clang пытается помочь нам удостовериться, что мы не только с помощью переменных

1314
01:09:14,170 --> 01:09:18,819
а потом случайно называя их что-то еще позже в нашем коде,

1315
01:09:18,819 --> 01:09:21,649
помогает нам избежать ошибок, которые путем.

1316
01:09:23,130 --> 01:09:28,810
>> Ладно, у нас есть вход от пользователя,

1317
01:09:28,810 --> 01:09:31,910
Мы сохранили его в переменную.

1318
01:09:31,910 --> 01:09:34,569
Следующим шагом было то

1319
01:09:34,569 --> 01:09:37,609
начать смотреть на все символы в строке

1320
01:09:37,609 --> 01:09:41,830
и определения, какие из них должны быть заглавными

1321
01:09:41,830 --> 01:09:44,600
и какие из них должны быть в нижнем регистре.

1322
01:09:44,600 --> 01:09:49,439
И, как Келли и Шарлотта воспитан,

1323
01:09:49,439 --> 01:09:52,340
Сделаем это с помощью цикла.

1324
01:09:52,340 --> 01:09:55,520
Так кто-нибудь помнит синтаксис для цикла

1325
01:09:55,520 --> 01:09:58,670
и хотели бы принять удар на просто писать

1326
01:09:58,670 --> 01:10:03,170
Первая строка цикла, только для бит?

1327
01:10:05,740 --> 01:10:07,330
Келли, ты хочешь попробовать?

1328
01:10:07,330 --> 01:10:10,300
>> Да, так что вы должны инициализировать первой,

1329
01:10:10,300 --> 01:10:13,170
так что я положил = 0,

1330
01:10:13,170 --> 01:10:15,390
а потом сделал я <StrLen ().

1331
01:10:15,390 --> 01:10:18,570
Есть ли в вашей Space - я могу вытащить его?

1332
01:10:18,570 --> 01:10:21,330
>> Да, я облажался немного, но да.

1333
01:10:21,330 --> 01:10:24,180
>> Хорошо, давайте потяните его вверх.

1334
01:10:24,180 --> 01:10:26,490
Awesome.

1335
01:10:26,490 --> 01:10:29,510
>> Но тогда я не знал, если у вас что -

1336
01:10:29,510 --> 01:10:32,180
Да, все в порядке.

1337
01:10:33,020 --> 01:10:36,030
Итак, вот что Келли получил: давайте посмотрим на это быстро.

1338
01:10:36,030 --> 01:10:40,290
Так что она включена CS50 библиотеке на самом верху.

1339
01:10:40,290 --> 01:10:44,790
Она включена в стандартную библиотеку ввода-вывода в верхней части,

1340
01:10:45,550 --> 01:10:48,990
и стандартного ввода-вывода имеет такие функции, как Printf,

1341
01:10:48,990 --> 01:10:51,690
так что если вы хотите использовать Printf, нужно эту линию.

1342
01:10:53,060 --> 01:10:56,140
А потом она включена строка библиотеки,

1343
01:10:56,140 --> 01:10:58,200
которых мы будем нуждаться,

1344
01:10:58,200 --> 01:11:01,010
потому что строка библиотеке StrLen функции,

1345
01:11:01,010 --> 01:11:04,320
которые мы получим в только немного.

1346
01:11:04,320 --> 01:11:07,560
Таким образом, если мы посмотрим на то, что Келли сделал здесь,

1347
01:11:07,560 --> 01:11:10,260
Вы можете идти с нами через что ты сделал?

1348
01:11:10,260 --> 01:11:13,600
>> Да, так - я имею в виду, у меня есть ошибки, а значит -

1349
01:11:13,600 --> 01:11:15,380
Да, Нет, это -

1350
01:11:15,380 --> 01:11:18,580
>> Так я хотел назвать строка, что я получил только "строка".

1351
01:11:18,580 --> 01:11:22,230
Я хотел, чтобы распечатать строку

1352
01:11:22,230 --> 01:11:25,640
а потом -

1353
01:11:27,450 --> 01:11:30,930
Я хотел бы хотела задать строку как массив каждого символа

1354
01:11:30,930 --> 01:11:33,170
быть различными [неразборчиво], правильно?

1355
01:11:33,170 --> 01:11:38,080
И тогда я хотел бы начать в позиции 0

1356
01:11:38,080 --> 01:11:40,630
, а затем каждые 2 места,

1357
01:11:40,630 --> 01:11:42,580
Я собирался воспользоваться,

1358
01:11:42,580 --> 01:11:45,680
так что я просто описал его как 23, так как я смотрел на ASCII таблицы.

1359
01:11:45,680 --> 01:11:48,730
Так вот что я думаю - я знаю, что это не так.

1360
01:11:48,730 --> 01:11:50,920
>> Понял, так что это отличное начало.

1361
01:11:50,920 --> 01:11:54,120
Я думаю, что много рамки в место здесь.

1362
01:11:54,120 --> 01:11:57,500
Давайте рассмотрим виды строка за строкой и посмотреть, что происходит.

1363
01:11:57,500 --> 01:12:01,040
Таким образом, я хотел бы сделать это только начало скомпилировать код

1364
01:12:01,040 --> 01:12:04,300
и позволить компилятору скажи мне, как то, что случилось с моим кодом,

1365
01:12:04,300 --> 01:12:07,450
потому что компилятор действительно хорошо говорю вам, что не так с вашим кодом.

1366
01:12:09,790 --> 01:12:12,780
Таким образом, если мы играем, строительство, и оно не строить.

1367
01:12:12,780 --> 01:12:14,860
Она говорит, что была ошибка,

1368
01:12:14,860 --> 01:12:17,320
поэтому, если мы прокрутите вниз и посмотрите на первую ошибку,

1369
01:12:17,320 --> 01:12:20,960
он сказал -

1370
01:12:20,960 --> 01:12:22,040
Мы прокрутить назад до самого верха,

1371
01:12:22,040 --> 01:12:26,070
мы видим, есть 5 ошибок, возникающих здесь внизу.

1372
01:12:26,070 --> 01:12:30,180
К сожалению, это действительно отрезали.

1373
01:12:31,810 --> 01:12:35,790
Я думаю, что просто не получите ничего лучшего.

1374
01:12:36,970 --> 01:12:38,500
>> Здесь мы идем.

1375
01:12:39,790 --> 01:12:42,530
Таким образом, существует всего 5 ошибок, генерируемых.

1376
01:12:42,530 --> 01:12:45,140
Здесь я вижу только первые 2,

1377
01:12:45,140 --> 01:12:49,100
так я могу двигаться до этого немного, а затем вид прокрутки вверх.

1378
01:12:49,100 --> 01:12:53,220
Это команда, которая была запущена для компиляции кода,

1379
01:12:53,220 --> 01:12:59,030
, а затем первая ошибка была в file.c прямо здесь:

1380
01:12:59,030 --> 01:13:03,300
"Ожидается определить или '('", и именно на этой линии

1381
01:13:03,300 --> 01:13:06,680
где мы сказали String = GetString ().

1382
01:13:07,660 --> 01:13:12,920
Вы можете посмотреть прямо здесь, что это было на строку 8 file.c,

1383
01:13:12,920 --> 01:13:17,230
и тогда я считаю, что это символ 12 - это ошибка.

1384
01:13:17,230 --> 01:13:20,390
Так что же происходит неправильно в строке 8 - Келли?

1385
01:13:20,390 --> 01:13:22,810
>> Вам просто нужно называть это, вроде бы, письмо или что-то,

1386
01:13:22,810 --> 01:13:24,400
как строка с или что-то?

1387
01:13:24,400 --> 01:13:28,250
Да, так получается, что эти специальные имена типа,

1388
01:13:28,250 --> 01:13:31,770
так что строка, Int, Char, короткие,

1389
01:13:31,770 --> 01:13:35,740
они все специальные ключевые слова,

1390
01:13:35,740 --> 01:13:38,940
и вы не можете использовать их как имена ваших переменных,

1391
01:13:38,940 --> 01:13:41,430
потому что компилятор смотрит на это и говорит:

1392
01:13:41,430 --> 01:13:43,680
"О, я знаю, что это типа"

1393
01:13:43,680 --> 01:13:46,530
поэтому вы не можете на самом деле есть строка переменной строки,

1394
01:13:46,530 --> 01:13:50,800
как я пытаюсь делать здесь, это не будет работать.

1395
01:13:52,610 --> 01:13:58,250
Но вместо этого, мы можем назвать это что-то вроде с и й или ул.

1396
01:13:58,250 --> 01:14:01,540
Мы также не могли бы назвать это Int.

1397
01:14:01,540 --> 01:14:03,740
Мы не можем есть строка называется Int.

1398
01:14:03,740 --> 01:14:06,740
Мы не можем есть строка называется символ, и никто из тех, кто будет работать.

1399
01:14:06,740 --> 01:14:09,420
>> Так что мы просто называем это с в настоящее время.

1400
01:14:10,630 --> 01:14:13,170
Awesome.

1401
01:14:13,170 --> 01:14:17,500
Так что же дальше происходит в этой строке?

1402
01:14:21,390 --> 01:14:24,350
String - эта линия выглядит довольно хорошо?

1403
01:14:24,350 --> 01:14:27,830
Давайте дадим ему еще один шанс, давайте запустить его.

1404
01:14:27,830 --> 01:14:30,360
Итак, мы по-прежнему получаю ошибки.

1405
01:14:30,360 --> 01:14:32,080
На этот раз, мы до 4 ошибки.

1406
01:14:32,080 --> 01:14:34,350
Таким образом, мы получили одну из них.

1407
01:14:34,350 --> 01:14:36,130
Давайте двигаться вверх.

1408
01:14:36,130 --> 01:14:38,890
"Неожиданный имя типа 'строка': ожидается выражение" да?

1409
01:14:38,890 --> 01:14:41,780
>> Да, это потому, что я попытался назвать строку.

1410
01:14:41,780 --> 01:14:44,270
Да, так что, похоже, мы теперь должны идти исправление

1411
01:14:44,270 --> 01:14:46,560
Все эти ссылки на строки.

1412
01:14:46,560 --> 01:14:50,070
Вы можете видеть, что есть ссылка на строку, по одному, по одному здесь,

1413
01:14:50,070 --> 01:14:53,440
так что мы можем переместить все эти в с.

1414
01:14:56,040 --> 01:15:00,930
Великий. Хорошо, запустите его снова.

1415
01:15:00,930 --> 01:15:03,260
Строительство - другая ошибка.

1416
01:15:03,260 --> 01:15:06,900
>> Хорошо, теперь мы до одной ошибки,

1417
01:15:06,900 --> 01:15:11,090
так Int I = S, а затем в квадратных скобках.

1418
01:15:11,090 --> 01:15:14,880
Таким образом, вы можете рассказать нам немного о том, что вы делаете здесь, Келли?

1419
01:15:14,880 --> 01:15:17,120
>> Да.

1420
01:15:17,120 --> 01:15:19,410
Это было на линии 10.

1421
01:15:19,410 --> 01:15:22,760
>> Я не знаю, если мы нуждались в нем все,

1422
01:15:22,760 --> 01:15:25,560
Но я думаю, что я пытался -

1423
01:15:25,560 --> 01:15:27,580
Я спасу его, чтобы вы могли следить вместе.

1424
01:15:27,580 --> 01:15:30,470
>> Я думаю, что я был

1425
01:15:30,470 --> 01:15:33,150
пытался сказать ему, чтобы начать в положение 0

1426
01:15:33,150 --> 01:15:35,030
В начале моего цикла,

1427
01:15:35,030 --> 01:15:38,370
так что я думаю, может быть, говорил, было ненужным.

1428
01:15:39,690 --> 01:15:41,350
Так просто Напомним, что

1429
01:15:41,350 --> 01:15:44,850
Вы говорили, что это - Вы пытались начать это в позиции 0

1430
01:15:44,850 --> 01:15:47,030
и получить это - да,

1431
01:15:47,030 --> 01:15:50,460
поэтому я думаю, раньше, тоже, когда вы шли через код,

1432
01:15:50,460 --> 01:15:54,070
Вы говорили о том, как вы хотели лечить строку как массив

1433
01:15:54,070 --> 01:15:57,440
так что мы можем получить доступ каждого персонажа в отдельности.

1434
01:15:57,440 --> 01:16:00,660
Я думаю, что Дэн упомянутых массивов, тоже пытается преобразовать строки в массивы.

1435
01:16:01,400 --> 01:16:03,300
>> Оказывается, что вид под капотом,

1436
01:16:03,300 --> 01:16:06,060
Строка на самом деле хранится в виде массива уже,

1437
01:16:06,060 --> 01:16:08,060
и вы можете обращаться к нему как массив;

1438
01:16:08,060 --> 01:16:12,390
нет преобразования, которые вы должны сделать.

1439
01:16:12,390 --> 01:16:15,770
Строка разве - так -

1440
01:16:15,770 --> 01:16:18,200
Строка на самом деле не массив,

1441
01:16:18,200 --> 01:16:21,940
но Вы можете получить доступ к нему как такового, поскольку все символы хранятся

1442
01:16:21,940 --> 01:16:25,160
один прямо рядом друг с другом в памяти,

1443
01:16:25,160 --> 01:16:28,310
так что если вы хотите, чтобы получить первый символ строки,

1444
01:16:28,310 --> 01:16:31,910
это то же самое, как получить первое число в массив целых чисел.

1445
01:16:31,910 --> 01:16:35,010
Таким образом, мы часто - МЫ

1446
01:16:35,010 --> 01:16:36,360
относятся к 2, как

1447
01:16:36,360 --> 01:16:38,590
ой, как строку, как массив,

1448
01:16:38,590 --> 01:16:40,830
хотя на самом деле - они очень разные вещи,

1449
01:16:40,830 --> 01:16:43,410
но вы можете относиться к ним очень то же самое.

1450
01:16:44,700 --> 01:16:47,400
Вот и получается, что эта линия на самом деле -

1451
01:16:47,400 --> 01:16:51,270
нам не нужно делать какие-либо преобразования,

1452
01:16:51,270 --> 01:16:53,500
и в самом деле,

1453
01:16:53,500 --> 01:16:56,790
это на самом деле не является допустимым выражением,

1454
01:16:56,790 --> 01:16:59,040
что и наш компилятор говорит нам.

1455
01:16:59,040 --> 01:17:01,290
Он говорит: "Эй, это ожидалось выражение,

1456
01:17:01,290 --> 01:17:04,610
и что я получил здесь является то, что это не слова ".

1457
01:17:04,610 --> 01:17:07,310
Чтобы объявить массив,

1458
01:17:07,310 --> 01:17:11,780
Все, что вам нужно сделать, это что-то вроде этого с запятой,

1459
01:17:11,780 --> 01:17:15,080
а затем вы говорите массива, как долго вы хотите, чтобы он,

1460
01:17:15,080 --> 01:17:18,370
такие как 5, так что эта линия 10

1461
01:17:18,370 --> 01:17:23,880
будет объявить массив называется я с 5 чисел в нем.

1462
01:17:23,880 --> 01:17:26,540
>> Это в сторону, это не является необходимым для кода,

1463
01:17:26,540 --> 01:17:30,970
Но это - это вроде того, что заявление выглядит.

1464
01:17:30,970 --> 01:17:35,310
>> Как бы вам не использовать символ I [StrLen (ы)]?

1465
01:17:35,310 --> 01:17:38,500
Char я [StrLen (ы)]?

1466
01:17:38,500 --> 01:17:41,500
>> CHAR I, а затем в скобках, StrLen (ы).

1467
01:17:43,900 --> 01:17:47,710
Да, так что мы могли -

1468
01:17:47,710 --> 01:17:49,460
Мы могли бы сделать это,

1469
01:17:49,460 --> 01:17:52,160
и это было бы объявить - что бы это сделать?

1470
01:17:52,160 --> 01:17:55,900
>> Я думаю, было бы объявить массив

1471
01:17:55,900 --> 01:18:01,780
из, например, - из -

1472
01:18:01,780 --> 01:18:04,540
Ах, вам не нужна я, - о,

1473
01:18:04,540 --> 01:18:06,420
Да, вы определенно не нужна я.

1474
01:18:06,420 --> 01:18:10,250
Вы объявляете массив символов

1475
01:18:10,250 --> 01:18:13,150
длины с.

1476
01:18:14,680 --> 01:18:16,770
И то, что Сэм говорит, что

1477
01:18:16,770 --> 01:18:20,660
эта строка 10 - позвольте мне некоторое пространство между ним и остальной таким образом мы можем изолировать его -

1478
01:18:20,660 --> 01:18:23,440
эта строка 10 будет объявить массив

1479
01:18:23,440 --> 01:18:28,520
из символов, StrLen (ы) стоит из них,

1480
01:18:28,520 --> 01:18:32,270
но на самом деле нам нужна я,

1481
01:18:32,270 --> 01:18:35,710
и по этой причине мы нуждаемся в меня, потому что мы должны дать имя массива;

1482
01:18:35,710 --> 01:18:38,900
В противном случае мы не имели бы способ обратиться к массиву позже в коде.

1483
01:18:38,900 --> 01:18:41,180
>> Так что это прямо здесь является имя массива

1484
01:18:41,180 --> 01:18:43,420
и внутри длину.

1485
01:18:43,420 --> 01:18:45,010
Это даст нам массив,

1486
01:18:45,010 --> 01:18:47,430
Но это - опять же, это заявление.

1487
01:18:47,430 --> 01:18:50,380
Это не назначение, это не инициализации.

1488
01:18:50,380 --> 01:18:52,330
Если объявить этот массив, как это,

1489
01:18:52,330 --> 01:18:54,490
там на самом деле ничего в содержимое массива.

1490
01:18:54,490 --> 01:18:57,490
Это просто мусор - все, что там.

1491
01:18:57,490 --> 01:18:59,780
И, как мы уже говорили,

1492
01:18:59,780 --> 01:19:01,340
мы на самом деле даже не нужно для этого преобразования,

1493
01:19:01,340 --> 01:19:04,810
потому что мы уже можем рассматривать строку как с массивом.

1494
01:19:06,750 --> 01:19:09,170
Я знаю, что вы работаете немного долго по времени,

1495
01:19:09,170 --> 01:19:12,330
но я хочу очень-очень быстро добраться до этого цикла

1496
01:19:12,330 --> 01:19:14,850
и показать вам, как получить доступ к отдельным символам в массиве,

1497
01:19:14,850 --> 01:19:17,170
потому что это ключевой для нашего задания.

1498
01:19:17,170 --> 01:19:20,790
И тогда мы дадим вам идти оттуда.

1499
01:19:20,790 --> 01:19:24,610
>> Так вот, у нас есть цикл

1500
01:19:24,610 --> 01:19:28,310
, который выглядит почти хорошо.

1501
01:19:28,310 --> 01:19:30,960
Что не совсем почти нет?

1502
01:19:30,960 --> 01:19:33,240
Как там - то, что это не совсем правильно об этом цикле?

1503
01:19:33,240 --> 01:19:36,010
>> Нет фигурные скобки?

1504
01:19:36,010 --> 01:19:38,420
Нет фигурные скобки, например.

1505
01:19:38,420 --> 01:19:42,580
Хотите убедиться, что у нас есть тело цикла в фигурные скобки.

1506
01:19:42,580 --> 01:19:45,240
К сожалению, не квадратная скобка!

1507
01:19:45,240 --> 01:19:48,660
И что следующая вещь, которую мы должны сделать с этой петли?

1508
01:19:48,660 --> 01:19:52,640
Если я пытаюсь и запустить его,

1509
01:19:52,640 --> 01:19:56,740
Что это ошибка, что я получаю?

1510
01:19:56,740 --> 01:20:00,990
Я получаю все эти ошибки - у меня есть для инициализации я.

1511
01:20:00,990 --> 01:20:03,610
Великий.

1512
01:20:03,610 --> 01:20:05,770
Таким образом, это будет цикл - это не совсем там,

1513
01:20:05,770 --> 01:20:08,680
но это становится очень близки.

1514
01:20:08,680 --> 01:20:11,260
Этот код мы можем запускать,

1515
01:20:11,260 --> 01:20:14,620
строить, ошибка все равно возникает.

1516
01:20:17,960 --> 01:20:19,800
Почему он до сих пор жалуется,

1517
01:20:19,800 --> 01:20:22,030
говоря выражение не используется,

1518
01:20:22,030 --> 01:20:24,600
и это потому, что эта линия не делать ничего.

1519
01:20:24,600 --> 01:20:27,620
Мы не хранить его в любом месте, мы не сохранить результат.

1520
01:20:27,620 --> 01:20:30,210
Где мы должны быть сохранение этого результата?

1521
01:20:30,210 --> 01:20:32,920
>> S или я?

1522
01:20:32,920 --> 01:20:35,990
Совершенно верно, и это фанк синтаксиса,

1523
01:20:35,990 --> 01:20:38,550
это с с квадратными скобками

1524
01:20:38,550 --> 01:20:41,500
означает, что доступ к I-ый символ с.

1525
01:20:41,500 --> 01:20:45,650
Это будет что-то, что действительно важно для выполнения задания.

1526
01:20:45,650 --> 01:20:48,070
К сожалению, мы собираемся, чтобы останавливаться на достигнутом,

1527
01:20:48,070 --> 01:20:50,550
так что Себастьян разделе можно прийти,

1528
01:20:50,550 --> 01:20:53,980
но я счастлив остаться после снаружи, так и будет предпринимать никаких вопросов.

1529
01:20:53,980 --> 01:20:56,680
Так что спасибо вам, ребята, что пришли.

1530
01:20:56,680 --> 01:20:59,730
Это должно теперь загружать, создавать, запускать.

1531
01:21:01,570 --> 01:21:04,320
Мы можем ввести строку вроде "привет"

1532
01:21:06,570 --> 01:21:08,730
и это выводит "QOX".

1533
01:21:08,730 --> 01:21:11,030
[Смех]

1534
01:21:11,030 --> 01:21:14,640
>> Так что не совсем там, но перемещение, получение на тех петель!

1535
01:21:14,640 --> 01:21:18,640
Спасибо, что пришли, и я буду снаружи.