1
00:00:00,000 --> 00:00:01,000
[Powered by Google Translate] [Дел 6] [поудобно]

2
00:00:01,000 --> 00:00:04,000
[Роб Бауден] [Универзитетот Харвард]

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
[Студентски] Проверки меморија протекување.

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
од 1.000 блокови unfreed.

40
00:02:23,000 --> 00:02:26,000
1.000 блокови 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
Ревизија 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
Притисни е само да ги ставите на магацинот.

75
00:04:34,000 --> 00:04:37,000
Поп е полетување на магацинот.

76
00:04:37,000 --> 00:04:43,000
И гледаме тука ние имаме typedef struct оџакот,

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
Еве, ние сме притисни декларирани како bool притисни (char * ул).

109
00:06:50,000 --> 00:06:54,000
Char * ул е стринг кој се врши притисок врз оџакот,

110
00:06:54,000 --> 00:06:58,000
и bool само вели дали успеавме или не.

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
зголеми капацитетот и Примерок или што враќа false.

132
00:08:26,000 --> 00:08:30,000
Потоа pop се без аргументи,

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
Во Јава, ако сте навикнати на тоа, или други јазици,

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

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
Постојат семејството на alloc функции.

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
>> Realloc е како Примерок и има многу посебни случаи,

156
00:10:15,000 --> 00:10:19,000
но во основа она што realloc не е

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

158
00:10:24,000 --> 00:10:27,000
Realloc е во функција сакате да се обрнувајќи внимание на овде.

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
па ти се јавам realloc на тој покажувач со 20 бајти,

163
00:10:42,000 --> 00:10:47,000
и realloc автоматски ќе копирајте над сè за вас.

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
Realloc ќе се справи со тоа за вас.

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
потоа празнина * кон меморија.

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
е сега ќе биде предадена realloc, а потоа големина

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
[Студентски] Прво на сите, јас зголемување на големината.

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
>> [Роб Б] Исто така забележите дека ние се користи убав bitwise оператор тука

202
00:14:07,000 --> 00:14:09,000
да множи со 2.

203
00:14:09,000 --> 00:14:11,000
Запомнете, лево поместување е секогаш ќе биде помножена со 2.

204
00:14:11,000 --> 00:14:15,000
Право промена се дели со 2 онолку долго колку што се сеќавам дека тоа значи

205
00:14:15,000 --> 00:14:18,000
подели со 2, како и во цел број поделен со 2.

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

207
00:14:20,000 --> 00:14:26,000
Но промена од лево со 1 е секогаш ќе биде помножена со 2,

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
На пропаднат услов тука е што не успеа да realloc, така да.

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
е тука, каде realloc враќа нула,

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

247
00:17:41,000 --> 00:17:44,000
>> Секој имате било што друго да се напомене? Да.

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

249
00:17:47,000 --> 00:17:55,000
[Роб Б] Да, вистинските binariness на тоа или само што е тоа?

250
00:17:55,000 --> 00:17:57,000
[Студентски] Така да тоа множи со 2?

251
00:17:57,000 --> 00:17:59,000
[Роб Б] Да, во основа.

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
Вие би можеле да ми се допаѓа, ако се случи да pop-еден куп,

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

273
00:19:38,000 --> 00:19:42,000
Вие би можеле да realloc да се намали количината на меморија имате,

274
00:19:42,000 --> 00:19:47,000
но вие не мора да се грижите за тоа, па само realloc случај ќе биде

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
Тука, ние се случи да ги вика Стави во ред и 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
Но, еве, имаме Стави во ред и dequeue.

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

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
[Студентски] Што се движат од 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 2, тогаш dequeue оваа.

316
00:23:05,000 --> 00:23:08,000
Ние не можеме да го користите realloc сега,

317
00:23:08,000 --> 00:23:11,000
или во најмала рака, мора да се користат realloc во еден поинаков начин.

318
00:23:11,000 --> 00:23:15,000
Но најверојатно не само треба да се користи realloc.

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 overrode оригиналниот 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
а потоа и по тоа, јас вметнете-земам главата + големина,

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
>> [Роб Б] Ова е дефинитивно една од оние случаи каде што ви се случува да сакаат да бидат со користење современи.

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
Char * нови е нашиот нов блок од меморија.

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
[Студентски] Тоа треба да биде знак **.

388
00:29:06,000 --> 00:29:12,000
Размислување назад кон нашите struct се тука,

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
[Студентски] Треба ли да се прави char *?

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
[Роб Б] Сакавме да го направите големината на char * затоа што ние веќе не се-

399
00:29:49,000 --> 00:29:53,000
ова всушност ќе биде многу голем проблем, бидејќи sizeof (знак) ќе биде 1.

400
00:29:53,000 --> 00:29:55,000
Sizeof char * ќе биде 4,

401
00:29:55,000 --> 00:29:58,000
па многу пати кога си имаш работа со ints,

402
00:29:58,000 --> 00:30:01,000
ќе имаат тенденција да се извлечеш со тоа, бидејќи големината на int и големината на int *

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

404
00:30:04,000 --> 00:30:09,000
Но, овде, sizeof (знак) и sizeof (char *) сега се случува да биде истото.

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
[Роб Б] Да, тоа е во ред.

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

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, така што 1 е место е нужно 0,

416
00:31:12,000 --> 00:31:16,000
па десно поместување од 1, ти си уште ќе биде во ред.

417
00:31:16,000 --> 00:31:19,000
[Студентски] Дали треба да го направи тоа пред да се врати?

418
00:31:19,000 --> 00:31:29,000
[Роб Б] Да, тоа го прави апсолутно никаква смисла.

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
[Студентски] Нови.

437
00:33:37,000 --> 00:33:39,000
[Роб Б] Да, и каде сме ние копирање од?

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
Што е адресата на која 1?

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

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

444
00:34:03,000 --> 00:34:05,000
Како да ја добиете првиот елемент во низата?

445
00:34:05,000 --> 00:34:10,000
[Студентски] задача.

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
Еве, нашата глава е 1. Одам да ги променам моите бои премногу.

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
[Студентски] Капацитет - глава.

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
[Студентски] Тоа треба да се подели со 2 тогаш.

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
Ние сакаме да го копирате овие 3 елементи.

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
[Студентски] Плус големина - глава.

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
[Студентски] Дали треба да се размножуваат 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
Да, па char * а дека ние сме копирање, не знаеме каде тие доаѓаат од.

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
Ние само треба да ги пратите на char * s себе.

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

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

501
00:38:03,000 --> 00:38:11,000
па ние ќе ја помножиш оваа страна sizeof (char *).

502
00:38:11,000 --> 00:38:17,000
Исто тука долу, главата * sizeof (char *).

503
00:38:17,000 --> 00:38:24,000
>> [Студентски] Што е [недоловим]?

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

505
00:38:26,000 --> 00:38:28,000
[Студентски] Не, под тоа, големината - глава.

506
00:38:28,000 --> 00:38:30,000
[Роб Б] Ова право тука?

507
00:38:30,000 --> 00:38:32,000
Покажувачот аритметика.

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
е токму еквивалентно на и нови [size - шеф]

512
00:38:56,000 --> 00:39:00,000
додека ние очекуваме дека може да функционира правилно,

513
00:39:00,000 --> 00:39:04,000
бидејќи ако ние не се занимаваат со int низа, тогаш ние не индекс од 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
Можете don't-[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
Ти си додавање на една char *, која може да биде еден бајти или whatever.

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
што Стави во ред случај, ако ние сме 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
Ако ние Стави во ред нула, ние би сакале да ја игнорираат.

532
00:40:34,000 --> 00:40:40,000
Секој има некои код можам да се повлече до?

533
00:40:40,000 --> 00:40:45,000
[Студентски] Јас само имаат 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
[Студентски] Прво, осигурајте се дека има нешто во ред

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
[Студентски] Ако вашата глава е во последен елемент,

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
ова ќе биде char *, она што ние го врати,

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
ова е случај на-you'll видите луѓе прават ако главата

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
Тоа е она решение Дејвид Malan е секогаш е

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
[Студентски] Тоа само укажува на следното покажувачот наместо на покажувачи,

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
И има бенефиции и detriments, и еден очигледно една

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 struct јазол, int i: struct јазол * следниот; јазол.

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

608
00:47:09,000 --> 00:47:14,000
Квиз 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
Претпоставувам неколку прашања, зошто не ни треба struct тука?

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
Но, како на овој момент, кога сме вид на парсирањето преку овој struct јазол дефиниција,

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
Но struct јазол прави тоа, и овој јазол овде,

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
Но, ова struct јазол треба да се нарекува истото како овој struct јазол.

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 struct,

630
00:48:42,000 --> 00:48:47,000
имплементација на struct, речник, или whatever.

631
00:48:47,000 --> 00:48:51,000
>> Зошто тука ние треба да се каже јазол?

632
00:48:51,000 --> 00:48:54,000
Зошто не може да биде анонимен struct?

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
Да, во рамките на структурата, што треба да се однесуваат на struct себе.

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

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
Зошто не може едноставно да се struct јазол следно?

642
00:49:34,000 --> 00:49:37,000
[Студентски] Покажувач на следниот struct.

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

644
00:49:39,000 --> 00:49:42,000
Зошто да не се биде struct јазол следно?

645
00:49:42,000 --> 00:49:50,000
Зошто тоа мора да биде struct јазол * следно? Да.

646
00:49:50,000 --> 00:49:53,000
[Студентски] Тоа е како бесконечна јамка.

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

648
00:49:55,000 --> 00:49:57,000
[Студентски] сето тоа ќе биде во една.

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

650
00:50:02,000 --> 00:50:08,000
Големина на struct е во основа + или - некои шема тука или таму.

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
Големина на struct јазол ќе биде големината на i + големината на следната.

654
00:50:24,000 --> 00:50:27,000
Големина на i ќе биде 4. Големина на следната ќе биде 4.

655
00:50:27,000 --> 00:50:30,000
Големина на struct јазол ќе биде 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
Големина на struct јазол следната ќе биде големината на i + големината на struct јазол следната

659
00:50:43,000 --> 00:50:46,000
+ Големината на i + големината на struct јазол следната.

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
Сакам да внесете 3, па се додека листата по себе е веќе сортирани,

680
00:52:24,000 --> 00:52:27,000
тоа е лесно да се најде каде 3 припаѓа.

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
[Студентски] Должина.

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
[Студентски] Јас само се создаде покажувачот јазол и иницијализира до првата, која е нашата глобална променлива,

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
>> [Роб Б] Дали некој има било какви коментари за ништо?

708
00:55:01,000 --> 00:55:06,000
Ова изгледа фино точноста мудар.

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

710
00:55:10,000 --> 00:55:13,000
Да, па ако јазол == NULL враќање 0.

711
00:55:13,000 --> 00:55:18,000
Но, ако јазол == null тогаш ова-ох, постои точноста прашање.

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 е помала од должината на низата i + +.

728
00:56:33,000 --> 00:56:38,000
Ако тоа е начинот на кој можете iterate преку низа, ова е како да iterate во текот на поврзани листа.

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
Сте ќе сакате да iterate во текот на поврзани листа.

732
00:56:57,000 --> 00:57:02,000
Ако јазол-Јас немам идеја што вредност се нарекува.

733
00:57:02,000 --> 00:57:04,000
Јазол i.

734
00:57:04,000 --> 00:57:15,000
Ако вредноста на тој јазол = i враќање вистина, и тоа е тоа.

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

736
00:57:18,000 --> 00:57:23,000
е ако ние iterate во текот на целиот поврзани листа и никогаш не се врати точно,

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 count = 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 count = 0 тоа би било редовните стари глобалната променлива.

747
00:58:20,000 --> 00:58:25,000
Што статички int count значи дека тоа е глобалната променлива за оваа датотека.

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
Сите во собата. Bye.

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