1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [4-й тиждень]

2
00:00:03,000 --> 00:00:05,000
[David J. Малан] [Harvard University]

3
00:00:05,000 --> 00:00:08,000
[Це CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:12,000
>> Все правильно, це CS50, і це початок тижня 4,

5
00:00:12,000 --> 00:00:16,000
і це одна з найбільш повільних можливі алгоритми сортування.

6
00:00:16,000 --> 00:00:19,000
Який це був, що ми просто дивилися туди?

7
00:00:19,000 --> 00:00:24,000
Це було бульбашкового сортування, для того, велика O (N ^ 2) + сума,

8
00:00:24,000 --> 00:00:28,000
та й ми не єдині в цьому світі, щоб, здається, знають

9
00:00:28,000 --> 00:00:30,000
що міхур сортування або час його роботи.

10
00:00:30,000 --> 00:00:33,000
Дійсно, це було інтерв'ю з Еріком Шмідтом з Google

11
00:00:33,000 --> 00:00:45,000
і колишній сенатор Барак Обама всього лише кілька років тому.

12
00:00:45,000 --> 00:00:48,000
>> Тепер, сенатор, ви тут, в Google,

13
00:00:48,000 --> 00:00:54,000
і мені подобається думати президентства, як співбесіда.

14
00:00:54,000 --> 00:00:58,000
Тепер, важко влаштуватися на роботу в якості президента, і ви збираєтеся через суворі зараз.

15
00:00:58,000 --> 00:01:00,000
Це також важко влаштуватися на роботу в Google.

16
00:01:00,000 --> 00:01:05,000
У нас є питання, і ми просимо наших кандидатів питання,

17
00:01:05,000 --> 00:01:10,000
і це одна з Ларрі Швіммер.

18
00:01:10,000 --> 00:01:14,000
Ви, хлопці, думаєте, я жартую? Це прямо тут.

19
00:01:14,000 --> 00:01:18,000
Який найефективніший спосіб сортування мільйонів 32-розрядних цілих чисел?

20
00:01:18,000 --> 00:01:21,000
[Сміх]

21
00:01:21,000 --> 00:01:24,000
Ну-

22
00:01:24,000 --> 00:01:26,000
Мені дуже шкода. >> Ні, ні, ні, ні.

23
00:01:26,000 --> 00:01:34,000
Я думаю, що бульбашкового сортування б неправильний шлях.

24
00:01:34,000 --> 00:01:39,000
>> Ну, хто сказав йому про це?

25
00:01:39,000 --> 00:01:43,000
Минулого тижня пам'ятаєте, ми взяли перерву з кодом, принаймні, на один день,

26
00:01:43,000 --> 00:01:46,000
і почав упором на більш високому рівні ідей і рішення проблем у більш загальному

27
00:01:46,000 --> 00:01:49,000
в контексті пошуку і сортування,

28
00:01:49,000 --> 00:01:53,000
і ми ввели те, що ми не шльопати це ім'я на минулому тижні,

29
00:01:53,000 --> 00:01:56,000
але асимптотичні позначення, Big O, Великий Omega,

30
00:01:56,000 --> 00:02:00,000
, А іноді і велику позначення Theta, і вони були просто способи

31
00:02:00,000 --> 00:02:02,000
опису часу роботи алгоритмів,

32
00:02:02,000 --> 00:02:05,000
Скільки часу потрібно для алгоритму для запуску.

33
00:02:05,000 --> 00:02:08,000
>> А ви пам'ятаєте, що ви говорили про час роботи з точки зору розміру

34
00:02:08,000 --> 00:02:11,000
на вході, який ми зазвичай називаємо п, що проблема може бути,

35
00:02:11,000 --> 00:02:13,000
де п-кількість людей в кімнаті,

36
00:02:13,000 --> 00:02:17,000
Кількість сторінок в телефонній книзі, і ми почали писати речі

37
00:02:17,000 --> 00:02:21,000
як O (N ^ 2) або O (п) або O (п § п),

38
00:02:21,000 --> 00:02:24,000
і навіть коли математика не зовсім виробити так чудово

39
00:02:24,000 --> 00:02:28,000
і це був п ² - п / 2 або щось на зразок того

40
00:02:28,000 --> 00:02:31,000
замість цього ми будемо просто викинути деякі з молодших членів,

41
00:02:31,000 --> 00:02:34,000
і мотивація є те, що ми дійсно хочемо

42
00:02:34,000 --> 00:02:37,000
роду об'єктивний спосіб оцінки

43
00:02:37,000 --> 00:02:39,000
виконання програми або виконання алгоритмів

44
00:02:39,000 --> 00:02:42,000
що в кінці дня не має нічого спільного, наприклад,

45
00:02:42,000 --> 00:02:45,000
зі швидкістю комп'ютера сьогодні.

46
00:02:45,000 --> 00:02:47,000
>> Наприклад, якщо ви реалізуєте бульбашкового сортування,

47
00:02:47,000 --> 00:02:50,000
або ви реалізуєте сортування злиттям або вибір роду на комп'ютері сьогоднішньому

48
00:02:50,000 --> 00:02:53,000
2 ГГц комп'ютер, і ви запустите його,

49
00:02:53,000 --> 00:02:56,000
і це займає кілька секунд, в наступному році є 3 ГГц

50
00:02:56,000 --> 00:02:59,000
або 4 ГГц комп'ютер, і ви могли б тоді стверджувати, що "Ух ти, мій алгоритм

51
00:02:59,000 --> 00:03:03,000
Тепер в два рази швидше ", коли насправді це, очевидно, не так.

52
00:03:03,000 --> 00:03:06,000
Це просто апаратні отримала швидше, але комп'ютер

53
00:03:06,000 --> 00:03:10,000
не, і тому ми дійсно хочемо, щоб викинути речі, як

54
00:03:10,000 --> 00:03:13,000
кратні 2 або кратних 3, коли справа доходить до опису

55
00:03:13,000 --> 00:03:17,000
як швидко чи як повільно алгоритм і дійсно просто зосередитися

56
00:03:17,000 --> 00:03:20,000
на п або деякий фактор їх,

57
00:03:20,000 --> 00:03:24,000
деякі сили його, як у випадку з видами на минулому тижні.

58
00:03:24,000 --> 00:03:27,000
І нагадаємо, що за допомогою сортування злиттям

59
00:03:27,000 --> 00:03:31,000
ми були в змозі зробити це набагато краще, ніж бульбашкового сортування та вибору роду

60
00:03:31,000 --> 00:03:33,000
і навіть вставок.

61
00:03:33,000 --> 00:03:36,000
>> Ми приступили до п § п, і знову,

62
00:03:36,000 --> 00:03:39,000
Нагадаємо, що журнал п як правило, відноситься до того, що росте

63
00:03:39,000 --> 00:03:43,000
повільніше, ніж я, так що п § п досі було добре

64
00:03:43,000 --> 00:03:45,000
тому що це було менше, ніж ² н.

65
00:03:45,000 --> 00:03:47,000
Але для досягнення п п увійти з сортування злиттям

66
00:03:47,000 --> 00:03:51,000
те, що було основною паросток ідея, що ми повинні були використовувати

67
00:03:51,000 --> 00:03:54,000
що ми також використовувала ще в тижні 0?

68
00:03:54,000 --> 00:03:58,000
Як ми будемо вирішувати завдання сортування розумно з сортування злиттям?

69
00:03:58,000 --> 00:04:04,000
Що було ключовим розумінням, чи що?

70
00:04:04,000 --> 00:04:07,000
Будь взагалі.

71
00:04:07,000 --> 00:04:09,000
Добре, давайте зробимо крок назад.

72
00:04:09,000 --> 00:04:11,000
Опишіть сортування злиттям в свої слова.

73
00:04:11,000 --> 00:04:15,000
Як це працює?

74
00:04:15,000 --> 00:04:17,000
Добре, ми будемо гребти назад в тиждень 0.

75
00:04:17,000 --> 00:04:19,000
Добре, да.

76
00:04:19,000 --> 00:04:22,000
[Нерозбірливо-студент]

77
00:04:22,000 --> 00:04:26,000
Гаразд, добре, так що ми розділили масив чисел на 2 частини.

78
00:04:26,000 --> 00:04:29,000
Ми відсортували кожної з цих частин, і тоді ми об'єднали їх,

79
00:04:29,000 --> 00:04:33,000
і ми бачили цю ідею до прийняття Проблема ось ця велика

80
00:04:33,000 --> 00:04:36,000
і подрібнення його в проблему, ось ця велика або це велике.

81
00:04:36,000 --> 00:04:38,000
>> Нагадаємо, наприклад, телефонну книгу.

82
00:04:38,000 --> 00:04:42,000
Нагадаємо, самостійного підрахунку алгоритм з тижні тому,

83
00:04:42,000 --> 00:04:45,000
так сортування злиттям були підведені підсумки цього псевдокод тут.

84
00:04:45,000 --> 00:04:48,000
Коли вам дають п елементів, спочатку це була перевірка справності.

85
00:04:48,000 --> 00:04:51,000
Якщо п <2, то нічого не робимо на всіх

86
00:04:51,000 --> 00:04:55,000
тому що, якщо п <2, то п, очевидно, 0 або 1,

87
00:04:55,000 --> 00:04:57,000
і тому, якщо це 0 або 1 немає нічого, щоб відсортувати.

88
00:04:57,000 --> 00:04:59,000
Ви зробили.

89
00:04:59,000 --> 00:05:01,000
Ваш список вже тривіально відсортовані.

90
00:05:01,000 --> 00:05:04,000
Але в іншому випадку, якщо у вас є 2 чи більше елементів, йти вперед і розділити їх

91
00:05:04,000 --> 00:05:06,000
на 2 половини, ліворуч і праворуч.

92
00:05:06,000 --> 00:05:09,000
Сортування кожній із цих половин, а потім об'єднати відсортовані половини.

93
00:05:09,000 --> 00:05:13,000
Але проблема тут в тому, що на перший погляд це виглядає, як ніби ми понтіровавшего.

94
00:05:13,000 --> 00:05:17,000
Це кругова визначення в тому, що, якщо я попросив вас розібратися цих п елементів

95
00:05:17,000 --> 00:05:22,000
і ти кажеш мені "Гаразд, добре, ми розберемося тих, п / 2 та тих, п / 2 елементів"

96
00:05:22,000 --> 00:05:27,000
Потім моє наступне запитання буде "Добре, як ви сортувати п / 2 елементів?"

97
00:05:27,000 --> 00:05:30,000
>> Але через структури цієї програми,

98
00:05:30,000 --> 00:05:33,000
тому що це базовий варіант, так би мовити,

99
00:05:33,000 --> 00:05:39,000
це особливий випадок, який говорить, що якщо п <деяке фіксоване значення, як 2 повернення негайно.

100
00:05:39,000 --> 00:05:42,000
Не відповідати з тієї ж кругової відповідь.

101
00:05:42,000 --> 00:05:46,000
Цей процес, ця циклічність в кінцевому рахунку закінчується.

102
00:05:46,000 --> 00:05:50,000
Якщо я запитаю тебе "Сортування цих п елементів", і ви кажете: "Добре, відсортувати п / 2"

103
00:05:50,000 --> 00:05:53,000
Потім ви кажете: "Добре, рід цих п / 4, п / 8, n/16"

104
00:05:53,000 --> 00:05:56,000
в кінцевому підсумку ви будете ділити на досить велике число

105
00:05:56,000 --> 00:05:59,000
що ви будете мати тільки 1 елемент вліво, і в цей момент можна сказати,

106
00:05:59,000 --> 00:06:02,000
"Ось, ось відсортовані одного елемента."

107
00:06:02,000 --> 00:06:06,000
Тоді блиск цього алгоритму тут є висновок з того факту,

108
00:06:06,000 --> 00:06:09,000
що, як тільки у Вас є всі ці відсортований списки,

109
00:06:09,000 --> 00:06:12,000
всі з яких мають розмір 1, який, здається, марно,

110
00:06:12,000 --> 00:06:15,000
як тільки ви починаєте їхнє злиття й об'єднання їх

111
00:06:15,000 --> 00:06:19,000
Ви сформуєте, нарешті, як Роб зробив у відео, нарешті, відсортований список.

112
00:06:19,000 --> 00:06:22,000
>> Але ця ідея виходить далеко за рамки сортування.

113
00:06:22,000 --> 00:06:26,000
Існує ця ідея вбудованих в цю програму відомий як рекурсія,

114
00:06:26,000 --> 00:06:29,000
Ідея, в якому ви перебуваєте програми,

115
00:06:29,000 --> 00:06:32,000
і вирішити деякі проблеми, ви називаєте себе,

116
00:06:32,000 --> 00:06:36,000
або покласти в контексті мов програмування ви знаходитеся функції,

117
00:06:36,000 --> 00:06:39,000
і для того, щоб вирішити проблему, ви називаєте себе функції

118
00:06:39,000 --> 00:06:42,000
знову і знову, і знову, але вам функцію

119
00:06:42,000 --> 00:06:44,000
не може називати себе нескінченно багато разів.

120
00:06:44,000 --> 00:06:47,000
В кінці кінців ви повинні дна, так би мовити,

121
00:06:47,000 --> 00:06:49,000
і є жорстко бази умови, що говорить

122
00:06:49,000 --> 00:06:53,000
в цей момент припинити називати себе так, що весь процес

123
00:06:53,000 --> 00:06:56,000
Нарешті, на ділі зупинити.

124
00:06:56,000 --> 00:06:58,000
Що це дійсно означає, рекурсивно?

125
00:06:58,000 --> 00:07:01,000
>> Давайте подивимося, якщо ми можемо зробити простий, банальний приклад, скажімо,

126
00:07:01,000 --> 00:07:03,000
3 людини зі мною тут, на сцені, якщо хтось це зручно.

127
00:07:03,000 --> 00:07:06,000
1, давай вгору, 2 і 3.

128
00:07:06,000 --> 00:07:09,000
Якщо вам 3 хочуть приїхати сюди.

129
00:07:09,000 --> 00:07:12,000
Якщо ви хочете стояти поруч зі мною тут, в лінію, припустимо, що проблема під рукою

130
00:07:12,000 --> 00:07:15,000
дуже тривіально підрахувати кількість людей, які знаходяться тут.

131
00:07:15,000 --> 00:07:18,000
Але, відверто кажучи, я втомився від всіх цих підрахунку прикладів.

132
00:07:18,000 --> 00:07:21,000
Це займе деякий час, 1, 2, і крапка, крапка, крапка.

133
00:07:21,000 --> 00:07:23,000
Це буде тривати вічно.

134
00:07:23,000 --> 00:07:25,000
Я б вважав за краще просто Пунт цієї проблеми в цілому за допомогою, як тебе звати?

135
00:07:25,000 --> 00:07:27,000
Сара. >> Сара, все в порядку.

136
00:07:27,000 --> 00:07:29,000
Келлі. >> Келлі і?

137
00:07:29,000 --> 00:07:31,000
>> Віллі. >> Віллі, Сара, Келлі, і Віллі.

138
00:07:31,000 --> 00:07:34,000
Зараз я задав питання хтось

139
00:07:34,000 --> 00:07:37,000
скільки людей на цьому етапі, і я поняття не маю.

140
00:07:37,000 --> 00:07:40,000
Це дуже довгий список, і тому замість цього я буду робити цей трюк.

141
00:07:40,000 --> 00:07:43,000
Я збираюся попросити людину поруч зі мною, щоб зробити більшу частину роботи,

142
00:07:43,000 --> 00:07:46,000
і як тільки вона робиться роблять більшу частину роботи

143
00:07:46,000 --> 00:07:49,000
Я збираюся зробити найменшу кількість робіт можна і просто додати 1

144
00:07:49,000 --> 00:07:51,000
до того, що її відповідь, так що тут ми йдемо.

145
00:07:51,000 --> 00:07:54,000
Я запитав, як багато людей на сцені.

146
00:07:54,000 --> 00:07:57,000
Скільки людей на сцену, щоб ліворуч від вас?

147
00:07:57,000 --> 00:08:00,000
Зліва від мене? >> Добре, але не обманюють.

148
00:08:00,000 --> 00:08:04,000
Це добре, це правильно, але якщо ми хочемо продовжити цю логіку

149
00:08:04,000 --> 00:08:08,000
Давайте припустимо, що ви так само хочете, щоб вибивати з рук цю проблему зліва від вас,

150
00:08:08,000 --> 00:08:11,000
Таким чином, замість відповіді безпосередньо йти вперед і просто звалювати.

151
00:08:11,000 --> 00:08:14,000
Ах, як багато людей знаходяться зліва від мене?

152
00:08:14,000 --> 00:08:16,000
Скільки людей наліво?

153
00:08:16,000 --> 00:08:18,000
1.

154
00:08:18,000 --> 00:08:27,000
[Сміх]

155
00:08:27,000 --> 00:08:30,000
Отже, 0, так що тепер Віллі зробив

156
00:08:30,000 --> 00:08:33,000
це ти повернувся ваша відповідь цим напрямком кажучи 0.

157
00:08:33,000 --> 00:08:36,000
Отже, що ви повинні зробити? >> 1.

158
00:08:36,000 --> 00:08:39,000
Отже, ви 1, так ви кажете: "Гаразд, я збираюся додати 1

159
00:08:39,000 --> 00:08:41,000
до того, що кількість Віллі було ", так що 1 + 0.

160
00:08:41,000 --> 00:08:43,000
Ви зараз 1 так що ваша відповідь на правому тепер-

161
00:08:43,000 --> 00:08:45,000
1. >> А моя буде 2.

162
00:08:45,000 --> 00:08:48,000
Добре, так ви приймаєте попередній відповідь 1,

163
00:08:48,000 --> 00:08:51,000
додавши мінімальну кількість роботи, яку ви хочете зробити, що є +1.

164
00:08:51,000 --> 00:08:55,000
Тепер у вас є 2, а потім ви передати мені, яке значення?

165
00:08:55,000 --> 00:08:57,000
3, я маю на увазі, вибачте, 2.

166
00:08:57,000 --> 00:08:59,000
Добре.

167
00:08:59,000 --> 00:09:02,000
>> Ну, у нас було від 0 до лівого.

168
00:09:02,000 --> 00:09:05,000
Тоді у нас була 1, а потім ми додаємо 2,

169
00:09:05,000 --> 00:09:07,000
і тепер ви вручаючи мені номер 2,

170
00:09:07,000 --> 00:09:10,000
і тому я кажу, ладно, +1, 3.

171
00:09:10,000 --> 00:09:13,000
Там справді 3 чоловік стояв поруч зі мною на цій сцені,

172
00:09:13,000 --> 00:09:16,000
таким чином, ми могли б, очевидно, зробив це дуже лінійно,

173
00:09:16,000 --> 00:09:19,000
дуже очевидним чином, але що ми дійсно робимо?

174
00:09:19,000 --> 00:09:21,000
Ми взяли проблемі розміром 3 на початковому етапі.

175
00:09:21,000 --> 00:09:24,000
Потім ми зламали його на проблемі розмір 2,

176
00:09:24,000 --> 00:09:27,000
Потім проблема розмір 1, і, нарешті, базовий сценарій

177
00:09:27,000 --> 00:09:29,000
дійсно, ой, там нікого немає,

178
00:09:29,000 --> 00:09:33,000
в цей момент Віллі повернувся ефективно жорстко відповісти пару раз,

179
00:09:33,000 --> 00:09:36,000
, А другий потім пропускають до бульбашками, вгору, вгору бульбашками,

180
00:09:36,000 --> 00:09:39,000
, А потім, додавши в цей додатковий 1

181
00:09:39,000 --> 00:09:41,000
ми реалізували цю основну ідею рекурсії.

182
00:09:41,000 --> 00:09:44,000
>> Тепер, в даному випадку це дійсно не вирішити проблему

183
00:09:44,000 --> 00:09:46,000
будь-який більш ефективно те, що ми бачили досі.

184
00:09:46,000 --> 00:09:48,000
Але думати про алгоритми ми зробили на сцені досі.

185
00:09:48,000 --> 00:09:51,000
У нас було 8 аркушів паперу на дошці,

186
00:09:51,000 --> 00:09:55,000
на відео, коли Шон шукав номер 7, і що він реально зробити?

187
00:09:55,000 --> 00:09:58,000
Ну, він не робив будь розділяй і володарюй.

188
00:09:58,000 --> 00:10:01,000
Він не зробив будь рекурсії.

189
00:10:01,000 --> 00:10:03,000
Швидше, він просто зробив це лінійний алгоритм.

190
00:10:03,000 --> 00:10:07,000
Але коли ми запропонували ідею відсортовані номери на сцені живуть на минулому тижні

191
00:10:07,000 --> 00:10:09,000
Потім у нас був цей інстинкт збирається до середини,

192
00:10:09,000 --> 00:10:13,000
в цей момент у нас було менше списку розмірі 4 або інший список розмірі 4,

193
00:10:13,000 --> 00:10:17,000
а потім у нас була точно така ж проблема, тому ми повторили, повторюється, повторюється.

194
00:10:17,000 --> 00:10:19,000
Іншими словами, ми рекурсія.

195
00:10:19,000 --> 00:10:24,000
Велике спасибі нашому 3 добровольців тут для демонстрації рекурсії з нами.

196
00:10:24,000 --> 00:10:28,000
>> Давайте подивимося, якщо ми не можемо зробити цього зараз трохи більш конкретним,

197
00:10:28,000 --> 00:10:30,000
вирішення проблеми, що знову ми могли б зробити досить легко,

198
00:10:30,000 --> 00:10:34,000
але ми будемо використовувати його як трамплін для здійснення цієї основної ідеї.

199
00:10:34,000 --> 00:10:37,000
Якщо я хочу, щоб обчислити підсумовуванням купу цифр,

200
00:10:37,000 --> 00:10:39,000
Наприклад, якщо ви проходите в число 3,

201
00:10:39,000 --> 00:10:42,000
Я хочу дати вам значення сигма-3,

202
00:10:42,000 --> 00:10:46,000
так що сума 3 + 2 + 1 + 0.

203
00:10:46,000 --> 00:10:48,000
Я хочу отримати назад відповідь 6,

204
00:10:48,000 --> 00:10:51,000
таким чином, ми будемо реалізовувати цю функцію сигма, ця функція підсумовування

205
00:10:51,000 --> 00:10:54,000
що, знову ж таки, бере на вході, а потім повертає підсумовування

206
00:10:54,000 --> 00:10:57,000
з цього числа аж до 0.

207
00:10:57,000 --> 00:10:59,000
Ми могли б зробити це досить просто, чи не так?

208
00:10:59,000 --> 00:11:01,000
Ми могли б зробити це з якоюсь цикл структури,

209
00:11:01,000 --> 00:11:04,000
так що дозвольте мені йти вперед і отримати цю роботу.

210
00:11:04,000 --> 00:11:07,000
>> Включити stdio.h.

211
00:11:07,000 --> 00:11:09,000
Дозвольте мені отримати собі в основну роботу з тут.

212
00:11:09,000 --> 00:11:12,000
Давайте збережемо це як sigma.c.

213
00:11:12,000 --> 00:11:14,000
Тоді я піду сюди, і я збираюся оголосити Int N,

214
00:11:14,000 --> 00:11:18,000
і я збираюся зробити наступне, поки користувач не співпрацюють.

215
00:11:18,000 --> 00:11:22,000
Поки користувач не дав мені позитивного числа

216
00:11:22,000 --> 00:11:26,000
Дозвольте мені йти вперед і спонукати їх до GetInt п =,

217
00:11:26,000 --> 00:11:28,000
і дозвольте мені дати їм інструкції щодо того, що робити,

218
00:11:28,000 --> 00:11:33,000
так що Е ("Позитивне ціле, будь ласка»).

219
00:11:33,000 --> 00:11:39,000
Просто щось відносно просте, як це так, що до того часу ми потрапили лінія 14

220
00:11:39,000 --> 00:11:42,000
у нас тепер є натуральне число, ймовірно, в с.

221
00:11:42,000 --> 00:11:44,000
>> Тепер давайте щось робити з цим.

222
00:11:44,000 --> 00:11:50,000
Дозвольте мені йти вперед і обчислити суми, так Int сума = сигма (п).

223
00:11:50,000 --> 00:11:54,000
Sigma просто підсумовування, так що я просто пишу це в химерні шляху.

224
00:11:54,000 --> 00:11:56,000
Ми просто називаємо це сигма там.

225
00:11:56,000 --> 00:11:58,000
Це сума, і тепер я збираюся роздрукувати результат,

226
00:11:58,000 --> 00:12:08,000
Е ("Сума% г \ п", сума).

227
00:12:08,000 --> 00:12:11,000
І тоді я буду повертати 0 для хорошої заходом.

228
00:12:11,000 --> 00:12:15,000
Ми зробили все, що ця програма вимагає, крім цікавої частини,

229
00:12:15,000 --> 00:12:18,000
яка є насправді реалізації сигма функції.

230
00:12:18,000 --> 00:12:22,000
>> Відпусти мене сюди на дно, і дозвольте мені оголосити функцію сигма.

231
00:12:22,000 --> 00:12:26,000
Це повинно приймати змінна, що це типу ціле число,

232
00:12:26,000 --> 00:12:30,000
і який тип даних, я хочу, щоб повернутися імовірно від Sigma?

233
00:12:30,000 --> 00:12:34,000
Int, тому що я хочу, щоб відповідати моїм очікуванням по лінії 15.

234
00:12:34,000 --> 00:12:37,000
У тут, дозвольте мені піти далі і реалізувати цю

235
00:12:37,000 --> 00:12:41,000
У досить простим способом.

236
00:12:41,000 --> 00:12:45,000
>> Давайте підемо далі і сказати Int сума = 0,

237
00:12:45,000 --> 00:12:47,000
і тепер я збираюся трохи циклу тут

238
00:12:47,000 --> 00:12:50,000
що збирається сказати щось на зразок цього,

239
00:12:50,000 --> 00:13:01,000
для (INT = 0; I <= номер, я + +) Сума + = я.

240
00:13:01,000 --> 00:13:05,000
А потім я збираюся повернути суму.

241
00:13:05,000 --> 00:13:07,000
Я міг би здійснюватися цьому в будь-якій кількості способами.

242
00:13:07,000 --> 00:13:09,000
Я міг би використовувати цикл.

243
00:13:09,000 --> 00:13:11,000
Я міг би пропустити за допомогою суми змінної, якщо я дійсно хотів,

244
00:13:11,000 --> 00:13:15,000
але в загальному, ми просто є функція, яка, якщо я не лох заявляє сума дорівнює 0.

245
00:13:15,000 --> 00:13:18,000
Потім він перебирає від 0 на вгору через номер,

246
00:13:18,000 --> 00:13:23,000
і на кожній ітерації він додає, що поточне значення суми, а потім повертає суму.

247
00:13:23,000 --> 00:13:25,000
>> Так от, є невелика оптимізація тут.

248
00:13:25,000 --> 00:13:29,000
Це, напевно, даремно крок, але нехай буде так. Це добре на даний момент.

249
00:13:29,000 --> 00:13:32,000
Ми принаймні бути ретельним і збирався 0 всі шляхи вгору.

250
00:13:32,000 --> 00:13:34,000
Не дуже жорсткий і досить проста,

251
00:13:34,000 --> 00:13:37,000
але виявляється, що за допомогою функції сигма ми маємо ті ж можливості

252
00:13:37,000 --> 00:13:39,000
як ми зробили тут, на сцені.

253
00:13:39,000 --> 00:13:42,000
На сцені ми просто порахував, скільки людей було поруч зі мною,

254
00:13:42,000 --> 00:13:47,000
але замість цього, якщо ми хочемо підрахувати число 3 + 2 + 1

255
00:13:47,000 --> 00:13:51,000
на до 0, ми могли аналогічним плоскодонки до функції

256
00:13:51,000 --> 00:13:55,000
що я буду описувати, а не як рекурсивні.

257
00:13:55,000 --> 00:13:57,000
Ось давайте зробимо швидко розсудливість перевірити і переконатися, що я не лох.

258
00:13:57,000 --> 00:14:00,000
>> Я знаю, що є принаймні одна річ в цій програмі, що я зробив неправильно.

259
00:14:00,000 --> 00:14:04,000
Коли я потрапила ввести я збираюся отримати будь-яку кричати на мене?

260
00:14:04,000 --> 00:14:06,000
Що мені буде кричати на про?

261
00:14:06,000 --> 00:14:11,000
Так, я забув прототип, тому я використовую функцію під назвою Sigma в рядку 15,

262
00:14:11,000 --> 00:14:16,000
але це не оголошені, поки лінія 22, так що я кращий активно йдуть сюди

263
00:14:16,000 --> 00:14:22,000
і оголосити прототип, і я скажу Int сигма (внутр номер), от і все.

264
00:14:22,000 --> 00:14:24,000
Він реалізований в нижній частині.

265
00:14:24,000 --> 00:14:27,000
>> Або інший спосіб я можу вирішити цю проблему,

266
00:14:27,000 --> 00:14:30,000
Я міг би перемістити функцію там, нагорі, який не поганий,

267
00:14:30,000 --> 00:14:32,000
але принаймні, коли ваші програми починають отримувати довгий, відверто кажучи,

268
00:14:32,000 --> 00:14:35,000
Я думаю, що є деяке значення в завжди з основними у верхньому

269
00:14:35,000 --> 00:14:38,000
так що ви у читача може відкрити файл, а потім відразу ж побачити

270
00:14:38,000 --> 00:14:40,000
те, що робить програма, без необхідності шукати через нього

271
00:14:40,000 --> 00:14:42,000
шукає, що основною функцією.

272
00:14:42,000 --> 00:14:49,000
Підемо в мій вікні терміналу тут, спробуйте зробити сигма зробити сигма,

273
00:14:49,000 --> 00:14:51,000
і я облажався тут.

274
00:14:51,000 --> 00:14:55,000
Неявна декларація функції GetInt означає, що я забув зробити те, що ще?

275
00:14:55,000 --> 00:14:57,000
[Нерозбірливо-студент]

276
00:14:57,000 --> 00:15:00,000
Добре, таким чином, очевидно поширена помилка, так давайте це тут,

277
00:15:00,000 --> 00:15:04,000
cs50.h, а тепер давайте повернемося до мого вікні терміналу.

278
00:15:04,000 --> 00:15:08,000
>> Я буду очистити екран, і я буду повторно зробити сигма.

279
00:15:08,000 --> 00:15:11,000
Мені здається, зібрали. Дозвольте мені тепер працювати сигма.

280
00:15:11,000 --> 00:15:15,000
Я введіть номер 3, і я отримати 6, так що не сувора перевірка,

281
00:15:15,000 --> 00:15:18,000
але принаймні, здається, працює на перший погляд, але тепер давай рвати його на частини,

282
00:15:18,000 --> 00:15:21,000
і давайте насправді спираються на ідею рекурсії, знову ж таки,

283
00:15:21,000 --> 00:15:24,000
У дуже простих умов, з тим, що протягом декількох тижнів

284
00:15:24,000 --> 00:15:27,000
коли ми починаємо вивчати любитель структур даних, ніж масиви

285
00:15:27,000 --> 00:15:30,000
у нас є ще один інструмент в інструментарії, з яким

286
00:15:30,000 --> 00:15:33,000
маніпулювати цими даними структурами, як ми побачимо.

287
00:15:33,000 --> 00:15:36,000
Це ітеративний підхід, цикл підходу.

288
00:15:36,000 --> 00:15:39,000
>> Дозвольте мені замість цього тепер зробити це.

289
00:15:39,000 --> 00:15:44,000
Дозвольте мені сказати, що замість підсумовування числа

290
00:15:44,000 --> 00:15:48,000
на до 0 насправді те ж саме,

291
00:15:48,000 --> 00:15:53,000
Число + сигма (кількість - 1).

292
00:15:53,000 --> 00:15:57,000
Іншими словами, так само, як на сцені, я пливла за течією, щоб кожен з людей поруч зі мною,

293
00:15:57,000 --> 00:16:00,000
а вони, в свою чергу, тримали понтіровавшего, поки ми, нарешті, дна на Віллі,

294
00:16:00,000 --> 00:16:03,000
, Які повинні були повернутися жорстко відповісти, як 0.

295
00:16:03,000 --> 00:16:07,000
Ось тепер ми так само понтіровавшего сигма

296
00:16:07,000 --> 00:16:10,000
ті ж функції, спочатку називалася, але ключ розуміння тут

297
00:16:10,000 --> 00:16:12,000
те, що ми не закликаємо сигма однаково.

298
00:16:12,000 --> 00:16:14,000
Ми не проходить російською мовою.

299
00:16:14,000 --> 00:16:17,000
Ми чітко проходить в номер - 1,

300
00:16:17,000 --> 00:16:20,000
так що трохи менше проблем, трохи менше проблем.

301
00:16:20,000 --> 00:16:23,000
>> На жаль, це не зовсім рішення ще, і перш, ніж ми фіксуємо

302
00:16:23,000 --> 00:16:26,000
що можна було б стрибати, як очевидно на деякі з вас

303
00:16:26,000 --> 00:16:28,000
Дозвольте мені йти вперед і повторно зробити.

304
00:16:28,000 --> 00:16:30,000
Здається, зібрати все в порядку.

305
00:16:30,000 --> 00:16:32,000
Дозвольте мені повторно сигма з 6.

306
00:16:32,000 --> 00:16:37,000
Ой, дайте мені повторно сигма з 6.

307
00:16:37,000 --> 00:16:42,000
Ми бачили це раніше, хоча і випадково останній раз.

308
00:16:42,000 --> 00:16:48,000
Чому я отримую це загадкове вини сегментації? Так.

309
00:16:48,000 --> 00:16:50,000
[Нерозбірливо-студент]

310
00:16:50,000 --> 00:16:53,000
Там немає базового варіанту і, більш конкретно, що, ймовірно, сталося?

311
00:16:53,000 --> 00:16:58,000
Це симптом того, що поведінка?

312
00:16:58,000 --> 00:17:00,000
Скажіть це трохи голосніше.

313
00:17:00,000 --> 00:17:02,000
[Нерозбірливо-студент]

314
00:17:02,000 --> 00:17:05,000
Це нескінченний цикл ефективно, і проблема з нескінченною петлі

315
00:17:05,000 --> 00:17:08,000
коли вони пов'язані рекурсії в даному випадку, функції, що називає себе,

316
00:17:08,000 --> 00:17:10,000
те, що відбувається кожного разу, коли ви викликаєте функцію?

317
00:17:10,000 --> 00:17:13,000
Ну, згадайте, як ми виклали пам'яті в комп'ютері.

318
00:17:13,000 --> 00:17:16,000
Ми сказали, що є цей шматок пам'яті, званої стеком, що це на дні,

319
00:17:16,000 --> 00:17:19,000
і кожного разу, коли ви викликаєте функцію трохи більше пам'яті, отримує покласти

320
00:17:19,000 --> 00:17:24,000
На цій так званій стеком, містять локальні змінні, функції або параметри,

321
00:17:24,000 --> 00:17:27,000
так що якщо сигма сигма називає дзвінки сигма називає сигма

322
00:17:27,000 --> 00:17:29,000
 закликає сигма де ж ця історія закінчиться?

323
00:17:29,000 --> 00:17:31,000
>> Ну, це в кінцевому підсумку перевитрата на загальну суму

324
00:17:31,000 --> 00:17:33,000
пам'яті, які у вас є для вашого комп'ютера.

325
00:17:33,000 --> 00:17:37,000
Ви переповнення сегмента, що ви повинні залишатися в межах,

326
00:17:37,000 --> 00:17:40,000
і ви отримаєте цю помилку сегментації, основні кинули,

327
00:17:40,000 --> 00:17:43,000
і те, що основний скидали означає, що тепер у мене є файл з ім'ям основного

328
00:17:43,000 --> 00:17:46,000
який являє собою файл, що містить нулі й одиниці

329
00:17:46,000 --> 00:17:49,000
що насправді в майбутньому буде діагностично корисні.

330
00:17:49,000 --> 00:17:52,000
Якщо це не очевидно для вас, де ваша помилка

331
00:17:52,000 --> 00:17:54,000
Ви можете фактично зробити трохи судово-медичної експертизи, так би мовити,

332
00:17:54,000 --> 00:17:58,000
На цій файлу дампа пам'яті, який, знову ж таки, це просто ціла купа нулів і одиниць

333
00:17:58,000 --> 00:18:02,000
, Що по суті являє стан вашої програми в пам'яті

334
00:18:02,000 --> 00:18:05,000
момент він розбився на цьому шляху.

335
00:18:05,000 --> 00:18:11,000
>> Виправлення в тому, що ми не можемо просто сліпо повернутися сигма,

336
00:18:11,000 --> 00:18:14,000
Число + сигма трохи менше проблем.

337
00:18:14,000 --> 00:18:16,000
Ми повинні мати якусь підставу в даному випадку,

338
00:18:16,000 --> 00:18:19,000
і що повинно базовий варіант, ймовірно, буде?

339
00:18:19,000 --> 00:18:22,000
[Нерозбірливо-студент]

340
00:18:22,000 --> 00:18:25,000
Отже, якщо число є позитивним, ми фактично повинні повернути це,

341
00:18:25,000 --> 00:18:29,000
або, іншими словами, якщо число, скажімо, <= 0,

342
00:18:29,000 --> 00:18:32,000
Ви знаєте, що я буду йти вперед і повертати 0,

343
00:18:32,000 --> 00:18:36,000
так само, як Віллі зробив, і ще, я збираюся йти вперед

344
00:18:36,000 --> 00:18:41,000
і повернути цю, так що це не те, що набагато коротше,

345
00:18:41,000 --> 00:18:44,000
ніж ітераційні версії, що ми на швидку руку спочатку за допомогою циклу,

346
00:18:44,000 --> 00:18:48,000
але зверніть увагу, що є така елегантність до нього.

347
00:18:48,000 --> 00:18:51,000
Замість повернення деякого числа і виконання всієї цієї математиці

348
00:18:51,000 --> 00:18:54,000
і додавання речі з локальними змінними

349
00:18:54,000 --> 00:18:57,000
Ви замість того, кажучи: "Добре, якщо це супер легка задача,

350
00:18:57,000 --> 00:19:01,000
як число <0, дозвольте мені негайно повернути 0 ".

351
00:19:01,000 --> 00:19:03,000
>> Ми не збираємося возитися підтримки негативних чисел,

352
00:19:03,000 --> 00:19:05,000
так що я збираюся на жорсткий код значенням 0.

353
00:19:05,000 --> 00:19:08,000
Але з іншого боку, для реалізації цієї ідеї підсумовування

354
00:19:08,000 --> 00:19:11,000
Всі ці цифри разом, ви можете ефективно взяти невеликий укус

355
00:19:11,000 --> 00:19:14,000
з цієї проблеми, так само, як ми робили тут, на сцені,

356
00:19:14,000 --> 00:19:18,000
Потім плоскодонки інші завдання на наступний людина,

357
00:19:18,000 --> 00:19:20,000
але в цьому випадку наступний людина, це ви самі.

358
00:19:20,000 --> 00:19:22,000
Це ж ім'ям функції.

359
00:19:22,000 --> 00:19:25,000
Просто передайте його все менше і менше проблемою кожного разу,

360
00:19:25,000 --> 00:19:28,000
І хоча у нас не зовсім формалізованих речі в коді тут

361
00:19:28,000 --> 00:19:33,000
це саме те, що відбувалося в тиждень 0 з телефонною книгою.

362
00:19:33,000 --> 00:19:36,000
Це саме те, що відбувається в останні тижні з Шоном

363
00:19:36,000 --> 00:19:39,000
і з нашої демонстрації пошуку номерів.

364
00:19:39,000 --> 00:19:42,000
Це займає проблема і розділивши його знову і знову.

365
00:19:42,000 --> 00:19:44,000
>> Іншими словами, є спосіб в даний час перекладу

366
00:19:44,000 --> 00:19:47,000
це реальна конструкція світу, це більш високий рівень конструкції

367
00:19:47,000 --> 00:19:51,000
розділяй і володарюй і робити щось знову і знову

368
00:19:51,000 --> 00:19:56,000
У коді, так це те, що ми побачимо знову протягом довгого часу.

369
00:19:56,000 --> 00:20:00,000
Тепер, як і в сторону, якщо ви новачок в рекурсії ви повинні принаймні, зрозуміти зараз

370
00:20:00,000 --> 00:20:02,000
чому це смішно.

371
00:20:02,000 --> 00:20:05,000
Я збираюся піти на google.com,

372
00:20:05,000 --> 00:20:17,000
і я буду шукати якісь поради та рекомендації щодо рекурсію, введіть.

373
00:20:17,000 --> 00:20:21,000
Розкажіть людина поруч з вами, якщо вони не сміялися тільки зараз.

374
00:20:21,000 --> 00:20:23,000
Ви мали на увазі рекурсії?

375
00:20:23,000 --> 00:20:25,000
Ви мали на увазі-а-а, ось так.

376
00:20:25,000 --> 00:20:28,000
Добре, тепер от решта кожного.

377
00:20:28,000 --> 00:20:30,000
Трохи пасхальне яйце вбудованих десь там, в Google.

378
00:20:30,000 --> 00:20:33,000
Як в сторону, однієї з посилань ми ставимо на сайті курсу

379
00:20:33,000 --> 00:20:36,000
на сьогоднішній день є тільки ця сітка різних алгоритмів сортування,

380
00:20:36,000 --> 00:20:39,000
деякі з яких ми подивилися на минулому тижні, але те, що добре про це візуалізація

381
00:20:39,000 --> 00:20:43,000
як ви намагаєтеся обернути ваш розум навколо різних речей, пов'язаних з алгоритмами

382
00:20:43,000 --> 00:20:46,000
знаю, що ви можете дуже легко починати з різними типами входів.

383
00:20:46,000 --> 00:20:50,000
Входи все назад, входи основному сортується, випадкові входи і так далі.

384
00:20:50,000 --> 00:20:53,000
Як ви намагаєтеся, знову ж таки, розрізняти ці речі в своєму розумі

385
00:20:53,000 --> 00:20:57,000
розумію, що це URL на веб-сайті курсу на лекції сторінку

386
00:20:57,000 --> 00:21:00,000
може допомогти вам причину через деякі з них.

387
00:21:00,000 --> 00:21:05,000
>> Сьогодні ми, нарешті, отримати, щоб вирішити цю проблему якийсь час назад,

388
00:21:05,000 --> 00:21:08,000
яких було те, що ця функція підкачки просто не працює,

389
00:21:08,000 --> 00:21:12,000
і те, що основна проблема з цією функцією підкачки,

390
00:21:12,000 --> 00:21:15,000
метою якої було, знову ж таки, для обміну значення тут і тут

391
00:21:15,000 --> 00:21:17,000
таке, що це відбувається?

392
00:21:17,000 --> 00:21:20,000
Це насправді не працюють. Чому?

393
00:21:20,000 --> 00:21:22,000
Так.

394
00:21:22,000 --> 00:21:28,000
[Нерозбірливо-студент]

395
00:21:28,000 --> 00:21:31,000
Точно, пояснення цьому грубих помилок

396
00:21:31,000 --> 00:21:34,000
Просто тому, що коли ви викликаєте функції в C

397
00:21:34,000 --> 00:21:38,000
і ці функції беруть аргументи, як і б тут,

398
00:21:38,000 --> 00:21:42,000
Ви передаєте в копії яке б значення ви надаєте до цієї функції.

399
00:21:42,000 --> 00:21:46,000
Ви не надання вихідних значень собі,

400
00:21:46,000 --> 00:21:49,000
таким чином, ми бачили це в контексті buggyc,

401
00:21:49,000 --> 00:21:52,000
buggy3.c, який виглядав трохи щось на зразок цього.

402
00:21:52,000 --> 00:21:57,000
>> Нагадаємо, що у нас було х і у инициализируются 1 і 2, відповідно.

403
00:21:57,000 --> 00:21:59,000
Потім роздрукувати те, що вони були.

404
00:21:59,000 --> 00:22:03,000
Я тоді стверджував, що я був замінюючи їх по телефону своп х, у.

405
00:22:03,000 --> 00:22:06,000
Але проблема в тому, що заміна працював,

406
00:22:06,000 --> 00:22:10,000
але тільки в рамках своп самої функції.

407
00:22:10,000 --> 00:22:13,000
Як тільки ми потрапили лінія 40 місцями ці значення

408
00:22:13,000 --> 00:22:16,000
були викинуті на звалище, а так нічого

409
00:22:16,000 --> 00:22:21,000
У вихідної функції основного був насправді змінилася,

410
00:22:21,000 --> 00:22:26,000
тому, якщо ви вважаєте, тоді як, в якій це виглядає з точки зору нашої пам'яті

411
00:22:26,000 --> 00:22:29,000
якщо це ліва сторона плати являє собою-

412
00:22:29,000 --> 00:22:33,000
і я зроблю все можливе, щоб всі бачили це, якщо це ліва сторона плати

413
00:22:33,000 --> 00:22:37,000
представляє, скажімо, ваша пам'ять і стек буде рости на цю чином,

414
00:22:37,000 --> 00:22:43,000
і ми викликаємо функцію як основного, а головне є 2 локальні змінні х і у,

415
00:22:43,000 --> 00:22:48,000
Давайте описувати їх як х тут, і опишемо, як у цих тут,

416
00:22:48,000 --> 00:22:55,000
і давайте в значення 1 і 2, так що тут головний,

417
00:22:55,000 --> 00:22:58,000
і коли основний викликає функцію підкачки операційної системи

418
00:22:58,000 --> 00:23:02,000
дає функцію підкачки свою смугу пам'яті в стеку,

419
00:23:02,000 --> 00:23:04,000
своїх кадрів у стеку, так би мовити.

420
00:23:04,000 --> 00:23:08,000
Він також виділяє 32 біт для цих цілими.

421
00:23:08,000 --> 00:23:11,000
Це відбувається називати їх А і Б, але це абсолютно довільними.

422
00:23:11,000 --> 00:23:13,000
Це могло б назвав їх, що хоче, але те, що відбувається, коли основний

423
00:23:13,000 --> 00:23:19,000
дзвінки своп він приймає це 1, поміщає копію там, поміщає копію там.

424
00:23:19,000 --> 00:23:23,000
>> Існує 1 інші локальні змінні в підкачки, однак, те, що називається? >> Tmp.

425
00:23:23,000 --> 00:23:27,000
Tmp, тому дозвольте мені дати собі ще 32 біта тут,

426
00:23:27,000 --> 00:23:29,000
і що ж мені робити в цій функції?

427
00:23:29,000 --> 00:23:34,000
Я сказав Int TMP отримує, таким чином, має 1, так що я зробив це, коли ми востаннє грали з цим прикладом.

428
00:23:34,000 --> 00:23:39,000
Тоді б отримує, таким чином, б = 2, так що тепер це стає 2,

429
00:23:39,000 --> 00:23:42,000
і тепер б отримує тимчасовий, так що температура дорівнює 1,

430
00:23:42,000 --> 00:23:44,000
так що тепер це стає б.

431
00:23:44,000 --> 00:23:46,000
Це здорово. Це спрацювало.

432
00:23:46,000 --> 00:23:49,000
Але тоді, як тільки функція повертає

433
00:23:49,000 --> 00:23:52,000
пам'яті свопу ефективно зникає, так що його можна використовувати повторно

434
00:23:52,000 --> 00:23:58,000
деякі інші функції в майбутньому, а головне, очевидно, зовсім не змінився.

435
00:23:58,000 --> 00:24:00,000
Нам потрібен спосіб принципово вирішити цю проблему,

436
00:24:00,000 --> 00:24:03,000
і сьогодні ми, нарешті, є спосіб зробити це за допомогою чого

437
00:24:03,000 --> 00:24:06,000
ми можемо ввести так званий покажчик.

438
00:24:06,000 --> 00:24:09,000
Виходить, що ми можемо вирішити цю проблему

439
00:24:09,000 --> 00:24:12,000
Не переходячи в копії х і у

440
00:24:12,000 --> 00:24:18,000
але замість цього, передавши в чому, як ви думаєте, в своп функції?

441
00:24:18,000 --> 00:24:20,000
Так, щодо адреси?

442
00:24:20,000 --> 00:24:22,000
Ми ще не говорили про адреси дуже докладно,

443
00:24:22,000 --> 00:24:25,000
але якщо ця дошка являє пам'яті мого комп'ютера

444
00:24:25,000 --> 00:24:28,000
Ми, безумовно, може почати нумерацію байт в моїй пам'яті

445
00:24:28,000 --> 00:24:31,000
і говорять, що це байт № 1, це байт № 2, № 3 байти,

446
00:24:31,000 --> 00:24:35,000
№ 4 байти, байт # ... 2 мільярдів, якщо у мене є 2 гігабайти оперативної пам'яті,

447
00:24:35,000 --> 00:24:38,000
таким чином, ми, безумовно, може виступити з деякими довільної схеми нумерації

448
00:24:38,000 --> 00:24:41,000
для всіх окремих байтів в пам'яті мого комп'ютера.

449
00:24:41,000 --> 00:24:43,000
>> Що, якщо замість цього, коли я називаю своп

450
00:24:43,000 --> 00:24:47,000
, А не пропуск в копії х і у

451
00:24:47,000 --> 00:24:51,000
чому б мені не пройти, а не на адресу х тут,

452
00:24:51,000 --> 00:24:55,000
адресу у тут, по суті, поштова адреса,

453
00:24:55,000 --> 00:24:59,000
х і у, тому що тоді змінитися, якщо він поінформував

454
00:24:59,000 --> 00:25:01,000
адреси в пам'ять про х і у,

455
00:25:01,000 --> 00:25:04,000
Потім помінятися, якщо ми навчили його небагато,

456
00:25:04,000 --> 00:25:07,000
Він потенційно може їздити по цій адресі, так би мовити,

457
00:25:07,000 --> 00:25:11,000
х, і змінити номер є, то їхати в адресу у,

458
00:25:11,000 --> 00:25:16,000
змінити номер є, навіть якщо насправді не отримує копії цих значень собі,

459
00:25:16,000 --> 00:25:19,000
так що навіть якщо ми про це говорили як основної пам'яті в

460
00:25:19,000 --> 00:25:23,000
і це як своп-пам'яті потужна і небезпечна частина C

461
00:25:23,000 --> 00:25:28,000
є те, що будь-яка функція може торкнутися пам'яті небудь в комп'ютер,

462
00:25:28,000 --> 00:25:32,000
і це потужний в тому, що ви можете зробити дуже модні речі з комп'ютерними програмами на мові C.

463
00:25:32,000 --> 00:25:36,000
Це небезпечно, тому що ви можете зіпсувати дуже легко.

464
00:25:36,000 --> 00:25:39,000
У самому справі, одним з найбільш поширених способів для програм, у ці дні бути використані

465
00:25:39,000 --> 00:25:42,000
як і раніше є для програміста, щоб не розуміти

466
00:25:42,000 --> 00:25:45,000
що він або вона дозволяє даних

467
00:25:45,000 --> 00:25:49,000
бути написані на місце в пам'яті, яка не була призначена.

468
00:25:49,000 --> 00:25:51,000
>> Наприклад, він або вона оголошує масив розміром 10

469
00:25:51,000 --> 00:25:56,000
але потім випадково намагається поставити 11 байт в цьому масиві пам'яті,

470
00:25:56,000 --> 00:25:59,000
і ви починаєте торкаючись частин пам'яті, які більше не є дійсними.

471
00:25:59,000 --> 00:26:02,000
Просто контекстної це, деякі з вас можуть знати, що

472
00:26:02,000 --> 00:26:06,000
Програмне забезпечення часто пропонує ввести серійний номер або реєстраційні ключі,

473
00:26:06,000 --> 00:26:08,000
Photoshop і Слово і подібних програмах.

474
00:26:08,000 --> 00:26:12,000
Там існують тріщини, так як деякі з вас знають, в Інтернеті, де ви можете запустити невелику програму,

475
00:26:12,000 --> 00:26:14,000
і вуаля, не більше запит на серійний номер.

476
00:26:14,000 --> 00:26:16,000
Як це працює?

477
00:26:16,000 --> 00:26:21,000
У багатьох випадках ці речі просто знайти в комп'ютерах

478
00:26:21,000 --> 00:26:24,000
Текст сегментів в реальному нулі комп'ютера і ті,

479
00:26:24,000 --> 00:26:28,000
де це функція, де серійний номер просив,

480
00:26:28,000 --> 00:26:31,000
і перезапису, що простір або під час виконання програми

481
00:26:31,000 --> 00:26:33,000
Ви можете з'ясувати, де ключ зберігається насправді

482
00:26:33,000 --> 00:26:37,000
використання так званих відладчик, і ви зможете зламати програмне забезпечення таким чином.

483
00:26:37,000 --> 00:26:40,000
Це не означає, що це наша мета на найближчі пару днів,

484
00:26:40,000 --> 00:26:42,000
але вона має дуже реальні наслідки.

485
00:26:42,000 --> 00:26:45,000
Той відбувається залучити крадіжку програмного забезпечення,

486
00:26:45,000 --> 00:26:47,000
але є також компроміс всієї машини.

487
00:26:47,000 --> 00:26:50,000
>> У самому справі, коли веб-сайти в ці дні експлуатується

488
00:26:50,000 --> 00:26:53,000
і скомпрометований і дані просочилися і паролі були вкрадені

489
00:26:53,000 --> 00:26:58,000
це дуже часто пов'язане з поганим управлінням своїй пам'яті,

490
00:26:58,000 --> 00:27:01,000
або, у випадку баз даних, нездатність передбачити

491
00:27:01,000 --> 00:27:03,000
змагальності вхід, так що більше на те, що в найближчі тижні,

492
00:27:03,000 --> 00:27:07,000
а зараз просто попередній перегляд роду збиток, який ви можете зробити

493
00:27:07,000 --> 00:27:11,000
, Не зовсім розуміючи, як все це працює під капотом.

494
00:27:11,000 --> 00:27:14,000
Давайте йти про розуміючи, чому це не працює

495
00:27:14,000 --> 00:27:17,000
з інструментом, який буде ставати все більш і більш корисними

496
00:27:17,000 --> 00:27:19,000
як наші програми стають все більш складними.

497
00:27:19,000 --> 00:27:21,000
До цих пір, коли у вас була помилка у вашій програмі

498
00:27:21,000 --> 00:27:23,000
як ви пішли про налагодження це?

499
00:27:23,000 --> 00:27:25,000
Що ваші методи були досі, вчив Чи ваша TF

500
00:27:25,000 --> 00:27:27,000
або просто самоучка?

501
00:27:27,000 --> 00:27:29,000
[Студент] Printf.

502
00:27:29,000 --> 00:27:31,000
Printf, так Printf, ймовірно, був вашим другом в тому, що якщо ви хочете побачити

503
00:27:31,000 --> 00:27:33,000
що відбувається всередині вашої програми

504
00:27:33,000 --> 00:27:36,000
ви просто покласти Printf тут, Printf тут, Printf тут.

505
00:27:36,000 --> 00:27:38,000
Тоді ви запустите його, і ви отримаєте цілу купу речей на екрані

506
00:27:38,000 --> 00:27:43,000
, Які можна використовувати, щоб потім визначити, що насправді відбувається не так у вашій програмі.

507
00:27:43,000 --> 00:27:45,000
>> Printf, як правило, дуже потужна річ,

508
00:27:45,000 --> 00:27:47,000
але це дуже ручний процес.

509
00:27:47,000 --> 00:27:49,000
Ви повинні поставити Printf тут, Printf тут,

510
00:27:49,000 --> 00:27:51,000
і якщо ви помістіть його всередині циклу ви можете отримати 100 ліній

511
00:27:51,000 --> 00:27:53,000
продукції, які потім потрібно просіяти через.

512
00:27:53,000 --> 00:27:58,000
Це не дуже зручно або інтерактивний механізм для налагодження програм,

513
00:27:58,000 --> 00:28:00,000
але, на щастя, існує альтернативи.

514
00:28:00,000 --> 00:28:03,000
Там у програмі, наприклад, називають GDB, GNU Debugger,

515
00:28:03,000 --> 00:28:06,000
який трохи таємницею в тому, як ви його використовуєте.

516
00:28:06,000 --> 00:28:08,000
Це трохи складно, але, відверто кажучи,

517
00:28:08,000 --> 00:28:11,000
це одна з тих речей, де, якщо ви покладете в цей тиждень і наступний

518
00:28:11,000 --> 00:28:14,000
додаткова година, щоб щось зрозуміти, як GDB

519
00:28:14,000 --> 00:28:18,000
це заощадить вам, ймовірно, десятки годин в довгостроковій перспективі,

520
00:28:18,000 --> 00:28:21,000
Так з цим, дозвольте мені дати вам тізер, як ця штука працює.

521
00:28:21,000 --> 00:28:23,000
>> Я в моєму вікні терміналу.

522
00:28:23,000 --> 00:28:26,000
Дозвольте мені йти вперед і скомпілювати цю програму, buggy3.

523
00:28:26,000 --> 00:28:28,000
Він вже в курсі.

524
00:28:28,000 --> 00:28:31,000
Дозвольте мені запустити його так само, як ми робили якийсь час назад, і, дійсно, вона зламана.

525
00:28:31,000 --> 00:28:34,000
Але чому це відбувається? Може бути, я облажався своп функції.

526
00:28:34,000 --> 00:28:37,000
Може бути, це і газети. Я не зовсім їх переміщенням правильно.

527
00:28:37,000 --> 00:28:39,000
Дозвольте мені йти вперед і робити це.

528
00:28:39,000 --> 00:28:43,000
Замість того, щоб просто запустити buggy3 дозвольте мені замість запуску цієї програми GDB,

529
00:28:43,000 --> 00:28:48,000
і я збираюся сказати йому, щоб запустити buggy3,

530
00:28:48,000 --> 00:28:52,000
і я збираюся включити параметр командного рядка,-туй,

531
00:28:52,000 --> 00:28:55,000
і ми помістимо це в майбутньому проблем у специфікації, щоб нагадати.

532
00:28:55,000 --> 00:28:57,000
І ось тепер цей чорно-білий інтерфейс вискочив, що, знову ж таки,

533
00:28:57,000 --> 00:28:59,000
трохи переважною спочатку, тому що все це

534
00:28:59,000 --> 00:29:02,000
Інформація про гарантії тут, але принаймні є щось знайоме.

535
00:29:02,000 --> 00:29:04,000
У верхній частині вікна знаходиться мій реальний код,

536
00:29:04,000 --> 00:29:08,000
і якщо я прокрутки вгору тут, дозвольте мені перейти до самої верхньої частини мого файлу,

537
00:29:08,000 --> 00:29:11,000
і, дійсно, є buggy3.c, і зверніть увагу, в нижній частині цього вікна

538
00:29:11,000 --> 00:29:13,000
У мене є GDB рядку.

539
00:29:13,000 --> 00:29:16,000
>> Це не те ж саме, як моя нормальна Джон Гарвард рядку.

540
00:29:16,000 --> 00:29:19,000
Це підказка, яка збирається, щоб дозволити мені контролювати GDB.

541
00:29:19,000 --> 00:29:21,000
GDB є відладчиком.

542
00:29:21,000 --> 00:29:24,000
Відладчик це програма, яка дозволяє вам йти через

543
00:29:24,000 --> 00:29:27,000
виконання програми рядок за рядком за рядком,

544
00:29:27,000 --> 00:29:30,000
по шляху робимо все, що ви хочете програму,

545
00:29:30,000 --> 00:29:33,000
навіть викликом функцій, або шукати, що ще більш важливо,

546
00:29:33,000 --> 00:29:35,000
при значеннях різних змінних.

547
00:29:35,000 --> 00:29:37,000
Давайте підемо далі і зробити це.

548
00:29:37,000 --> 00:29:40,000
Я збираюся піти далі і ввести в бігу на оперативне GDB,

549
00:29:40,000 --> 00:29:43,000
так що помітити в лівій нижній частині екрана, я набрав бігти,

550
00:29:43,000 --> 00:29:45,000
і я потрапив ввести, і що ж, що робити?

551
00:29:45,000 --> 00:29:50,000
Він буквально втік моя програма, але я насправді не бачу великої продовжувати тут

552
00:29:50,000 --> 00:29:55,000
тому що я насправді не сказав відладчик

553
00:29:55,000 --> 00:29:57,000
, Щоб призупинити на певний момент часу.

554
00:29:57,000 --> 00:29:59,000
Просто введіть перспективі запускає програму.

555
00:29:59,000 --> 00:30:01,000
Я насправді не бачу. Я не можу керувати нею.

556
00:30:01,000 --> 00:30:03,000
>> Замість цього дозвольте мені зробити це.

557
00:30:03,000 --> 00:30:08,000
У цьому рядку GDB дозвольте мені замість введіть перерви, ввести.

558
00:30:08,000 --> 00:30:10,000
Це не те, що я мав на увазі, щоб надрукувати.

559
00:30:10,000 --> 00:30:13,000
Давайте замість цього ввести перерву основний.

560
00:30:13,000 --> 00:30:15,000
Іншими словами, я хочу встановити так званий останову,

561
00:30:15,000 --> 00:30:18,000
яку назвали тому, що він зламається або паузи

562
00:30:18,000 --> 00:30:21,000
виконання програми в цьому конкретному місці.

563
00:30:21,000 --> 00:30:23,000
Головне це ім'я моєї функції.

564
00:30:23,000 --> 00:30:25,000
Зверніть увагу, що GDB є досить розумна.

565
00:30:25,000 --> 00:30:28,000
Він з'ясував, що основна відбувається, щоб почати приблизно на лінії 18

566
00:30:28,000 --> 00:30:32,000
з buggy3.c, а потім помітити тут, у лівому верхньому

567
00:30:32,000 --> 00:30:34,000
B + розташований поруч з лінією 18.

568
00:30:34,000 --> 00:30:38,000
Це нагадує мені, що я поставив крапку останова на рядку 18.

569
00:30:38,000 --> 00:30:42,000
Це час, коли я друкую перспективі, я збираюся запустити мою програму

570
00:30:42,000 --> 00:30:45,000
До вона потрапляє, що останову,

571
00:30:45,000 --> 00:30:48,000
так що програма буде припинена для мене в рядку 18.

572
00:30:48,000 --> 00:30:50,000
Тут ми йдемо, бігти.

573
00:30:50,000 --> 00:30:53,000
Ніщо, здається, сталося, але зверніть увагу на лівий нижній

574
00:30:53,000 --> 00:30:58,000
починаючи програму, buggy3, останова 1 в основний buggy3.c на лінії 18.

575
00:30:58,000 --> 00:31:00,000
Що я можу зробити зараз?

576
00:31:00,000 --> 00:31:03,000
>> Зверніть увагу, я можу почати друкувати такі речі, як друк,

577
00:31:03,000 --> 00:31:08,000
Чи не Printf, друк х, і зараз це дивно.

578
00:31:08,000 --> 00:31:11,000
$ 1 це просто цікавість, як ми побачимо

579
00:31:11,000 --> 00:31:14,000
кожен раз, коли ви друкуєте те, що ви одержите новий $ значення.

580
00:31:14,000 --> 00:31:18,000
Ось, так що ви можете повернутися до попередніх значень на всяк випадок,

581
00:31:18,000 --> 00:31:21,000
але зараз те, що печатка говорить мені, що значення х в цей момент в історії

582
00:31:21,000 --> 00:31:26,000
мабуть 134514032.

583
00:31:26,000 --> 00:31:29,000
Що? Де, що навіть взявся?

584
00:31:29,000 --> 00:31:31,000
[Нерозбірливо-студент]

585
00:31:31,000 --> 00:31:34,000
У самому справі, це те, що ми називаємо сміттям значення, і ми не говорили з цього приводу,

586
00:31:34,000 --> 00:31:37,000
але причина, що ви ініціалізація змінних

587
00:31:37,000 --> 00:31:40,000
Очевидно, так що вони мають деяке значення, яке ви хочете їх мати.

588
00:31:40,000 --> 00:31:44,000
Але улов нагадати, що ви можете оголошувати змінні

589
00:31:44,000 --> 00:31:46,000
як я хвилину тому в моєму прикладі сигма

590
00:31:46,000 --> 00:31:48,000
, Фактично не даючи їм значення.

591
00:31:48,000 --> 00:31:50,000
Нагадаємо, що я зробив тут, в сигма.

592
00:31:50,000 --> 00:31:52,000
Я заявив, п, але яке значення я дати йому?

593
00:31:52,000 --> 00:31:56,000
Ні, тому що я знав, що в найближчі кілька рядків

594
00:31:56,000 --> 00:31:59,000
GetInt буде піклуватися про проблему покласти значення всередині н.

595
00:31:59,000 --> 00:32:02,000
>> Але в цей момент в історії рядку 11

596
00:32:02,000 --> 00:32:05,000
і 12 лінією і лінією 13 і рядок 14

597
00:32:05,000 --> 00:32:08,000
протягом цих кількох рядках те, що значення п?

598
00:32:08,000 --> 00:32:10,000
У C Ви просто не знаю.

599
00:32:10,000 --> 00:32:14,000
Це взагалі якась фігня значення, деякі цілком випадкове число

600
00:32:14,000 --> 00:32:17,000
що залишається за головним чином з деяких попередніх функцій

601
00:32:17,000 --> 00:32:21,000
будучи працювати, так як ваша програма працює

602
00:32:21,000 --> 00:32:24,000
Нагадаємо, що функція отримує функції, функції, функції.

603
00:32:24,000 --> 00:32:27,000
Всі ці кадри отримати покласти на пам'ять, а потім ці функції повертають,

604
00:32:27,000 --> 00:32:31,000
і так само, як я запропонував, з гумкою їх пам'яті, в кінцевому рахунку повторно.

605
00:32:31,000 --> 00:32:37,000
Ну, так вже сталося, що ця змінна х у цій програмі

606
00:32:37,000 --> 00:32:41,000
по-видимому, містить деякі сміття значення, як 134514032

607
00:32:41,000 --> 00:32:44,000
від деяких попередніх функції, а не той, який я написав.

608
00:32:44,000 --> 00:32:47,000
Це може бути щось, що приходить ефективно з операційною системою,

609
00:32:47,000 --> 00:32:49,000
деякі функції під капотом.

610
00:32:49,000 --> 00:32:52,000
>> Гаразд, це добре, але давайте тепер перейти до наступного рядка.

611
00:32:52,000 --> 00:32:55,000
Якщо я типу "Наступний" на GDB мої рядки, і я вдарив увійти,

612
00:32:55,000 --> 00:32:58,000
зауважити, що виділення рухається вниз до лінії 19,

613
00:32:58,000 --> 00:33:01,000
але логічний мається на увазі, що рядок 18

614
00:33:01,000 --> 00:33:06,000
В даний час закінчив роботу, так що якщо я ще раз введіть "друк х"

615
00:33:06,000 --> 00:33:10,000
Я повинен з'явитися 1, і, дійсно, я роблю.

616
00:33:10,000 --> 00:33:14,000
Знову ж таки, $ речей є способом GDB нагадувати вам

617
00:33:14,000 --> 00:33:17,000
що історія відбитки, що ви зробили.

618
00:33:17,000 --> 00:33:21,000
Тепер дозвольте мені йти вперед і роздрукувати у, і, дійсно, у є деякі божевільні значення, а також,

619
00:33:21,000 --> 00:33:24,000
але не велика проблема, тому що в рядку 19 ми збираємося призначити його

620
00:33:24,000 --> 00:33:27,000
значення 2, так що дозвольте мені ввести "Наступний" ще раз.

621
00:33:27,000 --> 00:33:29,000
І зараз ми знаходимося на Printf лінії.

622
00:33:29,000 --> 00:33:31,000
Дозвольте мені зробити друк х.

623
00:33:31,000 --> 00:33:34,000
Дозвольте мені зробити друк у. Чесно кажучи, я вже трохи втомився від цієї печатки.

624
00:33:34,000 --> 00:33:38,000
Дозвольте мені замість цього ввести "дисплей X" та "Y Дисплей",

625
00:33:38,000 --> 00:33:41,000
і тепер кожен раз, коли я введіть команду в майбутньому

626
00:33:41,000 --> 00:33:45,000
Я буду нагадав про те, що це х і у, що х і у, що х і у.

627
00:33:45,000 --> 00:33:48,000
>> Я також можу, а в бік, типу "Інформація місцевими жителями".

628
00:33:48,000 --> 00:33:50,000
Інформація є спеціальною командою.

629
00:33:50,000 --> 00:33:52,000
Місцеві жителі означає, що він показує мені локальні змінні.

630
00:33:52,000 --> 00:33:55,000
На всяк випадок я забув, чи це божевільна, складна функція

631
00:33:55,000 --> 00:33:57,000
що я чи хтось інший писав Інформація місцеві жителі скажуть вам,

632
00:33:57,000 --> 00:34:00,000
що всі локальні змінні всередині цієї локальної функції

633
00:34:00,000 --> 00:34:03,000
що ви могли б дбати про те, якщо ви хочете, щоб ткнути навколо.

634
00:34:03,000 --> 00:34:07,000
Тепер, Printf збирається виконувати, тому дозвольте мені йти вперед і тільки типу "Далі".

635
00:34:07,000 --> 00:34:10,000
Тому що ми в цьому середовищі ми насправді не бачачи його

636
00:34:10,000 --> 00:34:14,000
виконати тут, але зауважив, що це стає трохи спотворене тут.

637
00:34:14,000 --> 00:34:17,000
Але зверніть увагу, що це перевизначення екрану є,

638
00:34:17,000 --> 00:34:21,000
так що це не ідеальна програма тут, але це нормально, тому що я завжди можу копатися

639
00:34:21,000 --> 00:34:23,000
використанням печатки, якщо я хочу.

640
00:34:23,000 --> 00:34:26,000
>> Дозвольте мені ввести наступний раз, і ось тепер найцікавіше.

641
00:34:26,000 --> 00:34:29,000
На даний момент у цій історії у 2, а х 1,

642
00:34:29,000 --> 00:34:32,000
як запропоновано тут, і знову,

643
00:34:32,000 --> 00:34:35,000
Причиною цього автоматично відображаються зараз, тому що я використовував команду

644
00:34:35,000 --> 00:34:40,000
Дисплей х і у дисплея, так що момент, коли я введіть наступну

645
00:34:40,000 --> 00:34:43,000
У теорії х і у мають стати місцями.

646
00:34:43,000 --> 00:34:45,000
Тепер ми вже знаємо, що не збирається бути в разі,

647
00:34:45,000 --> 00:34:49,000
але ми побачимо через мить, як ми можемо пірнати глибше, щоб з'ясувати, чому це так.

648
00:34:49,000 --> 00:34:54,000
Далі, і, на жаль, у ще 2 і х ще 1, і я можу підтвердити, як багато.

649
00:34:54,000 --> 00:34:56,000
Друк х, у пресі.

650
00:34:56,000 --> 00:34:59,000
Дійсно, ні заміна відбулося насправді, так що давайте почнемо над цим.

651
00:34:59,000 --> 00:35:01,000
Ясно, що своп зламаний.

652
00:35:01,000 --> 00:35:04,000
Давайте замість цього ввести "Виконати".

653
00:35:04,000 --> 00:35:07,000
Дозвольте мені сказати, так, я хочу, щоб перезапустити його з самого початку, ввести.

654
00:35:07,000 --> 00:35:09,000
>> Тепер я назад у рядку 18.

655
00:35:09,000 --> 00:35:11,000
Тепер зверніть увагу х і у сміттєвих значення знову.

656
00:35:11,000 --> 00:35:15,000
Наступний, наступний, наступний, наступний.

657
00:35:15,000 --> 00:35:17,000
Якщо я отримую нудно я можу просто введіть п для наступного.

658
00:35:17,000 --> 00:35:21,000
Ви можете скоротити його в найкоротші послідовність символів.

659
00:35:21,000 --> 00:35:23,000
Змінний тепер зламана.

660
00:35:23,000 --> 00:35:25,000
Давайте поринемо в, так що замість того, щоб друкувати далі,

661
00:35:25,000 --> 00:35:30,000
Тепер я збираюся ввести кроком, так що я активізації всередині цієї функції

662
00:35:30,000 --> 00:35:33,000
так що я можу пройти через це, так що я вдарив крок, а потім ввести.

663
00:35:33,000 --> 00:35:37,000
Зверніть увагу, що виділення скачки вниз нижче в моїй програмі лінії 36.

664
00:35:37,000 --> 00:35:39,000
Тепер те, що є локальні змінні?

665
00:35:39,000 --> 00:35:41,000
Інформація місцеві жителі.

666
00:35:41,000 --> 00:35:43,000
Ніщо не просто ще й тому, що ми не дійшли до цього рядка,

667
00:35:43,000 --> 00:35:47,000
так що давайте йти вперед і сказати: "Наступний".

668
00:35:47,000 --> 00:35:50,000
Тепер ми, здається, TMP, друк TMP.

669
00:35:50,000 --> 00:35:52,000
Сміття значення, чи не так? Я так думаю.

670
00:35:52,000 --> 00:35:55,000
Як щодо друк, друк б, 1 і 2?

671
00:35:55,000 --> 00:35:58,000
У момент, як тільки я набираю наступного разу

672
00:35:58,000 --> 00:36:02,000
TMP буде приймати значення 1, ми сподіваємося,

673
00:36:02,000 --> 00:36:05,000
TMP, тому що збирається бути присвоєно значення.

674
00:36:05,000 --> 00:36:08,000
>> Тепер давайте зробимо друк, друк б,

675
00:36:08,000 --> 00:36:11,000
але тепер друку TMP, і це дійсно 1.

676
00:36:11,000 --> 00:36:14,000
Дозвольте мені робити далі. Дозвольте мені робити далі.

677
00:36:14,000 --> 00:36:16,000
Я закінчив своп функції.

678
00:36:16,000 --> 00:36:19,000
Я все ще всередині нього в рядку 40, так що дозвольте мені печатку,

679
00:36:19,000 --> 00:36:22,000
б друку, і я не хвилює, що TMP є.

680
00:36:22,000 --> 00:36:27,000
Схоже, що своп правильно, коли справа доходить до заміни і б.

681
00:36:27,000 --> 00:36:31,000
Але якщо я зараз введіть наступну, я щоб повернутися до рядка 25,

682
00:36:31,000 --> 00:36:34,000
і, звичайно, якщо я типу х і друку у

683
00:36:34,000 --> 00:36:38,000
вони як і раніше без змін, так що ми не вирішили проблему.

684
00:36:38,000 --> 00:36:41,000
Але діагностично зараз, мабуть, з цією програмою GDB

685
00:36:41,000 --> 00:36:44,000
Ми принаймні, отримав один крок ближче до розуміння

686
00:36:44,000 --> 00:36:47,000
що відбувається не так, не засмічувати наш код, поставивши Printf тут,

687
00:36:47,000 --> 00:36:50,000
Printf тут, Printf тут, а потім запустити його знову і знову

688
00:36:50,000 --> 00:36:52,000
намагається з'ясувати, що відбувається не так.

689
00:36:52,000 --> 00:36:55,000
>> Я збираюся йти вперед і вийти із цього всього з палити.

690
00:36:55,000 --> 00:36:57,000
Це буде сказати: "Все одно вийти?" Так.

691
00:36:57,000 --> 00:37:00,000
Зараз я повернувся в мій нормальний рядки, і я зроблено за допомогою GDB.

692
00:37:00,000 --> 00:37:03,000
Як осторонь, ви не повинні використовувати цю-туй прапор.

693
00:37:03,000 --> 00:37:07,000
У самому справі, якщо ви пропустите його, то отримаєте по суті в нижній половині екрану.

694
00:37:07,000 --> 00:37:11,000
Якби я потім введіть перерву основний, а потім запустіть

695
00:37:11,000 --> 00:37:15,000
Я все ще можна запускати мою програму, але що він буде робити більше текстуально

696
00:37:15,000 --> 00:37:18,000
просто покажіть мені поточному один рядок за один раз.

697
00:37:18,000 --> 00:37:21,000
-Туй, текстовий користувацький інтерфейс,

698
00:37:21,000 --> 00:37:25,000
просто показує вам кілька програм одночасно, що, ймовірно, трохи концептуально простіше.

699
00:37:25,000 --> 00:37:27,000
Але насправді, я можу просто зробити наступний, наступний, наступний,

700
00:37:27,000 --> 00:37:30,000
і я йду до одного рядка за один раз, і якщо я дійсно хочу бачити, що відбувається на

701
00:37:30,000 --> 00:37:35,000
Я можу надрукувати список і побачити цілу купу сусідніх ліній.

702
00:37:35,000 --> 00:37:39,000
>> Там є відео, яке ми просили, що ви стежите за проблеми встановлює 3

703
00:37:39,000 --> 00:37:43,000
, В якому Nate покриває деякі з тонкощів GDB,

704
00:37:43,000 --> 00:37:46,000
і це одна з тих речей, чесно кажучи, де деякі нетривіальні відсоток ви

705
00:37:46,000 --> 00:37:49,000
ніколи не торкнеться GDB, і це буде погано

706
00:37:49,000 --> 00:37:53,000
тому що буквально ви будете в кінцевому підсумку витрачають більше часу в цьому семестрі

707
00:37:53,000 --> 00:37:56,000
ганятися за помилки, то ви б, якщо б ви поклали в тому, що півгодини / годину

708
00:37:56,000 --> 00:38:00,000
На цьому тижні і в наступному навчання, щоб освоїтися з GDB.

709
00:38:00,000 --> 00:38:02,000
Printf був вашим другом.

710
00:38:02,000 --> 00:38:05,000
GDB повинен тепер бути вашим другом.

711
00:38:05,000 --> 00:38:08,000
>> Будь-які питання по GDB?

712
00:38:08,000 --> 00:38:12,000
І ось короткий список деяких з найбільш потужних і корисних команд.

713
00:38:12,000 --> 00:38:15,000
Так. >> Чи можна друкувати рядок?

714
00:38:15,000 --> 00:38:17,000
Ви можете друкувати рядок? Абсолютно вірно.

715
00:38:17,000 --> 00:38:19,000
Це не повинні бути просто цілі числа.

716
00:38:19,000 --> 00:38:22,000
Якщо змінна а являє собою рядок, просто наберіть в пресі с.

717
00:38:22,000 --> 00:38:24,000
Він покаже вам, що це рядок змінної.

718
00:38:24,000 --> 00:38:26,000
[Нерозбірливо-студент]

719
00:38:26,000 --> 00:38:28,000
Це дасть вам адресу і саму рядок.

720
00:38:28,000 --> 00:38:32,000
Він покаже вам обом.

721
00:38:32,000 --> 00:38:34,000
І ще одна остання річ, тільки тому, що це добре, щоб знати теж.

722
00:38:34,000 --> 00:38:37,000
Backtrace і рами, дозвольте мені зануритися в це в останній раз,

723
00:38:37,000 --> 00:38:39,000
точно такий же програмі з GDB.

724
00:38:39,000 --> 00:38:44,000
Дозвольте мені йти вперед і запустити текстову версію користувальницького інтерфейсу,

725
00:38:44,000 --> 00:38:46,000
розбити основні.

726
00:38:46,000 --> 00:38:49,000
Дозвольте мені йти вперед і бігти знову. Ось я.

727
00:38:49,000 --> 00:38:55,000
Тепер дозвольте мені йти далі, далі, далі, далі, далі, крок, ввести.

728
00:38:55,000 --> 00:39:00,000
>> А тепер припустимо, що я зараз у своп навмисно, але я, як "Чорт, що було значення х?"

729
00:39:00,000 --> 00:39:02,000
Я не можу зробити більше х.

730
00:39:02,000 --> 00:39:05,000
Я не можу зробити у, тому що вони не входять в комплект.

731
00:39:05,000 --> 00:39:07,000
Вони не в контексті, але не проблема.

732
00:39:07,000 --> 00:39:09,000
Я можу надрукувати слід.

733
00:39:09,000 --> 00:39:13,000
Це показує мені всі функції, які виконуються до цього моменту часу.

734
00:39:13,000 --> 00:39:16,000
Зверніть увагу, що один на дно, головне, на одній лінії з основними

735
00:39:16,000 --> 00:39:18,000
перебуваючи на нижній частині нашої картини тут.

736
00:39:18,000 --> 00:39:22,000
Той факт, що своп вище лінії з своп бути вище його в пам'яті тут,

737
00:39:22,000 --> 00:39:26,000
і якщо я хочу повернутися до основної тимчасової я можу сказати "рамку".

738
00:39:26,000 --> 00:39:30,000
Який номер? Головне це кадр № 1.

739
00:39:30,000 --> 00:39:32,000
Я збираюся йти вперед і сказати: "кадр 1".

740
00:39:32,000 --> 00:39:36,000
>> Зараз я повернувся в основний, і я можу друкувати х, і я можу надрукувати в,

741
00:39:36,000 --> 00:39:40,000
але я не можу роздрукувати або б.

742
00:39:40,000 --> 00:39:43,000
Але я можу, якщо я скажу: «Добре, зачекайте хвилинку. Де був своп?"

743
00:39:43,000 --> 00:39:46,000
Дозвольте мені йти вперед і сказати: "кадр 0".

744
00:39:46,000 --> 00:39:48,000
Зараз я там, де я хочу бути, і в бік,

745
00:39:48,000 --> 00:39:52,000
є інші команди теж, як якби ви дійсно нудно набравши наступний, наступний, наступний, наступний,

746
00:39:52,000 --> 00:39:56,000
Ви можете взагалі сказати щось на кшталт "наступні 10", і що піде протягом наступних 10 рядків.

747
00:39:56,000 --> 00:39:59,000
Ви також можете написати "продовжити", коли ви дійсно втомлюєтеся від покрокового він.

748
00:39:59,000 --> 00:40:05,000
Продовжуйте буде запустити програму без перерви, поки не зустріне іншу точку зупину,

749
00:40:05,000 --> 00:40:07,000
будь то в петлю або нижче в вашу програму.

750
00:40:07,000 --> 00:40:11,000
>> У цьому випадку ми продовжували до кінця, і програма нормально завершився.

751
00:40:11,000 --> 00:40:13,000
Це химерний спосіб, поступається процесу.

752
00:40:13,000 --> 00:40:16,000
Просто ваша програма нормально завершився.

753
00:40:16,000 --> 00:40:24,000
Докладніше про це у відео і в налагодженні сесій в майбутньому.

754
00:40:24,000 --> 00:40:26,000
Це було багато.

755
00:40:26,000 --> 00:40:35,000
Давайте візьмемо наш 5-хвилинну перерву тут, і ми повернемося з структурам і файлів.

756
00:40:35,000 --> 00:40:38,000
>> Якщо ви пірнули в PSET на цьому тижні вже

757
00:40:38,000 --> 00:40:41,000
Ви будете знати, що ми використовуємо в розподілі код,

758
00:40:41,000 --> 00:40:45,000
вихідний код, який ми надаємо вам в якості відправної точки, деякі нові методи.

759
00:40:45,000 --> 00:40:50,000
Зокрема, ми ввели це нове ключове слово називається структура, для структури,

760
00:40:50,000 --> 00:40:53,000
так що ми можемо створювати користувальницькі змінні сортів.

761
00:40:53,000 --> 00:40:57,000
Ми також ввели поняття файлу I / O, файлового вводу і виводу,

762
00:40:57,000 --> 00:41:00,000
і це так, що ми можемо зберегти стан

763
00:41:00,000 --> 00:41:03,000
Вашій Scramble плати у файл на диску

764
00:41:03,000 --> 00:41:06,000
так що навчання стипендіатів і я можу зрозуміти

765
00:41:06,000 --> 00:41:09,000
що відбувається всередині вашої програми без необхідності вручну грати

766
00:41:09,000 --> 00:41:11,000
десятки ігор Scramble.

767
00:41:11,000 --> 00:41:13,000
Ми можемо зробити це більш automatedly.

768
00:41:13,000 --> 00:41:18,000
>> Ця ідея структури вирішує досить переконливі проблеми.

769
00:41:18,000 --> 00:41:21,000
Припустимо, що ми хочемо реалізувати деякі програми

770
00:41:21,000 --> 00:41:25,000
що якимось чином відстежує інформацію про студентів,

771
00:41:25,000 --> 00:41:28,000
і студенти могли б мати, наприклад, ID, ім'я,

772
00:41:28,000 --> 00:41:31,000
і будинок у такому місці, як Гарвард, тому ці 3 частини інформації

773
00:41:31,000 --> 00:41:34,000
ми хочемо, щоб навколо, так що дозвольте мені йти вперед і почати писати невелику програму тут,

774
00:41:34,000 --> 00:41:38,000
включає stdio.h.

775
00:41:38,000 --> 00:41:42,000
Дозвольте мені зробити включати cs50.h.

776
00:41:42,000 --> 00:41:44,000
А потім почати свою основну функцію.

777
00:41:44,000 --> 00:41:46,000
Я не буду з будь-якими аргументами командного рядка,

778
00:41:46,000 --> 00:41:49,000
і ось я хочу, щоб студент, так що я збираюся сказати,

779
00:41:49,000 --> 00:41:54,000
Студент має ім'я, так що я збираюся сказати "рядок ім'я".

780
00:41:54,000 --> 00:41:59,000
Тоді я збирався сказати студент також має ідентифікатор, так Int Ідентифікатор,

781
00:41:59,000 --> 00:42:03,000
і студент має будинок, тому я також хотів сказати "рядок дім".

782
00:42:03,000 --> 00:42:06,000
Тоді я замовлю ці трохи більш акуратно, як це.

783
00:42:06,000 --> 00:42:11,000
Добре, тепер у мене є 3 змінні, з якими представляють студента, так що "студент".

784
00:42:11,000 --> 00:42:15,000
>> А тепер я хочу, щоб заповнити ці цінності, так що дозвольте мені йти вперед і сказати щось на кшталт:

785
00:42:15,000 --> 00:42:18,000
"ID = 123".

786
00:42:18,000 --> 00:42:21,000
Ім'я збирається отримати Давида.

787
00:42:21,000 --> 00:42:24,000
Скажімо, будинок збирається отримати Mather,

788
00:42:24,000 --> 00:42:31,000
, А потім я збираюся зробити щось довільно, як Е ("% S,

789
00:42:31,000 --> 00:42:37,000
з ідентифікатором% D,% проживає в с.

790
00:42:37,000 --> 00:42:41,000
А тепер, що я хочу підключити сюди, один за іншим?

791
00:42:41,000 --> 00:42:47,000
Ім'я, ідентифікатор, будинок, повертається 0.

792
00:42:47,000 --> 00:42:50,000
Добре, якщо я облажався десь тут

793
00:42:50,000 --> 00:42:54,000
Я думаю, що у нас є досить хороша програма, яка зберігає один студент.

794
00:42:54,000 --> 00:42:57,000
Звичайно, це не все, що цікаво. Що робити, якщо я хочу мати 2 студента?

795
00:42:57,000 --> 00:42:59,000
Це не велика проблема. Я можу підтримувати 2 чоловік.

796
00:42:59,000 --> 00:43:03,000
Дозвольте мені піти далі і виділити це і спуститися сюди,

797
00:43:03,000 --> 00:43:09,000
і я можу сказати "ID = 456" для когось, як Роб, який живе в Kirkland.

798
00:43:09,000 --> 00:43:12,000
>> Гаразд, почекай, але я не можу назвати це те ж саме,

799
00:43:12,000 --> 00:43:15,000
і, схоже, я буду мати, щоб скопіювати це,

800
00:43:15,000 --> 00:43:19,000
так що дозвольте мені сказати, що це будуть змінні Давида,

801
00:43:19,000 --> 00:43:23,000
і дозвольте мені отримати копії цих Роба.

802
00:43:23,000 --> 00:43:27,000
Ми називаємо ці Роба, але це не буде працювати зараз

803
00:43:27,000 --> 00:43:33,000
тому що я-почекайте, давайте змінимо мене id1, name1 і House1.

804
00:43:33,000 --> 00:43:35,000
Роб буде 2, 2.

805
00:43:35,000 --> 00:43:42,000
Я повинен змінити це тут, тут, тут, тут, тут, тут.

806
00:43:42,000 --> 00:43:45,000
Зачекайте, а як же Томмі? Давайте зробимо це знову.

807
00:43:45,000 --> 00:43:49,000
Очевидно, що якщо ви все ще думаєте, що це хороший спосіб зробити це, це не так,

808
00:43:49,000 --> 00:43:52,000
так копіювати / вставити погано.

809
00:43:52,000 --> 00:43:55,000
Але ми вирішили цю неділю тому.

810
00:43:55,000 --> 00:43:59,000
>> Що це було наше рішення, коли ми хотіли мати кілька примірників одного і того ж типу даних?

811
00:43:59,000 --> 00:44:01,000
[Студенти] масиву.

812
00:44:01,000 --> 00:44:03,000
Масиву, так що дозвольте мені спробувати очистити це.

813
00:44:03,000 --> 00:44:07,000
Дозвольте мені зробити декілька номерів для себе на вершині, і дозвольте мені замість цього тут.

814
00:44:07,000 --> 00:44:12,000
Ми називаємо цих людей, а замість цього я збираюся сказати "Int ідентифікатори"

815
00:44:12,000 --> 00:44:14,000
і я збираюся підтримати 3 із нас в даний час.

816
00:44:14,000 --> 00:44:18,000
Я збираюся сказати "рядок імен", і я буду підтримувати 3 з нас,

817
00:44:18,000 --> 00:44:22,000
і тоді я буду говорити "рядок будинку", і я буду підтримувати 3 з нас.

818
00:44:22,000 --> 00:44:26,000
Тепер тут замість Давида отримувати свої локальні змінні

819
00:44:26,000 --> 00:44:28,000
Ми можемо позбавитися від них.

820
00:44:28,000 --> 00:44:30,000
Це відчуває себе добре, що ми очистка це.

821
00:44:30,000 --> 00:44:35,000
Потім я можу сказати Девід буде [0] і імен [0]

822
00:44:35,000 --> 00:44:38,000
і вдома [0].

823
00:44:38,000 --> 00:44:41,000
А потім Роб аналогічно можна заощадити на цьому.

824
00:44:41,000 --> 00:44:46,000
Давайте поставимо це тут, так що він збирається бути довільно ідентифікаторів [1].

825
00:44:46,000 --> 00:44:50,000
Він збирається бути імена [1],

826
00:44:50,000 --> 00:44:53,000
, А потім, нарешті, вдома [1].

827
00:44:53,000 --> 00:44:57,000
>> Ще трохи втомлює, і тепер у мене є, щоб зрозуміти це,

828
00:44:57,000 --> 00:45:03,000
так скажемо, "імена [0], ID [0], будинки [0],

829
00:45:03,000 --> 00:45:06,000
і давайте множині це.

830
00:45:06,000 --> 00:45:09,000
Ідентифікатори, ідентифікатори, ідентифікатори.

831
00:45:09,000 --> 00:45:12,000
І знову ж таки, я роблю це, так знову, я вже вдаючись до копіювати / вставити знову,

832
00:45:12,000 --> 00:45:14,000
так що шанси є інше рішення тут.

833
00:45:14,000 --> 00:45:18,000
Я, ймовірно, може очистити це далі з петлею або щось на зразок цього,

834
00:45:18,000 --> 00:45:21,000
Коротше кажучи, це трохи краще, але все ще відчуває себе

835
00:45:21,000 --> 00:45:24,000
Я вдаючись до копіювати / вставити, але навіть це, я стверджую,

836
00:45:24,000 --> 00:45:27,000
насправді не принципово правильне рішення, тому що

837
00:45:27,000 --> 00:45:29,000
Що робити, якщо коли-небудь ми вирішимо ви знаєте, що?

838
00:45:29,000 --> 00:45:32,000
Ми дійсно повинні були зберігання адрес електронної пошти для Девіда і Роб

839
00:45:32,000 --> 00:45:34,000
і все інше в цій програмі.

840
00:45:34,000 --> 00:45:36,000
Ми повинні також зберігати телефонні номери.

841
00:45:36,000 --> 00:45:39,000
Ми повинні також зберігати номери екстреного зв'язку.

842
00:45:39,000 --> 00:45:41,000
У нас є всі ці фрагменти даних, які ми хочемо зберегти,

843
00:45:41,000 --> 00:45:43,000
так як ви йдете для цього зробити?

844
00:45:43,000 --> 00:45:46,000
>> Ви оголошуєте інший масив у верхній частині, а потім вручну додати

845
00:45:46,000 --> 00:45:49,000
адресу електронної пошти [0], адресу електронної пошти [1]

846
00:45:49,000 --> 00:45:51,000
для Девіда і Роб і так далі.

847
00:45:51,000 --> 00:45:56,000
Але насправді всього лише припущення, що лежать в основі цієї конструкції

848
00:45:56,000 --> 00:45:59,000
що я використовую системі честі знати, що

849
00:45:59,000 --> 00:46:03,000
[I] в кожному з декількох масивів

850
00:46:03,000 --> 00:46:06,000
Просто так сталося, щоб звернутися до тих же особою,

851
00:46:06,000 --> 00:46:10,000
так [0] в ідентифікаторами це номер 123,

852
00:46:10,000 --> 00:46:13,000
і я буду вважати, що імена [0]

853
00:46:13,000 --> 00:46:16,000
таке ж ім'я людини і вдома [0]

854
00:46:16,000 --> 00:46:21,000
є домом того ж самої людини і так далі для всіх різних масивів, які я створюю.

855
00:46:21,000 --> 00:46:24,000
Але зверніть увагу, що немає ніяких фундаментальних зв'язків

856
00:46:24,000 --> 00:46:27,000
Серед цих 3 частин інформації, номер, ім'я і будинок,

857
00:46:27,000 --> 00:46:32,000
навіть якщо особа ми намагаємося модель в цій програмі не масиви.

858
00:46:32,000 --> 00:46:35,000
Масиви є саме цей програмний спосіб зробити це.

859
00:46:35,000 --> 00:46:38,000
Те, що ми дійсно хочемо, щоб змоделювати в нашій програмі це людина,

860
00:46:38,000 --> 00:46:41,000
як Давид, людина, як Роб, усередині якого

861
00:46:41,000 --> 00:46:46,000
або інкапсуляції це ім'я і ID і вдома.

862
00:46:46,000 --> 00:46:49,000
>> Чи можемо ми якось виразити цю ідею інкапсуляції

863
00:46:49,000 --> 00:46:52,000
, При якому людина має ідентифікатор, назва і будинок

864
00:46:52,000 --> 00:46:55,000
і не вдаватися до дійсності цей хак якої ми тільки що

865
00:46:55,000 --> 00:46:58,000
вірити, що щось кронштейн

866
00:46:58,000 --> 00:47:02,000
відноситься до тієї ж людської сутності в кожному з цих розрізнених масивів?

867
00:47:02,000 --> 00:47:04,000
Ми можемо реально зробити це.

868
00:47:04,000 --> 00:47:08,000
Дозвольте мені піти вище основного на даний момент, і дозвольте мені створити свій власний тип даних

869
00:47:08,000 --> 00:47:10,000
насправді в перший раз.

870
00:47:10,000 --> 00:47:14,000
Ми використовували цю техніку в Scramble,

871
00:47:14,000 --> 00:47:17,000
але тут я збираюся піти далі і створити тип даних,

872
00:47:17,000 --> 00:47:19,000
і ви знаєте, що я збираюся називати це студент або людина,

873
00:47:19,000 --> 00:47:23,000
і я збираюся використовувати ЬурейеЕ для визначення типу.

874
00:47:23,000 --> 00:47:25,000
Я хочу сказати, що це структура,

875
00:47:25,000 --> 00:47:29,000
а потім ця структура матиме тип студента, ми будемо говорити,

876
00:47:29,000 --> 00:47:31,000
хоча це трохи датовані тепер для мене.

877
00:47:31,000 --> 00:47:33,000
Ми говоримо "Int Ідентифікатор».

878
00:47:33,000 --> 00:47:35,000
Ми говоримо "рядок ім'я".

879
00:47:35,000 --> 00:47:37,000
Тоді ми говоримо "Рядок дім"

880
00:47:37,000 --> 00:47:40,000
так що тепер до кінця ці кілька рядків коду

881
00:47:40,000 --> 00:47:45,000
Я тільки що вчив брязкіт, що існує

882
00:47:45,000 --> 00:47:49,000
Тип даних, крім цілих чисел, крім рядків, крім того, в два рази, крім того, поплавці.

883
00:47:49,000 --> 00:47:54,000
>> Станом на даний момент часу рядок 11, в даний час новий тип даних, який називається студентів,

884
00:47:54,000 --> 00:47:58,000
і тепер я можу оголосити змінну будь-який студент я хочу,

885
00:47:58,000 --> 00:48:01,000
так що дозвольте мені прокрутіть вниз для людей.

886
00:48:01,000 --> 00:48:05,000
Тепер я можу позбутися від цього, і я можу повернутися вниз до Давида тут,

887
00:48:05,000 --> 00:48:10,000
і для Девіда я можу реально сказати, що Давид,

888
00:48:10,000 --> 00:48:13,000
можна буквально назвати змінної після себе,

889
00:48:13,000 --> 00:48:16,000
буде тип студента.

890
00:48:16,000 --> 00:48:18,000
Це може здатися трохи дивним, але це не все, що відрізняється

891
00:48:18,000 --> 00:48:22,000
від оголошення щось у вигляді цілого числа або рядки або з плаваючою точкою.

892
00:48:22,000 --> 00:48:24,000
Просто так трапилося, буде називатися студентом зараз,

893
00:48:24,000 --> 00:48:28,000
і якщо я хочу поставити щось всередині цієї структури

894
00:48:28,000 --> 00:48:31,000
У мене тепер є використовувати нову частину синтаксису, але це досить просто,

895
00:48:31,000 --> 00:48:39,000
david.id = 123, david.name = "Давид" у столиці D,

896
00:48:39,000 --> 00:48:42,000
і david.house = "Mather,"

897
00:48:42,000 --> 00:48:46,000
і тепер я можу позбутися від цієї речі тут.

898
00:48:46,000 --> 00:48:51,000
Зверніть увагу, зараз ми переробили наші програми дійсно набагато краще

899
00:48:51,000 --> 00:48:54,000
в тому, що тепер наша програма відображає реальний світ.

900
00:48:54,000 --> 00:48:57,000
>> Там в реальному світі поняття людини або студента.

901
00:48:57,000 --> 00:49:02,000
Тут ми маємо зараз версії C особи або, більш конкретно студента.

902
00:49:02,000 --> 00:49:05,000
Усередині цієї людини ці відповідні характеристики,

903
00:49:05,000 --> 00:49:10,000
ID, ім'я та будинок, так що Роб суті стає те ж саме тут,

904
00:49:10,000 --> 00:49:14,000
так пограбувати студента, а тепер rob.id = 456,

905
00:49:14,000 --> 00:49:17,000
rob.name = "Боб".

906
00:49:17,000 --> 00:49:20,000
Той факт, що змінна називається Rob є свого роду безглуздими.

907
00:49:20,000 --> 00:49:22,000
Ми могли б назвав це х або у, або р.

908
00:49:22,000 --> 00:49:25,000
Ми тільки що назвав його Роб бути семантично послідовним,

909
00:49:25,000 --> 00:49:28,000
але насправді звуть всередині цього самого поля,

910
00:49:28,000 --> 00:49:30,000
так що тепер у мене є.

911
00:49:30,000 --> 00:49:33,000
Це теж не схоже на кращий дизайн в тому, що я жорстко Давида.

912
00:49:33,000 --> 00:49:35,000
Я жорстко Роб.

913
00:49:35,000 --> 00:49:39,000
І я все ще змушені вдаватися до деяких скопіюйте і вставте кожен раз, коли я хочу нових змінних.

914
00:49:39,000 --> 00:49:43,000
Крім того, я повинен по-видимому дати кожній з цих змінних ім'я,

915
00:49:43,000 --> 00:49:46,000
хоча я б волів описати ці змінні

916
00:49:46,000 --> 00:49:48,000
 в більш загальному плані, як студенти.

917
00:49:48,000 --> 00:49:52,000
>> Тепер ми можемо об'єднати ідеї, які працюють добре для нас

918
00:49:52,000 --> 00:49:56,000
і замість цього сказав: "Знаєш що, дай мені змінну звану студентів,

919
00:49:56,000 --> 00:50:01,000
і нехай вас це буде розміром 3 ", так що тепер я можу уточнити це далі,

920
00:50:01,000 --> 00:50:04,000
позбавитися від ручного заявив Давид,

921
00:50:04,000 --> 00:50:08,000
і я можу, а сказати щось подібне студентів [0] тут.

922
00:50:08,000 --> 00:50:11,000
Потім я можу сказати студентів [0] тут,

923
00:50:11,000 --> 00:50:14,000
Студенти [0] Тут і так далі, і я можу ходити

924
00:50:14,000 --> 00:50:16,000
і чистий, що для Роба.

925
00:50:16,000 --> 00:50:19,000
Я міг би також йти про тепер, можливо, додавання петлі

926
00:50:19,000 --> 00:50:23,000
і використання GetString і GetInt насправді отримати ці значення від користувача.

927
00:50:23,000 --> 00:50:27,000
Я міг би йти про додавання постійною, тому що це взагалі погана практика

928
00:50:27,000 --> 00:50:29,000
на жорсткий код деякі довільні числа, як 3 прямо тут

929
00:50:29,000 --> 00:50:33,000
, А потім просто пам'ятайте, що ви повинні поставити не більше 3 студентів в ньому.

930
00:50:33,000 --> 00:50:36,000
Ймовірно, було б краще використовувати # визначити у верхній частині мого файлу

931
00:50:36,000 --> 00:50:40,000
і фактор, який, таким чином, дійсно, дай мені піти далі і узагальнити це.

932
00:50:40,000 --> 00:50:43,000
>> Дозвольте мені відкрити приміром, що серед сьогоднішніх

933
00:50:43,000 --> 00:50:46,000
Приклади заздалегідь, structs1.

934
00:50:46,000 --> 00:50:49,000
Це більш повна програма, яка використовує # визначити тут

935
00:50:49,000 --> 00:50:51,000
і говорить, що ми збираємося мати 3 студентів за замовчуванням.

936
00:50:51,000 --> 00:50:54,000
Тут я оголошенні класу коштує студентів,

937
00:50:54,000 --> 00:50:57,000
так класі студентів, і тепер я з допомогою циклу

938
00:50:57,000 --> 00:51:00,000
тільки, щоб зробити код трохи більш елегантно, заповнити клас

939
00:51:00,000 --> 00:51:05,000
з участю користувача, так ітерації з I = 0 на до студентів, що на 3.

940
00:51:05,000 --> 00:51:07,000
І тоді я запропонувати користувачеві в цій версії

941
00:51:07,000 --> 00:51:10,000
 Що ID студента, і я отримую його з GetInt.

942
00:51:10,000 --> 00:51:13,000
Що ім'я студента, а потім отримати його з GetString.

943
00:51:13,000 --> 00:51:15,000
Що домі студента? Я отримую його з GetString.

944
00:51:15,000 --> 00:51:19,000
А потім у нижній тут я просто вирішив змінити

945
00:51:19,000 --> 00:51:22,000
як я друкую ці, і насправді використовувати цикл,

946
00:51:22,000 --> 00:51:24,000
І хто я печаткою?

947
00:51:24,000 --> 00:51:27,000
Відповідно до коментарем я друкую нікому в Mather,

948
00:51:27,000 --> 00:51:30,000
і ось саме тому Роб і Томмі і так далі, насправді Томмі в Mather.

949
00:51:30,000 --> 00:51:34,000
Томмі і Девід будуть надруковані в цьому випадку, але як це працює?

950
00:51:34,000 --> 00:51:40,000
Ми не бачили цю функцію раніше, але зробити припущення про те, що це робить.

951
00:51:40,000 --> 00:51:42,000
Порівнює рядки.

952
00:51:42,000 --> 00:51:45,000
>> Це трохи неочевидним, як він порівнює рядки, тому що виявляється,

953
00:51:45,000 --> 00:51:49,000
якщо вона повертає 0, що означає, що рядки дорівнюють.

954
00:51:49,000 --> 00:51:53,000
Якщо вона повертає -1, що означає, що людина приходить в алфавітному порядку перед іншими,

955
00:51:53,000 --> 00:51:57,000
і якщо вона повертає +1, що означає слово приходить іншої в алфавітному порядку

956
00:51:57,000 --> 00:52:00,000
перед іншими, і ви можете дивитися онлайн або в довідкову сторінку

957
00:52:00,000 --> 00:52:04,000
, Щоб побачити, який саме спосіб яку, але все це зараз робить це говорить

958
00:52:04,000 --> 00:52:09,000
якщо [I]. Будинок одно "Мазер"

959
00:52:09,000 --> 00:52:13,000
потім піти далі і роздрукувати так і так знаходиться в Mather.

960
00:52:13,000 --> 00:52:16,000
Але ось те, що ми раніше не бачили, і ми повернемося до цього.

961
00:52:16,000 --> 00:52:21,000
Я не пам'ятаю, ніколи не маючи для цього ні в одній з моїх програм.

962
00:52:21,000 --> 00:52:24,000
Безкоштовні мабуть посиланням на пам'ять, звільняючи оперативну пам'ять,

963
00:52:24,000 --> 00:52:31,000
але те, що пам'ять я мабуть звільнення в цьому циклі в нижній частині цієї програми?

964
00:52:31,000 --> 00:52:34,000
Схоже, я звільняючи ім'я людини

965
00:52:34,000 --> 00:52:37,000
і будинок людини, але навіщо це?

966
00:52:37,000 --> 00:52:41,000
>> Виявляється, всі ці тижні, що ви використовуєте GetString

967
00:52:41,000 --> 00:52:45,000
Ми видів впроваджує помилку в кожній з ваших програм.

968
00:52:45,000 --> 00:52:51,000
GetString пам'яттю дизайн виділяє так що він може повернутися до вас рядки,

969
00:52:51,000 --> 00:52:55,000
подібно до Давида, і Роб, і ви можете робити все, що ви хочете

970
00:52:55,000 --> 00:52:59,000
з цього рядка в програмі, тому що ми захищені пам'яті для вас.

971
00:52:59,000 --> 00:53:02,000
Проблема в тому, весь цей час кожен раз, коли ви дзвоните GetString

972
00:53:02,000 --> 00:53:05,000
Ми, автори GetString, запитували операційної системи

973
00:53:05,000 --> 00:53:07,000
, Щоб дати нам трохи оперативної пам'яті для цього рядка.

974
00:53:07,000 --> 00:53:09,000
Дайте нам трохи ОЗУ для наступного рядка.

975
00:53:09,000 --> 00:53:11,000
Дайте нам трохи більше оперативної пам'яті для наступного рядка.

976
00:53:11,000 --> 00:53:13,000
Те, що ви програміст, ніколи не робив

977
00:53:13,000 --> 00:53:15,000
дає нам, що пам'ять назад,

978
00:53:15,000 --> 00:53:17,000
Таким чином, для цих декількох тижнів всі програми, ви написали

979
00:53:17,000 --> 00:53:20,000
було те, що називається пам'яттю стрибок якої вони продовжують використовувати

980
00:53:20,000 --> 00:53:24,000
більше і більше пам'яті при кожному виклику GetString, і це нормально.

981
00:53:24,000 --> 00:53:27,000
Ми свідомо робимо, що в перші тижні, тому що це не цікаво

982
00:53:27,000 --> 00:53:29,000
, Щоб турбуватися про те, де рядки і звідки.

983
00:53:29,000 --> 00:53:34,000
Все, що ви хочете це слово Робу повернутися, коли користувач вводить його дюйма

984
00:53:34,000 --> 00:53:38,000
>> Але рух вперед у нас тепер є, щоб почати отримувати більш складні з цього приводу.

985
00:53:38,000 --> 00:53:42,000
Кожен раз, коли ми виділяємо пам'ять, ми краще в кінцевому підсумку передати його назад.

986
00:53:42,000 --> 00:53:45,000
В іншому випадку в реальному світі на вашому Mac або PC ви, можливо, іноді досвідчені

987
00:53:45,000 --> 00:53:50,000
Симптоми, де ваш комп'ютер зависає в кінцевому підсумку

988
00:53:50,000 --> 00:53:54,000
чи дурний обертовий куля пляж знаходиться всього займають комп'ютера

989
00:53:54,000 --> 00:53:56,000
всі увагу, і ви не можете робити речі.

990
00:53:56,000 --> 00:54:00,000
Це можна пояснити будь-яку кількість помилок, але серед тих, можливі помилки

991
00:54:00,000 --> 00:54:03,000
які, що називається витік пам'яті якої той, хто писав, що частина програмного забезпечення

992
00:54:03,000 --> 00:54:07,000
Ви використовуєте не пам'ятаю, щоб звільнити пам'ять

993
00:54:07,000 --> 00:54:10,000
що він або вона попросила операційної системи для,

994
00:54:10,000 --> 00:54:14,000
не використовується GetString, тому що це CS50 річ, але з використанням аналогічних функцій

995
00:54:14,000 --> 00:54:16,000
запитаєте, що операційна система на пам'ять.

996
00:54:16,000 --> 00:54:19,000
Якщо ви або вони зіпсувати і ніколи не повернуться, що пам'ять

997
00:54:19,000 --> 00:54:24,000
симптом, який може бути те, що програма сповільнюється і сповільнюється і сповільнюється

998
00:54:24,000 --> 00:54:26,000
якщо ви пам'ятаєте, щоб подзвонити безкоштовно.

999
00:54:26,000 --> 00:54:28,000
>> Ми повернемося, коли і чому ви могли б назвати вільним,

1000
00:54:28,000 --> 00:54:32,000
Але давайте йти вперед тільки для хорошої заходом і спробуйте запустити цю конкретну програму.

1001
00:54:32,000 --> 00:54:35,000
Це називається structs1, введіть.

1002
00:54:35,000 --> 00:54:40,000
Дозвольте мені йти вперед і працювати structs1, 123, David Mather,

1003
00:54:40,000 --> 00:54:47,000
456, Rob Kirkland, 789,

1004
00:54:47,000 --> 00:54:50,000
Томмі Mather, і ми бачимо Давида в Mather, Томмі в Mather.

1005
00:54:50,000 --> 00:54:53,000
Це всього лише маленька перевірка осудності, що програма працює.

1006
00:54:53,000 --> 00:54:56,000
Зараз, на жаль, ця програма є трохи засмучує в тому, що

1007
00:54:56,000 --> 00:55:00,000
Я зробив усе, що робота, я набрав в 9 різних рядків, натисніть Enter,

1008
00:55:00,000 --> 00:55:04,000
сказали, хто був у Mather, але, очевидно, я не знав, хто був у Mather вже тому, що я набрав його.

1009
00:55:04,000 --> 00:55:07,000
Було б щонайменше непогано, якби ця програма більше схожа на базу даних

1010
00:55:07,000 --> 00:55:10,000
і він дійсно пам'ятає, що я набрав в

1011
00:55:10,000 --> 00:55:12,000
так що я ніколи більше не доведеться вводити ці записи студентів.

1012
00:55:12,000 --> 00:55:15,000
Може бути, це як registrarial системи.

1013
00:55:15,000 --> 00:55:21,000
>> Ми можемо зробити це за допомогою цього методу, відомого як файловий ввід / вивід, файлового вводу і виводу,

1014
00:55:21,000 --> 00:55:24,000
Дуже загальний спосіб сказати, що в будь-який час ви хочете читати файли або записати файли

1015
00:55:24,000 --> 00:55:26,000
Ви можете зробити це з певним набором функцій.

1016
00:55:26,000 --> 00:55:29,000
Дозвольте мені йти вперед і відкрити цей приклад structs2.c,

1017
00:55:29,000 --> 00:55:33,000
які майже ідентичні, але давайте подивимося, що він зараз робить.

1018
00:55:33,000 --> 00:55:36,000
У верхній частині файлу я оголосити клас студентів.

1019
00:55:36,000 --> 00:55:38,000
Я тоді заповнення класу з користувальницьким введенням,

1020
00:55:38,000 --> 00:55:41,000
так що ті рядки коду так само, як і раніше.

1021
00:55:41,000 --> 00:55:45,000
Тоді, якщо я прокрутіть вниз тут я друкую всі, хто знаходиться в Mather довільно, як і раніше,

1022
00:55:45,000 --> 00:55:47,000
Але це цікава нова функція.

1023
00:55:47,000 --> 00:55:51,000
Ці рядки коду є новими, і вони вносять щось тут,

1024
00:55:51,000 --> 00:55:55,000
FILE, усі великі, і вона має * тут також.

1025
00:55:55,000 --> 00:55:58,000
Дозвольте мені перенести цей сюди, * тут також.

1026
00:55:58,000 --> 00:56:00,000
>> Ця функція, яку ми раніше не бачили, Еореп,

1027
00:56:00,000 --> 00:56:03,000
але це означає відкриття файлу, так що давайте побіжно цим,

1028
00:56:03,000 --> 00:56:05,000
і це те, що ми повернемося в майбутньому psets,

1029
00:56:05,000 --> 00:56:10,000
але ця лінія тут по суті відкриває файл з ім'ям бази даних,

1030
00:56:10,000 --> 00:56:13,000
і це виразно відкриває його таким чином, що він може робити все, що з ним?

1031
00:56:13,000 --> 00:56:15,000
[Нерозбірливо-студент]

1032
00:56:15,000 --> 00:56:19,000
Право, таким чином, "W" означає лише те це говорить операційної системи

1033
00:56:19,000 --> 00:56:21,000
відкрити цей файл таким чином, що я можу написати до нього.

1034
00:56:21,000 --> 00:56:23,000
Я не хочу, щоб прочитати його. Я не хочу, щоб просто подивитися на неї.

1035
00:56:23,000 --> 00:56:26,000
Я хочу змінити і додати матеріал потенційно до нього,

1036
00:56:26,000 --> 00:56:28,000
і файл буде називатися базою даних.

1037
00:56:28,000 --> 00:56:30,000
Це можна назвати що завгодно.

1038
00:56:30,000 --> 00:56:32,000
Це може бути database.txt. Це могло б бути. Дб.

1039
00:56:32,000 --> 00:56:37,000
Це може бути слово, як Foo, але я довільно вибрав ім'я файлу бази даних.

1040
00:56:37,000 --> 00:56:42,000
Це трохи перевірку осудності, що ми повернемося до дуже докладно з плином часу,

1041
00:56:42,000 --> 00:56:47,000
Якщо FP, для покажчика файлу, не одно NULL, що означає, що все добре.

1042
00:56:47,000 --> 00:56:51,000
>> Коротше кажучи, такі функції, як Еореп іноді зазнають невдачі.

1043
00:56:51,000 --> 00:56:53,000
Можливо, файл не існує. Може бути, ви з дискового простору.

1044
00:56:53,000 --> 00:56:55,000
Може бути, ви не маєте прав доступу до цієї папки,

1045
00:56:55,000 --> 00:56:58,000
так що якщо Еореп повертає нульове щось погане сталося.

1046
00:56:58,000 --> 00:57:02,000
І навпаки, якщо Еореп не повертає нульове все добре

1047
00:57:02,000 --> 00:57:04,000
і я можу почати писати в цей файл.

1048
00:57:04,000 --> 00:57:06,000
Ось новий трюк.

1049
00:57:06,000 --> 00:57:08,000
Це цикл який ітерації по кожному з моїх студентів,

1050
00:57:08,000 --> 00:57:10,000
і це виглядає так схожі на те, що ми робили раніше,

1051
00:57:10,000 --> 00:57:15,000
але ця функція є двоюрідним братом Printf називається Fprintf для файлу Printf,

1052
00:57:15,000 --> 00:57:18,000
і помітите, що він відрізняється тільки 2 шляхи.

1053
00:57:18,000 --> 00:57:20,000
По-перше, він починається з F замість р,

1054
00:57:20,000 --> 00:57:23,000
але тоді її першим аргументом є те, що видиме?

1055
00:57:23,000 --> 00:57:25,000
[Студенти] файлу. >> Це файл.

1056
00:57:25,000 --> 00:57:30,000
Це те, що називається FP, який ми в кінці кінців дражнять один від одного, що файл покажчика,

1057
00:57:30,000 --> 00:57:35,000
але зараз FP являє собою просто файл, який я відкрив,

1058
00:57:35,000 --> 00:57:41,000
так Fprintf тут говорять роздрукувати ID цього користувача до файлу, а не на екран.

1059
00:57:41,000 --> 00:57:44,000
Роздрукувати ім'я користувача в файл, а не на екран,

1060
00:57:44,000 --> 00:57:47,000
Будинок в файл, а не на екрані, а потім тут, очевидно,

1061
00:57:47,000 --> 00:57:50,000
закрити файл, а потім сюди безкоштовний пам'яті.

1062
00:57:50,000 --> 00:57:53,000
>> Єдина різниця між цією версії 2 і версії 1

1063
00:57:53,000 --> 00:57:58,000
є введення Еореп і це файл з розширенням *

1064
00:57:58,000 --> 00:58:01,000
і це поняття Fprintf, так що давайте подивимося, що кінцевий результат.

1065
00:58:01,000 --> 00:58:03,000
Відпустіть мене в моєму вікні терміналу.

1066
00:58:03,000 --> 00:58:06,000
Дозвольте мені виконати structs2, введіть.

1067
00:58:06,000 --> 00:58:09,000
Схоже, все буде добре. Давайте повторно structs2.

1068
00:58:09,000 --> 00:58:15,000
123, David Mather, 456, Rob Kirkland,

1069
00:58:15,000 --> 00:58:19,000
789, Томмі Mather, введіть.

1070
00:58:19,000 --> 00:58:23,000
Схоже, він вів себе так само, але якщо я зараз роблю Ls

1071
00:58:23,000 --> 00:58:28,000
помітите, що файл знаходиться тут серед усіх мій код, бази даних,

1072
00:58:28,000 --> 00:58:32,000
так давайте відкриємо, що Gedit бази даних, і дивитися на це.

1073
00:58:32,000 --> 00:58:34,000
Це не найсексуальніший форматів файлів.

1074
00:58:34,000 --> 00:58:38,000
Це насправді одна частина даних лінії на лінію за лінією,

1075
00:58:38,000 --> 00:58:42,000
але ті з вас, хто використовує Excel або CSV файлів, значення, розділені комами,

1076
00:58:42,000 --> 00:58:47,000
Я міг би, звичайно, використовувати Fprintf замість цього, може бути, зробити щось на зразок цього

1077
00:58:47,000 --> 00:58:50,000
так що я міг фактично створити еквівалент файл Excel

1078
00:58:50,000 --> 00:58:53,000
шляхом відділення речі з комами, а не тільки нових ліній.

1079
00:58:53,000 --> 00:58:56,000
>> У цьому випадку, якщо б замість цього використовувати коми замість нових ліній

1080
00:58:56,000 --> 00:59:01,000
Я міг буквально відкрити цей файл бази даних в Excel, якщо я замість цього зробив його схожим на це.

1081
00:59:01,000 --> 00:59:03,000
Коротше кажучи, тепер, коли у нас є сили, щоб писати файли

1082
00:59:03,000 --> 00:59:07,000
Тепер ми можемо почати збереження даних, зберігаючи його на диск навколо

1083
00:59:07,000 --> 00:59:10,000
так що ми можемо зберігати інформацію навколо знову і знову.

1084
00:59:10,000 --> 00:59:14,000
Зверніть увагу на кілька інших речей, які зараз трохи більш знайоме.

1085
00:59:14,000 --> 00:59:16,000
У верхній частині цього файлу C ми маємо ЬурейеЕ

1086
00:59:16,000 --> 00:59:21,000
тому що ми хотіли створити тип даних, який являє собою слово,

1087
00:59:21,000 --> 00:59:25,000
так що цей тип називається словом, а всередині цієї структури

1088
00:59:25,000 --> 00:59:27,000
це трохи любитель зараз.

1089
00:59:27,000 --> 00:59:30,000
Чому слово складається з видимому масиву?

1090
00:59:30,000 --> 00:59:33,000
Що таке слово просто інтуїтивно?

1091
00:59:33,000 --> 00:59:35,000
>> Це масив символів.

1092
00:59:35,000 --> 00:59:37,000
Це послідовність символів, спина до спини до спини.

1093
00:59:37,000 --> 00:59:41,000
ЛИСТИ великими літерами, трапляється, ми як завгодно говорити максимальної довжини

1094
00:59:41,000 --> 00:59:44,000
будь-яке слово в словник, який ми використовуємо для Scramble.

1095
00:59:44,000 --> 00:59:46,000
Чому я +1?

1096
00:59:46,000 --> 00:59:48,000
Нульовий символ.

1097
00:59:48,000 --> 00:59:51,000
Нагадаємо, коли ми робили наприклад Bananagrams ми повинні особливе значення

1098
00:59:51,000 --> 00:59:55,000
В кінці слово для того, щоб відслідковувати

1099
00:59:55,000 --> 00:59:59,000
, Де слова насправді закінчилися, і як специфікація проблема набору говорить

1100
00:59:59,000 --> 01:00:03,000
Тут ми спілкування з даним словом логічне значення,

1101
01:00:03,000 --> 01:00:05,000
Прапор, так би мовити, істинним або хибним.

1102
01:00:05,000 --> 01:00:09,000
Чи знайшли ви це слово вже, бо ми розуміємо,

1103
01:00:09,000 --> 01:00:13,000
ми дійсно потребуємо спосіб запам'ятовування не лише те, що слово є в Scramble

1104
01:00:13,000 --> 01:00:15,000
але ви чи ні, людини, знайшли його

1105
01:00:15,000 --> 01:00:20,000
так що якщо ви знайдете слово "" Ви не можете просто ввести, вводити, вводити, введіть

1106
01:00:20,000 --> 01:00:23,000
і отримаєте 3 бали, 3 бали, 3 бали, 3 бали.

1107
01:00:23,000 --> 01:00:26,000
Ми хочемо мати можливість в чорний список, що слово, встановивши логічне

1108
01:00:26,000 --> 01:00:29,000
істинно, якщо ви вже знайшли його, і саме тому ми

1109
01:00:29,000 --> 01:00:31,000
інкапсульовані його в цю структуру.

1110
01:00:31,000 --> 01:00:35,000
>> Зараз, тут, в Scramble є ця інша структура називається словником.

1111
01:00:35,000 --> 01:00:39,000
При відсутності тут є слово ЬурейеЕ, тому що в цьому випадку

1112
01:00:39,000 --> 01:00:43,000
ми повинні інкапсулювати Ідея словника,

1113
01:00:43,000 --> 01:00:46,000
і словник містить цілу купу слів,

1114
01:00:46,000 --> 01:00:49,000
як випливає з цього масиву, і як багато з цих слів?

1115
01:00:49,000 --> 01:00:51,000
Ну, що б ця змінна розміром говорить.

1116
01:00:51,000 --> 01:00:53,000
Але нам просто потрібно один словник.

1117
01:00:53,000 --> 01:00:55,000
Нам не потрібні типи даних називаються словник.

1118
01:00:55,000 --> 01:00:58,000
Нам потрібно всього лише одне з них, так виходить в C

1119
01:00:58,000 --> 01:01:03,000
що, якщо ви не говорите ЬурейеЕ, ви просто говорите структури, то у фігурних дужках

1120
01:01:03,000 --> 01:01:05,000
Ви ставите ваші змінні, то ви ставите ім'я.

1121
01:01:05,000 --> 01:01:09,000
Це оголошення однієї змінної називається словник

1122
01:01:09,000 --> 01:01:11,000
який виглядає наступним чином.

1123
01:01:11,000 --> 01:01:16,000
З іншого боку, ці лінії створення багаторазових структура даних називається словом

1124
01:01:16,000 --> 01:01:19,000
що ви можете створити кілька копій, так само, як ми створили

1125
01:01:19,000 --> 01:01:22,000
кілька копій студентів.

1126
01:01:22,000 --> 01:01:24,000
>> Що це в кінцевому підсумку дозволить нам робити?

1127
01:01:24,000 --> 01:01:30,000
Дозвольте мені повернутися в, скажімо так, більш простий приклад з більш простих часів,

1128
01:01:30,000 --> 01:01:34,000
і дозвольте мені відкрити, скажімо, compare1.c.

1129
01:01:34,000 --> 01:01:38,000
Проблема тут в руках насправді відігніть

1130
01:01:38,000 --> 01:01:41,000
шар рядок і почати зліт цих навчальних класах

1131
01:01:41,000 --> 01:01:44,000
тому що виходить, що рядок весь цей час

1132
01:01:44,000 --> 01:01:47,000
є, як ми і обіцяли на тиждень 1 дійсно тільки прізвисько,

1133
01:01:47,000 --> 01:01:51,000
Синонім від CS50 бібліотеки за те, що виглядає трохи більш загадковим,

1134
01:01:51,000 --> 01:01:53,000
символ *, і ми бачили цю зірку раніше.

1135
01:01:53,000 --> 01:01:55,000
Ми бачили це в контексті файли.

1136
01:01:55,000 --> 01:01:59,000
>> Давайте подивимося, чому ми приховували цю деталь протягом деякого часу.

1137
01:01:59,000 --> 01:02:02,000
Ось файл з ім'ям compare1.c,

1138
01:02:02,000 --> 01:02:07,000
і він, очевидно, пропонує користувачеві на 2 рядки, з і т,

1139
01:02:07,000 --> 01:02:11,000
а потім він намагається порівняти ці рядки рівності в рядку 26,

1140
01:02:11,000 --> 01:02:14,000
і якщо вони рівні вона каже: "Ви набрали одне і те ж»,

1141
01:02:14,000 --> 01:02:17,000
і якщо вони не рівні вона каже: "Ви ввели різні речі".

1142
01:02:17,000 --> 01:02:19,000
Дозвольте мені йти вперед і запустити цю програму.

1143
01:02:19,000 --> 01:02:23,000
Відпустіть мене в мій вихідний каталог, зробити compare1. Він складений в порядку.

1144
01:02:23,000 --> 01:02:25,000
Дозвольте мені виконати compare1.

1145
01:02:25,000 --> 01:02:27,000
Я буду збільшувати, введіть.

1146
01:02:27,000 --> 01:02:29,000
Скажи що-небудь. HELLO.

1147
01:02:29,000 --> 01:02:32,000
Я скажу щось знову. HELLO.

1148
01:02:32,000 --> 01:02:34,000
Я безумовно не вводити різні речі.

1149
01:02:34,000 --> 01:02:37,000
>> Дозвольте мені спробувати це знову. BYE BYE.

1150
01:02:37,000 --> 01:02:40,000
Безумовно не відрізняється, так що тут відбувається?

1151
01:02:40,000 --> 01:02:44,000
Ну, те, що дійсно в порівнянні в рядку 26?

1152
01:02:44,000 --> 01:02:46,000
[Нерозбірливо-студент]

1153
01:02:46,000 --> 01:02:49,000
Так, так виходить, що рядок, тип даних, це свого роду брехня для порятунку.

1154
01:02:49,000 --> 01:02:53,000
Рядок символів *, але те, що символ *?

1155
01:02:53,000 --> 01:02:56,000
Символ *, як кажуть, є дороговказом,

1156
01:02:56,000 --> 01:03:00,000
і покажчик ефективно адресу,

1157
01:03:00,000 --> 01:03:05,000
Сума місце в пам'яті, і, якщо вам трапиться ввели в слово, як HELLO,

1158
01:03:05,000 --> 01:03:08,000
Нагадаємо минулих обговорень рядків

1159
01:03:08,000 --> 01:03:16,000
це схоже на слово HELLO.

1160
01:03:16,000 --> 01:03:19,000
Пам'ятайте, що слово, як ПРИВІТ можуть бути представлені

1161
01:03:19,000 --> 01:03:22,000
як масив символів, як це

1162
01:03:22,000 --> 01:03:25,000
а потім за допомогою спеціального символу в кінці званий нульовий символ,

1163
01:03:25,000 --> 01:03:27,000
як \ позначає.

1164
01:03:27,000 --> 01:03:29,000
Що насправді є рядком?

1165
01:03:29,000 --> 01:03:32,000
Зауважимо, що це кілька ділянок пам'яті,

1166
01:03:32,000 --> 01:03:36,000
і справді, кінець відомо тільки, якщо подивитися весь рядок

1167
01:03:36,000 --> 01:03:38,000
шукає особливий характер нульовий.

1168
01:03:38,000 --> 01:03:41,000
Але якщо це шматок пам'яті з мого комп'ютера,

1169
01:03:41,000 --> 01:03:44,000
Давайте довільно сказати, що цей рядок просто повезло,

1170
01:03:44,000 --> 01:03:47,000
і він, були влаштовані на самому початку оперативної пам'яті мого комп'ютера.

1171
01:03:47,000 --> 01:03:54,000
Це байт 0, 1, 2, 3, 4, 5, 6 ...

1172
01:03:54,000 --> 01:04:02,000
>> Коли я кажу щось на зразок GetString і я рядок S = GetString

1173
01:04:02,000 --> 01:04:04,000
що насправді повертаються?

1174
01:04:04,000 --> 01:04:08,000
За ці останні кілька тижнів, що насправді зберігається в и

1175
01:04:08,000 --> 01:04:13,000
Чи не цей рядок сама по собі, але в даному випадку те, що зберігається є

1176
01:04:13,000 --> 01:04:18,000
число 0, так що насправді робить GetString

1177
01:04:18,000 --> 01:04:20,000
воно фізично не повертати рядок.

1178
01:04:20,000 --> 01:04:22,000
Це навіть не реально зробити концептуальному сенсі.

1179
01:04:22,000 --> 01:04:24,000
Що вона робить повернення числа.

1180
01:04:24,000 --> 01:04:28,000
Це число є адресою ПРИВІТ в пам'яті,

1181
01:04:28,000 --> 01:04:32,000
і рядок з потом, якщо ми відігніть цей шар, рядок насправді не існує.

1182
01:04:32,000 --> 01:04:35,000
Це всього лише спрощення CS50 бібліотеки.

1183
01:04:35,000 --> 01:04:38,000
>> Це дійсно те, що називається символ *.

1184
01:04:38,000 --> 01:04:41,000
Char має сенс, тому що слово, як Алло?

1185
01:04:41,000 --> 01:04:44,000
Ну, це серія символів, набір символів.

1186
01:04:44,000 --> 01:04:47,000
Char * означає, що адреса характеру,

1187
01:04:47,000 --> 01:04:50,000
так що це означає для повернення рядки?

1188
01:04:50,000 --> 01:04:53,000
Хороший, простий спосіб повернення рядка

1189
01:04:53,000 --> 01:04:57,000
є, а не намагатися з'ясувати, як я повертаюся в 5 або 6 різних байтів

1190
01:04:57,000 --> 01:05:01,000
Дозвольте мені повернутися на адресу якого байт?

1191
01:05:01,000 --> 01:05:03,000
Перший.

1192
01:05:03,000 --> 01:05:06,000
Іншими словами, дозвольте мені дати вам адресу символу в пам'яті.

1193
01:05:06,000 --> 01:05:10,000
Ось що символ * являє собою, на адресу одного символу в пам'яті.

1194
01:05:10,000 --> 01:05:12,000
Викличте цю змінну с.

1195
01:05:12,000 --> 01:05:15,000
Зберігати зокрема, що з адреси, який я умовно сказав дорівнює 0,

1196
01:05:15,000 --> 01:05:19,000
тільки, щоб тримати речі простими, але насправді це взагалі великі числа.

1197
01:05:19,000 --> 01:05:21,000
>> Зачекайте хвилину.

1198
01:05:21,000 --> 01:05:23,000
Якщо ви тільки що дали мені адресу першого символу, як я знаю, що адреса

1199
01:05:23,000 --> 01:05:25,000
другий персонаж, третій, четвертий і п'ятий?

1200
01:05:25,000 --> 01:05:27,000
[Нерозбірливо-студент]

1201
01:05:27,000 --> 01:05:31,000
Ви тільки знаєте, де в кінці рядка через цей зручний трюк,

1202
01:05:31,000 --> 01:05:35,000
тому, коли ви використовуєте щось подібне Printf, що Printf буквально бере в якості аргументу,

1203
01:05:35,000 --> 01:05:39,000
Нагадаємо, що ми використовуємо заповнювач% з цим, а потім перейти в

1204
01:05:39,000 --> 01:05:41,000
змінної, яка зберігання рядка.

1205
01:05:41,000 --> 01:05:47,000
Те, що ви дійсно проходить це адреса першого символу цього рядка.

1206
01:05:47,000 --> 01:05:50,000
Printf потім використовується для циклу або час циклу при отриманні цією адресою,

1207
01:05:50,000 --> 01:05:53,000
Наприклад, 0, так що дозвольте мені зробити це зараз,

1208
01:05:53,000 --> 01:06:02,000
Е ("% з \ п", з);

1209
01:06:02,000 --> 01:06:07,000
Коли я називаю Е ("% з \ п", з); що я дійсно наданні Printf з

1210
01:06:07,000 --> 01:06:13,000
це адреса першого символу в S, яке в цьому випадку є довільним H.

1211
01:06:13,000 --> 01:06:16,000
>> Як Printf знати, що саме для відображення на екрані?

1212
01:06:16,000 --> 01:06:19,000
Людина, яка реалізується Printf реалізований цикл під час або цикл

1213
01:06:19,000 --> 01:06:23,000
, Що говорить ця характер дорівнює спеціальний символ NULL?

1214
01:06:23,000 --> 01:06:25,000
Якщо ні, то роздрукувати його. Як щодо цього?

1215
01:06:25,000 --> 01:06:28,000
Якщо не друкувати, друкувати, друкувати, друкувати.

1216
01:06:28,000 --> 01:06:32,000
О, це одне особливе. Зупиніть друк і повернутися до користувача.

1217
01:06:32,000 --> 01:06:35,000
І ось буквально все, що відбувалося під капотом,

1218
01:06:35,000 --> 01:06:38,000
і що це багато, щоб переварити в перший день класу,

1219
01:06:38,000 --> 01:06:43,000
але зараз це дійсно будівельний блок розумінні всі

1220
01:06:43,000 --> 01:06:46,000
, Який був відбувається всередині пам'яті нашого комп'ютера,

1221
01:06:46,000 --> 01:06:49,000
і в кінцевому підсумку ми будемо дражнити цього один від одного з невеликою допомогою

1222
01:06:49,000 --> 01:06:51,000
в одного з наших друзів в Стенфорді.

1223
01:06:51,000 --> 01:06:56,000
>> Професор Нік Parlante в Стенфорді зробили цей чудовий відеоряд

1224
01:06:56,000 --> 01:06:58,000
від усіх видів різних мов, які ввели

1225
01:06:58,000 --> 01:07:00,000
ця маленька Бінки характер Claymation.

1226
01:07:00,000 --> 01:07:03,000
Голос ви почуєте всього кілька секунд перегляду підлабузника

1227
01:07:03,000 --> 01:07:05,000
є те, що професор Стенфорда, і ви отримуєте

1228
01:07:05,000 --> 01:07:07,000
Тільки 5 або 6 секунд це прямо зараз,

1229
01:07:07,000 --> 01:07:09,000
Але це до відома, на яких ми закінчимо сьогодні

1230
01:07:09,000 --> 01:07:11,000
і почати в середу.

1231
01:07:11,000 --> 01:07:15,000
Я даю вам Покажчик Fun з Бінки, попередній перегляд.

1232
01:07:15,000 --> 01:07:18,000
[♪ Музика ♪] [Професор Parlante] Гей, Бінки.

1233
01:07:18,000 --> 01:07:21,000
Прокинься. Це час для покажчика весело.

1234
01:07:21,000 --> 01:07:24,000
[Бінки] Що це? Дізнатися про покажчиків?

1235
01:07:24,000 --> 01:07:26,000
О, сентиментальний!

1236
01:07:26,000 --> 01:07:29,000
>> Ми будемо бачити Вас в середу.

1237
01:07:29,000 --> 01:07:32,000
[CS50.TV]