1
00:00:00,000 --> 00:00:01,000
[Powered by Google Translate] [Раздел 6] [по-комфортно]

2
00:00:01,000 --> 00:00:04,000
[Роб Bowden] [Харвардския университет]

3
00:00:04,000 --> 00:00:09,000
[Това е CS50. [CS50.TV]

4
00:00:09,000 --> 00:00:11,000
>> Ние можем да се отправят към нашата секция на въпроси.

5
00:00:11,000 --> 00:00:17,000
Пратих URL за интервал преди.

6
00:00:17,000 --> 00:00:22,000
В началото на част от въпросите, казват

7
00:00:22,000 --> 00:00:26,000
явно аз не съм изцяло unsick е много лесен въпрос

8
00:00:26,000 --> 00:00:28,000
на какво точно се valgrind?

9
00:00:28,000 --> 00:00:30,000
Какво се valgrind направя?

10
00:00:30,000 --> 00:00:34,000
Някой иска ли да каже какво прави valgrind?

11
00:00:34,000 --> 00:00:36,000
[Student] проверява изтичане на памет.

12
00:00:36,000 --> 00:00:41,000
Да, valgrind е общ за проверка на паметта.

13
00:00:41,000 --> 00:00:44,000
Това, в крайна сметка, ти казва, ако имате някакви изтичане на памет,

14
00:00:44,000 --> 00:00:49,000
, която е най-вече това, което ние го използвате, защото ако искате да

15
00:00:49,000 --> 00:00:54,000
се справят добре в проблема набор или ако искате да

16
00:00:54,000 --> 00:00:59,000
да получите на големия съвет, имате нужда от каквато и да няма изтичане на памет,

17
00:00:59,000 --> 00:01:01,000
и в случай, че има изтичане на памет, че не можете да намерите,

18
00:01:01,000 --> 00:01:04,000
също така имайте предвид, че всеки път, когато отворите файл

19
00:01:04,000 --> 00:01:07,000
и ако не го затворите, това е изтичане на памет.

20
00:01:07,000 --> 00:01:10,000
>> Много хора се търсят за някои възел, че те не са освобождаване

21
00:01:10,000 --> 00:01:15,000
когато наистина, те не затворите речник в най-първата стъпка.

22
00:01:15,000 --> 00:01:19,000
Той също така ви казва, ако имате някакви невалиден чете или пише,

23
00:01:19,000 --> 00:01:22,000
което означава, че ако се опита и задайте стойност

24
00:01:22,000 --> 00:01:26,000
това е отвъд края на куп и това не се случи сегмента вина

25
00:01:26,000 --> 00:01:30,000
но valgrind я хваща, тъй като не трябва да се пише там,

26
00:01:30,000 --> 00:01:33,000
и така вие определено не трябва да има някое от тези или.

27
00:01:33,000 --> 00:01:38,000
Как да използвате valgrind?

28
00:01:38,000 --> 00:01:42,000
Как да използвате valgrind?

29
00:01:42,000 --> 00:01:45,000
>> Това е общ въпрос

30
00:01:45,000 --> 00:01:49,000
вид, стартирайте го и на изхода.

31
00:01:49,000 --> 00:01:51,000
Изходът е поразителен много пъти.

32
00:01:51,000 --> 00:01:54,000
Има също така и забавни грешки, където, ако имате някаква ужасно нещо погрешно

33
00:01:54,000 --> 00:01:59,000
случва в една линия, а след това в крайна сметка ще кажа, "твърде много грешки.

34
00:01:59,000 --> 00:02:03,000
Отивам да спре да брои сега. "

35
00:02:03,000 --> 00:02:08,000
Това е основно текстова продукция, която трябва да се направи разбор.

36
00:02:08,000 --> 00:02:13,000
В крайна сметка, тя ще ви каже изтичане на памет, които имате,

37
00:02:13,000 --> 00:02:16,000
колко блокове, които могат да бъдат полезни, защото

38
00:02:16,000 --> 00:02:20,000
ако това е един блок unfreed, тогава това е обикновено е по-лесно да се намери

39
00:02:20,000 --> 00:02:23,000
от 1000 блокове unfreed.

40
00:02:23,000 --> 00:02:26,000
1000 блокове unfreed вероятно означава, че не освобождава

41
00:02:26,000 --> 00:02:30,000
свързани списъци по подходящ начин или нещо такова.

42
00:02:30,000 --> 00:02:32,000
Това е valgrind.

43
00:02:32,000 --> 00:02:35,000
>> Сега имаме нашата секция на въпроси,

44
00:02:35,000 --> 00:02:38,000
които не е нужно да изтеглите.

45
00:02:38,000 --> 00:02:41,000
Можете да кликнете върху името ми и ги издърпайте нагоре в пространството.

46
00:02:41,000 --> 00:02:44,000
Сега кликнете върху мен.

47
00:02:44,000 --> 00:02:46,000
Преглед на 1 ще бъде стека, което правим първото.

48
00:02:46,000 --> 00:02:55,000
Revision 2 ще бъде опашка и ревизия 3 ще бъде поотделно свързан списък.

49
00:02:55,000 --> 00:02:58,000
Започвайки с нашия стак.

50
00:02:58,000 --> 00:03:02,000
Както се казва тук, комин е един от най-основните,

51
00:03:02,000 --> 00:03:07,000
основните структури от данни на компютърната наука.

52
00:03:07,000 --> 00:03:11,000
Много прототипни пример за това е

53
00:03:11,000 --> 00:03:13,000
стека на плочки в трапезарията.

54
00:03:13,000 --> 00:03:16,000
Това е основно, когато се запознават с комин,

55
00:03:16,000 --> 00:03:20,000
някой ще каже: "О, като купчина тави".

56
00:03:20,000 --> 00:03:22,000
Можете стека тава.

57
00:03:22,000 --> 00:03:24,000
Тогава, когато отидете да дръпнете поднос,

58
00:03:24,000 --> 00:03:31,000
първата тава, която ще се извади, е последният, който е бил пуснат на стека.

59
00:03:31,000 --> 00:03:34,000
Стак също така като казва тук

60
00:03:34,000 --> 00:03:37,000
имаме сегмент на памет, наречена стека.

61
00:03:37,000 --> 00:03:40,000
И защо се нарича стека?

62
00:03:40,000 --> 00:03:42,000
>> Тъй като структурата на стека данни,

63
00:03:42,000 --> 00:03:46,000
настоява и се появи стека рамки на стека,

64
00:03:46,000 --> 00:03:53,000
където стаковете рамки са като специална покана на функция.

65
00:03:53,000 --> 00:03:57,000
И като комин, винаги ще трябва да се върне

66
00:03:57,000 --> 00:04:03,000
от извикване на функция, преди да можете да получите на олекотени рамки стека отново.

67
00:04:03,000 --> 00:04:08,000
Не можете да имате повикване Foo повикване бар и връщане бар на основното директно.

68
00:04:08,000 --> 00:04:14,000
Винаги трябва да следи за правилното стека бутане и мак.

69
00:04:14,000 --> 00:04:18,000
Две операции, както казах, са тласък и поп.

70
00:04:18,000 --> 00:04:20,000
Това са универсални термини.

71
00:04:20,000 --> 00:04:26,000
Трябва да знаете, натискане и поп в условията на стекове без значение какво.

72
00:04:26,000 --> 00:04:28,000
Ще видим опашки са вид на различни.

73
00:04:28,000 --> 00:04:32,000
Всъщност няма универсален план, но тласък и поп са универсални за стакове.

74
00:04:32,000 --> 00:04:34,000
Push е само на стека.

75
00:04:34,000 --> 00:04:37,000
Поп е излитане стека.

76
00:04:37,000 --> 00:04:43,000
И ние виждаме тук ние имаме typedef стека структура,

77
00:04:43,000 --> 00:04:46,000
така че ние имаме Чар струни **.

78
00:04:46,000 --> 00:04:51,000
Да не се получи плаши от никакви **.

79
00:04:51,000 --> 00:04:54,000
Това е в крайна сметка ще е масив от низове

80
00:04:54,000 --> 00:04:58,000
или масив от указатели към символи, където

81
00:04:58,000 --> 00:05:00,000
указатели към героите са склонни да бъдат струни.

82
00:05:00,000 --> 00:05:05,000
Тя не трябва да бъде струни, но тук, те ще бъдат струни.

83
00:05:05,000 --> 00:05:08,000
>> Ние имаме масив от низове.

84
00:05:08,000 --> 00:05:14,000
Имаме размер, което представлява колко елементи са в момента на стека,

85
00:05:14,000 --> 00:05:19,000
и ние имаме капацитет, което е колко елементи могат да бъдат в стека.

86
00:05:19,000 --> 00:05:22,000
Капацитет трябва да започне като нещо по-голямо от 1,

87
00:05:22,000 --> 00:05:27,000
но размерът ще започне като 0.

88
00:05:27,000 --> 00:05:36,000
Сега там са основно три различни начини, по които можеш да се сетиш на комин.

89
00:05:36,000 --> 00:05:39,000
Е, там вероятно са повече, но два основни начина

90
00:05:39,000 --> 00:05:43,000
можете да го въведе масив, или да го изпълни с помощта на свързан списък.

91
00:05:43,000 --> 00:05:48,000
Свързани списъци са вид тривиално да направи купища.

92
00:05:48,000 --> 00:05:51,000
Много е лесно да се направи комин с помощта на свързани списъци,

93
00:05:51,000 --> 00:05:55,000
така че тук, ние ще направим комин употребата на масиви,

94
00:05:55,000 --> 00:05:59,000
и след това с помощта на масиви, има и два начини, по които можете да се сетите за това.

95
00:05:59,000 --> 00:06:01,000
Преди, когато казах, че имаме капацитет за стека,

96
00:06:01,000 --> 00:06:04,000
така че ние може да се побере елемент на стека.

97
00:06:04,000 --> 00:06:09,000
>> Единственият начин може да се случи веднага след като удари 10 елемента, а след това сте готови.

98
00:06:09,000 --> 00:06:13,000
Може би знаете, че има горна граница от 10 неща в света

99
00:06:13,000 --> 00:06:16,000
че никога няма да има повече от 10 неща на вашия стак,

100
00:06:16,000 --> 00:06:20,000
в който случай може да има горна граница на размера на стака си.

101
00:06:20,000 --> 00:06:23,000
Или бихте могли да имат вашия стак безгранична,

102
00:06:23,000 --> 00:06:27,000
но ако правиш масив, това означава, че всеки път, когато удари 10 елемента,

103
00:06:27,000 --> 00:06:29,000
това означава, че ще трябва да нарасне до 20 елемента, и когато ви удари 20 елементи,

104
00:06:29,000 --> 00:06:33,000
вие ще трябва да развиете своя масив до 30 елементи или 40 елементи.

105
00:06:33,000 --> 00:06:37,000
Вие ще трябва да се увеличи капацитет, което е това, което ние ще направим тук.

106
00:06:37,000 --> 00:06:40,000
Всеки път стигаме до максималния размер на нашия стак,

107
00:06:40,000 --> 00:06:46,000
когато натиснете нещо друго, ние ще трябва да увеличи капацитета.

108
00:06:46,000 --> 00:06:50,000
Ето, ние тласък декларирани като булев натискане (Чар * ул.).

109
00:06:50,000 --> 00:06:54,000
Чар * ул. е низ, че ние се мъчим върху стека,

110
00:06:54,000 --> 00:06:58,000
и булев просто казва дали сме успели или не са успели.

111
00:06:58,000 --> 00:07:00,000
>> Как можем да се провали?

112
00:07:00,000 --> 00:07:04,000
Каква е само обстоятелството, че можеш да се сетиш

113
00:07:04,000 --> 00:07:07,000
когато ние ще трябва да се върне фалшива?

114
00:07:07,000 --> 00:07:09,000
Да.

115
00:07:09,000 --> 00:07:12,000
Студентски] Ако това е пълна и ние използваме ограничена изпълнение.

116
00:07:12,000 --> 00:07:17,000
Да, така как ние определяме той отговори

117
00:07:17,000 --> 00:07:23,000
ако тя е пълна и ние използваме ограничена изпълнение.

118
00:07:23,000 --> 00:07:26,000
След това със сигурност ще се върне фалшиви.

119
00:07:26,000 --> 00:07:31,000
Веднага след като удари 10 неща в масива, ние не може да се побере 11, така че връщане фалшиви.

120
00:07:31,000 --> 00:07:32,000
Какво ще стане, ако тя е безгранична? Да.

121
00:07:32,000 --> 00:07:38,000
Ако по някаква причина не можете да разширите масив.

122
00:07:38,000 --> 00:07:43,000
Да, така паметта е ограничен ресурс,

123
00:07:43,000 --> 00:07:51,000
и в крайна сметка, ако продължаваш да се бориш неща върху стека отново и отново,

124
00:07:51,000 --> 00:07:54,000
ние ще се опитаме и да заделят по-голям масив да се поберат

125
00:07:54,000 --> 00:07:59,000
ще се върне по-голям капацитет, и изчистване или каквото и да използвате фалшив.

126
00:07:59,000 --> 00:08:02,000
Е, изчистване ще се върне празно.

127
00:08:02,000 --> 00:08:05,000
>> Не забравяйте, че всеки път, когато някога се обръщат изчистване, трябва да бъдат проверка да се види дали

128
00:08:05,000 --> 00:08:12,000
връща нула или друго, което е за вярност приспадане.

129
00:08:12,000 --> 00:08:17,000
Тъй като искаме да имаме неограничено стак,

130
00:08:17,000 --> 00:08:21,000
единственият случай, ние ще се завърне невярно е, ако ние се опитваме да

131
00:08:21,000 --> 00:08:26,000
увеличаване на капацитета и изчистване или каквото и да връща.

132
00:08:26,000 --> 00:08:30,000
Тогава поп не възприема аргументи,

133
00:08:30,000 --> 00:08:37,000
и го връща низ, който е на върха на стека.

134
00:08:37,000 --> 00:08:41,000
Каквото и да е най-скоро търсената върху стека е какво поп се връща,

135
00:08:41,000 --> 00:08:44,000
и тя също така премахва от стека.

136
00:08:44,000 --> 00:08:50,000
И забележите, че той се връща нула, ако няма нищо в стека.

137
00:08:50,000 --> 00:08:53,000
Той винаги е възможно, че стека е празен.

138
00:08:53,000 --> 00:08:55,000
В Java, ако сте свикнали с това, или на други езици,

139
00:08:55,000 --> 00:09:01,000
се опитва да изскочи от празна стак може да предизвика изключение или нещо такова.

140
00:09:01,000 --> 00:09:09,000
>> Но в C, нула е на много случаи, в начина, по който се справят с тези проблеми.

141
00:09:09,000 --> 00:09:13,000
Връщането на нула е как ние ще означава, че стека е празен.

142
00:09:13,000 --> 00:09:16,000
Сме предоставили кода, който ще тества функционалността на вашия стак,

143
00:09:16,000 --> 00:09:19,000
изпълнение натиснете и поп.

144
00:09:19,000 --> 00:09:23,000
Това няма да е много код.

145
00:09:23,000 --> 00:09:40,000
Ще го направя - всъщност, преди да направите това, намек, намек-

146
00:09:40,000 --> 00:09:44,000
ако не сте го виждали, изчистване не е единствената функция

147
00:09:44,000 --> 00:09:47,000
, която заделя памет на куп за вас.

148
00:09:47,000 --> 00:09:51,000
Има семейството на заделянето на памет функции.

149
00:09:51,000 --> 00:09:53,000
Първата е изчистване, което сме свикнали да.

150
00:09:53,000 --> 00:09:56,000
Тогава там е calloc, който прави същото нещо като изчистване,

151
00:09:56,000 --> 00:09:59,000
но това ще нулира всичко за вас.

152
00:09:59,000 --> 00:10:04,000
Ако някога сте искали да зададете всичко на нула, след mallocing нещо

153
00:10:04,000 --> 00:10:06,000
трябва да сте просто използва calloc на първо място, вместо на писане

154
00:10:06,000 --> 00:10:09,000
за линия до нула за целия блок от паметта.

155
00:10:09,000 --> 00:10:15,000
>> Презаделяне е като изчистване и има много специални случаи,

156
00:10:15,000 --> 00:10:19,000
но в общи линии какво презаделяне

157
00:10:19,000 --> 00:10:24,000
отнема показалеца, които вече са били разпределени.

158
00:10:24,000 --> 00:10:27,000
Презаделяне е функцията, която искате да се обръща внимание тук.

159
00:10:27,000 --> 00:10:31,000
Това отнема показалеца, които вече са били върнати от изчистване.

160
00:10:31,000 --> 00:10:35,000
Да речем, че поиска от изчистване на показалеца на 10 байта.

161
00:10:35,000 --> 00:10:38,000
По-късно осъзнаваш, че искаш 20 байта,

162
00:10:38,000 --> 00:10:42,000
така ти се обадя презаделяне на тази показалеца с 20 байта,

163
00:10:42,000 --> 00:10:47,000
и презаделяне автоматично ще копира всичко за вас.

164
00:10:47,000 --> 00:10:51,000
Ако току що се обади изчистване отново, като имам блок от 10 байта.

165
00:10:51,000 --> 00:10:53,000
Сега имам нужда от блок от 20 байта,

166
00:10:53,000 --> 00:10:58,000
така че, ако изчистване 20 байта, тогава аз трябва да копирате ръчно над 10 байта от първото нещо,

167
00:10:58,000 --> 00:11:01,000
във втората нещо и след това първото нещо.

168
00:11:01,000 --> 00:11:04,000
Презаделяне ще се справят с това за теб.

169
00:11:04,000 --> 00:11:11,000
>> Забележете подпис ще бъде нищожен *,

170
00:11:11,000 --> 00:11:15,000
която е просто връщане на показалеца на блок от памет,

171
00:11:15,000 --> 00:11:17,000
тогава нищожен * PTR.

172
00:11:17,000 --> 00:11:22,000
Можете да мислите за нищожен * като родово показалеца.

173
00:11:22,000 --> 00:11:27,000
Като цяло, никога няма да се справят с нищожен *,

174
00:11:27,000 --> 00:11:30,000
но изчистване се завръща нищожен *, и след това просто се използва като

175
00:11:30,000 --> 00:11:34,000
това всъщност ще бъде знак *.

176
00:11:34,000 --> 00:11:37,000
Предишната * нищожен, които са били върнати от изчистване

177
00:11:37,000 --> 00:11:41,000
вече ще бъдат предадени на презаделяне, и след това размер

178
00:11:41,000 --> 00:11:49,000
е новият брой на байтовете, които искат да се отпуснат, така че нови мощности.

179
00:11:49,000 --> 00:11:57,000
Ще ви дам няколко минути, и да го направя в нашето пространство.

180
00:11:57,000 --> 00:12:02,000
Започнете с Преработка 1.

181
00:12:16,000 --> 00:12:21,000
Аз ще ви спре след като се надяваме за достатъчно време да изпълнят тласък,

182
00:12:21,000 --> 00:12:24,000
и след това аз ще ви дам още една почивка, за да се направи поп.

183
00:12:24,000 --> 00:12:27,000
Но това наистина не е, че много код на всички.

184
00:12:27,000 --> 00:12:35,000
Най-код вероятно е разширяване на неща, разширяване на капацитета.

185
00:12:35,000 --> 00:12:39,000
Добре, няма натиск да бъдат напълно прави,

186
00:12:39,000 --> 00:12:47,000
но толкова дълго, колкото се почувствате сякаш сте на прав път, това е добре.

187
00:12:47,000 --> 00:12:53,000
>> Някой има ли код, те се чувстват комфортно с мен дърпа нагоре?

188
00:12:53,000 --> 00:12:59,000
Да, ще го направя, но не всеки има код на приложението, който може да тегли до?

189
00:12:59,000 --> 00:13:05,000
Добре, може да започнете, да го запишете, каквото и да е то?

190
00:13:05,000 --> 00:13:09,000
Аз винаги забравям тази стъпка.

191
00:13:09,000 --> 00:13:15,000
Добре, при натискане,

192
00:13:15,000 --> 00:13:18,000
искам да обясните вашата код?

193
00:13:18,000 --> 00:13:24,000
[Student] Преди всичко, аз увеличи размера.

194
00:13:24,000 --> 00:13:28,000
Предполагам, че може би трябва да има, че така или иначе, аз увеличи размера,

195
00:13:28,000 --> 00:13:31,000
и аз виждам, ако това е по-малко от капацитета.

196
00:13:31,000 --> 00:13:36,000
И ако това е по-малко от капацитета, добавя към масива, че вече имаме.

197
00:13:36,000 --> 00:13:42,000
И ако не е, ще умножа капацитет от 2,

198
00:13:42,000 --> 00:13:50,000
и аз да преразпредели струни масив за нещо с по-голям капацитет.

199
00:13:50,000 --> 00:13:55,000
И тогава, ако това не стане, казвам на потребителя и връщане фалшиви,

200
00:13:55,000 --> 00:14:04,000
и ако всичко е наред, след това сложих низ в ново място.

201
00:14:04,000 --> 00:14:07,000
>> [Роб Б. Също така забележете, че ние използвахме хубава оператор побитови тук

202
00:14:07,000 --> 00:14:09,000
се умножава по две.

203
00:14:09,000 --> 00:14:11,000
Не забравяйте, че олевяване винаги ще се умножава по две.

204
00:14:11,000 --> 00:14:15,000
Право промяна е разделен на две толкова дълго, колкото не забравяйте, че това означава,

205
00:14:15,000 --> 00:14:18,000
разделете на две, както в цяло число, разделено на две.

206
00:14:18,000 --> 00:14:20,000
Тя може да се отреже 1 тук или там.

207
00:14:20,000 --> 00:14:26,000
Но промяна, оставена от 1 винаги ще се умножава по две,

208
00:14:26,000 --> 00:14:32,000
освен ако не препълване на обхвата на целочисления, и след това тя няма да бъде.

209
00:14:32,000 --> 00:14:34,000
А страна коментар.

210
00:14:34,000 --> 00:14:39,000
Харесва ми да направя това не се случва за промяна на кодирането никакъв начин,

211
00:14:39,000 --> 00:14:48,000
но обичам да правя нещо подобно.

212
00:14:48,000 --> 00:14:51,000
То всъщност се случва да го правят малко по-дълго.

213
00:15:04,000 --> 00:15:08,000
Може би това не е идеалния случай да се покаже това,

214
00:15:08,000 --> 00:15:14,000
но ми харесва да сегмент в тези блокове-

215
00:15:14,000 --> 00:15:17,000
добре, ако това, ако се случи, тогава аз ще направя нещо,

216
00:15:17,000 --> 00:15:19,000
и след това функцията е направено.

217
00:15:19,000 --> 00:15:22,000
Не трябва след това да превъртите очите ми по целия път надолу функцията

218
00:15:22,000 --> 00:15:25,000
да видим какво ще стане след друго.

219
00:15:25,000 --> 00:15:27,000
Това е, ако това, ако се случи, тогава аз просто се върне.

220
00:15:27,000 --> 00:15:30,000
Той също така има хубаво допълнителна полза от всичко след това

221
00:15:30,000 --> 00:15:33,000
сега е изместен веднъж на ляво.

222
00:15:33,000 --> 00:15:40,000
Аз вече не се налага да, ако някога в близост до безумно дългите линии,

223
00:15:40,000 --> 00:15:45,000
тогава тези 4 байта може да помогне, а също и по-ляво нещо е,

224
00:15:45,000 --> 00:15:48,000
по-малко претоварени се почувствате, ако искал-добре, трябва да се помни

225
00:15:48,000 --> 00:15:53,000
Аз съм в момента в линия, докато във вътрешността на друг вътрешността на линия.

226
00:15:53,000 --> 00:15:58,000
Където и да може да направи това завръщане веднага, мен ми харесва.

227
00:15:58,000 --> 00:16:05,000
Това е напълно по желание и не се очаква по какъвто и да е начин.

228
00:16:05,000 --> 00:16:12,000
>> Студентски] Трябва ли да има размери - в провалят състояние?

229
00:16:12,000 --> 00:16:19,000
Се провалят условие тук е, че ние не успя да презаделяне, така че да.

230
00:16:19,000 --> 00:16:22,000
Забележете как в непременно условие, вероятно,

231
00:16:22,000 --> 00:16:26,000
освен ако ние безплатни неща по-късно, ние винаги ще се провалят

232
00:16:26,000 --> 00:16:29,000
без значение колко пъти ние се опитваме да прокара нещо.

233
00:16:29,000 --> 00:16:32,000
Ако продължаваш да се бориш, ние продължаваме увеличаване размера,

234
00:16:32,000 --> 00:16:36,000
въпреки че ние не поставяме нищо върху стека.

235
00:16:36,000 --> 00:16:39,000
Обикновено ние не увеличите размера, докато

236
00:16:39,000 --> 00:16:43,000
след като успешно са го постави на стека.

237
00:16:43,000 --> 00:16:50,000
Ние ще го направя, да речем, тук и тук.

238
00:16:50,000 --> 00:16:56,000
И тогава вместо да каже s.size ≤ капацитет, това е по-малко от капацитета,

239
00:16:56,000 --> 00:17:01,000
само защото ние се преместихме, където всичко беше.

240
00:17:01,000 --> 00:17:07,000
>> И помнете, единственото място, което бихме могли да евентуално връщане фалшиви

241
00:17:07,000 --> 00:17:14,000
е тук, където презаделяне връща нула,

242
00:17:14,000 --> 00:17:19,000
и ако се случи да се помни, стандартна грешка,

243
00:17:19,000 --> 00:17:22,000
може би ще може да разгледа този случай, когато искате да отпечатате стандартна грешка,

244
00:17:22,000 --> 00:17:26,000
така fprintf STDERR вместо просто директен печат на стандартния изход.

245
00:17:26,000 --> 00:17:31,000
Отново, това не е очаквания, но ако това е грешка,

246
00:17:31,000 --> 00:17:41,000
въведете ФОРМАТ, тогава може да искате да го отпечатате на стандартната грешка вместо на стандартния изход.

247
00:17:41,000 --> 00:17:44,000
>> Всеки, който има нещо друго, за да се отбележи? Да.

248
00:17:44,000 --> 00:17:47,000
[Student] Може ли да отидете над [недоловим]?

249
00:17:47,000 --> 00:17:55,000
[Rob B.] Да, действително binariness от него или от това, което е?

250
00:17:55,000 --> 00:17:57,000
[Student] Значи го умножете по две?

251
00:17:57,000 --> 00:17:59,000
[Rob B.] Да, общо взето.

252
00:17:59,000 --> 00:18:11,000
В двоичен земя, ние винаги имаме набор от цифри.

253
00:18:11,000 --> 00:18:22,000
Този променящ ляво от 1 По същество това вложки Тук, в дясната страна.

254
00:18:22,000 --> 00:18:25,000
Върнете се в това, просто се забравя, че всичко в двоичен

255
00:18:25,000 --> 00:18:28,000
е с мощност от 2, така че това представлява 2 до 0,

256
00:18:28,000 --> 00:18:30,000
2 към 1, този 2 на 2.

257
00:18:30,000 --> 00:18:33,000
Чрез въвеждане от 0 до дясната страна, ние просто смени всичко.

258
00:18:33,000 --> 00:18:38,000
Какво да бъде 2 на 0 сега е 2 към 1, 2 на 2.

259
00:18:38,000 --> 00:18:41,000
Дясната страна, че сме поставили

260
00:18:41,000 --> 00:18:44,000
е задължително да бъде 0,

261
00:18:44,000 --> 00:18:46,000
което има смисъл.

262
00:18:46,000 --> 00:18:49,000
Ако някога сте се размножават номер 2, това няма да се свърши странно,

263
00:18:49,000 --> 00:18:54,000
така трябва да бъде от 2 до мястото 0 0,

264
00:18:54,000 --> 00:18:59,000
и това е, което едва ли не предупреди за това, преди да е, ако ви се случи да се променя

265
00:18:59,000 --> 00:19:01,000
извън броя на битовете в цяло число,

266
00:19:01,000 --> 00:19:04,000
след това 1 ще свърши тръгна.

267
00:19:04,000 --> 00:19:10,000
Това е единственото притеснение, ако се случи да се занимава с наистина големи възможности.

268
00:19:10,000 --> 00:19:15,000
Но в този момент, а след това сте се занимават с набор от милиарди неща,

269
00:19:15,000 --> 00:19:25,000
, които не могат да се поберат в паметта, така или иначе.

270
00:19:25,000 --> 00:19:31,000
>> Сега ние можем да стигнем до поп, което е още по-лесно.

271
00:19:31,000 --> 00:19:36,000
Може да ми харесва, ако се случи да се появи цял куп,

272
00:19:36,000 --> 00:19:38,000
и сега сте на половин капацитет.

273
00:19:38,000 --> 00:19:42,000
Можете да презаделяне да се свие размера на паметта имате,

274
00:19:42,000 --> 00:19:47,000
но вие не трябва да се тревожи за това, така че единственият случай презаделяне ще бъде

275
00:19:47,000 --> 00:19:50,000
отглеждането на паметта, никога не свива памет,

276
00:19:50,000 --> 00:19:59,000
която ще направи поп супер лесно.

277
00:19:59,000 --> 00:20:02,000
Сега опашки, които ще бъдат като стакове,

278
00:20:02,000 --> 00:20:06,000
но за да ви отведе нещата да се отпише.

279
00:20:06,000 --> 00:20:10,000
Прототипният пример на опашката е една линия,

280
00:20:10,000 --> 00:20:12,000
така че предполагам, ако бяха англичани, бих казал,

281
00:20:12,000 --> 00:20:17,000
прототип на пример на опашката е опашката.

282
00:20:17,000 --> 00:20:22,000
Така че, като, ако сте първият човек, в съответствие,

283
00:20:22,000 --> 00:20:24,000
очаквате да бъде първият човек на линията.

284
00:20:24,000 --> 00:20:31,000
Ако сте последният човек в съответствие, ще бъде последният човек, трябва да се ремонтира.

285
00:20:31,000 --> 00:20:35,000
Ние наричаме това FIFO модел, като има предвид, че стека е LIFO модел.

286
00:20:35,000 --> 00:20:40,000
Тези думи са доста универсални.

287
00:20:40,000 --> 00:20:46,000
>> Както стакове и за разлика от масиви, опашки обикновено не позволява достъп до елементите в средата.

288
00:20:46,000 --> 00:20:50,000
Тук комин, ние имаме тласък и поп.

289
00:20:50,000 --> 00:20:54,000
Ето, ние се случи да ги призовал enqueue и dequeue.

290
00:20:54,000 --> 00:20:58,000
Аз съм чувал и ги нарича смяна и unshift.

291
00:20:58,000 --> 00:21:02,000
Съм чувала хора да казват тласък и поп да се прилага по отношение на опашки.

292
00:21:02,000 --> 00:21:05,000
Чувал съм, поставяйте, не изваждайте,

293
00:21:05,000 --> 00:21:11,000
натиснете и поп, ако говорим за стакове, се мъчим и мак.

294
00:21:11,000 --> 00:21:16,000
Ако говориш за опашки, бихте могли да изберете думите, които искате да използвате

295
00:21:16,000 --> 00:21:23,000
за поставяне и премахване, и няма консенсус за това какво трябва да се нарича.

296
00:21:23,000 --> 00:21:27,000
Но тук имаме enqueue и dequeue.

297
00:21:27,000 --> 00:21:37,000
Сега, структура изглежда почти идентичен с стека структура.

298
00:21:37,000 --> 00:21:40,000
Но ние трябва да следим на главата.

299
00:21:40,000 --> 00:21:44,000
Предполагам, че се казва тук, но защо ние се нуждаем от главата?

300
00:21:53,000 --> 00:21:57,000
Прототипите са основно еднакви, за да прокара и поп.

301
00:21:57,000 --> 00:21:59,000
Можете да мислите за него като натискане и поп.

302
00:21:59,000 --> 00:22:08,000
Единствената разлика е, поп се връща, вместо на последния, е връщането на първо.

303
00:22:08,000 --> 00:22:12,000
2, 1, 3, 4, или нещо такова.

304
00:22:12,000 --> 00:22:14,000
И тук е началото.

305
00:22:14,000 --> 00:22:17,000
Нашата опашката се напълни догоре, така че има четири елемента в него.

306
00:22:17,000 --> 00:22:21,000
Края на опашката ни в момента е 2,

307
00:22:21,000 --> 00:22:24,000
и сега отиваме да вмъкнете нещо друго.

308
00:22:24,000 --> 00:22:29,000
>> Когато искаме да вмъкнем, че нещо друго, това, което направихме за стека версия

309
00:22:29,000 --> 00:22:36,000
се удължава блок на паметта.

310
00:22:36,000 --> 00:22:40,000
Какъв е проблемът с това?

311
00:22:40,000 --> 00:22:45,000
[Student] преместите 2.

312
00:22:45,000 --> 00:22:51,000
Това, което казах преди около края на опашката,

313
00:22:51,000 --> 00:22:57,000
това не прави смисъл, че ние започваме на 1,

314
00:22:57,000 --> 00:23:01,000
тогава ние искаме да dequeue 1, а след това dequeue 3, след което dequeue 4,

315
00:23:01,000 --> 00:23:05,000
dequeue два след това, тогава dequeue това.

316
00:23:05,000 --> 00:23:08,000
Презаделяне Не можем да използваме сега,

317
00:23:08,000 --> 00:23:11,000
или най-малкото, трябва да използвате презаделяне по различен начин.

318
00:23:11,000 --> 00:23:15,000
Но най-вероятно не трябва просто да използвате презаделяне.

319
00:23:15,000 --> 00:23:18,000
Вие ще трябва да копирате ръчно паметта си.

320
00:23:18,000 --> 00:23:21,000
>> Има две функции, за да копирате памет.

321
00:23:21,000 --> 00:23:25,000
Има memcopy и memmove.

322
00:23:25,000 --> 00:23:29,000
Аз съм в момента четене мъж страници, за да видите кои от тях вие ще искате да използвате.

323
00:23:29,000 --> 00:23:35,000
Добре, memcopy, разликата е

324
00:23:35,000 --> 00:23:38,000
memcopy и memmove, дръжки случая правилно

325
00:23:38,000 --> 00:23:41,000
, където можете копирате в региона, което се случва, да се припокриват региона

326
00:23:41,000 --> 00:23:46,000
копирате.

327
00:23:46,000 --> 00:23:50,000
Memcopy не се справя. Memmove.

328
00:23:50,000 --> 00:23:59,000
Можете да мислите за проблем, тъй като

329
00:23:59,000 --> 00:24:09,000
Да кажем, че искате да копирате този човек,

330
00:24:09,000 --> 00:24:13,000
тези четири с този човек повече.

331
00:24:13,000 --> 00:24:16,000
В крайна сметка, това, което масива трябва да изглежда така

332
00:24:16,000 --> 00:24:26,000
след копието е 2, 1, 2, 1, 3, 4, и след това някои неща в края.

333
00:24:26,000 --> 00:24:29,000
Но това е в зависимост от реда, в който ние всъщност копирате,

334
00:24:29,000 --> 00:24:32,000
тъй като, ако не се вземат под внимание факта, че регионът ни копирате в

335
00:24:32,000 --> 00:24:35,000
припокрива сме копиране,

336
00:24:35,000 --> 00:24:46,000
тогава бихме могли да направим като начало тук, копирате 2 в мястото, където искаме да отидем,

337
00:24:46,000 --> 00:24:52,000
след това преместете указатели напред.

338
00:24:52,000 --> 00:24:56,000
>> Сега ще бъда тук и тук, и сега ние искаме да копирате

339
00:24:56,000 --> 00:25:04,000
този човек над този човек и да се премести на нашите указатели напред.

340
00:25:04,000 --> 00:25:07,000
Това, което ще се намира на 2, 1, 2, 1, 2, 1

341
00:25:07,000 --> 00:25:10,000
вместо на съответния 2, 1, 2, 1, 3, 4, тъй като

342
00:25:10,000 --> 00:25:15,000
2, 1, припокрива първоначалното 3, 4.

343
00:25:15,000 --> 00:25:19,000
Memmove обработва правилно.

344
00:25:19,000 --> 00:25:23,000
В този случай, просто винаги използвайте memmove

345
00:25:23,000 --> 00:25:26,000
тъй като тя борави правилно.

346
00:25:26,000 --> 00:25:29,000
Като цяло не се представят по-зле.

347
00:25:29,000 --> 00:25:32,000
Идеята е вместо да се започне от самото начало и копиране този начин

348
00:25:32,000 --> 00:25:35,000
като ние просто направих тук, тя започва от края и да копира,

349
00:25:35,000 --> 00:25:38,000
и в този случай, никога не може да има проблем.

350
00:25:38,000 --> 00:25:40,000
Няма да има изпълнение загуби.

351
00:25:40,000 --> 00:25:47,000
Винаги използвайте memmove. Никога не се тревожи за memcopy.

352
00:25:47,000 --> 00:25:51,000
И това е мястото, където вие ще трябва да отделно memmove

353
00:25:51,000 --> 00:26:01,000
увит около част от опашката си.

354
00:26:01,000 --> 00:26:04,000
Не се тревожете, ако не и напълно прави.

355
00:26:04,000 --> 00:26:10,000
Това е по-трудно, отколкото стека, тласък, и поп.

356
00:26:10,000 --> 00:26:15,000
>> Всеки, който има всеки код, който може да работи с?

357
00:26:15,000 --> 00:26:21,000
Дори ако напълно непълна?

358
00:26:21,000 --> 00:26:23,000
Студентски Да, това е напълно непълна, все пак.

359
00:26:23,000 --> 00:26:27,000
Напълно непълна е добре, докато ние може да ви спести преразглеждане?

360
00:26:27,000 --> 00:26:32,000
Забравяме, че всеки един момент.

361
00:26:32,000 --> 00:26:39,000
Добре, без да обръща внимание на това, което се случва, когато имаме нужда, за да преоразмерите неща.

362
00:26:39,000 --> 00:26:42,000
Напълно да игнорира преоразмеряване.

363
00:26:42,000 --> 00:26:49,000
Обяснете този код.

364
00:26:49,000 --> 00:26:54,000
Аз съм проверка на първо място, ако размерът е по-малко от копие на първо място

365
00:26:54,000 --> 00:27:01,000
и тогава, след това, като поставя-I главата + размер,

366
00:27:01,000 --> 00:27:05,000
и съм сигурен, че го обгръща капацитета на масива,

367
00:27:05,000 --> 00:27:08,000
и аз поставете на новия стринг в това положение.

368
00:27:08,000 --> 00:27:12,000
Тогава увеличаване на размера и връщане вярно.

369
00:27:12,000 --> 00:27:22,000
>> [Rob B.] Това определено е един от онези случаи, когато започваш да искате да се използва мод.

370
00:27:22,000 --> 00:27:25,000
Каквато и да е случай, когато сте обвивка около, ако мислите, обвивка около

371
00:27:25,000 --> 00:27:29,000
непосредствена мисъл трябва да бъде мод.

372
00:27:29,000 --> 00:27:36,000
Като бърза оптимизация / вашия код един ред по-кратък,

373
00:27:36,000 --> 00:27:42,000
забележите, че линията веднага след това

374
00:27:42,000 --> 00:27:53,000
е само размера + +, така че се сливат, че в този ред, размер + +.

375
00:27:53,000 --> 00:27:58,000
Сега тук имаме случай

376
00:27:58,000 --> 00:28:01,000
където ние не разполагат с достатъчно памет,

377
00:28:01,000 --> 00:28:05,000
така че ние се увеличава способността ни по 2.

378
00:28:05,000 --> 00:28:09,000
Предполагам, че тук може да има същия проблем, но можем да го игнорирате,

379
00:28:09,000 --> 00:28:13,000
, където, ако не успя да увеличи капацитета си,

380
00:28:13,000 --> 00:28:18,000
тогава вие ще искате да намалите капацитет от 2 отново.

381
00:28:18,000 --> 00:28:24,000
Друг кратка бележка е точно като можете да направите + =,

382
00:28:24,000 --> 00:28:30,000
можете да направите << =.

383
00:28:30,000 --> 00:28:43,000
Почти всичко да мине преди равен, + =, | =, & =, << =.

384
00:28:43,000 --> 00:28:52,000
Чар * нов е нашият нов блок от памет.

385
00:28:52,000 --> 00:28:55,000
О, тук.

386
00:28:55,000 --> 00:29:02,000
>> Какво мислят хората за вида на нашия нов блок от памет?

387
00:29:02,000 --> 00:29:06,000
[Student] Тя трябва да бъде Чар **.

388
00:29:06,000 --> 00:29:12,000
Мисля обратно към нашата структура тук,

389
00:29:12,000 --> 00:29:14,000
низ е това, което ние сме преразпределение.

390
00:29:14,000 --> 00:29:21,000
Ние сме цяла нова динамика за съхранение на елементите в опашката.

391
00:29:21,000 --> 00:29:25,000
Това, което ще бъде възлагане на вашите струни е това, което ние сме mallocing точно сега,

392
00:29:25,000 --> 00:29:30,000
и толкова ново ще бъде знак **.

393
00:29:30,000 --> 00:29:34,000
Ще бъде масив от низове.

394
00:29:34,000 --> 00:29:38,000
Тогава какъв е случаят, при които отиваме да се върне фалшива?

395
00:29:38,000 --> 00:29:41,000
[Student] трябва да правим Чар *?

396
00:29:41,000 --> 00:29:44,000
[Роб Б. Да, добър разговор.

397
00:29:44,000 --> 00:29:46,000
Студентски] Какво беше това?

398
00:29:46,000 --> 00:29:49,000
[Rob B.] Искахме да направим размера на Чар *, защото ние вече не сме

399
00:29:49,000 --> 00:29:53,000
това всъщност ще бъде много голям проблем, защото sizeof (Чар) ще бъде 1.

400
00:29:53,000 --> 00:29:55,000
Sizeof Чар * ще бъде 4,

401
00:29:55,000 --> 00:29:58,000
толкова много пъти, когато имаш работа с цели числа,

402
00:29:58,000 --> 00:30:01,000
сте склонни да се размине с него, защото размера на вътр и размера на INT *

403
00:30:01,000 --> 00:30:04,000
на 32-битова система ще бъде едно и също нещо.

404
00:30:04,000 --> 00:30:09,000
Но тук, sizeof (Чар) и sizeof (Чар *) са сега щеше да бъде едно и също нещо.

405
00:30:09,000 --> 00:30:15,000
>> Каква е обстоятелство, при връщане фалшиви?

406
00:30:15,000 --> 00:30:17,000
[Студентски] Нови е нула.

407
00:30:17,000 --> 00:30:23,000
Да, ако нова е нищожна, ние връщаме невярна,

408
00:30:23,000 --> 00:30:34,000
и аз отивам да хвърли тук

409
00:30:34,000 --> 00:30:37,000
[Студентски] [недоловим]

410
00:30:37,000 --> 00:30:39,000
[Rob B.] Да, това е добре.

411
00:30:39,000 --> 00:30:46,000
Можете да направите два пъти капацитета или смяна капацитет 1 и след това само го тук или каквото.

412
00:30:46,000 --> 00:30:52,000
Ще го направим както трябва.

413
00:30:52,000 --> 00:30:56,000
Капацитет >> = 1.

414
00:30:56,000 --> 00:31:08,000
И ти никога няма да трябва да се притеснявате за загуба на 1 място

415
00:31:08,000 --> 00:31:12,000
защото сте оставили изместен от 1, така че на едно място е задължително 0

416
00:31:12,000 --> 00:31:16,000
толкова прав преместване от едно, ти все още ще бъде наред.

417
00:31:16,000 --> 00:31:19,000
Студентски Имате ли нужда да направя това преди завръщането?

418
00:31:19,000 --> 00:31:29,000
Rob B.] Да, това няма никакъв смисъл.

419
00:31:29,000 --> 00:31:36,000
>> Сега си отиваме до края връщане верен до края.

420
00:31:36,000 --> 00:31:39,000
Начинът, по който ние ще направим тези memmoves,

421
00:31:39,000 --> 00:31:45,000
ние трябва да бъдем внимателни с това как ние ги правим.

422
00:31:45,000 --> 00:31:50,000
Някой има ли някакви предложения за това как ги правим?

423
00:32:17,000 --> 00:32:21,000
Ето нашето начало.

424
00:32:21,000 --> 00:32:28,000
Неизбежно, искаме да започнем отново в началото

425
00:32:28,000 --> 00:32:35,000
и копирни неща от там, 1, 3, 4, 2.

426
00:32:35,000 --> 00:32:41,000
Как го правиш това?

427
00:32:41,000 --> 00:32:52,000
Първо, аз трябва да гледам към мъжа страница за memmove отново.

428
00:32:52,000 --> 00:32:57,000
Memmove, за аргументи винаги е важно.

429
00:32:57,000 --> 00:33:01,000
Искаме нашата дестинация първият източник второто, размер трета.

430
00:33:01,000 --> 00:33:06,000
Има много функции, които обратната източника и дестинацията.

431
00:33:06,000 --> 00:33:11,000
Дестинация източник води до известна степен да бъдат последователни.

432
00:33:17,000 --> 00:33:21,000
Преместване, какво се върне?

433
00:33:21,000 --> 00:33:27,000
Тя връща указател към дестинация, за каквато и да е причина да искате, че.

434
00:33:27,000 --> 00:33:32,000
Мога да картина го прочете, но ние искаме да се движи в нашата дестинация.

435
00:33:32,000 --> 00:33:35,000
>> Какво е нашата дестинация ще бъде?

436
00:33:35,000 --> 00:33:37,000
[Студентски] New.

437
00:33:37,000 --> 00:33:39,000
[Rob B.] Да, и къде сме копиране?

438
00:33:39,000 --> 00:33:43,000
Първото нещо, което копирате това е 1, 3, 4.

439
00:33:43,000 --> 00:33:50,000
Какъв е този 1, 3, 4.

440
00:33:50,000 --> 00:33:55,000
Какъв е адресът на този 1?

441
00:33:55,000 --> 00:33:58,000
Какъв е адресът на тази една?

442
00:33:58,000 --> 00:34:01,000
[Студентски] [недоловим]

443
00:34:01,000 --> 00:34:03,000
[Роб Б.] Head + адреса на първия елемент.

444
00:34:03,000 --> 00:34:05,000
Как да стигнем до първия елемент в масива?

445
00:34:05,000 --> 00:34:10,000
[Student] опашката.

446
00:34:10,000 --> 00:34:15,000
[Роб Б. Да, q.strings.

447
00:34:15,000 --> 00:34:20,000
Не забравяйте, че тук, главата ни е 1.

448
00:34:20,000 --> 00:34:24,000
Дяволски. Просто мисля, че това е магически

449
00:34:24,000 --> 00:34:29,000
Ето, главата ни е една. Отивам да си сменя цвета също.

450
00:34:29,000 --> 00:34:36,000
И тук е струни.

451
00:34:36,000 --> 00:34:41,000
Това може да го напиша, както направихме тук

452
00:34:41,000 --> 00:34:43,000
с глави + q.strings.

453
00:34:43,000 --> 00:34:51,000
Много хора също го напиша и q.strings [глава].

454
00:34:51,000 --> 00:34:55,000
Това не е много по-малко ефективен.

455
00:34:55,000 --> 00:34:58,000
Може би си мислите за него като го dereferencing и след получаване на адрес на

456
00:34:58,000 --> 00:35:04,000
но компилатора ще все пак да го преведете на това, което сме имали преди, q.strings + главата.

457
00:35:04,000 --> 00:35:06,000
Така или иначе, искате да мисля за него.

458
00:35:06,000 --> 00:35:11,000
>> И колко байта искате да копирате?

459
00:35:11,000 --> 00:35:15,000
[Student] Капацитет - главата.

460
00:35:15,000 --> 00:35:18,000
Капацитет - главата.

461
00:35:18,000 --> 00:35:21,000
И тогава вие винаги може да напишете пример

462
00:35:21,000 --> 00:35:23,000
за да разбера дали това е точно.

463
00:35:23,000 --> 00:35:26,000
[Student] Необходимо е да се раздели на две след това.

464
00:35:26,000 --> 00:35:30,000
Да, така че предполагам, бихме могли да използваме размер.

465
00:35:30,000 --> 00:35:35,000
Ние все още имаме размер-

466
00:35:35,000 --> 00:35:39,000
използване на размер, имаме размер, равен на 4.

467
00:35:39,000 --> 00:35:42,000
Нашата размер е 4. Нашата глава е 1.

468
00:35:42,000 --> 00:35:46,000
Ние искаме да копирате тези три елемента.

469
00:35:46,000 --> 00:35:54,000
Това е здрав разум да се провери дали размера - главата е правилно 3.

470
00:35:54,000 --> 00:35:58,000
И да се върнем тук, както казахме преди,

471
00:35:58,000 --> 00:36:00,000
ако използваме капацитет, тогава ние ще трябва да се разделят с 2

472
00:36:00,000 --> 00:36:04,000
, защото ние сме вече пораснали нашия капацитет, така че вместо ние отиваме да използвате размер.

473
00:36:11,000 --> 00:36:13,000
Копия тази част.

474
00:36:13,000 --> 00:36:18,000
Сега, ние трябва да копирате друга част, частта, която е останало от самото начало.

475
00:36:18,000 --> 00:36:28,000
>> Това ще да memmove в каква позиция?

476
00:36:28,000 --> 00:36:32,000
[Student] Плюс Размер - главата.

477
00:36:32,000 --> 00:36:38,000
Да, така че ние вече са копирани в размер байта за глава,

478
00:36:38,000 --> 00:36:43,000
и така, когато искаме да копирате останалите байта ново

479
00:36:43,000 --> 00:36:48,000
и след това размер на минус-добре, броят на байтовете сме вече копира инча

480
00:36:48,000 --> 00:36:52,000
И тогава къде сме копиране?

481
00:36:52,000 --> 00:36:54,000
[Студентски] Q.strings [0].

482
00:36:54,000 --> 00:36:56,000
[Роб Б. Да, q.strings.

483
00:36:56,000 --> 00:37:02,000
Бихме могли да направите и q.strings [0].

484
00:37:02,000 --> 00:37:05,000
Това е значително по-често, отколкото това.

485
00:37:05,000 --> 00:37:14,000
Ако това е просто ще бъде 0, тогава ще са склонни да видите q.strings.

486
00:37:14,000 --> 00:37:16,000
Това е мястото, където ние сме копиране от.

487
00:37:16,000 --> 00:37:18,000
Колко байта ние оставихме да копирате? >> Студентски] 10.

488
00:37:18,000 --> 00:37:20,000
Точно така.

489
00:37:20,000 --> 00:37:25,000
[Student] имаме да се размножават 5 - 10 пъти по-голяма от байтове или нещо?

490
00:37:25,000 --> 00:37:30,000
Да, така че това е къде-какво точно копиране?

491
00:37:30,000 --> 00:37:32,000
[Студентски] [недоловим]

492
00:37:32,000 --> 00:37:34,000
Какъв е типът на нещо, което копирате?

493
00:37:34,000 --> 00:37:36,000
[Студентски] [недоловим]

494
00:37:36,000 --> 00:37:41,000
Да, така Чар * е, че ние сме копиране, ние не знам къде са тези, идващи от.

495
00:37:41,000 --> 00:37:47,000
Е, където те се посочи, подобно на струните, ние в крайна сметка го натиснете върху опашката

496
00:37:47,000 --> 00:37:49,000
или enqueuing върху опашката.

497
00:37:49,000 --> 00:37:51,000
Когато тези, които идват, ние нямаме идея.

498
00:37:51,000 --> 00:37:56,000
Ние просто трябва да следим на знак * и се.

499
00:37:56,000 --> 00:38:00,000
Ние не искаме да копирате размер - главата байта.

500
00:38:00,000 --> 00:38:03,000
Ние искаме да копирате размер - главата Чар * S,

501
00:38:03,000 --> 00:38:11,000
така че отиваме да се размножават от sizeof (Чар *).

502
00:38:11,000 --> 00:38:17,000
Същото тук главата * sizeof (Чар *).

503
00:38:17,000 --> 00:38:24,000
>> [Student] [чува?

504
00:38:24,000 --> 00:38:26,000
Това право тук?

505
00:38:26,000 --> 00:38:28,000
[Student] Не, по-долу, размер на главата.

506
00:38:28,000 --> 00:38:30,000
[Rob B.] Това тук?

507
00:38:30,000 --> 00:38:32,000
Pointer аритметика.

508
00:38:32,000 --> 00:38:35,000
Как ще работи показалеца аритметика

509
00:38:35,000 --> 00:38:40,000
той автоматично се размножава от размера на вид, че си имаме работа с.

510
00:38:40,000 --> 00:38:46,000
Точно както тук, нов + (размер - главата)

511
00:38:46,000 --> 00:38:56,000
е точно еквивалентна на & [размер - началник]

512
00:38:56,000 --> 00:39:00,000
докато ние очакваме, че за да работи правилно,

513
00:39:00,000 --> 00:39:04,000
тъй като, ако си имаме работа с едно цяло число масив, тогава ние не индекс от INT-

514
00:39:04,000 --> 00:39:07,000
или ако е по размер на 5 и искате 4-ти елемент, тогава ние индекс в

515
00:39:07,000 --> 00:39:10,000
Int масив [4].

516
00:39:10,000 --> 00:39:14,000
Не ... [4] * размер на вътр.

517
00:39:14,000 --> 00:39:21,000
Това обработва автоматично, и този случай

518
00:39:21,000 --> 00:39:29,000
е буквално еквивалент, така че скобата синтаксис

519
00:39:29,000 --> 00:39:34,000
тепърва ще се превръща в това, веднага след като се състави.

520
00:39:34,000 --> 00:39:38,000
Това е нещо, което трябва да бъдат внимателни на това

521
00:39:38,000 --> 00:39:42,000
когато добавяте размер - главата

522
00:39:42,000 --> 00:39:45,000
не се добавят един байт.

523
00:39:45,000 --> 00:39:53,000
Добавяте един знак *, който може да бъде един байта или каквито и да било.

524
00:39:53,000 --> 00:39:56,000
>> Други въпроси?

525
00:39:56,000 --> 00:40:04,000
Добре, dequeue ще бъде по-лесно.

526
00:40:04,000 --> 00:40:11,000
Ще ви дам минути за изпълнение.

527
00:40:11,000 --> 00:40:18,000
О, и аз предполагам, че това е същата ситуация, където

528
00:40:18,000 --> 00:40:21,000
какво enqueue случай,, ако сме enqueuing нула,

529
00:40:21,000 --> 00:40:24,000
може би искаме да се справя, може би не го правим.

530
00:40:24,000 --> 00:40:27,000
Ние няма да го направя отново тук, но същата като нашата стека случай.

531
00:40:27,000 --> 00:40:34,000
Ако ние enqueue нула, бихме искали да го отхвърлят.

532
00:40:34,000 --> 00:40:40,000
Всеки, който има някакъв код мога да спра?

533
00:40:40,000 --> 00:40:45,000
[Student] Аз просто имам dequeue.

534
00:40:45,000 --> 00:40:56,000
Версия 2 е, че става.

535
00:40:56,000 --> 00:40:59,000
Искаш ли да обясни?

536
00:40:59,000 --> 00:41:01,000
[Student] Първо, се уверете, че има нещо в опашката

537
00:41:01,000 --> 00:41:07,000
и че размерът е от 1.

538
00:41:07,000 --> 00:41:11,000
Вие трябва да направите това, а после се върнете главата

539
00:41:11,000 --> 00:41:13,000
и след това преместете главата 1.

540
00:41:13,000 --> 00:41:19,000
Добре, така че има ъгъл случай, че трябва да се помисли. Да.

541
00:41:19,000 --> 00:41:24,000
[Student] Ако главата ти е последният елемент,

542
00:41:24,000 --> 00:41:26,000
след това не искате главата до точка извън масива.

543
00:41:26,000 --> 00:41:29,000
>> Да, така че веднага след като главата удари края на нашата масив,

544
00:41:29,000 --> 00:41:35,000
когато ние dequeue, главата ни трябва да бъде Modded обратно в 0.

545
00:41:35,000 --> 00:41:40,000
За съжаление, ние не можем да направим това в една стъпка.

546
00:41:40,000 --> 00:41:44,000
Предполагам, че вероятно щях да се определи, че е

547
00:41:44,000 --> 00:41:52,000
това ще бъде знак *, какво Връщаме

548
00:41:52,000 --> 00:41:55,000
каквото си име на променлива иска да бъде.

549
00:41:55,000 --> 00:42:02,000
След това ние искаме да моден главата от способността ни

550
00:42:02,000 --> 00:42:10,000
и след това се върнете кисна.

551
00:42:10,000 --> 00:42:14,000
Много хора тук биха могли да сторят-

552
00:42:14,000 --> 00:42:19,000
такъв е случаят - Ще видите хора, ако главата

553
00:42:19,000 --> 00:42:29,000
е по-голяма от капацитета, главата - капацитет.

554
00:42:29,000 --> 00:42:36,000
И това е само около това, което Министерството на отбраната.

555
00:42:36,000 --> 00:42:41,000
Ръководител мод = капацитет е много по-чист

556
00:42:41,000 --> 00:42:51,000
на обвивка около отколкото ако главата по-голяма от капацитета на главата - капацитет.

557
00:42:51,000 --> 00:42:56,000
>> Въпроси?

558
00:42:56,000 --> 00:43:02,000
Добре, последното нещо, което ни е останало, е нашето свързан списък.

559
00:43:02,000 --> 00:43:07,000
Може да се използва за някои от свързан списък поведение, ако си направил

560
00:43:07,000 --> 00:43:11,000
свързани списъци във вашите хеш таблици, ако си направил хеш таблица.

561
00:43:11,000 --> 00:43:15,000
Горещо препоръчвам прави хеш таблица.

562
00:43:15,000 --> 00:43:17,000
Може би вече са го направили Trie

563
00:43:17,000 --> 00:43:23,000
но се опитва по-трудно.

564
00:43:23,000 --> 00:43:27,000
На теория, те са асимптотично по-добре.

565
00:43:27,000 --> 00:43:30,000
Но просто погледнете голямата съвет,

566
00:43:30,000 --> 00:43:35,000
и се опитва никога не се справят по-добре, и те заемат повече памет.

567
00:43:35,000 --> 00:43:43,000
Всичко за опитва в крайна сметка е по-лошо за повече работа.

568
00:43:43,000 --> 00:43:49,000
Това е това, което винаги е решение Дейвид Малан

569
00:43:49,000 --> 00:43:56,000
Той винаги е мнението му Trie решение, и нека видим къде в момента той е.

570
00:43:56,000 --> 00:44:00,000
Това, което той е бил под, Дейвид J?

571
00:44:00,000 --> 00:44:06,000
Той е # 18, така че не е ужасно лош,

572
00:44:06,000 --> 00:44:09,000
и това ще бъде един от най-добрите опитва можеш да се сетиш

573
00:44:09,000 --> 00:44:17,000
или на един от най-добрите се опитва на Trie.

574
00:44:17,000 --> 00:44:23,000
Не е дори първоначалното си решение?

575
00:44:23,000 --> 00:44:29,000
Аз се чувствам като Trie решения са склонни да бъдат повече в този диапазон на използване на RAM.

576
00:44:29,000 --> 00:44:33,000
>> Отиди до самия връх, както и използването на RAM е в едноцифрени числа.

577
00:44:33,000 --> 00:44:36,000
Слез надолу към дъното, а след това започнете да виждате опитва

578
00:44:36,000 --> 00:44:41,000
, където можете да получите огромна RAM използване,

579
00:44:41,000 --> 00:44:45,000
и се опитва по-трудно.

580
00:44:45,000 --> 00:44:53,000
Не съвсем си струва, но образователен опит, ако си направил.

581
00:44:53,000 --> 00:44:56,000
Последното нещо, което е нашата свързан списък,

582
00:44:56,000 --> 00:45:04,000
и тези три неща, стекове, опашки и свързани списъци,

583
00:45:04,000 --> 00:45:09,000
всяко бъдещо нещо, което някога по компютърни науки

584
00:45:09,000 --> 00:45:12,000
ще предположим, че имате запознати с тези неща.

585
00:45:12,000 --> 00:45:19,000
Те са също толкова фундаментално значение за всичко.

586
00:45:19,000 --> 00:45:25,000
>> Свързани списъци, и тук имаме самостоятелно свързан списък ще бъде нашето изпълнение.

587
00:45:25,000 --> 00:45:34,000
Какво прави поотделно свързани кажа, за разлика от двойно свързан? Да.

588
00:45:34,000 --> 00:45:37,000
[Student само насочва към следващия показалеца, а не на указатели,

589
00:45:37,000 --> 00:45:39,000
като един преди и след него.

590
00:45:39,000 --> 00:45:44,000
Да, така и в формат на картината, какво съм просто правя?

591
00:45:44,000 --> 00:45:48,000
Аз имам две неща. Имам картина и картина.

592
00:45:48,000 --> 00:45:51,000
Формат на картината, нашите единично свързани списъци,

593
00:45:51,000 --> 00:45:57,000
неизбежно, ние имаме някакъв вид на показалеца на главата на нашия списък,

594
00:45:57,000 --> 00:46:02,000
и след това в рамките на нашия списък, ние просто трябва указатели,

595
00:46:02,000 --> 00:46:05,000
и може би това показва нула.

596
00:46:05,000 --> 00:46:08,000
Ще бъде типичен чертеж на самостоятелно свързан списък.

597
00:46:08,000 --> 00:46:14,000
Двойно свързан списък, можете да се върнете назад.

598
00:46:14,000 --> 00:46:19,000
Ако ти дам всеки възел в списъка, а след това е задължително да се стигне до

599
00:46:19,000 --> 00:46:23,000
всеки друг възел в списъка, ако е двойно свързан списък.

600
00:46:23,000 --> 00:46:27,000
Но ако можете да получите на трети възел в списъка и това е самостоятелно свързан списък,

601
00:46:27,000 --> 00:46:30,000
никакъв начин не сте никога няма да стигнем до първа и втора възли.

602
00:46:30,000 --> 00:46:34,000
А има и ползи и вреди, и една очевидна

603
00:46:34,000 --> 00:46:42,000
ви отнеме повече размер, и вие трябва да следите, където тези неща са насочени сега.

604
00:46:42,000 --> 00:46:49,000
Но ние само се грижи за самостоятелно свързани.

605
00:46:49,000 --> 00:46:53,000
>> Няколко неща, които ще трябва да прилагат.

606
00:46:53,000 --> 00:47:00,000
Typedef възел структура, вътр аз: структура възел * следващия; възел.

607
00:47:00,000 --> 00:47:09,000
Това typedef трябва да се изгори в съзнанието си.

608
00:47:09,000 --> 00:47:14,000
Quiz 1 трябва да се даде typedef на свързан списък възел,

609
00:47:14,000 --> 00:47:18,000
и трябва да бъде в състояние незабавно да драскам, че

610
00:47:18,000 --> 00:47:22,000
без дори да мисля за това.

611
00:47:22,000 --> 00:47:27,000
Предполагам, че няколко въпроса, защо имаме нужда от структура тук?

612
00:47:27,000 --> 00:47:32,000
Защо не можем да кажем възел *?

613
00:47:32,000 --> 00:47:35,000
[Студентски] [недоловим]

614
00:47:35,000 --> 00:47:38,000
Да.

615
00:47:38,000 --> 00:47:44,000
Единственото нещо, което определя възел като нещо

616
00:47:44,000 --> 00:47:47,000
е самата typedef.

617
00:47:47,000 --> 00:47:55,000
Но от този момент, когато сме на морфологичните чрез това определение структурата възел,

618
00:47:55,000 --> 00:48:01,000
не сме готови все още ни typedef така, тъй като typedef не е приключил,

619
00:48:01,000 --> 00:48:05,000
възел не съществува.

620
00:48:05,000 --> 00:48:12,000
Но структурата на възел прави, и този възел тук,

621
00:48:12,000 --> 00:48:14,000
това може да се нарече всичко друго.

622
00:48:14,000 --> 00:48:16,000
Това може да се нарече N.

623
00:48:16,000 --> 00:48:19,000
Това може да се нарече свързан списък възел.

624
00:48:19,000 --> 00:48:21,000
Това може да се нарече нищо.

625
00:48:21,000 --> 00:48:26,000
Но тази структура възел трябва да се нарича едно и също нещо, тъй като това структурата възел.

626
00:48:26,000 --> 00:48:29,000
Това, което наричате това трябва да бъде тук,

627
00:48:29,000 --> 00:48:32,000
и така, че отговаря също на втората точка на въпроса

628
00:48:32,000 --> 00:48:37,000
поради което много пъти, когато видите structs и typedefs на structs

629
00:48:37,000 --> 00:48:42,000
ще видите анонимни structs където ще видите typedef структура,

630
00:48:42,000 --> 00:48:47,000
изпълнението на структура, речник, или каквото.

631
00:48:47,000 --> 00:48:51,000
>> Защо тук трябва да кажем възел?

632
00:48:51,000 --> 00:48:54,000
Защо не може да е анонимен структура?

633
00:48:54,000 --> 00:48:56,000
Това е почти един и същ отговор.

634
00:48:56,000 --> 00:48:58,000
Студентски] трябва да се отнасят към него в рамките на структурата.

635
00:48:58,000 --> 00:49:04,000
Да, в рамките на структура, трябва да се отнасят до самата структура.

636
00:49:04,000 --> 00:49:10,000
Ако не дават структура име, ако е анонимен структура, не може да се отнася към него.

637
00:49:10,000 --> 00:49:17,000
И накрая, но не на последно място, всички те трябва да бъдат малко по-ясно,

638
00:49:17,000 --> 00:49:20,000
и те трябва да ви помогнат да реализирате ако пишете това

639
00:49:20,000 --> 00:49:24,000
, че правиш нещо нередно, ако тези видове неща не правят смисъл.

640
00:49:24,000 --> 00:49:28,000
И накрая, но не на последно място, защо това да бъде структура * възел?

641
00:49:28,000 --> 00:49:34,000
Защо не може просто да се структура възел следващият?

642
00:49:34,000 --> 00:49:37,000
[Student] Pointer към следващия структура.

643
00:49:37,000 --> 00:49:39,000
Това е неизбежно, което искаме.

644
00:49:39,000 --> 00:49:42,000
Защо никога не може да бъде структура възел следващия?

645
00:49:42,000 --> 00:49:50,000
Защо това трябва да бъде структурата възел * следващия? Да.

646
00:49:50,000 --> 00:49:53,000
[Student] Това е като един безкраен цикъл.

647
00:49:53,000 --> 00:49:55,000
Да.

648
00:49:55,000 --> 00:49:57,000
[Student] Всичко щеше да бъде в едно.

649
00:49:57,000 --> 00:50:02,000
Да, просто мисля за това как ние ще направим размер или нещо.

650
00:50:02,000 --> 00:50:08,000
Размер на структурата е основно + или - някои модел тук или там.

651
00:50:08,000 --> 00:50:15,000
Това е основно ще бъде сумата от размерите на нещата в структурата.

652
00:50:15,000 --> 00:50:18,000
Това право тук, без да се променя нищо, размерът ще бъде лесно.

653
00:50:18,000 --> 00:50:24,000
Размер на структурата възел ще бъде размера на I + размера на следващата.

654
00:50:24,000 --> 00:50:27,000
Размер на I ще бъде 4. Размер на следващата ще бъде 4.

655
00:50:27,000 --> 00:50:30,000
Размер на структурата възел ще бъде 8.

656
00:50:30,000 --> 00:50:34,000
Ако ние нямаме *, мислейки, sizeof,

657
00:50:34,000 --> 00:50:37,000
sizeof (I) ще бъде 4.

658
00:50:37,000 --> 00:50:43,000
Размер на структурата възел следващата ще бъде размера на I + размера на структурата възел следващия

659
00:50:43,000 --> 00:50:46,000
+ Размера на I + размера на структурата възел следващия.

660
00:50:46,000 --> 00:50:55,000
Това ще бъде безкрайна рекурсия на възли.

661
00:50:55,000 --> 00:51:00,000
Това е така, защо това е начина, по който нещата трябва да бъдат.

662
00:51:00,000 --> 00:51:03,000
>> Отново, определено запомните, че

663
00:51:03,000 --> 00:51:06,000
или поне го разбирам достатъчно, че да може да бъде в състояние да

664
00:51:06,000 --> 00:51:12,000
причина през това, което би трябвало да изглежда.

665
00:51:12,000 --> 00:51:14,000
Неща, които ще искат да приложат.

666
00:51:14,000 --> 00:51:18,000
Ако дължината на списъка

667
00:51:18,000 --> 00:51:21,000
да надхитриш и поддържа около

668
00:51:21,000 --> 00:51:24,000
общата продължителност или нещо подобно, но ние няма да направим това.

669
00:51:24,000 --> 00:51:28,000
Отиваме да отчитат дължината на списъка.

670
00:51:28,000 --> 00:51:34,000
Ние сме съдържа, така че това е основно като търсене,

671
00:51:34,000 --> 00:51:41,000
така че ние имаме свързан списък от цели числа, за да видите, ако това число е в свързан списък.

672
00:51:41,000 --> 00:51:44,000
Добавя се случва да вмъкнете в началото на списъка.

673
00:51:44,000 --> 00:51:46,000
Добавяне ще се вмъкнете в края.

674
00:51:46,000 --> 00:51:53,000
Insert_sorted ще да вмъкнете в сортират позиция в списъка.

675
00:51:53,000 --> 00:52:01,000
Insert_sorted вид предполага, че никога не сте използвали добавя нищо в лоши отношения.

676
00:52:01,000 --> 00:52:09,000
>> Insert_sorted когато сте прилагане insert_sorted

677
00:52:09,000 --> 00:52:13,000
Да кажем, че имаме свързан списък.

678
00:52:13,000 --> 00:52:18,000
Това е, което в момента изглежда, 2, 4, 5.

679
00:52:18,000 --> 00:52:24,000
Искам да вмъкнете три, толкова дълго, колкото самият списък вече е сортиран,

680
00:52:24,000 --> 00:52:27,000
това е лесно да се намери, където три принадлежи.

681
00:52:27,000 --> 00:52:29,000
Започват от 2.

682
00:52:29,000 --> 00:52:32,000
Добре, 3 е по-голямо от 2, така че искам да продължа.

683
00:52:32,000 --> 00:52:35,000
О, 4 е твърде голям, така че аз знам 3 ще отиде между 2 и 4,

684
00:52:35,000 --> 00:52:39,000
и аз трябва да определи насоки и всички тези неща.

685
00:52:39,000 --> 00:52:43,000
Но ако ние не строго използвате insert_sorted,

686
00:52:43,000 --> 00:52:50,000
харесва нека просто кажем, предшестван 6,

687
00:52:50,000 --> 00:52:55,000
след това ми свързан списък ще стане това.

688
00:52:55,000 --> 00:53:01,000
Сега няма смисъл, така че за insert_sorted, можете просто да поеме

689
00:53:01,000 --> 00:53:04,000
че списъкът се сортира, въпреки че операциите съществуват

690
00:53:04,000 --> 00:53:09,000
което може да причини да не бъде сортирана и това е всичко.

691
00:53:09,000 --> 00:53:20,000
Вижте полезна вмъква така че тези са основните неща, които ще трябва да прилагат.

692
00:53:20,000 --> 00:53:24,000
>> За сега, отделете малко време да се направи дължина и съдържа

693
00:53:24,000 --> 00:53:30,000
и тези, които трябва да бъдат сравнително бързо.

694
00:53:41,000 --> 00:53:48,000
Наближава края на работното време, така че всеки има нещо за дължина или съдържа?

695
00:53:48,000 --> 00:53:50,000
Те ще бъдат почти идентични.

696
00:53:50,000 --> 00:53:57,000
[Student] Дължина.

697
00:53:57,000 --> 00:54:01,000
Да видим, преразглеждане.

698
00:54:01,000 --> 00:54:04,000
Добре.

699
00:54:12,000 --> 00:54:15,000
Искаш ли да обясни?

700
00:54:15,000 --> 00:54:21,000
[Student] Аз просто се създаде възел показалеца и да я инициализираме на първото, което е нашата глобална променлива,

701
00:54:21,000 --> 00:54:27,000
и след това да проверя, за да се види дали е нула, така че аз не се получи сегмент вина и да се върне 0, ако случаят е такъв.

702
00:54:27,000 --> 00:54:34,000
В противен случай, аз верига, следене в рамките на цяло число

703
00:54:34,000 --> 00:54:38,000
колко пъти съм достъп до следващия елемент от списъка

704
00:54:38,000 --> 00:54:43,000
и в една и съща операция нарастване също, че реалният елемент,

705
00:54:43,000 --> 00:54:47,000
и след това аз постоянно се направи проверка, за да видите дали това е нищожна,

706
00:54:47,000 --> 00:54:56,000
и ако това е нищожно, то тогава прекъсва и се връща броя на елементите, които съм достъпни.

707
00:54:56,000 --> 00:55:01,000
>> [Rob B.] Някой има ли някакви коментари за нещо?

708
00:55:01,000 --> 00:55:06,000
Глоба коректност Това изглежда разумно.

709
00:55:06,000 --> 00:55:10,000
[Студентски] Аз не мисля, че трябва възел == нула.

710
00:55:10,000 --> 00:55:13,000
Да, така че ако възел == нула връщането на 0.

711
00:55:13,000 --> 00:55:18,000
Но ако възел == нула, то това О, там е въпросът за вярност.

712
00:55:18,000 --> 00:55:23,000
Това беше просто сте и връщане, но това не е в обхвата точно сега.

713
00:55:23,000 --> 00:55:30,000
Ти просто трябва Int I, така че аз = 0.

714
00:55:30,000 --> 00:55:34,000
Но ако възел е нула, тогава аз все още ще бъде 0,

715
00:55:34,000 --> 00:55:39,000
и ние ще върне 0, така че този случай е идентичен.

716
00:55:39,000 --> 00:55:48,000
Друг често срещан нещо е да съхранява декларацията

717
00:55:48,000 --> 00:55:51,000
възел вътрешната страна за цикъла.

718
00:55:51,000 --> 00:55:54,000
Може да се каже, о, не.

719
00:55:54,000 --> 00:55:56,000
Да се ​​запази, тъй като това.

720
00:55:56,000 --> 00:55:59,000
Вероятно бих Int I = 0 тук,

721
00:55:59,000 --> 00:56:05,000
възел * възел = първо тук.

722
00:56:05,000 --> 00:56:11,000
И това е може би как да се отървем от това сега.

723
00:56:11,000 --> 00:56:14,000
Това е може би, как щях да го написали.

724
00:56:14,000 --> 00:56:21,000
Вие също може да го гледа по този начин.

725
00:56:21,000 --> 00:56:25,000
Това за контур структура тук

726
00:56:25,000 --> 00:56:30,000
трябва да бъде почти толкова естествено за вас като за Int I = 0

727
00:56:30,000 --> 00:56:33,000
I е по-малко от дължината на масива + +.

728
00:56:33,000 --> 00:56:38,000
Ако това е начина, по който обхождане на масив, това е начина, по който обхождане на свързан списък.

729
00:56:38,000 --> 00:56:45,000
>> Това трябва да е втора природа в някакъв момент.

730
00:56:45,000 --> 00:56:50,000
С това се има предвид, че това ще е почти едно и също нещо.

731
00:56:50,000 --> 00:56:57,000
Вие ще искате за обхождане на свързан списък.

732
00:56:57,000 --> 00:57:02,000
Ако възел Нямам представа каква стойност се нарича.

733
00:57:02,000 --> 00:57:04,000
Възел.

734
00:57:04,000 --> 00:57:15,000
Ако стойността на този възел = върна вярно, и това е всичко.

735
00:57:15,000 --> 00:57:18,000
Забележете, че единствения начин да се върнат някога фалшива

736
00:57:18,000 --> 00:57:23,000
е, ако ние обхождане на цялата свързан списък и никога не се връщат истина,

737
00:57:23,000 --> 00:57:29,000
така че какво прави това.

738
00:57:29,000 --> 00:57:36,000
Като страна нота-вероятно няма да стигнем до добавяте или да се добавя нищо.

739
00:57:36,000 --> 00:57:39,000
>> Бързо последната нота.

740
00:57:39,000 --> 00:57:52,000
Ако видите статично ключова дума, така че нека кажем статичен Int брой = 0,

741
00:57:52,000 --> 00:57:56,000
тогава ние се броят + +, можете да основно мисля за него като глобална променлива,

742
00:57:56,000 --> 00:58:00,000
въпреки че току-що казах, това не е начина, по който ще приложи дължина.

743
00:58:00,000 --> 00:58:06,000
Правя това, и след това разчитат + +.

744
00:58:06,000 --> 00:58:11,000
Всеки път, можем да влезем възел в свързан нашия списък са увеличаване броя.

745
00:58:11,000 --> 00:58:15,000
Смисълът на това е, какво означава статичното ключова дума.

746
00:58:15,000 --> 00:58:20,000
Ако аз просто трябваше INT брой = 0, това би било редовно стар глобална променлива.

747
00:58:20,000 --> 00:58:25,000
Какво статични INT брой на средствата е, че тя е глобална променлива за този файл.

748
00:58:25,000 --> 00:58:28,000
Невъзможно е за някой друг файл,

749
00:58:28,000 --> 00:58:34,000
мисля за pset 5, ако сте започнали.

750
00:58:34,000 --> 00:58:39,000
Имате и двете speller.c и имате dictionary.c,

751
00:58:39,000 --> 00:58:42,000
и ако просто декларира нещо в световен мащаб, а след това нещо в speller.c

752
00:58:42,000 --> 00:58:45,000
могат да бъдат достъпни в dictionary.c и обратно.

753
00:58:45,000 --> 00:58:48,000
Глобалните променливи са достъпни от всеки файл в

754
00:58:48,000 --> 00:58:54,000
но статични променливи са достъпни само от самия файл,

755
00:58:54,000 --> 00:59:01,000
така че в рамките на проверка на правописа или отвътре dictionary.c

756
00:59:01,000 --> 00:59:06,000
това е един вид как щях да заявя променлива за размера на моя масив

757
00:59:06,000 --> 00:59:10,000
или размера на броя на думите в речника.

758
00:59:10,000 --> 00:59:15,000
Тъй като аз не искам да обяви глобална променлива, че всеки има достъп до

759
00:59:15,000 --> 00:59:18,000
Аз наистина само се грижи за собствените си цели.

760
00:59:18,000 --> 00:59:21,000
>> Хубавото на това е цялото име сблъсък неща.

761
00:59:21,000 --> 00:59:27,000
Ако някой друг файл се опитва да използва глобална променлива, наречена брой, нещата вървят много, много грешно,

762
00:59:27,000 --> 00:59:33,000
така че това добре поддържа нещата безопасно, и само вие можете да получите достъп до него,

763
00:59:33,000 --> 00:59:38,000
и никой друг не може, а ако някой друг декларира глобална променлива, наречена брой,

764
00:59:38,000 --> 00:59:43,000
то тогава няма да се намесва със статично променлива наречена брой.

765
00:59:43,000 --> 00:59:47,000
Ето какво статично. Това е глобална променлива файл.

766
00:59:47,000 --> 00:59:52,000
>> Въпроси за всичко?

767
00:59:52,000 --> 00:59:59,000
Всичко е готово. Чао.

768
00:59:59,000 --> 01:00:03,000
[CS50.TV]