1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Седмица 4]

2
00:00:03,000 --> 00:00:05,000
[Дейвид Дж. Малан] [Харвардския университет]

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, Big Омега,

30
00:01:56,000 --> 00:02:00,000
и понякога Big 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
на вложените материали, което ние обикновено наричаме N, каквото може да има проблем,

35
00:02:11,000 --> 00:02:13,000
където N е броят на хората в стаята,

36
00:02:13,000 --> 00:02:17,000
броя на страници в телефонния указател, и ние започнахме да пишем за неща,

37
00:02:17,000 --> 00:02:21,000
като O (N ^ 2) или O (N) или O (N дневник н),

38
00:02:21,000 --> 00:02:24,000
и дори когато математиката не е съвсем работи толкова перфектно

39
00:02:24,000 --> 00:02:28,000
и това е н ² - N / 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 GHz компютър, и можете да го стартирате,

49
00:02:53,000 --> 00:02:56,000
и то под известен брой секунди, през следващата година има 3 GHz

50
00:02:56,000 --> 00:02:59,000
или 4 GHz компютър, и може да се твърди, че: "Уау, ми алгоритъм

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
>> Трябва да влезете N N, и отново,

62
00:03:36,000 --> 00:03:39,000
припомни, че дневника н обикновено се отнася до нещо, което расте

63
00:03:39,000 --> 00:03:43,000
по-бавно N, така че N дневник N до този момент е добро

64
00:03:43,000 --> 00:03:45,000
защото тя е по-малко от N ².

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
Добре, добре, така че ние раздели масив от числа в две парчета.

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
така се слеят вид са обобщени от този pseudocode тук.

84
00:04:45,000 --> 00:04:48,000
Когато сте н елементи, първо, че е здрав разум проверите.

85
00:04:48,000 --> 00:04:51,000
Ако N <2 не правят нищо

86
00:04:51,000 --> 00:04:55,000
защото ако N <2, тогава N очевидно е 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
Но в противен случай, ако имаш два или повече елемента отидете напред и да ги разделят

91
00:05:04,000 --> 00:05:06,000
в две половини, наляво и надясно.

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
и сте ми казваш "Добре, добре, ние ще сортирате тези N / 2 и тези N / 2 елементи"

96
00:05:22,000 --> 00:05:27,000
тогава следващият ми въпрос ще бъде "Добре, как да сортирате N / 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
този специален случай, който казва, че ако N <някаква фиксирана стойност, като две връщане веднага.

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
Ако аз ви питам "Сортиране тези н елементи," и вие казвате: "Добре, сортирайте ги N / 2"

103
00:05:50,000 --> 00:05:53,000
тогава ще каже: "Добре, сортирате N / 4, N / 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
>> Уили. >> Willy, Сара, Кели и Уили.

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
Добре, така че сте като предишния отговор на една

163
00:08:48,000 --> 00:08:51,000
добавяне на минимално количество работа, което искате да направите, е един.

164
00:08:51,000 --> 00:08:55,000
Сега имате две, а след това на ръка ми коя стойност?

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
Имахме осем парчета хартия върху дъската,

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
С други думи, ние recursed.

195
00:10:19,000 --> 00:10:24,000
Благодаря ви много на нашите три доброволци тук за доказване на рекурсия с нас.

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
позволете ми да отида напред и да ги пита за N = 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
сега ние имаме положително число вероятно в N.

221
00:11:42,000 --> 00:11:44,000
>> Сега нека направим нещо с него.

222
00:11:44,000 --> 00:11:50,000
Нека вървим напред и изчисляване на сумиране, така вътр сума = сигма (N).

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
и какъв тип данни искам да се върна вероятно от сигма?

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 I = 0; I <= брой; + +) сумата + = 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
Да, забравих прототип, така че аз съм с функция, наречена сигма по линия 15,

262
00:14:11,000 --> 00:14:16,000
но това не е обявен до ред 22, така че най-добре активно тук

263
00:14:16,000 --> 00:14:22,000
и да обявят прототип, и аз ще кажа INT сигма (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
Implicit декларация на функцията 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, и аз се получи шест, така че не е строга проверка,

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
С други думи, точно като на сцената punted на всеки един от хората, които са до мен,

293
00:15:57,000 --> 00:16:00,000
и те на свой ред плоскодънни лодки, докато най-накрая дъно от Willy,

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
Точно така, обяснението за тази bugginess

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
Тогава твърдяха, че съм ги смяна, като се обадите на замяна на X, Y.

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
представлява, да речем, RAM, и стека ще растат нагоре по този начин,

414
00:22:37,000 --> 00:22:43,000
и ние наричаме функция, като основния, и главните има две локални променливи, х и у,

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
ПТУ, така че нека си даде още 32 бита,

426
00:23:27,000 --> 00:23:29,000
и това, което съм направил в тази функция?

427
00:23:29,000 --> 00:23:34,000
Казах INT малки получава, така че има едно, така че направих това, когато за последен път се играе с този пример.

428
00:23:34,000 --> 00:23:39,000
Тогава получава б, така че Б е 2, така че сега това става 2,

429
00:23:39,000 --> 00:23:42,000
и сега б получава температура, така че темп е едно,

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
ние със сигурност може да започне номерирането байта в моя RAM

445
00:24:28,000 --> 00:24:31,000
и да кажа това е байт # 1, това е байт # 2, байт # 3,

446
00:24:31,000 --> 00:24:35,000
байт # 4, байт # ... 2 милиарда, ако имам 2 гигабайта RAM,

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
отколкото пропуск копия на Х и Y

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
X, както и промяна на номера има, след това карам на адреса на у

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 и Word и програми като тази.

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
[Student] ФОРМАТ.

502
00:27:29,000 --> 00:27:31,000
ФОРМАТ, така ФОРМАТ вероятно е бил ваш приятел в това, ако искате да видите

503
00:27:31,000 --> 00:27:33,000
какво се случва в рамките на програмата си

504
00:27:33,000 --> 00:27:36,000
просто ФОРМАТ тук, ФОРМАТ тук, ФОРМАТ тук.

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
>> ФОРМАТ има тенденция да бъде много мощно нещо,

508
00:27:45,000 --> 00:27:47,000
но това е много ръчен процес.

509
00:27:47,000 --> 00:27:49,000
Трябва да се сложи ФОРМАТ тук, ФОРМАТ тук,

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
и аз отивам да се включи аргумент на командния ред, TUI,

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
б + е в непосредствена близост до линията 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
не ФОРМАТ, печатни Х, и сега това е странно.

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
Аз заявих N, но каква стойност съм го даде?

593
00:31:52,000 --> 00:31:56,000
Няма, защото знаех, че в следващите няколко реда

594
00:31:56,000 --> 00:31:59,000
GetInt ще се погрижи на проблема на стойност вътрешността на N.

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
през тези няколко реда каква е стойността на N?

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
Аз сега трябва да видим една и наистина правя.

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
Сега нека да вървим напред и да отпечатате г., и наистина, Y е някаква луда стойност, както и,

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

620
00:33:24,000 --> 00:33:27,000
на стойност 2, така че нека да въведете отново "Next".

621
00:33:27,000 --> 00:33:29,000
И сега сме на ФОРМАТ линия.

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
Нека вместо въведете "дисплей х" и "дисплей г.,

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
Сега, ФОРМАТ за да се изпълни, така че нека да отида напред и просто напишете "следващата".

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
Показване на X и дисплей г., така че в момента пиша следващия

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
На следващо място, и за съжаление, Y е все още 2 и х е все още едно, и мога да потвърдя толкова.

649
00:34:54,000 --> 00:34:56,000
Печат X, печат Y.

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
Нека вместо да напишете "Run" отново.

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
Ако аз се отегчават мога да просто да напишете N следващия.

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

659
00:35:21,000 --> 00:35:23,000
Swap сега е счупен.

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
Сега изглежда, имаме малки, малки печат.

669
00:35:50,000 --> 00:35:52,000
Garbage стойност, нали? Мисля, че да.

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
ПТУ ще отнеме на стойност от 1, да се надяваме,

673
00:36:02,000 --> 00:36:05,000
защото ПТУ е ще трябва да бъде назначен стойността на.

674
00:36:05,000 --> 00:36:08,000
>> Сега нека да се отпечатват, печат б,

675
00:36:08,000 --> 00:36:11,000
но сега да отпечатате малки, и това е наистина едно.

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
печат б, и не ми пука какво ПТУ е.

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
какво не е наред, без да се налага да постеля нашия код чрез поставяне ФОРМАТ тук,

687
00:36:47,000 --> 00:36:50,000
ФОРМАТ тук, ФОРМАТ тук и след това да я пуснете отново и отново

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
Като настрана, не е нужно да използвате тази TUI флаг.

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
, в която Нейт обхваща някои от тънкостите на 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
ФОРМАТ ти беше приятел.

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
Обратно проследяване и рамката, позволете ми да се потопите в този последен път,

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-минутна почивка тук, и ние ще се върне с structs и файлове.

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
и къща на място, като Харвард, така че това са три парчета информация

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
Тогава аз ще кажа един студент има ID, така че 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
Добре, сега имам три променливи, с които да представляват един студент, така че "студент".

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
чието ID е% г, живее в% S.

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" за някой като Роб, който живее в Къркланд.

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
и аз ще подкрепи три от нас за сега.

816
00:44:14,000 --> 00:44:18,000
Отивам да се каже "струнни имена", и аз ще подкрепя три от нас,

817
00:44:18,000 --> 00:44:22,000
и тогава аз ще да каже "струнни къщи", и аз ще подкрепи три от нас.

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
сред тези три парчета от информация, номер, име и къща,

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
или капсулиране е име и документ за самоличност и къща.

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
и аз ще използвам typedef за определяне на вида.

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
Фактът, че променливата се нарича Роб е нещо безсмислено.

907
00:49:20,000 --> 00:49:22,000
Бихме могли да го наричат ​​Х или У или Z.

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
и след това просто не забравяйте, че трябва да се поставят не повече от три студенти в него.

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
и казва, че ще има три студенти по подразбиране.

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
и ако той се връща една, това означава, че другата дума идва по азбучен ред

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]. Къщата е равна на "Mather"

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
да ни даде малко RAM за този низ.

974
00:53:07,000 --> 00:53:09,000
Дайте ни малко RAM за следващия низ.

975
00:53:09,000 --> 00:53:11,000
Дайте ни малко повече RAM за следващия низ.

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, Дейвид Mather,

1003
00:54:40,000 --> 00:54:47,000
456, Роб 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 различни низове, натиснете въведете,

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
>> Ние можем да направим това, като използвате тази техника, известна като файл I / O, файл входа и на изхода,

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
Файл, всички капачки, и тя е * в тук, както и.

1025
00:55:55,000 --> 00:55:58,000
Нека ме премести тук, * тук, както и.

1026
00:55:58,000 --> 00:56:00,000
>> Тази функция не сме виждали преди, fopen,

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. Това би могло да бъде. Db.

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
,, ако РП, файлов указател не е равно на NULL, това означава, че всичко е наред.

1042
00:56:47,000 --> 00:56:51,000
>> Дълга история Накратко, функции като fopen понякога не успяват.

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
така че ако fopen връща NULL нещо лошо се е случило.

1046
00:56:58,000 --> 00:57:02,000
И обратното, ако fopen не се връща нула всичко е наред

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
но тази функция е братовчед на ФОРМАТ нарича fprintf за файла ФОРМАТ

1052
00:57:15,000 --> 00:57:18,000
и да забележите, че е различно само два начина.

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
Това нещо, наречено РП, която в крайна сметка ще дразни, освен това, което е файлов указател,

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
е въвеждането на fopen и този файл с *

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, Дейвид Mather, 456, Роб Къркланд,

1069
00:58:15,000 --> 00:58:19,000
789, Томи Mather, въведете.

1070
00:58:19,000 --> 00:58:23,000
Изглежда, че се държи една и съща, но ако аз сега правя ли

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 имаме typedef

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
на всяка дума в речника, който използваме за катеря.

1095
00:59:44,000 --> 00:59:46,000
Защо имам едно?

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
и да получите три точки, три точки, три точки, три точки.

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
Липсата тук е думата typedef, защото в този случай

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
, че ако не се каже, typedef, само кажи структура, а след това вътре в фигурни скоби

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
е, както обещахме в седмица една наистина просто псевдоним,

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
и той очевидно пита потребителя за две струни, и т,

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
Кажи нещо. Здравейте.

1147
01:02:29,000 --> 01:02:32,000
Аз ще кажа нещо отново. Здравейте.

1148
01:02:32,000 --> 01:02:34,000
Аз определено не въвеждате различни неща.

1149
01:02:34,000 --> 01:02:37,000
>> Нека да опитаме отново. Чао.

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
Не забравяйте, че може да бъде представена една дума като HELLO

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
и го поставя в самото начало на моя компютър RAM.

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 и правя низ = GetString

1173
01:04:02,000 --> 01:04:04,000
какво всъщност се връщат?

1174
01:04:04,000 --> 01:04:08,000
За тези последните няколко седмици, какво наистина се съхраняват в S

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
Този брой е адреса на HELLO в паметта,

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
Чар има смисъл, защото това, което е една дума, като HELLO?

1185
01:04:41,000 --> 01:04:44,000
Е, това е поредица от символи, поредица от знаци.

1186
01:04:44,000 --> 01:04:47,000
Чар * означава адреса на герой,

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
е по-скоро, отколкото се опитват да разбера как да се върна до пет или шест различни байта

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
така че, когато използва нещо като ФОРМАТ, какво ФОРМАТ буквално като аргумент,

1203
01:05:35,000 --> 01:05:39,000
припомним, че ние използваме контейнер% S, и след това да премине в

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
ФОРМАТ използва за линия или цикъл, докато при получаване на този адрес,

1207
01:05:50,000 --> 01:05:53,000
например, 0, така че нека да направим това сега,

1208
01:05:53,000 --> 01:06:02,000
ФОРМАТ ("% S \ N");

1209
01:06:02,000 --> 01:06:07,000
Когато аз наричам ФОРМАТ ("% S \ N"); това, което аз съм наистина предоставяне ФОРМАТ с

1210
01:06:07,000 --> 01:06:13,000
е адресът на първия знак, който в тази произволна случай е H.

1211
01:06:13,000 --> 01:06:16,000
>> Как ФОРМАТ знам какво точно да се показва на екрана?

1212
01:06:16,000 --> 01:06:19,000
Лице, което изпълнява ФОРМАТ реализира докато линия или за контур

1213
01:06:19,000 --> 01:06:23,000
казва, че този герой е равна на специалния характер нула?

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
тази малка Binky глинената анимация характер.

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
Аз ви давам Pointer Fun с Бинки, за предварителен преглед.

1232
01:07:15,000 --> 01:07:18,000
♪ Music ♪] [професор 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]