1
00:00:00,000 --> 00:00:11,280

2
00:00:11,280 --> 00:00:13,650
>> Выступающий 1: Хорошо.

3
00:00:13,650 --> 00:00:14,390
С возвращением.

4
00:00:14,390 --> 00:00:19,260
Это неделя Два CS50, и у нас есть
до сих пор используют функции, но

5
00:00:19,260 --> 00:00:20,830
значительной мере взял их как должное.

6
00:00:20,830 --> 00:00:23,430
Мы использовали Е, который имеет
Побочный эффект печати

7
00:00:23,430 --> 00:00:24,110
вещи на экране.

8
00:00:24,110 --> 00:00:25,790
Мы использовали получить-INT, получить плавать.

9
00:00:25,790 --> 00:00:29,230
>> Но что, если вы на самом деле хотите создать
свои собственные функции, а некоторые из

10
00:00:29,230 --> 00:00:31,740
Вы, возможно, уже начали
сделать для Проблема Установите один, хотя

11
00:00:31,740 --> 00:00:33,140
не является обязательным?

12
00:00:33,140 --> 00:00:37,150
Ну, давайте идти вперед и вернуться к этому
Проблема только запросить у пользователя

13
00:00:37,150 --> 00:00:40,660
их имена и печати что-то на
экране, но попробуйте для исключения некоторых

14
00:00:40,660 --> 00:00:44,000
общности, что мы
видели в нашем коде до сих пор.

15
00:00:44,000 --> 00:00:45,120
Итак, что я имею в виду следующее.

16
00:00:45,120 --> 00:00:47,315
>> Я собираюсь пойти дальше и создать
Новая программа, просто позвоните

17
00:00:47,315 --> 00:00:49,320
это hello.c как обычно.

18
00:00:49,320 --> 00:00:53,730
Я собираюсь идти вперед и дать себе
включают в себя стандартные io.h на самом верху.

19
00:00:53,730 --> 00:00:57,040
Я собираюсь также дать себе
превентивно CS50 библиотеку так, чтобы

20
00:00:57,040 --> 00:00:59,080
Я не получаю кричал на компилятор.

21
00:00:59,080 --> 00:01:02,400
И теперь я собираюсь идти вперед
и объявить Интернешнл, основным, недействительными.

22
00:01:02,400 --> 00:01:09,020
>> А потом здесь, это то, где я хочу
начать аутсорсинг функциональность

23
00:01:09,020 --> 00:01:12,090
некоторые другие функции, что я сам
собираюсь написать, но это не

24
00:01:12,090 --> 00:01:13,820
В настоящее время существуют.

25
00:01:13,820 --> 00:01:19,210
Например, предположим, что я хотел
написать функцию, которая позволяет мне

26
00:01:19,210 --> 00:01:23,830
распечатать Привет, запятая, и
Затем некоторое имя пользователя.

27
00:01:23,830 --> 00:01:29,010
Вместо того, чтобы продолжать делать Е
Здравствуйте,% S, не было бы неплохо, если бы

28
00:01:29,010 --> 00:01:33,380
было просто функция называется
Е не для печати, но имя?

29
00:01:33,380 --> 00:01:36,600
>> Итак, другими словами, я хочу, чтобы иметь возможность
написать программу, которая делает немного

30
00:01:36,600 --> 00:01:37,710
что-то вроде этого.

31
00:01:37,710 --> 00:01:42,070
Во-первых, я хочу сказать Е вашей
имя, тем самым предлагая пользователю

32
00:01:42,070 --> 00:01:46,150
дайте мне его или ее имя, а затем я
собирается использовать знакомые с строку

33
00:01:46,150 --> 00:01:47,290
объявить строку.

34
00:01:47,290 --> 00:01:50,420
Дайте мне переменную типа строка,
называем это с, и хранить в том, что

35
00:01:50,420 --> 00:01:52,120
Результат вызова получить строку.

36
00:01:52,120 --> 00:01:56,060
Но теперь в прошлые недели, я бы
Несколько утомительно сделано привет,% S / N.

37
00:01:56,060 --> 00:01:58,630

38
00:01:58,630 --> 00:02:02,570
>> А другими словами, мы видели в этом
Например кучу раз, и это

39
00:02:02,570 --> 00:02:05,280
тривиальный пример, потому что есть только одна
строка кода так что это действительно не

40
00:02:05,280 --> 00:02:06,860
большое дело для продолжайте вводить снова.

41
00:02:06,860 --> 00:02:09,990
Но предположим, что эта строка кода
на самом деле становятся в тягость, и

42
00:02:09,990 --> 00:02:12,900
это не одна строка кода, но это 10
строк кода пару недель с этого момента,

43
00:02:12,900 --> 00:02:15,190
А ты просто устал
копирования и вставки или

44
00:02:15,190 --> 00:02:17,180
перепечатывания тот же код.

45
00:02:17,180 --> 00:02:22,100
Не было бы неплохо, а не делать
Е привет,% S и т. д.,

46
00:02:22,100 --> 00:02:26,500
не было бы хорошо, если бы были просто
Функция называется печатными буквами, что

47
00:02:26,500 --> 00:02:27,560
принимает аргумент -

48
00:02:27,560 --> 00:02:29,120
другими словами, он принимает вход -

49
00:02:29,120 --> 00:02:30,620
а затем с запятой.

50
00:02:30,620 --> 00:02:33,240
Так, что функции, не так ли
бы хорошо, если, которые существовали?

51
00:02:33,240 --> 00:02:36,690
Тогда бы мне не придется беспокоиться о
что Е есть, какой% с и все

52
00:02:36,690 --> 00:02:39,400
эти сложности, которые
Не все, что интересно.

53
00:02:39,400 --> 00:02:40,570
Они полезны.

54
00:02:40,570 --> 00:02:44,700
>> Так надписью названия, к сожалению, не было
изобрел около 40 с лишним лет назад.

55
00:02:44,700 --> 00:02:45,980
Никто не думал, чтобы написать ее.

56
00:02:45,980 --> 00:02:48,300
Но в этом вся прелесть наличия
Язык программирования, как и в

57
00:02:48,300 --> 00:02:52,930
Царапины можно определить пользовательские блоки, так что
В С и наиболее любом языке, не так ли

58
00:02:52,930 --> 00:02:57,260
определить свою собственную функциональность, может
Вы можете определить собственные функции.

59
00:02:57,260 --> 00:03:01,710
Поэтому, даже если мы получаем по основным
автоматически бесплатно, мы можем объявить

60
00:03:01,710 --> 00:03:02,730
наши собственные функции.

61
00:03:02,730 --> 00:03:05,670
>> Так что я собираюсь сделать несколько номеров здесь
наверху, и я собираюсь объявить мое

62
00:03:05,670 --> 00:03:08,210
собственные функции, которая будет выглядеть
немного странным сначала, но мы приедем

63
00:03:08,210 --> 00:03:09,400
вернуться к этому в ближайшее время.

64
00:03:09,400 --> 00:03:12,310
Я собираюсь сказать, пустоту, тем самым
Указывает, что функция делает

65
00:03:12,310 --> 00:03:16,040
что-то, имеет побочный эффект, но
не возвращает мне что-то в

66
00:03:16,040 --> 00:03:18,810
так же, как получить или десятичного
получить строка сама по себе.

67
00:03:18,810 --> 00:03:22,450
И я собираюсь дать эту функцию
имя печатными буквами, и я собираюсь

68
00:03:22,450 --> 00:03:26,470
указать, что этот парень собирается взять
строку, а я буду называть, что

69
00:03:26,470 --> 00:03:27,600
Строка имени.

70
00:03:27,600 --> 00:03:32,100
Я мог бы назвать это все, что я хочу, но я
хочу, чтобы мой код был самодокументируемыми.

71
00:03:32,100 --> 00:03:34,770
Другими словами, если один из вас были
открыть этот файл и прочитать его, вы можете

72
00:03:34,770 --> 00:03:39,020
рода заключить из названия, что
входного какую роль он должен играть.

73
00:03:39,020 --> 00:03:42,270
>> А теперь ниже, что, я собираюсь открыть
фигурной скобкой и закрытых фигурной скобки,

74
00:03:42,270 --> 00:03:47,140
и так замечаю я следовал той же
узор на линиях с четвертого по седьмой, как

75
00:03:47,140 --> 00:03:51,622
Я следил за хорошую неделю плюс
Теперь, скажем, между девятью и линий

76
00:03:51,622 --> 00:03:53,400
14, которые составляют основной.

77
00:03:53,400 --> 00:03:56,160
Другими словами, напечатать имя
Другой функцией.

78
00:03:56,160 --> 00:03:58,990
Теперь, компилятор не будет знать,
поворачивается назвать это автоматически

79
00:03:58,990 --> 00:04:02,670
потому что я буквально только что придумал,
но он будет знать еще называют основным

80
00:04:02,670 --> 00:04:08,710
автоматически, а затем, конечно, в
строка 13, я призываю моих собственных функций.

81
00:04:08,710 --> 00:04:12,805
И потому, что я заявил, что функции
на четвертой строке перед основным,

82
00:04:12,805 --> 00:04:16,579
это будет учить компилятор
то, что цитата, конец цитаты ", расшифровка подписи"

83
00:04:16,579 --> 00:04:18,140
означает и то, что он должен делать.

84
00:04:18,140 --> 00:04:22,700
Так я вроде придав ему новый пользовательский
блокировать в контексте, скажем, царапины.

85
00:04:22,700 --> 00:04:27,240
>> Так что здесь, я могу поставить, что очень часто
или повторяющиеся структуры кода я держу

86
00:04:27,240 --> 00:04:32,300
писать в классе, Е
% S привет,% S / N ", -

87
00:04:32,300 --> 00:04:36,720

88
00:04:36,720 --> 00:04:37,590
Что я хочу поставить здесь?

89
00:04:37,590 --> 00:04:39,200
S?

90
00:04:39,200 --> 00:04:41,420
Так я хочу поставить имя в этом контексте.

91
00:04:41,420 --> 00:04:43,440
Так заметить немного дихотомии здесь.

92
00:04:43,440 --> 00:04:47,680
Потому что я объявляю мою собственную функцию
и я несколько условно называется

93
00:04:47,680 --> 00:04:50,880
распечатать имя, а потому, что я
указанные в скобках, что это

94
00:04:50,880 --> 00:04:55,035
Функция принимает один аргумент типа
который является строкой - так это слово

95
00:04:55,035 --> 00:05:00,010
или фраза или что-то вроде этого - и
Я звоню, что имя аргумента, что

96
00:05:00,010 --> 00:05:04,770
означает, единственная переменная, которая находится в
сферы, так сказать, это имя.

97
00:05:04,770 --> 00:05:07,780
>> S существует только между тем, что два
фигурные скобки, конечно?

98
00:05:07,780 --> 00:05:12,990
Ну действительно, как через линию 10
14, так же, как в понедельник не может использовать

99
00:05:12,990 --> 00:05:17,650
S, но что я могу сделать, это пройти
S в печать имя.

100
00:05:17,650 --> 00:05:21,030
Напечатать имя именно так происходит, чтобы дать ему
псевдоним, синоним, прозвище,

101
00:05:21,030 --> 00:05:24,400
назвав его имя, и теперь
использовать его в этой линии.

102
00:05:24,400 --> 00:05:26,840
Так что теперь позвольте мне сохранить это, уменьшения.

103
00:05:26,840 --> 00:05:31,250
>> Позвольте мне пойти дальше и сделать привет.

104
00:05:31,250 --> 00:05:32,400
Выглядит хорошо.

105
00:05:32,400 --> 00:05:36,110
Не выплевывать любые ошибки.
. / Привет Enter.

106
00:05:36,110 --> 00:05:37,020
Как меня зовут?

107
00:05:37,020 --> 00:05:38,060
Давида.

108
00:05:38,060 --> 00:05:39,270
И привет Давиду.

109
00:05:39,270 --> 00:05:41,820
Так что не все, что интересно,
Но подумайте сейчас.

110
00:05:41,820 --> 00:05:44,310
Теперь у вас есть, что же ингредиенты
как мы делали в пустом месте, чтобы

111
00:05:44,310 --> 00:05:45,420
сделать наши собственные функции.

112
00:05:45,420 --> 00:05:46,770
>> Но есть немного Гоча.

113
00:05:46,770 --> 00:05:50,620
Предположим, что я действительно не думал,
это через и я фактически без

114
00:05:50,620 --> 00:05:54,250
действительно думал об этом писал
эта функция здесь.

115
00:05:54,250 --> 00:05:55,420
Ощущается вполне разумным.

116
00:05:55,420 --> 00:05:58,440
В царапин нет понятия
нахождения в ваших сценариях.

117
00:05:58,440 --> 00:06:00,670
Вы можете поднять один здесь, один здесь,
один здесь, и он может начать

118
00:06:00,670 --> 00:06:03,310
, чтобы выглядеть немного грязным, если вы не
положите его аккуратно, но это не так

119
00:06:03,310 --> 00:06:05,910
имеет значения, где физически скрипты
были на экране.

120
00:06:05,910 --> 00:06:09,660
К сожалению, в C - и это в отличие от
языки, как Java и Python

121
00:06:09,660 --> 00:06:13,600
и другие, которые вы можете быть знакомы
с - к сожалению, в C, порядок не

122
00:06:13,600 --> 00:06:15,830
имеет значения, потому что часы
сейчас произойдет.

123
00:06:15,830 --> 00:06:19,010
>> Функция по умолчанию, что происходит
запустить, является, конечно, основным.

124
00:06:19,010 --> 00:06:22,290
Главное собирается позвонить печати имя на
линии восемь, но, к сожалению,

125
00:06:22,290 --> 00:06:26,660
компилятор даже не будут знать, что печатные название
существует, пока не доберется до линии 11,

126
00:06:26,660 --> 00:06:28,520
которая, к сожалению,
будет слишком поздно.

127
00:06:28,520 --> 00:06:30,660
Так что давайте делают привет.

128
00:06:30,660 --> 00:06:32,950
А теперь, черт побери, две ошибки генерируется.

129
00:06:32,950 --> 00:06:36,050
Так что теперь позвольте мне прокрутить до самого
Во-первых, как мы всегда должны делать, и

130
00:06:36,050 --> 00:06:39,560
заметите, что он кричит на меня,
"Неявная декларация функции

131
00:06:39,560 --> 00:06:40,540
напечатать имя. "

132
00:06:40,540 --> 00:06:43,860
>> Итак, мы рассмотрели это сообщение раньше,
неявная декларация функции.

133
00:06:43,860 --> 00:06:48,080
Когда мы видели такую ​​ошибку?

134
00:06:48,080 --> 00:06:49,180
Когда я не включал библиотеку.

135
00:06:49,180 --> 00:06:53,470
Если я забыл cs50.h и я хотел бы получить
кричал на для получаю строку или получить Int.

136
00:06:53,470 --> 00:06:56,880
Но в данном случае, эта функция печати
имя не в библиотеке, не так ли?

137
00:06:56,880 --> 00:07:00,230
Это буквально в этом файле, так что
что на самом деле проблема?

138
00:07:00,230 --> 00:07:04,660
>> Ну к сожалению, в C, это займет у вас
буквально так невероятно, что если вы

139
00:07:04,660 --> 00:07:08,640
хотят функция называется печати имя
существует, вы должны либо осуществление

140
00:07:08,640 --> 00:07:11,940
, которые функционируют на самом верху
код так, чтобы она была доступна для снижения

141
00:07:11,940 --> 00:07:15,070
функции, но честно говоря, это становится
неаккуратно очень быстро.

142
00:07:15,070 --> 00:07:18,160
Лично я, как положить первый основной
потому что тогда это очень ясно, что это

143
00:07:18,160 --> 00:07:19,890
Программа делает на первый взгляд.

144
00:07:19,890 --> 00:07:23,290
И плюс, вы можете попасть в странный угол
случаях, когда, если X хочет назвать

145
00:07:23,290 --> 00:07:27,530
у, но могли бы назвать Y X, вы просто
физически не может на самом деле положил одну

146
00:07:27,530 --> 00:07:28,540
над другим.

147
00:07:28,540 --> 00:07:31,230
>> Но оказывается, в C, мы можем
решить это очень просто.

148
00:07:31,230 --> 00:07:34,010
Я собираюсь положить немного пространства
здесь, и я просто хочу, чтобы

149
00:07:34,010 --> 00:07:38,170
превентивно, хотя и несколько
избыточно, научу

150
00:07:38,170 --> 00:07:42,320
компилятор, который существует функция
называется печатными буквами, он принимает строку,

151
00:07:42,320 --> 00:07:46,330
и я буду называть
его называют точкой с запятой.

152
00:07:46,330 --> 00:07:50,220
>> Так что это время в очереди четыре, которые мы
раньше не видели, это декларация

153
00:07:50,220 --> 00:07:53,940
имени функции печати, но это только
обещание, что эта функция будет

154
00:07:53,940 --> 00:07:56,620
в конечном счете быть определен, в конечном счете
реализованы.

155
00:07:56,620 --> 00:08:00,180
Это теперь я могу оставить в покое, потому что
Сейчас это определение,

156
00:08:00,180 --> 00:08:04,090
реализации, вроде последней мили
реализации этого

157
00:08:04,090 --> 00:08:05,130
определенной функции.

158
00:08:05,130 --> 00:08:08,450
Так откровенно, что это глупо, это раздражает,
но это путь С, и это

159
00:08:08,450 --> 00:08:12,050
потому что он принимает вас очень буквально
и, как компьютер прямо следует,

160
00:08:12,050 --> 00:08:16,020
того, что именно то, что вы скажете ей
делать, и так, что порядок важен.

161
00:08:16,020 --> 00:08:18,940
>> Так что имейте это в виду, и снова, начинают
заметите повторения узоров.

162
00:08:18,940 --> 00:08:21,850
Вполне вероятно, вы будете, если вы еще не
Уже сейчас начинают сталкиваться с сообщениями

163
00:08:21,850 --> 00:08:24,700
как это, которые на первый взгляд кажутся
совершенно загадочным, но если вы начинаете

164
00:08:24,700 --> 00:08:29,000
смотреть на эти ключевые слова, как
"Неявная декларация", упоминание о

165
00:08:29,000 --> 00:08:32,380
функция в данном случае - и, честно говоря, вы
иногда даже получить немножко зеленых

166
00:08:32,380 --> 00:08:35,010
морковь символ, который говорит вам, где
Вероятно, проблема есть -

167
00:08:35,010 --> 00:08:40,980
Вы можете начать работать ваш путь через
еще не было видимо сообщения об ошибках.

168
00:08:40,980 --> 00:08:45,860
Есть вопросы по написанию
собственную функцию таким образом?

169
00:08:45,860 --> 00:08:47,540
>> Давайте делать то, что это
немного более убедительным.

170
00:08:47,540 --> 00:08:51,760
Вместо того, чтобы просто делать то, что имеет
Побочный эффект печати, отпусти меня

171
00:08:51,760 --> 00:08:55,340
вперед и сохранить новый файл, и мы
называем это positive.c, даже если это

172
00:08:55,340 --> 00:08:57,600
будет немного по-другому
по сравнению с прошлым временем.

173
00:08:57,600 --> 00:09:01,910
И на этот раз, я хочу повторно реализовать
Например positive.C последний раз, которое

174
00:09:01,910 --> 00:09:04,430
как заставить пользователя, чтобы дать
мне положительное целое число.

175
00:09:04,430 --> 00:09:07,280
Но я должен был использовать десятичного получить последний раз.

176
00:09:07,280 --> 00:09:10,780
Разве не было бы хорошо, если было
Функция называется получить Позитивный Межд

177
00:09:10,780 --> 00:09:13,610
что я мог просто передать эту
кусок функциональности?

178
00:09:13,610 --> 00:09:16,480
Таким образом, разница здесь мы будем
реализации получить положительные Интеллект, но в отличие от

179
00:09:16,480 --> 00:09:20,330
печать имя, которое имеет побочный эффект - он
не вернул мне что-то вроде

180
00:09:20,330 --> 00:09:21,710
число или строка -

181
00:09:21,710 --> 00:09:25,510
Позитивный Межд получить, конечно, собираюсь
вернуться, мы надеемся, положительно Int.

182
00:09:25,510 --> 00:09:26,170
>> Так давайте сделаем это.

183
00:09:26,170 --> 00:09:30,840
Включите cs50.h, включают в себя стандартные io.h.

184
00:09:30,840 --> 00:09:33,520
Тап_п недействительными.

185
00:09:33,520 --> 00:09:42,160
И теперь здесь, я собираюсь идти вперед
и скажем, Интеллект, называют его N, равна

186
00:09:42,160 --> 00:09:44,270
получить положительные Int.

187
00:09:44,270 --> 00:09:49,080
И так же, как получить десятичного уже существует
потому что сотрудники ее написал, я собираюсь

188
00:09:49,080 --> 00:09:53,950
предположим на минуту, что получить
Позитивный Межд существует, и теперь я собираюсь

189
00:09:53,950 --> 00:09:57,730
идти вперед и сказал Е,
спасибо за% I / N ", N.

190
00:09:57,730 --> 00:10:02,940

191
00:10:02,940 --> 00:10:07,770
>> Так что теперь, если я компиляции этой программы, что
будет происходить в моем терминале

192
00:10:07,770 --> 00:10:09,075
окно в нижней части экрана?

193
00:10:09,075 --> 00:10:11,580

194
00:10:11,580 --> 00:10:13,900
Я собираюсь получить, что, вероятно,
такая же ошибка, как раньше.

195
00:10:13,900 --> 00:10:14,570
Так давайте попробуем это.

196
00:10:14,570 --> 00:10:16,450
Сделать положительным.

197
00:10:16,450 --> 00:10:19,900
И опять же, неявное объявление
функции, получить положительные Int.

198
00:10:19,900 --> 00:10:21,970
Поэтому мы можем разрешить это в
несколькими способами.

199
00:10:21,970 --> 00:10:27,310
Я собираюсь сохранить его простым и просто
положил мое заявление здесь и получить

200
00:10:27,310 --> 00:10:28,120
положительные Int.

201
00:10:28,120 --> 00:10:29,720
Мне нужна так называемая подпись.

202
00:10:29,720 --> 00:10:32,410
Подпись относится только
к эстетике

203
00:10:32,410 --> 00:10:34,090
Первая строка программы.

204
00:10:34,090 --> 00:10:37,420
Итак, что нужно получить положительные
десятичного взамен?

205
00:10:37,420 --> 00:10:37,970
>> Так Int.

206
00:10:37,970 --> 00:10:41,540
Я имею в виду в идеале, он вернется
что-то вроде Позитивный Межд, но это

207
00:10:41,540 --> 00:10:42,160
не существует.

208
00:10:42,160 --> 00:10:45,280
Мы не видели, что среди наших данных
типы, так что мы имеем дело с

209
00:10:45,280 --> 00:10:47,170
То, что у нас очень мало
Типы данных для работы с.

210
00:10:47,170 --> 00:10:50,360
Но мы можем вернуться Целочисленное и просто
доверять, что она будет положительной.

211
00:10:50,360 --> 00:10:52,690
Это будет называться
получить положительные Int.

212
00:10:52,690 --> 00:10:55,122
>> И теперь, как о его аргументы?

213
00:10:55,122 --> 00:10:56,440
Оно принимает любой вход?

214
00:10:56,440 --> 00:10:58,280
Нужно ли любой вход?

215
00:10:58,280 --> 00:11:00,900
Поэтому не нужно знать
Заранее ничего.

216
00:11:00,900 --> 00:11:03,220
Получить строка не, получить десятичного нет.

217
00:11:03,220 --> 00:11:06,430
Printf делает - для этого нужно иметь некоторые
входных данных, передаваемых в нее - и распечатать имя

218
00:11:06,430 --> 00:11:09,020
необходимы некоторые материалы, но получить
Позитивный Межд нет.

219
00:11:09,020 --> 00:11:11,530
Так что я буду явным
сказали компилятору недействительными.

220
00:11:11,530 --> 00:11:13,470
Пустота является отсутствие что-либо еще.

221
00:11:13,470 --> 00:11:17,990
Так что ничего не означает Пустотность происходит внутри
тех скобки, точка с запятой.

222
00:11:17,990 --> 00:11:20,840
>> И теперь в нижней части моего файла - и
опять же, я просто вид анальных

223
00:11:20,840 --> 00:11:23,640
Здесь поставив основной в верхней части, который
хорошая практика, потому что таким образом,

224
00:11:23,640 --> 00:11:26,220
в любое время вы или кто-то другой
открывает файл,

225
00:11:26,220 --> 00:11:27,400
функциональности тут же.

226
00:11:27,400 --> 00:11:29,660
Вы можете погрузиться в с нуля.

227
00:11:29,660 --> 00:11:34,190
Так что теперь я собираюсь дублировать этот,
получить Позитивный Межд пустота, но я не

228
00:11:34,190 --> 00:11:35,430
ударю запятой сейчас.

229
00:11:35,430 --> 00:11:38,280
Я собираюсь открыть фигурные скобки,
и теперь мне нужно заимствовать

230
00:11:38,280 --> 00:11:39,700
некоторые идеи с понедельника.

231
00:11:39,700 --> 00:11:44,450
>> Итак, как вы помните, мы сделали что-то
Нравится следующее время

232
00:11:44,450 --> 00:11:45,830
что-то было правдой.

233
00:11:45,830 --> 00:11:46,630
И что же мне делать?

234
00:11:46,630 --> 00:11:51,540
Я сделал что-то вроде дают
меня положительное целое число,

235
00:11:51,540 --> 00:11:52,430
Немного строке.

236
00:11:52,430 --> 00:11:53,540
Я мог бы использовать любые слова, которые я хочу.

237
00:11:53,540 --> 00:11:54,960
И тогда я использовал то, что?

238
00:11:54,960 --> 00:11:59,530
Int N равно получить Интеллект,
Никакие доводы на него.

239
00:11:59,530 --> 00:12:00,550
>> И заметите разницы.

240
00:12:00,550 --> 00:12:04,680
Когда вы вызываете функцию, когда вы используете
функции, вы не ставите в пустоту.

241
00:12:04,680 --> 00:12:08,570
Вы делать это только при объявлении
функции, преподавание, что компилятор

242
00:12:08,570 --> 00:12:09,780
он должен быть готов.

243
00:12:09,780 --> 00:12:11,650
Так что вам не нужно положить
аннулированию туда сами.

244
00:12:11,650 --> 00:12:12,940
>> А теперь то, что было мое состояние?

245
00:12:12,940 --> 00:12:19,670
Хорошо, п не равно положительным,
но это только псевдо-кода.

246
00:12:19,670 --> 00:12:22,530
Так как я могу выразить это более аккуратно?

247
00:12:22,530 --> 00:12:24,090
Таким образом, меньшее или равное нулю.

248
00:12:24,090 --> 00:12:26,250
Итак, еще раз обратите внимание, что вы можете сделать
меньше или равно.

249
00:12:26,250 --> 00:12:28,100
Даже если это два отдельных
символы, вы можете сделать это на

250
00:12:28,100 --> 00:12:29,350
клавиатуры как таковой.

251
00:12:29,350 --> 00:12:33,950
>> Но есть еще ошибка,
Я облажался прошлый раз также.

252
00:12:33,950 --> 00:12:36,950
Я должен объявить -

253
00:12:36,950 --> 00:12:37,460
точно.

254
00:12:37,460 --> 00:12:39,640
Я должен объявить вне N
цикла.

255
00:12:39,640 --> 00:12:44,180
Так что мне нужно поставить п до здесь, и я не
хотите повторно объявить его здесь

256
00:12:44,180 --> 00:12:46,480
чтобы я получить новую переменную.

257
00:12:46,480 --> 00:12:48,860
Я просто хочу, чтобы присвоить значение здесь.

258
00:12:48,860 --> 00:12:54,320
>> И теперь я не совсем закончили.

259
00:12:54,320 --> 00:12:57,290
Позвольте мне забегать вперед
и делать вид, я сделал.

260
00:12:57,290 --> 00:13:01,220
Принимать позитивные, и теперь
есть новая ошибку.

261
00:13:01,220 --> 00:13:04,550
Управление достигает конца
непустых функции.

262
00:13:04,550 --> 00:13:07,760
Так новое сообщение об ошибке, но если вы вид
дразнить друг от друга каждое из слов, он

263
00:13:07,760 --> 00:13:09,620
, вероятно, намекает на то, что это неправильно.

264
00:13:09,620 --> 00:13:11,240
>> Управления.

265
00:13:11,240 --> 00:13:14,250
Управление означает лишь порядка
операций в программе.

266
00:13:14,250 --> 00:13:16,510
Компьютера в контроле и
что-то пошло не так.

267
00:13:16,510 --> 00:13:18,510
Таким образом, достигает конца
непустое функции.

268
00:13:18,510 --> 00:13:21,760
Какую функцию он, очевидно,
в виду?

269
00:13:21,760 --> 00:13:24,790
Какая функция не является недействительным?

270
00:13:24,790 --> 00:13:27,400
Так что положительные Интеллект, и немного
путаницу, ну,

271
00:13:27,400 --> 00:13:29,010
это вроде недействительными.

272
00:13:29,010 --> 00:13:33,070
Она имеет спецификацию пустоту своими
аргументы, но его выход будет

273
00:13:33,070 --> 00:13:34,540
иметь тип N.

274
00:13:34,540 --> 00:13:37,260
Таким образом, слово на левой стороне
так называемый тип возвращаемого значения.

275
00:13:37,260 --> 00:13:40,320
Слово на внутренней здесь
нуль или более аргументов

276
00:13:40,320 --> 00:13:41,970
что функция принимает.

277
00:13:41,970 --> 00:13:44,060
>> Так что же мне нужно сделать?

278
00:13:44,060 --> 00:13:47,650
На данный момент в моем коде, строка 21, где
быстрое мигание сейчас, я

279
00:13:47,650 --> 00:13:51,430
есть Позитивный Межд внутри
переменной называется N.

280
00:13:51,430 --> 00:13:55,200
Как мне вернуть ее основным?

281
00:13:55,200 --> 00:13:55,960
В буквальном смысле.

282
00:13:55,960 --> 00:13:59,320
Вернуться N запятой.

283
00:13:59,320 --> 00:14:04,090
>> Так же, как Колтон вернулся кусок
бумаги с ответом на меня, понижая

284
00:14:04,090 --> 00:14:07,020
эту бумажку в маленьком черном
коробку на стол, сделать это в

285
00:14:07,020 --> 00:14:10,100
Код, вы в буквальном смысле просто написать, вернуть
N, и это, как будто были Колтон

286
00:14:10,100 --> 00:14:12,140
протягивая мне что-то физическое назад.

287
00:14:12,140 --> 00:14:15,870
В этом случае то, что происходит, это получить
Позитивный Межд собирается вручить назад

288
00:14:15,870 --> 00:14:19,220
что предположительно положительным
целое для кого?

289
00:14:19,220 --> 00:14:21,380
Где, что значение в конечном итоге?

290
00:14:21,380 --> 00:14:29,080
, Который заканчивается в этой переменной, N, и
Затем мы продолжим линию девять.

291
00:14:29,080 --> 00:14:31,920
>> Итак, другими словами, в порядке
операций, эта программа начинает

292
00:14:31,920 --> 00:14:34,430
выполнения и компилятор понимает,
Ах, вы хотите в библиотеку?

293
00:14:34,430 --> 00:14:36,310
Отпусти меня захватить все, что находится внутри.

294
00:14:36,310 --> 00:14:37,750
Ах, вы хотите стандартной библиотеки IO?

295
00:14:37,750 --> 00:14:39,660
Отпусти меня захватить все, что находится внутри.

296
00:14:39,660 --> 00:14:44,510
Что же компилятор сказать себе
, когда она попадает четыре линии?

297
00:14:44,510 --> 00:14:47,980
О, вы обещали реализовать
Функция называется получить положительные, но

298
00:14:47,980 --> 00:14:50,820
мы вернемся к этому позже,
что-то в этом направлении.

299
00:14:50,820 --> 00:14:53,450
>> Int основных пустоту просто означает вот
внутренности моей программе.

300
00:14:53,450 --> 00:14:54,990
Линия семи просто фигурной скобкой.

301
00:14:54,990 --> 00:14:59,540
Линия восемь говорит на левом, дать
мне 32 бита для целого, назовем его п.

302
00:14:59,540 --> 00:15:02,160
На правой стороне, это
говоря получить положительные Int.

303
00:15:02,160 --> 00:15:07,120
Теперь давайте остановимся эту историю, потому что теперь
Я не держу перемещении моего курсора вниз.

304
00:15:07,120 --> 00:15:11,720
Мой курсор теперь идет сюда, потому что
теперь получить Позитивный Межд выполняет.

305
00:15:11,720 --> 00:15:13,100
Int N объявлен.

306
00:15:13,100 --> 00:15:14,040
Выполните следующие действия.

307
00:15:14,040 --> 00:15:16,090
Printf дает мне положительное целое число.

308
00:15:16,090 --> 00:15:19,740
>> Получить Целочисленное от пользователя, храните его в N,
и, возможно, сделать это снова и снова.

309
00:15:19,740 --> 00:15:23,010
Этот цикл означает, что этот код может
выполнить вверх и вниз как это снова

310
00:15:23,010 --> 00:15:25,810
и снова, но когда пользователь окончательно
сотрудничает и дает мне положительные

311
00:15:25,810 --> 00:15:31,750
Интеллект, я ударил линии 21, и в этот момент
номер вернул, а какой

312
00:15:31,750 --> 00:15:34,280
я должен выделить сейчас?

313
00:15:34,280 --> 00:15:35,070
Девять.

314
00:15:35,070 --> 00:15:39,010
Управления, так сказать, возвращается
в линию девять.

315
00:15:39,010 --> 00:15:40,650
Это линия, которая сейчас у власти.

316
00:15:40,650 --> 00:15:43,250
>> Так вот то, что происходило все
на этот раз под капотом, но

317
00:15:43,250 --> 00:15:46,480
когда мы использовали функции, такие как Е
или даже получить строку, что кто-то другой

318
00:15:46,480 --> 00:15:50,600
написал вам, контроль того, как передал
прочь к чужой код линии

319
00:15:50,600 --> 00:15:51,290
По линии По линии.

320
00:15:51,290 --> 00:15:53,770
Это просто мы не могли видеть его, и мы
не мог представить ее в этом

321
00:15:53,770 --> 00:15:57,620
программу, потому что это в некоторых других
файлов на жестком диске

322
00:15:57,620 --> 00:16:00,000
без ведома нам.

323
00:16:00,000 --> 00:16:02,100
Так что давайте компилировать
и запустить это сейчас.

324
00:16:02,100 --> 00:16:03,890
>> Сделать положительным.

325
00:16:03,890 --> 00:16:05,260
Компиляция, это прогресс.

326
00:16:05,260 --> 00:16:06,650
. / Положительным.

327
00:16:06,650 --> 00:16:08,020
Дайте мне положительное целое число.

328
00:16:08,020 --> 00:16:08,800
Давайте быть трудным.

329
00:16:08,800 --> 00:16:10,430
Отрицательные 1.

330
00:16:10,430 --> 00:16:11,360
Ноль.

331
00:16:11,360 --> 00:16:13,370
Давайте дадим ему 50.

332
00:16:13,370 --> 00:16:18,100
Спасибо за 50, так и управления
сейчас вернулась.

333
00:16:18,100 --> 00:16:21,750
Любые вопросы, то, по этому поводу?

334
00:16:21,750 --> 00:16:23,180
Да?

335
00:16:23,180 --> 00:16:25,630
>> [Неразборчиво].

336
00:16:25,630 --> 00:16:26,130
>> Скажи еще раз.

337
00:16:26,130 --> 00:16:27,860
О, хороший вопрос.

338
00:16:27,860 --> 00:16:31,100
Таким образом, вы можете заметить, что здесь параллель
Я вроде резки углу.

339
00:16:31,100 --> 00:16:35,420
В строке 12, я говорю, получить Позитивный Межд
возвращает целое, но к тому же

340
00:16:35,420 --> 00:16:39,660
логике, теперь понятно, что в
линии шесть, я говорю, что основная возвращается

341
00:16:39,660 --> 00:16:44,040
Интеллект, но то, что мы никогда раньше не
было ни в одной из наших программ?

342
00:16:44,040 --> 00:16:46,470
У нас никогда не было упоминания о
это клавиши возврата слова.

343
00:16:46,470 --> 00:16:49,970
>> Вот и получается, что в C, по крайней мере
версия, что мы используем

344
00:16:49,970 --> 00:16:55,750
сделано в 1999 году, технически, это
происходит автоматически.

345
00:16:55,750 --> 00:16:59,300
В любое время вы реализуете программу, и вы
реализовать функцию, называется основным,

346
00:16:59,300 --> 00:17:04,230
что функция возвратит нуль
умолчанию, если вы не говорите, в противном случае,

347
00:17:04,230 --> 00:17:05,849
и нулевой всего лишь соглашение.

348
00:17:05,849 --> 00:17:09,430
Мир тем самым возвращает ноль
о том, что все хорошо,

349
00:17:09,430 --> 00:17:13,040
эффективно оставляя нас с четырех миллиардов
возможные вещи, которые могли бы пойти

350
00:17:13,040 --> 00:17:17,530
неправильно, таким образом, что, если мы вернемся одной, что
может означать код, который означает, что этот

351
00:17:17,530 --> 00:17:18,310
вещь пошло не так.

352
00:17:18,310 --> 00:17:20,589
Мы могли бы вернуть два, что означает,
это другая вещь пошло не так.

353
00:17:20,589 --> 00:17:23,440
Мы могли бы вернуться четырех миллиардов, которые
означает, что это другая вещь пошло не так.

354
00:17:23,440 --> 00:17:27,170
>> И если вы сейчас думаете о своем собственном
ПК или Mac, вы можете вспомнить, что

355
00:17:27,170 --> 00:17:29,610
иногда вы получаете сообщения об ошибках,
от программного обеспечения, которое вы

356
00:17:29,610 --> 00:17:32,650
использовании, а иногда он имеет человеческое
понятное описание, но есть

357
00:17:32,650 --> 00:17:35,265
Часто код или номер
на экране?

358
00:17:35,265 --> 00:17:37,800
Если это не приходит в голову,
просто следите за это.

359
00:17:37,800 --> 00:17:40,790
Это обычно, что эти
Коды в виду.

360
00:17:40,790 --> 00:17:44,200
Они включены в Microsoft Word и
других программ, так что, если вы подадите

361
00:17:44,200 --> 00:17:48,850
отчет об ошибке с компанией, вы можете
скажите им, ой, я получил номер ошибки 45.

362
00:17:48,850 --> 00:17:51,750
А некоторые программист назад в компании
можете посмотреть, что в свою

363
00:17:51,750 --> 00:17:54,940
код и сказать: о, это потому что я сделал
это ошибка, и именно поэтому пользователь

364
00:17:54,940 --> 00:17:56,240
получил это сообщение.

365
00:17:56,240 --> 00:17:59,490
>> Но, откровенно говоря, это просто немного
отвлекает и немного утомительно

366
00:17:59,490 --> 00:18:02,130
заключить, что, по крайней мере, на наш
Первые несколько программ, итак, мы

367
00:18:02,130 --> 00:18:02,970
были опуская его.

368
00:18:02,970 --> 00:18:07,450
Но все это время каждый из ваших
Основными функциями тайно была эта

369
00:18:07,450 --> 00:18:11,600
линии автоматически добавляется для Вас
компилятора, просто конвенции

370
00:18:11,600 --> 00:18:13,172
сэкономить ваше время.

371
00:18:13,172 --> 00:18:14,620
>> [Неразборчиво].

372
00:18:14,620 --> 00:18:16,250
>> Вам не нужно включать его в основной.

373
00:18:16,250 --> 00:18:16,700
Это прекрасно.

374
00:18:16,700 --> 00:18:20,260
Вы должны включить его, если вы были
реализации функции, как это.

375
00:18:20,260 --> 00:18:22,850
В противном случае функция плоского
из не будет работать.

376
00:18:22,850 --> 00:18:24,480
Но в главном, в этом нет необходимости.

377
00:18:24,480 --> 00:18:28,450
Через неделю или две, мы начнем получать
в эту привычку, как только мы хотим начать

378
00:18:28,450 --> 00:18:29,690
означающее ошибок.

379
00:18:29,690 --> 00:18:32,550
Очень хороший вопрос.

380
00:18:32,550 --> 00:18:36,880
>> Так быстро словесные перерыв, чтобы отметить, что
в эту пятницу, мы не будем обедать

381
00:18:36,880 --> 00:18:39,980
как таковой, но мы будем обедать с
некоторые из студентов и преподавателей.

382
00:18:39,980 --> 00:18:42,940
Если вы хотите присоединиться к нам, чувствуют себя
свободно ходить в cs50.net/rsvp.

383
00:18:42,940 --> 00:18:45,030
6:00 вечера в эту пятницу.

384
00:18:45,030 --> 00:18:47,990
Пространство, как всегда, ограничено, но мы
продолжать делать это на почти

385
00:18:47,990 --> 00:18:51,420
еженедельной основе, если пространство
закончится на этой неделе.

386
00:18:51,420 --> 00:18:56,160
>> Так захватывающим, что мы остановились на
Понедельник было то, что строки могут на самом деле

387
00:18:56,160 --> 00:19:00,520
быть проиндексированы на, который просто означает, что вы
может получить с первого символа,

388
00:19:00,520 --> 00:19:03,770
Второй персонаж, третий символ
и так далее, потому что вы можете

389
00:19:03,770 --> 00:19:07,860
эффективно думать строкой, например
привет, как в данном случае пять

390
00:19:07,860 --> 00:19:09,670
Письма внутри коробки.

391
00:19:09,670 --> 00:19:13,370
И вы можете получить на каждом из этих
коробки с тем, что мы сделали синтаксиса

392
00:19:13,370 --> 00:19:15,230
ввести в понедельник?

393
00:19:15,230 --> 00:19:16,760
Те квадратные скобки
на клавиатуре.

394
00:19:16,760 --> 00:19:18,980
Это просто означало пойти в расположение нуля.

395
00:19:18,980 --> 00:19:22,840
>> Мы начинаем отсчет с нуля, так что кронштейн
нулю означает, ч, кронштейн одной

396
00:19:22,840 --> 00:19:25,170
означает, е, и так далее.

397
00:19:25,170 --> 00:19:28,490
И так все время, когда мы были
используя строки и печатать на машинке "привет"

398
00:19:28,490 --> 00:19:31,250
и "Мир" и другие вещи на
экране, это было сохранено

399
00:19:31,250 --> 00:19:32,820
в коробках, как это.

400
00:19:32,820 --> 00:19:33,370
И сделать предположение.

401
00:19:33,370 --> 00:19:37,470
Что означает каждая коробка представляют физически
внутри компьютера?

402
00:19:37,470 --> 00:19:38,250
>> [Неразборчиво].

403
00:19:38,250 --> 00:19:39,150
>> Простите?

404
00:19:39,150 --> 00:19:39,580
>> Персонажей.

405
00:19:39,580 --> 00:19:44,760
>> Таким характером, конечно, в случае
строк, и характер просто

406
00:19:44,760 --> 00:19:46,800
восемь битов или один байт.

407
00:19:46,800 --> 00:19:49,550
Таким образом, вы, вероятно, по крайней мере смутно
знакомы с тем фактом, что ваш

408
00:19:49,550 --> 00:19:50,500
Компьютер имеет память.

409
00:19:50,500 --> 00:19:52,110
Она состоит из двух типов памяти по крайней мере.

410
00:19:52,110 --> 00:19:54,810
Одним из них является жесткий диск, где Вы сохранили
вещи постоянно, и это

411
00:19:54,810 --> 00:19:57,400
обычно большие, поэтому вы можете есть фильмы
и музыки и так далее.

412
00:19:57,400 --> 00:20:04,010
>> Тогда у вас есть другой тип памяти
называется RAM, R-A-M, произвольный доступ

413
00:20:04,010 --> 00:20:07,510
Памяти, и это тип памяти
, который используется, когда компьютер

414
00:20:07,510 --> 00:20:11,520
работает, но, если вы потеряли власть или ваш
аккумулятор умирает, все, что хранится

415
00:20:11,520 --> 00:20:15,300
в оперативной памяти исчезает, если вы потеряли власть
в целом, потому что это не

416
00:20:15,300 --> 00:20:16,060
стойким.

417
00:20:16,060 --> 00:20:19,120
Как правило, есть, в эти дни,
концерт этого, два концерта, может больше.

418
00:20:19,120 --> 00:20:23,490
И вверх оперативной памяти, что намного
гораздо, гораздо быстрее, чем жесткие диски

419
00:20:23,490 --> 00:20:27,390
или даже твердотельных накопителей в эти дни,
но это правило, дороже, так

420
00:20:27,390 --> 00:20:28,480
у вас есть меньше.

421
00:20:28,480 --> 00:20:32,400
>> Поэтому сегодняшний разговор действительно относится
в ОЗУ, что тип памяти, который

422
00:20:32,400 --> 00:20:35,270
существует только пока есть власть
подается в компьютер.

423
00:20:35,270 --> 00:20:40,530
Итак, когда вы вводите в Н-Е-Л-Л-О, Enter на
клавиатуры, H происходит в одном

424
00:20:40,530 --> 00:20:44,550
байт оперативной памяти, E собирается в
другой байт оперативной памяти, как это

425
00:20:44,550 --> 00:20:45,800
остальные слова.

426
00:20:45,800 --> 00:20:49,010
Так вспомним, что мы смогли
сделать последний раз было так.

427
00:20:49,010 --> 00:20:53,940
Позвольте мне идти вперед и открывать файл
, который мы назвали string.c, и вспомнить

428
00:20:53,940 --> 00:20:56,860
что это выглядело немного
что-то вроде этого.

429
00:20:56,860 --> 00:20:59,860
Позвольте мне на самом деле откат и измените
это именно то, что это было похоже,

430
00:20:59,860 --> 00:21:02,654
длина строки с.

431
00:21:02,654 --> 00:21:04,560
>> Так что смотрите на программу здесь.

432
00:21:04,560 --> 00:21:08,530
Мы включаем библиотеку, так CS50
что мы можем использовать получить строку.

433
00:21:08,530 --> 00:21:11,400
Мы включили в стандартную io.h
поэтому мы можем использовать Е.

434
00:21:11,400 --> 00:21:13,580
Почему мы включаем string.h?

435
00:21:13,580 --> 00:21:16,980
Это было новым в понедельник.

436
00:21:16,980 --> 00:21:18,230
Таким образом, мы хотели длину строки.

437
00:21:18,230 --> 00:21:19,090
Ленг ул.

438
00:21:19,090 --> 00:21:21,470
Люди решили лет назад,
давайте просто быть краткими.

439
00:21:21,470 --> 00:21:24,290
Вместо того, назвав его "длина строки"
назовем ее "ул Ленг", и пусть

440
00:21:24,290 --> 00:21:28,540
мир понять это, и таким образом, это
то, что мы получаем доступ к string.h с.

441
00:21:28,540 --> 00:21:29,390
>> Это знакомо.

442
00:21:29,390 --> 00:21:30,320
Это знакомо.

443
00:21:30,320 --> 00:21:31,450
Это знакомо.

444
00:21:31,450 --> 00:21:32,370
Это немного новых.

445
00:21:32,370 --> 00:21:35,420
В линии 22 - и мы вернемся
к этому, но сейчас знаю -

446
00:21:35,420 --> 00:21:37,880
и вы бы только знаю, что это от того,
читать документацию или если

447
00:21:37,880 --> 00:21:39,010
Вы знали, С, уже -

448
00:21:39,010 --> 00:21:41,510
получить строка иногда может испортить.

449
00:21:41,510 --> 00:21:45,130
Если пользователь действительно состязательного или
отказывающихся от сотрудничества, и он или она просто

450
00:21:45,130 --> 00:21:49,450
не вводите ничего с клавиатуры или
Типы столько на клавиатуре, которая

451
00:21:49,450 --> 00:21:53,760
переполняет память компьютера,
В теории, взять веревку может вернуться

452
00:21:53,760 --> 00:21:56,270
нечто иное, чем
строку символов.

453
00:21:56,270 --> 00:22:01,930
Он может вернуться специальное значение, называемое
NULL заглавными буквами, N-U-L-L, а это

454
00:22:01,930 --> 00:22:03,390
только так называемые дозорные значения.

455
00:22:03,390 --> 00:22:08,010
Это специальное значение, которое означает
что-то плохое произошло в данном случае.

456
00:22:08,010 --> 00:22:10,520
Это отсутствие строки.

457
00:22:10,520 --> 00:22:16,190
>> Так нуль я проверяю для просто так, что,
Короче говоря, ул Ленг и

458
00:22:16,190 --> 00:22:20,230
другие функции, которые приходят с C, если
они ожидают строку, но их можно передавать

459
00:22:20,230 --> 00:22:23,630
отсутствие строку, если вы передаете
их ничтожными, компьютер или программа

460
00:22:23,630 --> 00:22:25,000
будет просто потерпеть крах сразу.

461
00:22:25,000 --> 00:22:25,610
Она будет висеть.

462
00:22:25,610 --> 00:22:27,250
Это будет бросить некоторое сообщение об ошибке.

463
00:22:27,250 --> 00:22:28,690
Могут произойти неприятные вещи.

464
00:22:28,690 --> 00:22:31,130
Так что, хотя это по-прежнему
не четко -

465
00:22:31,130 --> 00:22:33,730
это будет иметь больше смысла в неделю или
два - в линии 22, это всего лишь

466
00:22:33,730 --> 00:22:38,790
Примером самостоятельного оборонительного проверки ошибок
на всякий случай один раз из

467
00:22:38,790 --> 00:22:42,040
млн. что-то пойдет не так, по крайней
крайней мере, моя программа не рухнет.

468
00:22:42,040 --> 00:22:45,960
>> Так что, если с не равно что-то плохое,
У меня есть цикл, и это было

469
00:22:45,960 --> 00:22:47,710
где у нас было, что другие
новая часть синтаксиса.

470
00:22:47,710 --> 00:22:51,580
У меня есть цикл итерации от
нуля до длины с.

471
00:22:51,580 --> 00:22:56,140
А потом вот, я была распечатка с
Кронштейн я, но почему я использую C% всех

472
00:22:56,140 --> 00:23:00,770
Внезапно вместо% даже с
хотя ей это строка?

473
00:23:00,770 --> 00:23:02,110
Это символ, не так ли?

474
00:23:02,110 --> 00:23:06,560
S является строкой, но что-то с кронштейном,
с кронштейном я, где я равна нулю

475
00:23:06,560 --> 00:23:10,380
или один или два, это отдельные
символа в строке, и поэтому для

476
00:23:10,380 --> 00:23:14,970
что Е должен быть проинформирован, что
это действительно символ ожидать.

477
00:23:14,970 --> 00:23:18,096
>> А потом вспомнить, что сделал это
Программа на самом деле?

478
00:23:18,096 --> 00:23:19,848
>> Распечатал его в столбцах.

479
00:23:19,848 --> 00:23:21,120
>> Да, именно.

480
00:23:21,120 --> 00:23:24,990
Это просто напечатал слово, которое я печатаю в
колонка, один символ в строке.

481
00:23:24,990 --> 00:23:26,190
Итак, давайте посмотрим это снова.

482
00:23:26,190 --> 00:23:27,810
Так что строка.

483
00:23:27,810 --> 00:23:30,200
Составитель OK. . / Строка.

484
00:23:30,200 --> 00:23:35,560
Позвольте мне ввести Н-Е-Л-Л-О, ввода и
более того, я понимаю, по одному на строку.

485
00:23:35,560 --> 00:23:37,280
>> Итак, позвольте мне сделать одно оптимизации здесь.

486
00:23:37,280 --> 00:23:40,240
Если вы думаете об этом, особенно если
вы программировали раньше, есть

487
00:23:40,240 --> 00:23:43,340
возможно неэффективности линии 24.

488
00:23:43,340 --> 00:23:46,160
Другими словами, это не обязательно
лучший дизайн.

489
00:23:46,160 --> 00:23:50,200
Простой, по крайней мере, как только вы
помните, что Ленг ул есть, но это

490
00:23:50,200 --> 00:23:52,640
делать что-то потенциально немой.

491
00:23:52,640 --> 00:23:54,863
Что это может быть?

492
00:23:54,863 --> 00:23:56,280
>> [Неразборчиво].

493
00:23:56,280 --> 00:23:56,800
>> Именно так.

494
00:23:56,800 --> 00:24:00,340
Это проверка на длину с
каждый раз, даже при том,

495
00:24:00,340 --> 00:24:02,980
H-E-L-L-O всегда будет
в пять символов.

496
00:24:02,980 --> 00:24:05,490
Каждый раз, когда через этот цикл
пять не меняется.

497
00:24:05,490 --> 00:24:08,750
Я мог бы увеличивая я, но то, что
это длина с на каждый

498
00:24:08,750 --> 00:24:09,690
итерации этого цикла?

499
00:24:09,690 --> 00:24:15,810
Это пять, это пять, это пять, а
все же я задаю этот, тем не менее

500
00:24:15,810 --> 00:24:18,320
вопрос снова и снова и снова.

501
00:24:18,320 --> 00:24:20,750
Сейчас, честно говоря, компьютер так чертовски
быстро, никто не заметит

502
00:24:20,750 --> 00:24:23,780
Разница в этом случае, однако эти виды
бедных дизайнерских решений может

503
00:24:23,780 --> 00:24:28,330
начнут расти, если сам компилятор
не пытается исправить это для вас, которые

504
00:24:28,330 --> 00:24:30,630
он обычно не будет, по крайней
мере, в устройстве.

505
00:24:30,630 --> 00:24:31,540
>> Так что я собираюсь сделать это.

506
00:24:31,540 --> 00:24:34,580
Я собираюсь добавить запятую после
моя первая переменная, я.

507
00:24:34,580 --> 00:24:37,310
Я собираюсь дать себе еще
переменную, назвав его N, просто

508
00:24:37,310 --> 00:24:41,330
Конвенция для чисел, а затем я
собирается назначить п значение строки

509
00:24:41,330 --> 00:24:42,530
длина с.

510
00:24:42,530 --> 00:24:46,060
А потом я собираюсь изменить
мое состояние то, что?

511
00:24:46,060 --> 00:24:51,960
Я собираюсь изменить свое состояние
в то время как я меньше N.

512
00:24:51,960 --> 00:24:55,700
>> Так что теперь, сколько раз я
проверка длины с?

513
00:24:55,700 --> 00:25:00,110
Один раз, но это нормально, чтобы проверить, что я против
N снова и снова, потому что теперь эти

514
00:25:00,110 --> 00:25:03,170
значения фактически не меняется.

515
00:25:03,170 --> 00:25:06,020
Сейчас на данный момент, просто знаю, что в любое время вы
вызвать функцию, есть немного

516
00:25:06,020 --> 00:25:09,930
над головой, не достаточно, чтобы отговорить вас
от действительно никогда не используя функции, но

517
00:25:09,930 --> 00:25:12,750
конечно, когда есть строка кода
нравится, что - и границы получите

518
00:25:12,750 --> 00:25:15,490
более интересным вскоре - где
есть возможность подумать, если я

519
00:25:15,490 --> 00:25:18,320
введите этот код, сколько
раз он будет выполнять?

520
00:25:18,320 --> 00:25:20,950
Вы начнете видеть в течение долгого времени
выполнение своих программ

521
00:25:20,950 --> 00:25:21,660
действительно изменится.

522
00:25:21,660 --> 00:25:24,110
>> В самом деле, одним из домашних заданий мы в
сделано в прошлые годы включает в себя

523
00:25:24,110 --> 00:25:27,600
реализации, как вы помните из
нулевой неделе, проверка орфографии, но

524
00:25:27,600 --> 00:25:31,380
проверки орфографии, которая была разработана для поддержки
словарь 150000 плюс

525
00:25:31,380 --> 00:25:32,860
Слова, которые мы даем вам, ребята.

526
00:25:32,860 --> 00:25:37,100
Вы должны были бы написать код, который загружает
эти слова в памяти, так что в

527
00:25:37,100 --> 00:25:40,700
коробки, как мы видели на экране момент
назад, а затем так быстро, как вы

528
00:25:40,700 --> 00:25:43,740
может, вы должны быть в состоянии ответить
вопрос о форме, это слово

529
00:25:43,740 --> 00:25:44,280
орфографическими ошибками?

530
00:25:44,280 --> 00:25:45,420
Это слово с ошибкой?

531
00:25:45,420 --> 00:25:46,770
Это слово с ошибкой?

532
00:25:46,770 --> 00:25:49,525
>> И что-то в этом роде, что мы
сделано в прошлые годы включении его в,

533
00:25:49,525 --> 00:25:53,500
хотя и на отказ в факультативной основе
Конкурс родов, в результате чего

534
00:25:53,500 --> 00:25:59,470
студентов, которые используют меньше памяти и меньше
время, уменьшается загрузка процессора, в конечном итоге

535
00:25:59,470 --> 00:26:02,640
пузырьков вверх к верхней части немного
доски лидера или рейтинг, который мы ставим на

536
00:26:02,640 --> 00:26:04,770
Конечно домашнюю страницу, как мы
сделано в прошлые годы.

537
00:26:04,770 --> 00:26:08,100
Итак, еще раз, совершенно необязательно, но это
говорит о возможности дизайна

538
00:26:08,100 --> 00:26:11,250
которые впереди как только мы начинаем
построение поверх некоторых из этих

539
00:26:11,250 --> 00:26:14,010
основные строительные блоки.

540
00:26:14,010 --> 00:26:16,780
>> Итак, позвольте мне вернуться к этой схеме
На мгновение и раскрыть немного

541
00:26:16,780 --> 00:26:17,610
нечто большее.

542
00:26:17,610 --> 00:26:21,400
Разумеется, эта строка, и мы взяли
Преимущество несколько библиотек

543
00:26:21,400 --> 00:26:25,150
стандартные io.h которая имеет -

544
00:26:25,150 --> 00:26:26,110
>> Printf.

545
00:26:26,110 --> 00:26:27,860
>> Printf, между прочим.

546
00:26:27,860 --> 00:26:31,540
cs50.h, который получают десятичного и получить строку
и так далее, string.h, который

547
00:26:31,540 --> 00:26:32,570
Ленг был ул.

548
00:26:32,570 --> 00:26:34,800
Но, оказывается, есть еще один.

549
00:26:34,800 --> 00:26:38,540
Честно говоря, есть много-много заголовков
файлы, которые объявлять функции

550
00:26:38,540 --> 00:26:43,320
для библиотек, но это является ctype.h
на самом деле происходит, чтобы быть несколько

551
00:26:43,320 --> 00:26:46,900
выгодно, потому что я собираюсь
идти вперед и реализовать один

552
00:26:46,900 --> 00:26:48,120
другие программы здесь.

553
00:26:48,120 --> 00:26:52,420
>> Позвольте мне идти вперед и открывать что-то
Я написал заранее называют

554
00:26:52,420 --> 00:26:55,750
capitalize.c, и давайте
Посмотрите, как это работает.

555
00:26:55,750 --> 00:27:00,340
Обратите внимание, что я использую, в этой версии
его, три знакомы файлов.

556
00:27:00,340 --> 00:27:04,110
Обратите внимание, что в строке 18, я
получение строки текста.

557
00:27:04,110 --> 00:27:07,660
Уведомление в строке 21, я, утверждая, что
Следующий код будет

558
00:27:07,660 --> 00:27:12,170
выгоду с, что введенный пользователем
в, и как я это делаю?

559
00:27:12,170 --> 00:27:13,300
Ну, я беру -

560
00:27:13,300 --> 00:27:14,750
Урок, извлеченный из последнего времени -

561
00:27:14,750 --> 00:27:18,370
Я объявляю я и н и итерации
более символов в строке.

562
00:27:18,370 --> 00:27:22,720
И тогда то, что этот блок
код в соответствии с 24 по 27

563
00:27:22,720 --> 00:27:24,550
делать с точки зрения непрофессионала?

564
00:27:24,550 --> 00:27:27,766

565
00:27:27,766 --> 00:27:29,730
>> Строчной буквы обратно.

566
00:27:29,730 --> 00:27:30,430
>> Именно так.

567
00:27:30,430 --> 00:27:35,920
Если я с кронштейном - так что если г-й
Характер с, что конкретный

568
00:27:35,920 --> 00:27:40,220
символов в строке, больше
или равна нижнему регистру и -

569
00:27:40,220 --> 00:27:42,670
Напомним, что двойной амперсанд
и означает -

570
00:27:42,670 --> 00:27:46,810
и тот же характер, с кронштейном I, является
меньше или равно в нижний регистр Z,

571
00:27:46,810 --> 00:27:50,600
, что означает, что он или B или C или
точка, точка, точка, или Z, что означает,

572
00:27:50,600 --> 00:27:51,340
это строчными буквами.

573
00:27:51,340 --> 00:27:52,900
Что я хочу сделать в таком случае?

574
00:27:52,900 --> 00:27:55,010
Ну, что я могу сделать это несколько
загадочно, но

575
00:27:55,010 --> 00:27:56,160
давай дразнить этого друг от друга.

576
00:27:56,160 --> 00:28:00,210
>> Я буду называть Е, печатает% C
потому что я хочу, чтобы перепечатать эту

577
00:28:00,210 --> 00:28:01,580
символа на экране.

578
00:28:01,580 --> 00:28:06,650
Я тогда собираюсь взять с кронштейном I,
I-ый символ в сек, то почему бы и

579
00:28:06,650 --> 00:28:12,330
я делаю это маленькая хитрость,
нижний регистр минус капитала?

580
00:28:12,330 --> 00:28:16,352
И что это даст
Мне, вообще говоря?

581
00:28:16,352 --> 00:28:18,600
>> [Неразборчиво].

582
00:28:18,600 --> 00:28:19,390
>> Именно так.

583
00:28:19,390 --> 00:28:20,860
Я действительно не помню -

584
00:28:20,860 --> 00:28:24,390
это было 65 на капитальный А. Мне не очень
помните, что нижний регистр есть,

585
00:28:24,390 --> 00:28:25,540
Но независимо от того.

586
00:28:25,540 --> 00:28:26,580
Компьютер знает.

587
00:28:26,580 --> 00:28:30,380
Так, говоря, нижний регистр минус
капитала, это странно, чтобы быть

588
00:28:30,380 --> 00:28:33,530
вычитания один символ от другого, но
какие символы под капотом?

589
00:28:33,530 --> 00:28:34,520
Они просто цифры.

590
00:28:34,520 --> 00:28:36,980
Поэтому, что бы эти цифры,
пусть компьютер помню

591
00:28:36,980 --> 00:28:38,240
а не мне человека.

592
00:28:38,240 --> 00:28:41,710
>> Так нижний регистр вычетом капитальных является
собирается дать мне разницу.

593
00:28:41,710 --> 00:28:45,370
Это, оказывается, 32, и это было бы
в случае строчными B и B капитала

594
00:28:45,370 --> 00:28:45,930
и так далее.

595
00:28:45,930 --> 00:28:47,710
Он остается последовательной, к счастью.

596
00:28:47,710 --> 00:28:51,930
Так что я по сути, говорит, возьми
строчной буквы, что Вычтем

597
00:28:51,930 --> 00:28:55,340
стандарт различие, и
эффективно изменений с кронштейном я от

598
00:28:55,340 --> 00:28:59,400
нижний регистр, чтобы, конечно, прописные,
без моего действительно того, чтобы думать

599
00:28:59,400 --> 00:29:03,040
о или вспомнить, что это были за
номера мы говорили о том, когда восемь

600
00:29:03,040 --> 00:29:04,800
добровольцы пришли на сцену?

601
00:29:04,800 --> 00:29:08,800
Теперь Между тем, в другой, если это не
строчной буквы, как это определено

602
00:29:08,800 --> 00:29:10,400
по линии 24, его можно просто вывести.

603
00:29:10,400 --> 00:29:12,590
Я только хочу, чтобы коснуться
символов, которые были

604
00:29:12,590 --> 00:29:14,410
на самом деле изначально нижний регистр.

605
00:29:14,410 --> 00:29:15,150
>> Итак, давайте посмотрим это.

606
00:29:15,150 --> 00:29:17,400
Сделать выгоду.

607
00:29:17,400 --> 00:29:18,470
Составитель, OK.

608
00:29:18,470 --> 00:29:19,730
. / Выгоду.

609
00:29:19,730 --> 00:29:23,530
И позвольте мне ввести Н-Е-Л-Л-О
в нижнем регистре, Enter.

610
00:29:23,530 --> 00:29:26,370
И заметьте, что он преобразуется
в верхнем регистре.

611
00:29:26,370 --> 00:29:27,940
Позволь мне сделать это снова
другое слово.

612
00:29:27,940 --> 00:29:32,720
Как насчет D--V-I-D с первым D
капитализируются как правило, это имя?

613
00:29:32,720 --> 00:29:33,560
Enter.

614
00:29:33,560 --> 00:29:34,870
Обратите внимание, она по-прежнему верна.

615
00:29:34,870 --> 00:29:40,250
Это только первый вывод, что D неизменным
через что еще построить.

616
00:29:40,250 --> 00:29:42,170
>> Поэтому имейте в виду, то,
Пару вещей.

617
00:29:42,170 --> 00:29:45,060
Один из них, если вы хотите проверить два
условия сразу, вы можете и их

618
00:29:45,060 --> 00:29:46,500
вместе, как мы и предсказывали.

619
00:29:46,500 --> 00:29:49,900
Вы можете сравнить символы таким образом
и эффективно лечить как символы

620
00:29:49,900 --> 00:29:53,050
цифры, но, честно говоря, это так чертовски
загадочные Я никогда не буду помнить

621
00:29:53,050 --> 00:29:56,510
Как придумал это с нуля
без объяснения причин через него в течение достаточно

622
00:29:56,510 --> 00:29:57,140
немного времени.

623
00:29:57,140 --> 00:30:00,590
>> Разве не было бы хорошо, если кто-то
там написал вызванная функция

624
00:30:00,590 --> 00:30:05,390
ниже, чем мог ответить для меня истинным или
ложными, этот символ в нижнем регистре?

625
00:30:05,390 --> 00:30:09,350
Ну, к счастью, тот, кто писал
ctype.h сделал именно это.

626
00:30:09,350 --> 00:30:15,540
Хотел бы я пойти здесь и добавьте CType для C
типа, а теперь отпустил меня сюда и

627
00:30:15,540 --> 00:30:18,820
переписать эту строку следующим образом.

628
00:30:18,820 --> 00:30:27,510
>> Так что если это называется ниже, я утверждаю, с
Кронштейн я, то я собираюсь удалить

629
00:30:27,510 --> 00:30:29,400
эти две линии в целом.

630
00:30:29,400 --> 00:30:32,570
Так что теперь кого-то еще, я надеюсь, написал
Функция называется ниже, и это

631
00:30:32,570 --> 00:30:36,250
Оказывается, что они сделали и они объявлены
его внутри ctype.h.

632
00:30:36,250 --> 00:30:39,480
А теперь я собираюсь оставить линию 27
один, я собираюсь оставить линии 31

633
00:30:39,480 --> 00:30:41,890
один, не заметить, как сильно я
затянул мне кода.

634
00:30:41,890 --> 00:30:42,690
Это теперь чище.

635
00:30:42,690 --> 00:30:47,250
Это меньше, трудно смотреть через
потому что теперь функции, кроме того,

636
00:30:47,250 --> 00:30:50,080
так чудесно назвал его просто
делает то, что он говорит.

637
00:30:50,080 --> 00:30:51,520
>> Так что теперь я иду, чтобы спасти этого.

638
00:30:51,520 --> 00:30:52,930
Я иду, чтобы уменьшить масштаб.

639
00:30:52,930 --> 00:30:56,650
И так же, как и в нуля, вы могли бы
Логические, логические значения истина или

640
00:30:56,650 --> 00:31:01,530
ложными, это именно то, что
эффективно снизить отдачу.

641
00:31:01,530 --> 00:31:02,960
Позвольте мне перекомпилировать.

642
00:31:02,960 --> 00:31:04,500
Позвольте мне опять запустить.

643
00:31:04,500 --> 00:31:07,350
А теперь давайте попробуем это снова,
H-E-L-L-О, Enter.

644
00:31:07,350 --> 00:31:07,970
Это очень хорошо.

645
00:31:07,970 --> 00:31:10,150
И попробуйте еще раз, убедиться, что я
не что-либо испортите.

646
00:31:10,150 --> 00:31:11,670
То есть капитализируются, а также.

647
00:31:11,670 --> 00:31:14,190
>> Но этого не достаточно хорош, потому что
Другая вещь, которую я никогда не собираюсь

648
00:31:14,190 --> 00:31:19,090
помните, если я не работать через него действительно
тщательно, скажем, бумага

649
00:31:19,090 --> 00:31:19,920
эту проклятую линию.

650
00:31:19,920 --> 00:31:23,450
Не было бы неплохо, если бы
Функция называется в верхний?

651
00:31:23,450 --> 00:31:26,930
Ну оказывается, есть
находится в ctype.h также.

652
00:31:26,930 --> 00:31:30,150
Я собираюсь идти вперед и тип -

653
00:31:30,150 --> 00:31:31,340
лучше я выведу эту линию спины.

654
00:31:31,340 --> 00:31:36,430
Вместо этого здесь, позвольте мне идти вперед
и сказать, заменить C%

655
00:31:36,430 --> 00:31:42,110
результате вызова этой функции
верхняя на I-ый символ с.

656
00:31:42,110 --> 00:31:45,430
А теперь замечаю это становится
немного сбалансированы.

657
00:31:45,430 --> 00:31:48,870
Я должен следить за сколько
скобках я открываться и закрываться.

658
00:31:48,870 --> 00:31:50,050
>> Так что теперь это даже чище.

659
00:31:50,050 --> 00:31:53,460
Теперь эта программа становится все лучше и
лучше разработаны, возможно, потому что это

660
00:31:53,460 --> 00:31:56,450
многое, многое другое для чтения, но
Ведь не давайте исправим.

661
00:31:56,450 --> 00:31:57,600
Сделать выгоду.

662
00:31:57,600 --> 00:31:58,930
. / Выгоду.

663
00:31:58,930 --> 00:32:03,220
H-E-L-L-вывода. Давайте запустим его снова,
D-A-V-I-D. Итак, мы все еще в

664
00:32:03,220 --> 00:32:04,250
довольно хорошей форме.

665
00:32:04,250 --> 00:32:06,030
>> Но теперь к верхнему.

666
00:32:06,030 --> 00:32:09,720
Я полагаю, что есть еще одна
Уточнение мы могли бы сделать, что бы

667
00:32:09,720 --> 00:32:12,820
действительно хороший, которые могли бы действительно затянуть
этот код и действительно, дайте нам пять

668
00:32:12,820 --> 00:32:15,150
из пяти дизайн, например.

669
00:32:15,150 --> 00:32:16,510
Что неплохо бы избавиться?

670
00:32:16,510 --> 00:32:20,770
Ну, посмотрите, как чертовски долго этот блок
код только, чтобы сделать что-то простое.

671
00:32:20,770 --> 00:32:23,850
>> Теперь, как в стороне, как вы могли
видели в этом разделе супер прошлом

672
00:32:23,850 --> 00:32:27,570
выходные, вам не нужно строго
фигурные скобки, когда у Вас только одна

673
00:32:27,570 --> 00:32:32,180
строка кода, хотя мы предложили
держать их так, что он делает много

674
00:32:32,180 --> 00:32:36,190
более ясным, как для Scratch в П-образной
блоки, что внутри отрасли.

675
00:32:36,190 --> 00:32:40,170
Но разве не было бы неплохо, если бы в верхний,
когда дано его вход, превратил его в

676
00:32:40,170 --> 00:32:44,730
верхний регистр, если это не так, и что будет
быть замечательными в противном случае, если

677
00:32:44,730 --> 00:32:47,210
это уже верхний регистр?

678
00:32:47,210 --> 00:32:49,620
Просто передайте его через
и оставить его в покое.

679
00:32:49,620 --> 00:32:50,660
>> Поэтому, возможно, он делает это.

680
00:32:50,660 --> 00:32:52,990
Я мог бы попробовать и просто надеюсь,
что она делает, но позвольте мне

681
00:32:52,990 --> 00:32:54,450
ввести еще одну вещь.

682
00:32:54,450 --> 00:32:57,440
Вместо использования этого встроенный терминал
окна здесь, напомним, что

683
00:32:57,440 --> 00:33:01,130
это квадратный значок черного дает
большие окна терминала, что я может полный

684
00:33:01,130 --> 00:33:02,260
экран, если я хочу?

685
00:33:02,260 --> 00:33:05,820
Вот и получается, что они вроде странно
имени, но есть такие вещи называются

686
00:33:05,820 --> 00:33:10,970
Человек страниц, страниц руководства, человек для краткости,
и я могу получить доступ к ним

687
00:33:10,970 --> 00:33:14,515
человек, набрав -

688
00:33:14,515 --> 00:33:15,570
Что я хочу набрать?

689
00:33:15,570 --> 00:33:17,830
Человек в верхний.

690
00:33:17,830 --> 00:33:21,090
>> А теперь обратите внимание, если существует
функционировать внутри компьютера, в

691
00:33:21,090 --> 00:33:23,970
этом случае устройство, которое как раз
операционная система Linux, она собирается

692
00:33:23,970 --> 00:33:27,920
дать мне несколько загадочным набором
выход, но вы увидите, что с течением времени

693
00:33:27,920 --> 00:33:31,720
она всегда форматируется в значительной степени
так же вы начинаете привыкать к нему.

694
00:33:31,720 --> 00:33:35,130
Обратите внимание, в верхней части до верхней и
видимо, те же самые документы

695
00:33:35,130 --> 00:33:35,680
для снижения.

696
00:33:35,680 --> 00:33:38,740
Кто бы ни написал он резал некоторых
углы и положил все это на одной странице.

697
00:33:38,740 --> 00:33:40,720
Эти вещи "в целях
жизни заключается в преобразовании

698
00:33:40,720 --> 00:33:42,780
Письмо верхний или нижний регистр.

699
00:33:42,780 --> 00:33:46,290
>> Обратите внимание, что под Synopsis, справочную страницу
учит меня, что у меня есть файл

700
00:33:46,290 --> 00:33:48,130
включить, чтобы использовать эту вещь.

701
00:33:48,130 --> 00:33:51,320
Это дает мне подписей для этих
Функции, оба из них, даже

702
00:33:51,320 --> 00:33:53,510
хотя мы сейчас только
заботиться об одном.

703
00:33:53,510 --> 00:33:54,730
Вот теперь описании.

704
00:33:54,730 --> 00:33:58,800
Для верхней преобразует символ
C в верхний регистр, если возможно.

705
00:33:58,800 --> 00:34:02,280
>> Еще не так поучительно, но позвольте мне
Теперь смотрите под возвращаемого значения, вещь

706
00:34:02,280 --> 00:34:03,520
который вернул.

707
00:34:03,520 --> 00:34:08,600
Таким образом, значение, возвращенное в том, что из
преобразуется буква или С, если

708
00:34:08,600 --> 00:34:09,870
преобразование не удалось.

709
00:34:09,870 --> 00:34:11,202
Что такое C?

710
00:34:11,202 --> 00:34:12,560
>> Оригинальный характер.

711
00:34:12,560 --> 00:34:15,370
>> Оригинальный характер и мы знаем,
что, опять же, подойдя к

712
00:34:15,370 --> 00:34:19,179
синопсис, и тот, кто написал это
Функция просто решил, что входной

713
00:34:19,179 --> 00:34:22,909
чтобы на верхний и нижний просто
произвольно будет называться C.

714
00:34:22,909 --> 00:34:24,909
Они могли бы назвал это практически все,
они хотят, но они оставили его

715
00:34:24,909 --> 00:34:26,270
просто, как в.

716
00:34:26,270 --> 00:34:27,880
Так что я консультировался с человеком странице.

717
00:34:27,880 --> 00:34:31,870
Эта фраза меня успокаивает, что если
это не строчной буквы, это

718
00:34:31,870 --> 00:34:34,969
собирается просто отдай мне с, что
совершенной, которая означает, что я могу избавиться от

719
00:34:34,969 --> 00:34:36,199
мое другое состояние.

720
00:34:36,199 --> 00:34:39,679
>> Итак, позвольте мне вернуться к Gedit и
Теперь позвольте мне сделать это.

721
00:34:39,679 --> 00:34:41,960
Я собираюсь скопировать мой Е заявлении.

722
00:34:41,960 --> 00:34:45,969
Я собираюсь идти вперед и прямо в
цикл, что из печати, и получить

723
00:34:45,969 --> 00:34:48,760
Теперь избавиться от всего этого, если конструкцией.

724
00:34:48,760 --> 00:34:51,860
Был не плохая идея, и это было очень
много правильно и согласуются с

725
00:34:51,860 --> 00:34:54,100
все, что мы проповедовали,
но только не надо.

726
00:34:54,100 --> 00:34:57,070
Как только вы понимаете, некоторые библиотеки
функция существует, что кто-то другой

727
00:34:57,070 --> 00:35:01,340
написал, или может быть, вы писали в другом месте
файла, вы можете использовать его и в самом деле

728
00:35:01,340 --> 00:35:02,690
начать подтянуть кода.

729
00:35:02,690 --> 00:35:06,080
>> И когда я говорю такие вещи, как хороший стиль,
на то, что этот человек называется

730
00:35:06,080 --> 00:35:11,490
функционировать в верхний или ранее является
нижняя удивительно полезно, потому что

731
00:35:11,490 --> 00:35:12,900
они очень описательный характер.

732
00:35:12,900 --> 00:35:16,120
Вы не хотели бы обратить ваше функций
X и Y и Z, которые имеют

733
00:35:16,120 --> 00:35:19,620
гораздо, гораздо меньше смысла.

734
00:35:19,620 --> 00:35:25,160
Любые вопросы по этой серии
улучшений?

735
00:35:25,160 --> 00:35:28,010
>> Таким образом, достаточно сказать, один из
вынос еще как свои собственные проблемы

736
00:35:28,010 --> 00:35:30,960
Набор - может быть, проблема набора, но
конечно P установить два и далее, даже

737
00:35:30,960 --> 00:35:34,380
когда они правы, не обязательно
означает, что они просто идеально

738
00:35:34,380 --> 00:35:36,155
или все же продуманным дизайном.

739
00:35:36,155 --> 00:35:38,420
Вот другой оси
начать думать о.

740
00:35:38,420 --> 00:35:41,730
Так что это было строку внутри вашего
памяти компьютера, но если у вас есть

741
00:35:41,730 --> 00:35:46,180
целая куча персонажей вроде H-E-L-L-O
внутри оперативной памяти, и предположим,

742
00:35:46,180 --> 00:35:51,330
что вам в вашей программе называем получить строку
несколько раз так, что вы

743
00:35:51,330 --> 00:35:54,200
позвоните получить строку один раз, то вы
позвоните получить строку снова.

744
00:35:54,200 --> 00:35:55,880
Ну, то, что собирается
произойти с течением времени?

745
00:35:55,880 --> 00:35:59,170
>> Другими словами, если у вас есть линия
кода, хотя из контекста, как

746
00:35:59,170 --> 00:36:02,120
Строка с добирается -

747
00:36:02,120 --> 00:36:02,960
давайте сделаем это.

748
00:36:02,960 --> 00:36:05,270
Имя строки равно получить строку.

749
00:36:05,270 --> 00:36:08,590
Поэтому предположим, что строка кода предназначен
спросить у пользователя его или ее имя.

750
00:36:08,590 --> 00:36:14,580
В следующей строке кода хотела спросить
пользователю для его или ее школе, и

751
00:36:14,580 --> 00:36:15,920
эта следующая строка, и так далее.

752
00:36:15,920 --> 00:36:18,150
Предположим, что мы постоянно спрашивают
Пользователь еще и

753
00:36:18,150 --> 00:36:19,750
еще и еще строку.

754
00:36:19,750 --> 00:36:22,390
Они собираются оставаться в памяти
в то же время.

755
00:36:22,390 --> 00:36:24,280
Один из них не собирается замещать другие.

756
00:36:24,280 --> 00:36:26,420
Школе не перекрывать друг друга.

757
00:36:26,420 --> 00:36:28,520
Но там, где они все
в конечном итоге в памяти?

758
00:36:28,520 --> 00:36:32,030
>> Ну, если мы начнем рисовать на экране,
которые мы можем использовать эту вещь

759
00:36:32,030 --> 00:36:35,800
здесь, как доска, если это черный
прямоугольник представляет моего компьютера

760
00:36:35,800 --> 00:36:39,800
памяти, я собираюсь начать произвольно
разделив его на небольшие квадраты,

761
00:36:39,800 --> 00:36:42,120
каждый из которых представляет
один байт памяти.

762
00:36:42,120 --> 00:36:46,560
Честно говоря, если у вас есть гигабайт оперативной памяти
в эти дни, у вас есть миллиард байт

763
00:36:46,560 --> 00:36:49,540
памяти в вашем компьютере, так
миллиардов из этих квадратов.

764
00:36:49,540 --> 00:36:52,110
Так что достаточно сказать, это
на самом деле не в масштабе.

765
00:36:52,110 --> 00:36:58,250
>> Но мы могли бы сохранить рисунок все эти
ясно не в масштабе квадратов, и эта

766
00:36:58,250 --> 00:37:01,260
коллективно представляет
моей памяти компьютера.

767
00:37:01,260 --> 00:37:03,136
Теперь мы просто сделаем точка, точка, точка.

768
00:37:03,136 --> 00:37:06,260
Итак, другими словами, когда я теперь побудить
пользователю взять веревку, чтобы дать мне

769
00:37:06,260 --> 00:37:07,350
Строка, что происходит?

770
00:37:07,350 --> 00:37:14,270
Если пользователь введет в "привет", который заканчивается
в H-E-L-L-вывода. Но предположим, что

771
00:37:14,270 --> 00:37:15,720
Затем пользователь типов -

772
00:37:15,720 --> 00:37:17,250
На самом деле, я не должен был делать
привет, потому что мы просим

773
00:37:17,250 --> 00:37:18,330
их за их имена.

774
00:37:18,330 --> 00:37:20,580
Итак, давайте вернемся, если я могу сделать это.

775
00:37:20,580 --> 00:37:26,130
>> Так что если я типа в D--V-I-D имени Моему,
но напомнить, что во второй строке

776
00:37:26,130 --> 00:37:29,220
Код был получить строку снова
чтобы получить их школе.

777
00:37:29,220 --> 00:37:32,090
Где это слово, которое пользователь
типы собирается идти дальше?

778
00:37:32,090 --> 00:37:38,290
Ну, может, это будет идти в
H-A-R-V-A-R-D. Так что, хотя я

779
00:37:38,290 --> 00:37:41,560
нарисовал его в виде двух строк, это будет просто
целая куча байтов в вашем

780
00:37:41,560 --> 00:37:42,710
оперативной памяти компьютера.

781
00:37:42,710 --> 00:37:46,560
Там проблема сейчас, потому что сейчас, если я
использование оперативной памяти в этом очень разумно

782
00:37:46,560 --> 00:37:49,910
а как бы наивно, что вы можете
видимо, не отличить?

783
00:37:49,910 --> 00:37:52,640

784
00:37:52,640 --> 00:37:54,680
Где начинается одно и где
заканчивается один, верно?

785
00:37:54,680 --> 00:37:55,860
Они вроде размытия вместе.

786
00:37:55,860 --> 00:37:57,920
>> Вот и получается, компьютер
не делает этого.

787
00:37:57,920 --> 00:38:04,720
Позвольте мне на самом деле прокрутить назад во времени
несколько символов, а вместо Гарварда

788
00:38:04,720 --> 00:38:09,570
собирается сразу после имени пользователя,
пользователь получает на самом деле, за

789
00:38:09,570 --> 00:38:12,000
кулисами, специальные символы
вставляется

790
00:38:12,000 --> 00:38:13,885
Компьютер для него или нее.

791
00:38:13,885 --> 00:38:19,470
/ 0, иначе известной как нулевой символ
раздражающе называемый N-U-L, не

792
00:38:19,470 --> 00:38:22,190
N-U-L-L, но вы пишете его как / 0.

793
00:38:22,190 --> 00:38:27,130
Это просто все нули является маркером в
между первое слово, которое пользователь

794
00:38:27,130 --> 00:38:28,290
напечатан и второго.

795
00:38:28,290 --> 00:38:33,020
>> Так что на самом деле сейчас Гарвардского заканчивается
как это последовательность символов

796
00:38:33,020 --> 00:38:36,110
И еще один / 0.

797
00:38:36,110 --> 00:38:41,690
Итак, другими словами, при наличии этих
дозорные значения, восьми последовательных нуля

798
00:38:41,690 --> 00:38:45,220
бит, теперь вы можете начать различать
один символ от другого.

799
00:38:45,220 --> 00:38:49,720
Так что все это время, что был "привет" является
на самом деле "привет" с / 0, а

800
00:38:49,720 --> 00:38:53,580
Между тем, вполне может
будет немного больше оперативной памяти

801
00:38:53,580 --> 00:38:56,400
внутрь компьютера.

802
00:38:56,400 --> 00:38:57,810
>> Позвольте мне сделать еще одну вещь сейчас.

803
00:38:57,810 --> 00:39:01,800
Оказывается, что все эти квадраты
мы рисую, они, да,

804
00:39:01,800 --> 00:39:06,140
строки, но в более общем
эти вещи являются массивы.

805
00:39:06,140 --> 00:39:10,590
Массив это просто кусок памяти
вот спина к спине, чтобы спина к спине,

806
00:39:10,590 --> 00:39:15,130
и как правило, используется массив путем
этой площади обозначения кронштейна.

807
00:39:15,130 --> 00:39:18,210
Итак, мы собираемся, чтобы увидеть эти совсем немного
с течением времени, но позвольте мне идти вперед и

808
00:39:18,210 --> 00:39:21,160
открываются, назовем его возраста.

809
00:39:21,160 --> 00:39:23,920
И обратите внимание, что мы можем сделать с
эти же трюки, немного

810
00:39:23,920 --> 00:39:25,750
немного больше синтаксисом.

811
00:39:25,750 --> 00:39:29,270
>> Таким образом, в строке 17 этой программы -
на самом деле, позвольте мне запустить программу первым

812
00:39:29,270 --> 00:39:30,770
поэтому мы можем видеть, что эта вещь делает.

813
00:39:30,770 --> 00:39:33,530
Позвольте мне обратить возрастов, чтобы сделать
компиляции этой программы.

814
00:39:33,530 --> 00:39:34,950
. / Возрастов.

815
00:39:34,950 --> 00:39:36,480
Сколько человек в комнате?

816
00:39:36,480 --> 00:39:38,020
Назовите это три.

817
00:39:38,020 --> 00:39:39,575
Возраст первого лица?

818
00:39:39,575 --> 00:39:42,710
18, 19 и 20.

819
00:39:42,710 --> 00:39:46,770
А теперь несколько смешно, я просто
сделали программу, которая возрастов тех,

820
00:39:46,770 --> 00:39:47,740
трех человек.

821
00:39:47,740 --> 00:39:50,390
>> Таким образом, есть очевидная возможность
для некоторой забавы вот арифметика.

822
00:39:50,390 --> 00:39:51,560
К счастью, математика является правильным.

823
00:39:51,560 --> 00:39:54,720
18 пошел в 19, 19 пошел
20 и так далее.

824
00:39:54,720 --> 00:39:58,510
Но что на самом деле значит быть
иллюстративные вот как мы сохраняем

825
00:39:58,510 --> 00:40:00,190
этих трех людей возрастов.

826
00:40:00,190 --> 00:40:02,370
Позвольте мне увеличения на то, что
здесь происходит.

827
00:40:02,370 --> 00:40:06,240
>> Итак, сначала, эти первые несколько строк должно
получать довольно хорошо знакомы.

828
00:40:06,240 --> 00:40:08,770
Я просто с помощью которого пользователь
Количество человек в комнате.

829
00:40:08,770 --> 00:40:11,490
Тогда я использую получить десятичного и время, чтобы сделать
делать это снова и снова и снова.

830
00:40:11,490 --> 00:40:15,780
Мы видели, что модель и раньше, но
строка 27 является новым и на самом деле довольно

831
00:40:15,780 --> 00:40:18,160
полезными, и станет
более полезными.

832
00:40:18,160 --> 00:40:21,620
Обратите внимание, что что по-другому в линии 27
то, что я, кажется, объявив

833
00:40:21,620 --> 00:40:23,960
Int называется возрастов, но ждать.

834
00:40:23,960 --> 00:40:27,140
Это не просто десятичного возрастов.

835
00:40:27,140 --> 00:40:30,130
Там в эти квадратные скобки,
внутри которого п.

836
00:40:30,130 --> 00:40:35,150
>> Таким образом, кронштейн н в данном контексте не
Внутри Е заявление здесь, но

837
00:40:35,150 --> 00:40:44,370
В этой единственной линии 27, эта линия
говоря: дайте и мне целых N, каждый из которых

838
00:40:44,370 --> 00:40:46,080
имеет тип Int.

839
00:40:46,080 --> 00:40:49,870
Так что это ведро, так сказать, из,
В этом случае, три целых Вернуться к

840
00:40:49,870 --> 00:40:52,770
спина к спине так, что я эффективно
есть три переменных.

841
00:40:52,770 --> 00:40:54,890
В качестве альтернативы, быть
Ясно, это было бы.

842
00:40:54,890 --> 00:40:57,400
>> Если бы я хотел первым студента
возраста, я мог бы это сделать.

843
00:40:57,400 --> 00:40:59,520
Если бы я хотела второго студента
возрасту я мог бы сделать это.

844
00:40:59,520 --> 00:41:01,860
Если бы я хотел третьего студента
возраста, я мог бы это сделать.

845
00:41:01,860 --> 00:41:04,320
И не дай Бог нам нужно каждому
возраста в этой комнате -

846
00:41:04,320 --> 00:41:07,670
Я имею в виду, это чертовски много копий,
вставьте снова и снова и снова.

847
00:41:07,670 --> 00:41:10,870
И плюс, как только я компиляции этой программы
Если другой студент ходит в более чем из

848
00:41:10,870 --> 00:41:14,200
этой двери, теперь мой номер
переменных является неправильным.

849
00:41:14,200 --> 00:41:17,450
>> Так что приятно об массив как
только вы начинаете чувствовать себя

850
00:41:17,450 --> 00:41:20,190
копирование и вставка, вполне вероятно, что это
не самый лучший подход.

851
00:41:20,190 --> 00:41:22,240
Динамический массив потенциально.

852
00:41:22,240 --> 00:41:24,610
Я не знаю заранее, сколько людей
собираются быть в комнате,

853
00:41:24,610 --> 00:41:28,670
но я знаю, что нужно п из них, а я
выяснить, N, когда придет время.

854
00:41:28,670 --> 00:41:35,500
Эта строка кода в настоящее время означает, дай мне
участок памяти, который выглядит следующим

855
00:41:35,500 --> 00:41:40,380
где количество окон на экране
полностью зависит от N, что

856
00:41:40,380 --> 00:41:42,010
Пользователь ввели дюйма

857
00:41:42,010 --> 00:41:44,850
>> Так что теперь на остальной части этой программы
на самом деле очень похоже на то, что мы

858
00:41:44,850 --> 00:41:46,860
только что сделали с символами.

859
00:41:46,860 --> 00:41:49,970
Заметьте, что я для петли
начиная с линии 30.

860
00:41:49,970 --> 00:41:54,920
Так что сразу после я получаю массив, я
итерации от Y равно нулю на до н.

861
00:41:54,920 --> 00:41:58,890
Я просто эту поучительную Е
сообщение просто говорю, дайте мне возрасте

862
00:41:58,890 --> 00:42:03,690
человек #% я, так что номер один,
номер два, номер три.

863
00:42:03,690 --> 00:42:04,730
И почему я это делаю?

864
00:42:04,730 --> 00:42:08,870
Честно говоря, люди предпочитают считать от одного
в то время как на компьютере до ученых,

865
00:42:08,870 --> 00:42:09,620
нулю и выше.

866
00:42:09,620 --> 00:42:11,700
Компьютер ученые не собираются
использовать этот вид программы, так что мы

867
00:42:11,700 --> 00:42:13,990
собирается просто начать отсчет
в одно, как нормальные люди.

868
00:42:13,990 --> 00:42:17,630
>> И сейчас в строке 33, обратите внимание на несколько
другой кусок синтаксис.

869
00:42:17,630 --> 00:42:23,710
I-го возраста, что в переменной типа
Массив собирается получить Int.

870
00:42:23,710 --> 00:42:25,770
И теперь, наконец, это просто
арифметические здесь.

871
00:42:25,770 --> 00:42:29,200
Я решил в отдельной петле требовать
проходит некоторое время, и теперь в этом

872
00:42:29,200 --> 00:42:31,400
отдельный цикл, эти строки выполнить.

873
00:42:31,400 --> 00:42:35,810
>> Через год, человек, которого я буду я
лет, не заметить, что это не

874
00:42:35,810 --> 00:42:36,500
Я переменную.

875
00:42:36,500 --> 00:42:38,390
Это сейчас я% для Int.

876
00:42:38,390 --> 00:42:43,210
И обратите внимание, как первый заполнитель, я
подключите я плюс 1, так что мы рассчитываем как

877
00:42:43,210 --> 00:42:44,250
нормальный человек.

878
00:42:44,250 --> 00:42:49,190
И тогда для значения их возраст, для
Я лет, я беру возрастов кронштейн

879
00:42:49,190 --> 00:42:52,980
Я - и зачем я это делаю плюс один здесь?

880
00:42:52,980 --> 00:42:53,760
Они только в возрасте.

881
00:42:53,760 --> 00:42:55,030
Это мой глупый выбор программ.

882
00:42:55,030 --> 00:42:56,810
Они просто в возрасте одного года.

883
00:42:56,810 --> 00:42:59,770
Я могу ввести любое число, которое
Я действительно хочу там.

884
00:42:59,770 --> 00:43:02,430
>> Так что на самом деле все
отношение к вышесказанному?

885
00:43:02,430 --> 00:43:07,610
Ну, позвольте мне на самом деле прокрутить назад
сюда и нарисовать картину

886
00:43:07,610 --> 00:43:10,830
, что ждет впереди.

887
00:43:10,830 --> 00:43:15,720
Что мы будем делать с нашим следующим
Проблема будет установить два вмешиваются в

888
00:43:15,720 --> 00:43:17,070
Мир криптографии.

889
00:43:17,070 --> 00:43:22,500
Так что это строка символов, так что
Последовательность из нескольких символов, и что

890
00:43:22,500 --> 00:43:23,750
это говорит?

891
00:43:23,750 --> 00:43:28,530

892
00:43:28,530 --> 00:43:30,600
Это не в онлайн-версии
из слайдов.

893
00:43:30,600 --> 00:43:35,880
>> Поэтому я утверждаю, что это равно это,
глупая реклама в течение многих лет

894
00:43:35,880 --> 00:43:39,950
назад, что может на самом деле вспомнить
одна из его происхождении.

895
00:43:39,950 --> 00:43:42,740
Так что это пример шифрования
или криптографии.

896
00:43:42,740 --> 00:43:46,150
Получается, что, если вы хотите
на самом деле отправить информацию или поделиться

897
00:43:46,150 --> 00:43:49,310
Информация с кем-то надежно,
как такое сообщение, вы можете

898
00:43:49,310 --> 00:43:50,500
карабкаться букв.

899
00:43:50,500 --> 00:43:53,170
Но, как правило, слова
Не случайно яичницу.

900
00:43:53,170 --> 00:43:56,365
Они переставляются в той или изменен
в некотором роде, так что - ой.

901
00:43:56,365 --> 00:43:59,040
Это весело спойлер в следующий раз.

902
00:43:59,040 --> 00:44:04,390
>> Таким образом, вы можете отобразить, что является очевидно
O заметить, что Б. выстраивает

903
00:44:04,390 --> 00:44:05,420
Капитализация-мудрым.

904
00:44:05,420 --> 00:44:07,960
Видимо R становится электронной.

905
00:44:07,960 --> 00:44:14,000
Видимо F-H-E-R становится S-U-R-E. Так
оказывается, есть отображение, а в

906
00:44:14,000 --> 00:44:18,720
этом случае есть довольно глупо
отображение, если кто понял это?

907
00:44:18,720 --> 00:44:21,440
Это то, что называется
Rot 13, поворот 13.

908
00:44:21,440 --> 00:44:24,760
Это самая глупая шифрования
механизмы, потому что буквально только что

909
00:44:24,760 --> 00:44:29,160
добавляет 13 к каждому из писем,
глупо в том смысле, что если вы просто

910
00:44:29,160 --> 00:44:31,890
есть немного свободного времени на ваших руках
и карандаш, или вы просто думаю, что это

911
00:44:31,890 --> 00:44:35,260
через в вашей голове, вы можете попробовать
всех возможных дополнений - один, два,

912
00:44:35,260 --> 00:44:38,470
три, точка, точка, точка, от 25 до всего
вращать весь алфавит, и

913
00:44:38,470 --> 00:44:40,860
в конце концов, вы поймете,
то, что это сообщение.

914
00:44:40,860 --> 00:44:43,700
Так что если вы сделали что-то вроде этого в
начальной школе передачи сообщений вашего

915
00:44:43,700 --> 00:44:46,830
лучший друг, если ваш начальной школе
Учитель просто прочитать

916
00:44:46,830 --> 00:44:50,320
сообщение и грубой вынуждены решение,
Вы, возможно, получили

917
00:44:50,320 --> 00:44:52,550
Ответа на это.

918
00:44:52,550 --> 00:44:54,970
>> Теперь, конечно, в реальном мире,
криптографии является более сложным.

919
00:44:54,970 --> 00:45:00,120
Это фрагмент текста из
Компьютерная система, которая имеет имя пользователя и

920
00:45:00,120 --> 00:45:03,630
паролей, так как почти все наши делают, и
это то, что пароль может

921
00:45:03,630 --> 00:45:07,260
выглядеть, если хранящиеся на жестком
диск, но в зашифрованном виде.

922
00:45:07,260 --> 00:45:11,050
Это не только вращение буквы
А В и В С. Это

923
00:45:11,050 --> 00:45:15,620
гораздо более сложной, но использует
то, что обычно называют секретным ключом

924
00:45:15,620 --> 00:45:16,690
криптографии.

925
00:45:16,690 --> 00:45:20,210
Эта картина рассказывает следующую
сюжет с несколькими иконами.

926
00:45:20,210 --> 00:45:22,250
>> На левом, мы имеем то,
мы будем называть простой текст.

927
00:45:22,250 --> 00:45:25,420
В мире криптографии, простой
текст только исходное сообщение

928
00:45:25,420 --> 00:45:29,050
написано на английском или французском
или любой язык вообще.

929
00:45:29,050 --> 00:45:32,405
Если вы хотите зашифровать его, мы передадим
это наглядно через замок, так что

930
00:45:32,405 --> 00:45:35,580
некоторые виды алгоритмов, некоторые функции
или программы, которые кто-то написал

931
00:45:35,580 --> 00:45:39,880
что карабкается буквы, надеюсь
более сложно, чем просто добавление 13

932
00:45:39,880 --> 00:45:40,980
для каждого из них.

933
00:45:40,980 --> 00:45:43,780
>> Что вы получаете из этого процесса в
среднего там называется cyphertext.

934
00:45:43,780 --> 00:45:44,850
Так вид сексуального слова.

935
00:45:44,850 --> 00:45:47,630
Это просто означает, что это зашифрованный
версия простой текст.

936
00:45:47,630 --> 00:45:52,570
И только если у вас есть, что же тайна,
13 или минус 13, вы в состоянии

937
00:45:52,570 --> 00:45:54,970
расшифровать подобное сообщение.

938
00:45:54,970 --> 00:45:57,770
>> Таким образом, в проблеме установить два, среди вещей
вы будете делать, если в хакерской

939
00:45:57,770 --> 00:46:01,860
Издание, вам придется писать код для
взломать эти пароли, выясняя

940
00:46:01,860 --> 00:46:05,170
то, что они были и как они были
зашифрованное, хотя мы и дать вам немного

941
00:46:05,170 --> 00:46:06,460
руководства по пути.

942
00:46:06,460 --> 00:46:09,320
В Standard Edition, введем
пару шифров, шифрование

943
00:46:09,320 --> 00:46:12,400
Механизмы, одна называется Цезарь, один
называется Vigenere, которые все еще

944
00:46:12,400 --> 00:46:16,100
вращения шифры, где становится
что-то, B становится чем-то, но

945
00:46:16,100 --> 00:46:18,820
Вы должны сделать это программно
потому что там действительно будет тайным

946
00:46:18,820 --> 00:46:22,840
ключ участвует который обычно представляет собой число
или ключевое слово, что только

947
00:46:22,840 --> 00:46:26,420
отправителем и получателем этих
сообщения должны понять.

948
00:46:26,420 --> 00:46:28,660
>> Теперь, это на самом деле имеет воплощений
в реальном мире.

949
00:46:28,660 --> 00:46:32,910
Это, к примеру, сиротка
Тайные декодер Энни кольцо, и вы

950
00:46:32,910 --> 00:46:35,180
может на самом деле реализации этих
вращения шифры -

951
00:46:35,180 --> 00:46:37,930
Что-то становится, B становится
что-то - с парой колес,

952
00:46:37,930 --> 00:46:40,840
один на внешней стороне, один на внутренней
такое, что если повернуть колесо или

953
00:46:40,840 --> 00:46:44,170
кольца, вы можете выстроить
письма с разных букв,

954
00:46:44,170 --> 00:46:45,430
получения секретного кода.

955
00:46:45,430 --> 00:46:48,110
И так как на сегодняшний день захватывающим,
то, что я думал, что я делаю это немного

956
00:46:48,110 --> 00:46:52,170
возврат, что если вы включите телевизор
24 декабря, вы можете смотреть

957
00:46:52,170 --> 00:46:55,390
фильм до тошноты для
24 часов подряд.

958
00:46:55,390 --> 00:47:06,030
Но на сегодняшний день, я открою его здесь
и дать нам только две минуты

959
00:47:06,030 --> 00:47:13,493
педагогически соответствующих Рождественская история
с маленьким человеком по имени Ральфи.

960
00:47:13,493 --> 00:47:14,400
>> [ВОСПРОИЗВЕДЕНИЕ ВИДЕО]

961
00:47:14,400 --> 00:47:17,420
>> -Да будет известно всем и каждому, что
Ральф Паркер Настоящим назначен

962
00:47:17,420 --> 00:47:20,650
Член сиротка Энни тайну
круга и имеет право на все

963
00:47:20,650 --> 00:47:23,460
почести и преимущества
происходящих ней.

964
00:47:23,460 --> 00:47:25,990
>> -Подпись, сиротка Энни.

965
00:47:25,990 --> 00:47:30,100
Контрассигнуют, Пьер-Андре, в чернила.

966
00:47:30,100 --> 00:47:34,270
Почести и преимущества уже
в возрасте девяти лет.

967
00:47:34,270 --> 00:47:39,440
>> [Кричит по радио]

968
00:47:39,440 --> 00:47:40,770
>> Давай, давай покончим с этим.

969
00:47:40,770 --> 00:47:44,965
Мне не нужны все такое прочее о
контрабандистов и пиратов.

970
00:47:44,965 --> 00:47:48,270
>> -Слушай завтра ночь для
заключительные приключения черного

971
00:47:48,270 --> 00:47:49,650
пиратский корабль.

972
00:47:49,650 --> 00:47:53,320
Теперь пришло время тайных Энни
Сообщение для Вас членами

973
00:47:53,320 --> 00:47:55,720
тайного круга.

974
00:47:55,720 --> 00:47:56,580
Помните, дети.

975
00:47:56,580 --> 00:48:01,720
Только члены Тайного круга Энни
может расшифровать секретное сообщение Энни.

976
00:48:01,720 --> 00:48:05,872
Помните, что Энни в зависимости от вас.

977
00:48:05,872 --> 00:48:08,670
Установите контакты до B2.

978
00:48:08,670 --> 00:48:11,000
Вот сообщение.

979
00:48:11,000 --> 00:48:12,335
12, 11, 2 -

980
00:48:12,335 --> 00:48:14,670
>> -Я в моей первой встречи тайной.

981
00:48:14,670 --> 00:48:19,720
>> -25, 14, 11, 18, 16 -

982
00:48:19,720 --> 00:48:21,650
>> -Пьер был в отличной сегодня голос.

983
00:48:21,650 --> 00:48:24,830
Я могу сказать, что сообщение сегодняшнего
было действительно важно.

984
00:48:24,830 --> 00:48:26,400
>> -3, 25.

985
00:48:26,400 --> 00:48:28,540
Вот сообщение из себя Энни.

986
00:48:28,540 --> 00:48:30,086
Помните, не говори никому.

987
00:48:30,086 --> 00:48:34,370

988
00:48:34,370 --> 00:48:38,710
>> -90 Секунд спустя, я в единственном номере
В доме, где девятилетний мальчик

989
00:48:38,710 --> 00:48:42,668
могла сидеть в уединении и декодирования.

990
00:48:42,668 --> 00:48:47,628
Ага, Б. Я пошел к другому.

991
00:48:47,628 --> 00:48:53,060
E. Первое слово "быть". С.
Он доносился проще.

992
00:48:53,060 --> 00:48:54,980
U. 25.

993
00:48:54,980 --> 00:48:55,940
Это R.

994
00:48:55,940 --> 00:48:56,900
>> -Давай, Ральфи.

995
00:48:56,900 --> 00:48:57,860
Я должен идти.

996
00:48:57,860 --> 00:48:59,780
>> -Я сейчас спущусь, Ма.

997
00:48:59,780 --> 00:49:01,030
Вот здорово.

998
00:49:01,030 --> 00:49:04,300

999
00:49:04,300 --> 00:49:08,220
>> -T. О. Обязательно.

1000
00:49:08,220 --> 00:49:09,500
Будьте уверены, к чему?

1001
00:49:09,500 --> 00:49:11,660
Что было сиротка
Энни пытается сказать?

1002
00:49:11,660 --> 00:49:12,844
Будьте уверены, к чему?

1003
00:49:12,844 --> 00:49:14,732
>> -Ральфи, Рэнди должен уйти.

1004
00:49:14,732 --> 00:49:16,148
Не могли бы вы выйти?

1005
00:49:16,148 --> 00:49:17,092
>> -Все в порядке, мама.

1006
00:49:17,092 --> 00:49:18,510
Я сейчас выйду.

1007
00:49:18,510 --> 00:49:20,270
>> -Я все ближе к теперь.

1008
00:49:20,270 --> 00:49:21,823
Напряжение было ужасно.

1009
00:49:21,823 --> 00:49:23,045
Что это было?

1010
00:49:23,045 --> 00:49:26,510
Судьба планеты может
висят на волоске.

1011
00:49:26,510 --> 00:49:28,985
>> -Ральфи, должен идти Рэнди.

1012
00:49:28,985 --> 00:49:32,680
>> -Я сейчас выйду на
с ума сойти.

1013
00:49:32,680 --> 00:49:33,956
>> -Почти.

1014
00:49:33,956 --> 00:49:35,140
Мои пальцы полетели.

1015
00:49:35,140 --> 00:49:36,880
Мой разум был стальной капкан.

1016
00:49:36,880 --> 00:49:38,010
Каждую пору вибрации.

1017
00:49:38,010 --> 00:49:39,878
Это было почти ясно.

1018
00:49:39,878 --> 00:49:43,210
Да, да, да, да, да.

1019
00:49:43,210 --> 00:49:49,030
>> -Обязательно пейте вашей Ovaltine.

1020
00:49:49,030 --> 00:49:50,280
Ovaltine?

1021
00:49:50,280 --> 00:49:53,980

1022
00:49:53,980 --> 00:49:55,230
Вшивой коммерческой?

1023
00:49:55,230 --> 00:49:58,572

1024
00:49:58,572 --> 00:50:00,694
Сын сука.

1025
00:50:00,694 --> 00:50:01,900
>> [КОНЕЦ ВИДЕОВОСПРОИЗВЕДЕНИЕ]

1026
00:50:01,900 --> 00:50:04,260
>> АС 1: Это CS50, и
Проблема будет установить два.

1027
00:50:04,260 --> 00:50:06,305
Увидимся на следующей неделе.

1028
00:50:06,305 --> 00:50:08,800
>> Докладчик 2: На следующей
CS50, это происходит.

1029
00:50:08,800 --> 00:50:11,060
>> Выступающий 1: Так одна тема у нас нет
посмотрел на до сих пор является

1030
00:50:11,060 --> 00:50:12,220
, что указателей на функции.

1031
00:50:12,220 --> 00:50:14,540
Теперь, указатель на функцию только
адрес общественных

1032
00:50:14,540 --> 00:50:17,000
функции, но так же, как -

1033
00:50:17,000 --> 00:50:18,250
Сын -

1034
00:50:18,250 --> 00:50:19,670